Attachment #6219 for bug #43613

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 43613
Collapse All | Expand All




				if (shell.getParent() != null)
					return;
			}
			
			KeyStroke[] keyStrokes = new KeyStroke[3];
			keyStrokes[0] = KeySupport.convertAcceleratorToKeyStroke(KeySupport.convertEventToUnmodifiedAccelerator(event));
			keyStrokes[1] = KeySupport.convertAcceleratorToKeyStroke(KeySupport.convertEventToUnshiftedModifiedAccelerator(event));
			keyStrokes[2] = KeySupport.convertAcceleratorToKeyStroke(KeySupport.convertEventToModifiedAccelerator(event));

			if (press(keyStrokes, event)) {
				KeySupport.convertAcceleratorToKeyStroke(
					KeySupport.convertEventToAccelerator(event));

			if (press(keyStroke, event)) {
				switch (event.type) {
					case SWT.KeyDown :
						event.doit = false;

		return true;
	}

	/**
	 * Processes a key press with respect to the key binding architecture.  This
	 * updates the mode of the command manager, and runs the current handler for
	 * the command that matches the key sequence, if any.
	 * 
	 * @param potentialKeyStrokes The key strokes that could potentially match,
	 * in the order of priority; must not be <code>null</code>.
	 * @param event The event to pass to the action; may be <code>null</code>.
	 * 
	 * @return <code>true</code> if a command is executed; <code>false</code>
	 * otherwise.
	 */
	public boolean press(KeyStroke[] potentialKeyStrokes, Event event) {
		// TODO move this method to CommandManager once getMode() is added to ICommandManager (and triggers and change event)
		// TODO remove event parameter once key-modified actions are removed
		
		// Check every potential key stroke until one matches.
		for (int i = 0; i < potentialKeyStrokes.length; i++) {
			KeySequence modeBeforeKeyStroke = commandManager.getMode();
			List keyStrokes = new ArrayList(modeBeforeKeyStroke.getKeyStrokes());
			keyStrokes.add(potentialKeyStrokes[i]);
			KeySequence modeAfterKeyStroke = KeySequence.getInstance(keyStrokes);
			Map matchesByKeySequenceForModeBeforeKeyStroke = commandManager.getMatchesByKeySequenceForMode();
			commandManager.setMode(modeAfterKeyStroke);
			Map matchesByKeySequenceForModeAfterKeyStroke = commandManager.getMatchesByKeySequenceForMode();
			boolean consumeKeyStroke = false;

			if (!matchesByKeySequenceForModeAfterKeyStroke.isEmpty()) {
				// this key stroke is part of one or more possible completions: consume the keystroke
				updateModeLines(modeAfterKeyStroke);
				consumeKeyStroke = true;
			} else {
				// there are no possible longer multi-stroke sequences, allow a completion now if possible
				Match match = (Match) matchesByKeySequenceForModeBeforeKeyStroke.get(modeAfterKeyStroke);

				if (match != null) {
					// a completion was found. 
					String commandId = match.getCommandId();
					Map actionsById = commandManager.getActionsById();
					org.eclipse.ui.commands.IAction action = (org.eclipse.ui.commands.IAction) actionsById.get(commandId);

					if (action != null) {
						// an action was found corresponding to the completion

						if (action.isEnabled()) {
							updateModeLines(modeAfterKeyStroke);
							try {
								action.execute(event);
							} catch (Exception e) {
								// TODO 						
							}
						}
	
						// consume the keystroke
						consumeKeyStroke = true;
					}

					// consume the keystroke
					consumeKeyStroke = true;
				}
	
				// possibly no completion was found, or no action was found corresponding to the completion, but if we were already in a mode consume the keystroke anyway.									
				if (modeBeforeKeyStroke.getKeyStrokes().size() >= 1)
					consumeKeyStroke = true;
	
				// clear mode			
				commandManager.setMode(KeySequence.getInstance());
				updateModeLines(KeySequence.getInstance());
			}
	
			// TODO is this necessary?		
			updateActiveContextIds();
			
			if (consumeKeyStroke) {
				// We found a match, so stop now.
				return consumeKeyStroke;
			} else {
				// Restore the mode, so we can try again.
				commandManager.setMode(modeBeforeKeyStroke);
			}

			// possibly no completion was found, or no action was found corresponding to the completion, but if we were already in a mode consume the keystroke anyway.									
			if (modeBeforeKeyStroke.getKeyStrokes().size() >= 1)
				consumeKeyStroke = true;

			// clear mode			
			commandManager.setMode(KeySequence.getInstance());
			updateModeLines(KeySequence.getInstance());
		}
		
		// No key strokes match.
		return false;
		return consumeKeyStroke;
	}	
	
	/**

Lines 1320-1326 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/commands/KeysPreferencePage.java (-1 / +1 lines)
1320	}	1320	}
1321		1321
1322	private void setKeySequence(KeySequence keySequence) {	1322	private void setKeySequence(KeySequence keySequence) {
1323	textKeySequence.setKeySequence(keySequence, null);	1323	textKeySequence.setKeySequence(keySequence);
1324	}	1324	}
1325		1325
1326	private void update() {	1326	private void update() {




import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.keys.CharacterKey;
import org.eclipse.ui.keys.KeySequence;
import org.eclipse.ui.keys.KeyStroke;
import org.eclipse.ui.keys.NaturalKey;
import org.eclipse.ui.keys.ParseException;

/**

	private KeySequence keySequence = KeySequence.getInstance();
	/** The maximum number of key strokes permitted in the sequence. */
	private int maxStrokes = INFINITE;
	/** The incomplete key stroke, if any. */
	private KeyStroke temporaryStroke = null;
	/** The text widget that is wrapped for this class. */
	private final Text text;
	/** The listener that makes sure that the text widget remains up-to-date

		final Listener keyFilter = new KeyTrapListener();
		text.addListener(SWT.KeyUp, keyFilter);
		text.addListener(SWT.KeyDown, keyFilter);
		
		// Add the focus listener that attaches the global traversal filter.
		text.addFocusListener(new TraversalFilterManager());

		// Add an internal modify listener.
		text.addModifyListener(updateSequenceListener);
	}

	/**
	 * Changes the font on the underlying text widget.
	 * @param font The new font.
	 */
	public void setFont(Font font) {
		text.setFont(font);
	}

	 * Clears the text field and resets all the internal values.
	 */
	public final void clear() {
		keySequence = KeySequence.getInstance();
		temporaryStroke = null;
		text.setText(EMPTY_STRING);
	}


		return keySequence;
	}
	
	/**
	 * An accessor for the <code>KeyStroke</code> that is currently held as an
	 * incomplete stroke (i.e., one without a natural key).
	 * @return The incomplete stroke; may be <code>null</code> if there are no
	 * incomplete strokes.
	 */
	final KeyStroke getTemporaryStroke() {
		return temporaryStroke;
	}
	
	/** 
	 * An accessor for the underlying text widget's contents.
	 * @return The text contents of this entry; never <code>null</code>.
	 */
	final String getText() {
		return text.getText();
	}

	/**

	 * <code>false</code> otherwise.
	 */
	public final boolean hasIncompleteStroke() {
		return !keySequence.isComplete();
	}

	/**
	 * Checks whether the given key stroke is a temporary key stroke or not.
	 * @param keyStroke The key stroke to check for completion; may be
	 * <code>null</code>, which results in <code>false</code>.
	 * @return <code>true</code> if the key stroke has no natural key; 
	 * <code>false</code> otherwise.
	 */
	static final boolean isComplete(final KeyStroke keyStroke) {
		if (keyStroke != null) {
			final NaturalKey naturalKey = keyStroke.getNaturalKey();

			if (naturalKey instanceof CharacterKey) {
				final CharacterKey characterKey = (CharacterKey) naturalKey;
				return (characterKey.getCharacter() != '\0');
			} else
				return true;
		}

		return false;
	}

	/**


	/**
	 * <p>
	 * A mutator for the key sequence stored within this widget.  The text and
	 * caret position are updated.
	 * really incomplete; if it is complete, then it is rolled into the key 
	 * sequence.  The text and caret position are updated.
	 * </p>
	 * <p>
	 * All sequences are limited to maxStrokes number of strokes in length.

	 *   
	 * @param newKeySequence The new key sequence for this widget; may be
	 * <code>null</code> if none.
	 * @param incompleteStroke The new incomplete stroke for this widget; may be
	 * <code>null</code> or incomplete -- both conditions are dealt with.
	 */
	public void setKeySequence(KeySequence newKeySequence) {
		keySequence = newKeySequence;
		
		// Trim any extra strokes.
		if (maxStrokes != INFINITE) {
			List keyStrokes = new ArrayList(keySequence.getKeyStrokes());
			int keyStrokesSize = keyStrokes.size();
			for (int i = keyStrokesSize - 1; i >= maxStrokes; i--) {
				keyStrokes.remove(i);
				if (maxStrokes != INFINITE) {
					final int keyStrokesSize = keyStrokes.size();
					for (int i = keyStrokesSize - 1; i >= maxStrokes; i--) {
						keyStrokes.remove(i);
					}
				}
				keySequence = KeySequence.getInstance(keyStrokes);
			}
			temporaryStroke = null;
		} else {
			if ((newKeySequence != null) && (maxStrokes != INFINITE)) {
				final List untrimmedKeyStrokes = newKeySequence.getKeyStrokes();
				final int keyStrokesSize = untrimmedKeyStrokes.size();
				if (keyStrokesSize > maxStrokes) {
					final List keyStrokes = new ArrayList(untrimmedKeyStrokes);
					for (int i = keyStrokesSize - 1; i >= maxStrokes; i--) {
						keyStrokes.remove(i);
					}
					keySequence = KeySequence.getInstance(keyStrokes);
					temporaryStroke = null;
				} else if (keyStrokesSize == maxStrokes) {
					keySequence = newKeySequence;
					temporaryStroke = null;
				} else {
					keySequence = newKeySequence;
					temporaryStroke = incompleteStroke;
				}
			} else {
				keySequence = newKeySequence;
				temporaryStroke = incompleteStroke;
			}
		}

		/* Create a dummy (and rather invalid) sequence to get localized display
		 * formatting
		 */
		final KeySequence dummySequence;
		if (keySequence == null) {
			if (temporaryStroke == null) {
				dummySequence = KeySequence.getInstance();
			} else {
				dummySequence = KeySequence.getInstance(temporaryStroke);
			}
		} else {
			final List keyStrokes = new ArrayList(keySequence.getKeyStrokes());
			if (temporaryStroke != null) {
				keyStrokes.add(temporaryStroke);
			}
			keySequence = KeySequence.getInstance(keyStrokes);	
		}
				
		// We need to update the text, but we don't need to synchronize.
		text.removeModifyListener(updateSequenceListener);
		text.setText(keySequence.format());
		text.addModifyListener(updateSequenceListener);

		// Update the caret position.
		text.setSelection(getText().length());
	}

	/**
	 * A mutator for the layout information associated with the wrapped widget.
	 * @param layoutData The layout information; must not be <code>null</code>.
	 */
	public void setLayoutData(Object layoutData) {
		text.setLayoutData(layoutData);
	}


	 * @param maximumStrokes The maximum number of strokes; should be a positive
	 * integer or <code>INFINITE</code>.
	 */
	public void setMaxStrokes(int maximumStrokes) {
		if ((maximumStrokes > 0) || (maximumStrokes == INFINITE)) {
			maxStrokes = maximumStrokes;
		}
	}

	/**
	 * A traversal listener that blocks all traversal except for tabs and arrow
	 * keys.
	 */
	private final class FocusTrapListener implements TraverseListener {

		/**
		 * Handles the traverse event on the text field wrapped by this class.
		 * It swallows all traverse events example for tab and arrow key 
		 * navigation.  The other forms of navigation can be reached by tabbing
		 * off of the control.
		 * 
		 * @param event The trigger event; must not be <code>null</code>.
		 */
		public final void keyTraversed(final TraverseEvent event) {
			switch (event.detail) {
				case SWT.TRAVERSE_ESCAPE :
				case SWT.TRAVERSE_MNEMONIC :
				case SWT.TRAVERSE_NONE :
				case SWT.TRAVERSE_PAGE_NEXT :
				case SWT.TRAVERSE_PAGE_PREVIOUS :
				case SWT.TRAVERSE_RETURN :
					event.doit = false;
					break;
					
				case SWT.TRAVERSE_TAB_NEXT :
				case SWT.TRAVERSE_TAB_PREVIOUS :				
					// Check if modifiers other than just 'Shift' were down.
					if ((event.stateMask & (SWT.MODIFIER_MASK ^ SWT.SHIFT)) != 0) {
						// Modifiers other than shift were down.
						event.doit = false;
						break;
					}
					// fall through -- either no modifiers, or just shift.
				
				case SWT.TRAVERSE_ARROW_NEXT :
				case SWT.TRAVERSE_ARROW_PREVIOUS :
				default :
					// Let the traversal happen, but clear the incomplete stroke
					setKeySequence(getKeySequence(), null);
			}
		}
	}

	/**
	 * A key listener that traps incoming events and displays them in the 
	 * wrapped text field.  It has no effect on traversal operations.
	 */
	private class KeyTrapListener implements Listener {
		/**
		 * Handles the key pressed and released events on the wrapped text 
		 * widget.  This makes sure to either add the pressed key to the 

		 * 
		 * @param event The triggering event; must not be <code>null</code>. 
		 */
		public void handleEvent(Event event) {
			List keyStrokes = new ArrayList(getKeySequence().getKeyStrokes());
			
			if (event.type == SWT.KeyDown) {
				if ((event.character == SWT.BS) && (event.stateMask == 0)) {
					// Remove the last key stroke.
					if (!keyStrokes.isEmpty()) {
						keyStrokes.remove(keyStrokes.size() - 1);
						 * be possible, but it is better to be safe than sorry.
						 */
						setKeySequence(getKeySequence(), null);
					} else {
						// Remove the last complete stroke.
						final KeySequence sequence = getKeySequence();
						final List keyStrokes = new ArrayList(sequence.getKeyStrokes());
						if (!keyStrokes.isEmpty()) {
							keyStrokes.remove(keyStrokes.size() - 1);
							setKeySequence(KeySequence.getInstance(keyStrokes), null);
						}
					}
					
				} else {
					// Handles the key pressed event.
					// Remove the incomplete stroke, if any.
					if ((hasIncompleteStroke()) && (!keyStrokes.isEmpty())) {
						keyStrokes.remove(keyStrokes.size() - 1);
					}
					
					// Add the new stroke.
					int key = KeySupport.convertEventToUnmodifiedAccelerator(event);
					KeyStroke stroke = KeySupport.convertAcceleratorToKeyStroke(key);
					keyStrokes.add(stroke);
				}

			} else if ((event.type == SWT.KeyUp) && (hasIncompleteStroke())) {
				/* Handles the key released event, which is only relevant if
				 * there is an incomplete stroke.
				 */
				/* Figure out the SWT integer representation of the remaining
				 * values.
				 */
				Event mockEvent = new Event();
				if ((event.keyCode & SWT.MODIFIER_MASK) != 0) {
					// This key up is a modifier key being released.
					mockEvent.stateMask = event.stateMask - event.keyCode;

				/* Get a reasonable facsimile of the stroke that is still
				 * pressed.
				 */
				int key = KeySupport.convertEventToUnmodifiedAccelerator(mockEvent);
				KeyStroke remainingStroke = KeySupport.convertAcceleratorToKeyStroke(key);
				if (!keyStrokes.isEmpty()) {
					keyStrokes.remove(keyStrokes.size() - 1);
				}
				if (!remainingStroke.getModifierKeys().isEmpty()) {
					keyStrokes.add(remainingStroke);
				}

			}
					
			// Update the underlying widget.
			setKeySequence(KeySequence.getInstance(keyStrokes));

			// Prevent the event from reaching the widget.
			event.doit = false;

	}

	/**
	 * A traversal listener that blocks all traversal except for tabs and arrow
	 * keys.
	 */
	private class TraversalFilter implements Listener {
		/**
		 * Handles the traverse event on the text field wrapped by this class.
		 * It swallows all traverse events example for tab and arrow key 
		 * navigation.  The other forms of navigation can be reached by tabbing
		 * off of the control.
		 * 
		 * @param event The trigger event; must not be <code>null</code>.
		 */
		public void handleEvent(Event event) {
			switch (event.detail) {
				case SWT.TRAVERSE_ESCAPE :
				case SWT.TRAVERSE_MNEMONIC :
				case SWT.TRAVERSE_NONE :
				case SWT.TRAVERSE_PAGE_NEXT :
				case SWT.TRAVERSE_PAGE_PREVIOUS :
				case SWT.TRAVERSE_RETURN :
					event.type = SWT.None;
					event.doit = false;
					break;
					
				case SWT.TRAVERSE_TAB_NEXT :
				case SWT.TRAVERSE_TAB_PREVIOUS :				
					// Check if modifiers other than just 'Shift' were down.
					if ((event.stateMask & (SWT.MODIFIER_MASK ^ SWT.SHIFT)) != 0) {
						// Modifiers other than shift were down.
						event.type = SWT.None;
						event.doit = false;
						break;
					}
					// fall through -- either no modifiers, or just shift.
				
				case SWT.TRAVERSE_ARROW_NEXT :
				case SWT.TRAVERSE_ARROW_PREVIOUS :
				default :
					// Let the traversal happen, but clear the incomplete stroke
					if (hasIncompleteStroke()) {
						List keyStrokes = new ArrayList(getKeySequence().getKeyStrokes());
						if (!keyStrokes.isEmpty()) {
							keyStrokes.remove(keyStrokes.size() - 1);
						}
						setKeySequence(KeySequence.getInstance(keyStrokes));
					}
			}
			
		}
	}
	
	/**
	 * The manager resposible for installing and removing the traversal filter
	 * when the key sequence entry widget gains and loses focus.
	 */
	private class TraversalFilterManager implements FocusListener {
		/** The managed filter.  We only need one instance. */
		private TraversalFilter filter = new TraversalFilter();
		
		/**
		 * Attaches the global traversal filter.
		 * @param event Ignored.
		 */
		public void focusGained(FocusEvent event) {
			Display.getCurrent().addFilter(SWT.Traverse, filter);
		}
		
		/**
		 * Detaches the global traversal filter.
		 * @param event Ignored.
		 */
		public void focusLost(FocusEvent event) {
			Display.getCurrent().removeFilter(SWT.Traverse, filter);
		}
	}

	/**
     * A modification listener that makes sure that external events to this 
     * class (i.e., direct modification of the underlying text) do not break
     * this class' view of the world.
     */
	private class UpdateSequenceListener implements ModifyListener {
		/**
		 * Handles the modify event on the underlying text widget.
         * @param event The triggering event; ignored.
         */
		public void modifyText(ModifyEvent event) {
			try {
				// The original sequence.
				KeySequence originalSequence = getKeySequence();
				final List keyStrokes = new ArrayList(originalSequence.getKeyStrokes());
				if (getTemporaryStroke() != null) {
					keyStrokes.add(getTemporaryStroke());
				}
				final KeySequence sequenceFromStrokes = KeySequence.getInstance(keyStrokes);

				// The new sequence drawn from the text.
				String contents = getText();
				KeySequence newSequence = KeySequence.getInstance(contents);

				// Check to see if they're the same.
				if (!originalSequence.equals(newSequence)) {
					setKeySequence(newSequence);
					final Iterator strokeItr = strokes.iterator();
					while (strokeItr.hasNext()) {
						// Make sure that it's a valid sequence.
						if (!isComplete((KeyStroke) strokeItr.next())) {
							setKeySequence(getKeySequence(), getTemporaryStroke());
							return;
						}
					}
					setKeySequence(sequenceFromText, null);
				}
				
			} catch (ParseException e) {
				// Abort any cut/paste-driven modifications
				setKeySequence(getKeySequence());
			}
		}
	}




		if ((accelerator & SWT.SHIFT) != 0)
			modifierKeys.add(ModifierKey.SHIFT);

		if (((accelerator & SWT.KEY_MASK) == 0) && (accelerator != 0)) {
			// There were only accelerators
			naturalKey = null;
		} else {
			// There were other keys.
			accelerator &= SWT.KEY_MASK;

			switch (accelerator) {
				case SWT.ARROW_DOWN :
					naturalKey = SpecialKey.ARROW_DOWN;
					break;
				case SWT.ARROW_LEFT :
					naturalKey = SpecialKey.ARROW_LEFT;
					break;
				case SWT.ARROW_RIGHT :
					naturalKey = SpecialKey.ARROW_RIGHT;
					break;
				case SWT.ARROW_UP :
					naturalKey = SpecialKey.ARROW_UP;
					break;
				case SWT.END :
					naturalKey = SpecialKey.END;
					break;
				case SWT.F1 :
					naturalKey = SpecialKey.F1;
					break;
				case SWT.F10 :
					naturalKey = SpecialKey.F10;
					break;
				case SWT.F11 :
					naturalKey = SpecialKey.F11;
					break;
				case SWT.F12 :
					naturalKey = SpecialKey.F12;
					break;
				case SWT.F2 :
					naturalKey = SpecialKey.F2;
					break;
				case SWT.F3 :
					naturalKey = SpecialKey.F3;
					break;
				case SWT.F4 :
					naturalKey = SpecialKey.F4;
					break;
				case SWT.F5 :
					naturalKey = SpecialKey.F5;
					break;
				case SWT.F6 :
					naturalKey = SpecialKey.F6;
					break;
				case SWT.F7 :
					naturalKey = SpecialKey.F7;
					break;
				case SWT.F8 :
					naturalKey = SpecialKey.F8;
					break;
				case SWT.F9 :
					naturalKey = SpecialKey.F9;
					break;
				case SWT.HOME :
					naturalKey = SpecialKey.HOME;
					break;
				case SWT.INSERT :
					naturalKey = SpecialKey.INSERT;
					break;
				case SWT.PAGE_DOWN :
					naturalKey = SpecialKey.PAGE_DOWN;
					break;
				case SWT.PAGE_UP :
					naturalKey = SpecialKey.PAGE_UP;
					break;
				default :
					naturalKey = CharacterKey.getInstance((char) (accelerator & 0xFFFF));
			}
		}

		return KeyStroke.getInstance(modifierKeys, naturalKey);
	}

	/**
	 * Converts the given event into an SWT accelerator value -- considering
	 * the modified character with the shift modifier. This is the third
	 * accelerator value that should be checked.
	 * 
	 * @param event
	 *           The event to be converted; must not be <code>null</code>.
	 * @return The combination of the state mask and the unmodified character.
	 */
	public static int convertEventToModifiedAccelerator(Event event) {
		int modifiers = event.stateMask & SWT.MODIFIER_MASK;
		int modifiedCharacter = topKey(event);
		return modifiers + modifiedCharacter;
	}

	/**
	 * Converts the given event into an SWT accelerator value -- considering
	 * the unmodified character with all modifier keys. This is the first
	 * accelerator value that should be checked. However, all alphabetic
	 * characters are considered as their uppercase equivalents.
	 * 
	 * @param event
	 *           The event to be converted; must not be <code>null</code>.
	 * @return The combination of the state mask and the unmodified character.
	 */
	public static int convertEventToUnmodifiedAccelerator(Event event) {
		int modifiers = event.stateMask & SWT.MODIFIER_MASK;
		int unmodifiedCharacter = upperCase(event.keyCode);

		return modifiers + unmodifiedCharacter;
	}

	/**
	 * Converts the given event into an SWT accelerator value -- considering
	 * the modified character without the shift modifier. This is the second
	 * accelerator value that should be checked.
	 * 
	 * @param event
	 *           The event to be converted; must not be <code>null</code>.
	 * @return The combination of the state mask without shift, and the
	 *         modified character.
	 */
	public static int convertEventToUnshiftedModifiedAccelerator(Event event) {
		int modifiers = event.stateMask & (SWT.MODIFIER_MASK ^ SWT.SHIFT);
		int modifiedCharacter = topKey(event);
		return modifiers + modifiedCharacter;
	}

	public static final int convertKeyStrokeToAccelerator(final KeyStroke keyStroke) {
		if (keyStroke == null)
			throw new NullPointerException();

		}

		return accelerator;
	}

	/**
	 * Makes sure that a fully-modified character is converted to the normal
	 * form. This means that "Ctrl+" key strokes must reverse the modification
	 * caused by control-escaping. Also, all lower case letters are converted
	 * to uppercase.
	 * 
	 * @param event
	 *           The event from which the fully-modified character should be
	 *           pulled.
	 * @return The modified character, uppercase and without control-escaping.
	 */
	private static int topKey(Event event) {
		boolean ctrlDown = (event.stateMask & SWT.CTRL) != 0;
		char modifiedCharacter;
		if ((ctrlDown) && (event.character != event.keyCode) && (event.character < 0x20)) {
			modifiedCharacter = (char) (event.character + 0x40);
		} else {
			modifiedCharacter = event.character;
		}

		return upperCase(modifiedCharacter);
	}

	/**
	 * Makes the given character uppercase if it is a letter.
	 * 
	 * @param character
	 *           The character to convert.
	 * @return The uppercase equivalent, if any; otherwise, the character
	 *         itself.
	 */
	private static int upperCase(int character) {
		if (Character.isLetter((char) character)) {
			return Character.toUpperCase((char) character);
		}

		return character;
	}

	private KeySupport() {

Return to bug 43613

Lines 208-219 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/Workbench.java (-63 / +82 lines)
208	if (shell.getParent() != null)	208	if (shell.getParent() != null)
209	return;	209	return;
210	}	210	}
		211
		212	KeyStroke[] keyStrokes = new KeyStroke[3];
		213	keyStrokes[0] = KeySupport.convertAcceleratorToKeyStroke(KeySupport.convertEventToUnmodifiedAccelerator(event));
		214	keyStrokes[1] = KeySupport.convertAcceleratorToKeyStroke(KeySupport.convertEventToUnshiftedModifiedAccelerator(event));
		215	keyStrokes[2] = KeySupport.convertAcceleratorToKeyStroke(KeySupport.convertEventToModifiedAccelerator(event));
211		216
212	KeyStroke keyStroke =	217	if (press(keyStrokes, event)) {
213	KeySupport.convertAcceleratorToKeyStroke(
214	KeySupport.convertEventToAccelerator(event));
215
216	if (press(keyStroke, event)) {
217	switch (event.type) {	218	switch (event.type) {
218	case SWT.KeyDown :	219	case SWT.KeyDown :
219	event.doit = false;	220	event.doit = false;
Lines 413-481 Link Here
413	return true;	414	return true;
414	}	415	}
415		416
416	// TODO move this method to CommandManager once getMode() is added to ICommandManager (and triggers and change event)	417	/**
417	// TODO remove event parameter once key-modified actions are removed	418	* Processes a key press with respect to the key binding architecture. This
418	public final boolean press(KeyStroke keyStroke, Event event) {	419	* updates the mode of the command manager, and runs the current handler for
419	final KeySequence modeBeforeKeyStroke = commandManager.getMode();	420	* the command that matches the key sequence, if any.
420	final List keyStrokes =	421	*
421	new ArrayList(modeBeforeKeyStroke.getKeyStrokes());	422	* @param potentialKeyStrokes The key strokes that could potentially match,
422	keyStrokes.add(keyStroke);	423	* in the order of priority; must not be <code>null</code>.
423	final KeySequence modeAfterKeyStroke =	424	* @param event The event to pass to the action; may be <code>null</code>.
424	KeySequence.getInstance(keyStrokes);	425	*
425	final Map matchesByKeySequenceForModeBeforeKeyStroke =	426	* @return <code>true</code> if a command is executed; <code>false</code>
426	commandManager.getMatchesByKeySequenceForMode();	427	* otherwise.
427	commandManager.setMode(modeAfterKeyStroke);	428	*/
428	final Map matchesByKeySequenceForModeAfterKeyStroke =	429	public boolean press(KeyStroke[] potentialKeyStrokes, Event event) {
429	commandManager.getMatchesByKeySequenceForMode();	430	// TODO move this method to CommandManager once getMode() is added to ICommandManager (and triggers and change event)
430	boolean consumeKeyStroke = false;	431	// TODO remove event parameter once key-modified actions are removed
431		432
432	if (!matchesByKeySequenceForModeAfterKeyStroke.isEmpty()) {	433	// Check every potential key stroke until one matches.
433	// this key stroke is part of one or more possible completions: consume the keystroke	434	for (int i = 0; i < potentialKeyStrokes.length; i++) {
434	updateModeLines(modeAfterKeyStroke);	435	KeySequence modeBeforeKeyStroke = commandManager.getMode();
435	consumeKeyStroke = true;	436	List keyStrokes = new ArrayList(modeBeforeKeyStroke.getKeyStrokes());
436	} else {	437	keyStrokes.add(potentialKeyStrokes[i]);
437	// there are no possible longer multi-stroke sequences, allow a completion now if possible	438	KeySequence modeAfterKeyStroke = KeySequence.getInstance(keyStrokes);
438	final Match match =	439	Map matchesByKeySequenceForModeBeforeKeyStroke = commandManager.getMatchesByKeySequenceForMode();
439	(Match) matchesByKeySequenceForModeBeforeKeyStroke.get(	440	commandManager.setMode(modeAfterKeyStroke);
440	modeAfterKeyStroke);	441	Map matchesByKeySequenceForModeAfterKeyStroke = commandManager.getMatchesByKeySequenceForMode();
441		442	boolean consumeKeyStroke = false;
442	if (match != null) {	443
443	// a completion was found.	444	if (!matchesByKeySequenceForModeAfterKeyStroke.isEmpty()) {
444	final String commandId = match.getCommandId();	445	// this key stroke is part of one or more possible completions: consume the keystroke
445	final Map actionsById = commandManager.getActionsById();	446	updateModeLines(modeAfterKeyStroke);
446	org.eclipse.ui.commands.IAction action =	447	consumeKeyStroke = true;
447	(org.eclipse.ui.commands.IAction) actionsById.get(	448	} else {
448	commandId);	449	// there are no possible longer multi-stroke sequences, allow a completion now if possible
449		450	Match match = (Match) matchesByKeySequenceForModeBeforeKeyStroke.get(modeAfterKeyStroke);
450	if (action != null) {	451
451	// an action was found corresponding to the completion	452	if (match != null) {
452		453	// a completion was found.
453	if (action.isEnabled()) {	454	String commandId = match.getCommandId();
454	updateModeLines(modeAfterKeyStroke);	455	Map actionsById = commandManager.getActionsById();
455	try {	456	org.eclipse.ui.commands.IAction action = (org.eclipse.ui.commands.IAction) actionsById.get(commandId);
456	action.execute(event);	457
457	} catch (final Exception e) {	458	if (action != null) {
458	// TODO	459	// an action was found corresponding to the completion
		460
		461	if (action.isEnabled()) {
		462	updateModeLines(modeAfterKeyStroke);
		463	try {
		464	action.execute(event);
		465	} catch (Exception e) {
		466	// TODO
		467	}
459	}	468	}
		469
		470	// consume the keystroke
		471	consumeKeyStroke = true;
460	}	472	}
461
462	// consume the keystroke
463	consumeKeyStroke = true;
464	}	473	}
		474
		475	// possibly no completion was found, or no action was found corresponding to the completion, but if we were already in a mode consume the keystroke anyway.
		476	if (modeBeforeKeyStroke.getKeyStrokes().size() >= 1)
		477	consumeKeyStroke = true;
		478
		479	// clear mode
		480	commandManager.setMode(KeySequence.getInstance());
		481	updateModeLines(KeySequence.getInstance());
		482	}
		483
		484	// TODO is this necessary?
		485	updateActiveContextIds();
		486
		487	if (consumeKeyStroke) {
		488	// We found a match, so stop now.
		489	return consumeKeyStroke;
		490	} else {
		491	// Restore the mode, so we can try again.
		492	commandManager.setMode(modeBeforeKeyStroke);
465	}	493	}
466
467	// possibly no completion was found, or no action was found corresponding to the completion, but if we were already in a mode consume the keystroke anyway.
468	if (modeBeforeKeyStroke.getKeyStrokes().size() >= 1)
469	consumeKeyStroke = true;
470
471	// clear mode
472	commandManager.setMode(KeySequence.getInstance());
473	updateModeLines(KeySequence.getInstance());
474	}	494	}
475		495
476	// TODO is this necessary?	496	// No key strokes match.
477	updateActiveContextIds();	497	return false;
478	return consumeKeyStroke;
479	}	498	}
480		499
481	/**	500	/**

Lines 41-138 Link Here

(-)Eclipse UI/org/eclipse/ui/internal/keys/KeySupport.java (-84 / +158 lines)
41	if ((accelerator & SWT.SHIFT) != 0)	41	if ((accelerator & SWT.SHIFT) != 0)
42	modifierKeys.add(ModifierKey.SHIFT);	42	modifierKeys.add(ModifierKey.SHIFT);
43		43
44	accelerator &= SWT.KEY_MASK;	44	if (((accelerator & SWT.KEY_MASK) == 0) && (accelerator != 0)) {
45		45	// There were only accelerators
46	switch (accelerator) {	46	naturalKey = null;
47	case SWT.ARROW_DOWN :	47	} else {
48	naturalKey = SpecialKey.ARROW_DOWN;	48	// There were other keys.
49	break;	49	accelerator &= SWT.KEY_MASK;
50	case SWT.ARROW_LEFT :	50
51	naturalKey = SpecialKey.ARROW_LEFT;	51	switch (accelerator) {
52	break;	52	case SWT.ARROW_DOWN :
53	case SWT.ARROW_RIGHT :	53	naturalKey = SpecialKey.ARROW_DOWN;
54	naturalKey = SpecialKey.ARROW_RIGHT;	54	break;
55	break;	55	case SWT.ARROW_LEFT :
56	case SWT.ARROW_UP :	56	naturalKey = SpecialKey.ARROW_LEFT;
57	naturalKey = SpecialKey.ARROW_UP;	57	break;
58	break;	58	case SWT.ARROW_RIGHT :
59	case SWT.END :	59	naturalKey = SpecialKey.ARROW_RIGHT;
60	naturalKey = SpecialKey.END;	60	break;
61	break;	61	case SWT.ARROW_UP :
62	case SWT.F1 :	62	naturalKey = SpecialKey.ARROW_UP;
63	naturalKey = SpecialKey.F1;	63	break;
64	break;	64	case SWT.END :
65	case SWT.F10 :	65	naturalKey = SpecialKey.END;
66	naturalKey = SpecialKey.F10;	66	break;
67	break;	67	case SWT.F1 :
68	case SWT.F11 :	68	naturalKey = SpecialKey.F1;
69	naturalKey = SpecialKey.F11;	69	break;
70	break;	70	case SWT.F10 :
71	case SWT.F12 :	71	naturalKey = SpecialKey.F10;
72	naturalKey = SpecialKey.F12;	72	break;
73	break;	73	case SWT.F11 :
74	case SWT.F2 :	74	naturalKey = SpecialKey.F11;
75	naturalKey = SpecialKey.F2;	75	break;
76	break;	76	case SWT.F12 :
77	case SWT.F3 :	77	naturalKey = SpecialKey.F12;
78	naturalKey = SpecialKey.F3;	78	break;
79	break;	79	case SWT.F2 :
80	case SWT.F4 :	80	naturalKey = SpecialKey.F2;
81	naturalKey = SpecialKey.F4;	81	break;
82	break;	82	case SWT.F3 :
83	case SWT.F5 :	83	naturalKey = SpecialKey.F3;
84	naturalKey = SpecialKey.F5;	84	break;
85	break;	85	case SWT.F4 :
86	case SWT.F6 :	86	naturalKey = SpecialKey.F4;
87	naturalKey = SpecialKey.F6;	87	break;
88	break;	88	case SWT.F5 :
89	case SWT.F7 :	89	naturalKey = SpecialKey.F5;
90	naturalKey = SpecialKey.F7;	90	break;
91	break;	91	case SWT.F6 :
92	case SWT.F8 :	92	naturalKey = SpecialKey.F6;
93	naturalKey = SpecialKey.F8;	93	break;
94	break;	94	case SWT.F7 :
95	case SWT.F9 :	95	naturalKey = SpecialKey.F7;
96	naturalKey = SpecialKey.F9;	96	break;
97	break;	97	case SWT.F8 :
98	case SWT.HOME :	98	naturalKey = SpecialKey.F8;
99	naturalKey = SpecialKey.HOME;	99	break;
100	break;	100	case SWT.F9 :
101	case SWT.INSERT :	101	naturalKey = SpecialKey.F9;
102	naturalKey = SpecialKey.INSERT;	102	break;
103	break;	103	case SWT.HOME :
104	case SWT.PAGE_DOWN :	104	naturalKey = SpecialKey.HOME;
105	naturalKey = SpecialKey.PAGE_DOWN;	105	break;
106	break;	106	case SWT.INSERT :
107	case SWT.PAGE_UP :	107	naturalKey = SpecialKey.INSERT;
108	naturalKey = SpecialKey.PAGE_UP;	108	break;
109	break;	109	case SWT.PAGE_DOWN :
110	default :	110	naturalKey = SpecialKey.PAGE_DOWN;
111	naturalKey = CharacterKey.getInstance((char) (accelerator & 0xFFFF));	111	break;
		112	case SWT.PAGE_UP :
		113	naturalKey = SpecialKey.PAGE_UP;
		114	break;
		115	default :
		116	naturalKey = CharacterKey.getInstance((char) (accelerator & 0xFFFF));
		117	}
112	}	118	}
113		119
114	return KeyStroke.getInstance(modifierKeys, naturalKey);	120	return KeyStroke.getInstance(modifierKeys, naturalKey);
115	}	121	}
116		122
117	public static int convertEventToAccelerator(Event event) {	123	/**
118	int key = event.character;	124	* Converts the given event into an SWT accelerator value -- considering
119		125	* the modified character with the shift modifier. This is the third
120	if (key == 0)	126	* accelerator value that should be checked.
121	key = event.keyCode;	127	*
122	else {	128	* @param event
123	if (0 <= key && key <= 0x1F) {	129	* The event to be converted; must not be <code>null</code>.
124	if ((event.stateMask & SWT.CTRL) != 0 && event.keyCode != event.character)	130	* @return The combination of the state mask and the unmodified character.
125	key += 0x40;	131	*/
126	} else {	132	public static int convertEventToModifiedAccelerator(Event event) {
127	if ('a' <= key && key <= 'z')	133	int modifiers = event.stateMask & SWT.MODIFIER_MASK;
128	key -= 'a' - 'A';	134	int modifiedCharacter = topKey(event);
129	}	135	return modifiers + modifiedCharacter;
130	}	136	}
131		137
		138	/**
		139	* Converts the given event into an SWT accelerator value -- considering
		140	* the unmodified character with all modifier keys. This is the first
		141	* accelerator value that should be checked. However, all alphabetic
		142	* characters are considered as their uppercase equivalents.
		143	*
		144	* @param event
		145	* The event to be converted; must not be <code>null</code>.
		146	* @return The combination of the state mask and the unmodified character.
		147	*/
		148	public static int convertEventToUnmodifiedAccelerator(Event event) {
132	int modifiers = event.stateMask & SWT.MODIFIER_MASK;	149	int modifiers = event.stateMask & SWT.MODIFIER_MASK;
133	return modifiers + key;	150	int unmodifiedCharacter = upperCase(event.keyCode);
		151
		152	return modifiers + unmodifiedCharacter;
		153	}
		154
		155	/**
		156	* Converts the given event into an SWT accelerator value -- considering
		157	* the modified character without the shift modifier. This is the second
		158	* accelerator value that should be checked.
		159	*
		160	* @param event
		161	* The event to be converted; must not be <code>null</code>.
		162	* @return The combination of the state mask without shift, and the
		163	* modified character.
		164	*/
		165	public static int convertEventToUnshiftedModifiedAccelerator(Event event) {
		166	int modifiers = event.stateMask & (SWT.MODIFIER_MASK ^ SWT.SHIFT);
		167	int modifiedCharacter = topKey(event);
		168	return modifiers + modifiedCharacter;
134	}	169	}
135		170
136	public static final int convertKeyStrokeToAccelerator(final KeyStroke keyStroke) {	171	public static final int convertKeyStrokeToAccelerator(final KeyStroke keyStroke) {
137	if (keyStroke == null)	172	if (keyStroke == null)
138	throw new NullPointerException();	173	throw new NullPointerException();
Lines 205-210 Link Here
205	}	240	}
206		241
207	return accelerator;	242	return accelerator;
		243	}
		244
		245	/**
		246	* Makes sure that a fully-modified character is converted to the normal
		247	* form. This means that "Ctrl+" key strokes must reverse the modification
		248	* caused by control-escaping. Also, all lower case letters are converted
		249	* to uppercase.
		250	*
		251	* @param event
		252	* The event from which the fully-modified character should be
		253	* pulled.
		254	* @return The modified character, uppercase and without control-escaping.
		255	*/
		256	private static int topKey(Event event) {
		257	boolean ctrlDown = (event.stateMask & SWT.CTRL) != 0;
		258	char modifiedCharacter;
		259	if ((ctrlDown) && (event.character != event.keyCode) && (event.character < 0x20)) {
		260	modifiedCharacter = (char) (event.character + 0x40);
		261	} else {
		262	modifiedCharacter = event.character;
		263	}
		264
		265	return upperCase(modifiedCharacter);
		266	}
		267
		268	/**
		269	* Makes the given character uppercase if it is a letter.
		270	*
		271	* @param character
		272	* The character to convert.
		273	* @return The uppercase equivalent, if any; otherwise, the character
		274	* itself.
		275	*/
		276	private static int upperCase(int character) {
		277	if (Character.isLetter((char) character)) {
		278	return Character.toUpperCase((char) character);
		279	}
		280
		281	return character;
208	}	282	}
209		283
210	private KeySupport() {	284	private KeySupport() {