| /******************************************************************************* |
| * Copyright (c) 2000, 2006 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.ui.keys; |
| |
| import java.util.Iterator; |
| import java.util.SortedSet; |
| import java.util.TreeSet; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.ui.internal.keys.NativeKeyFormatter; |
| |
| /** |
| * A utility class for converting SWT events into key strokes. |
| * |
| * @deprecated Please use org.eclipse.jface.bindings.keys.SWTKeySupport |
| * @since 3.0 |
| */ |
| public final class SWTKeySupport { |
| |
| /** |
| * Given an SWT accelerator value, provide the corresponding key stroke. |
| * |
| * @param accelerator |
| * The accelerator to convert; should be a valid SWT accelerator |
| * value. |
| * @return The equivalent key stroke; never <code>null</code>. |
| */ |
| public static KeyStroke convertAcceleratorToKeyStroke(int accelerator) { |
| final SortedSet modifierKeys = new TreeSet(); |
| NaturalKey naturalKey = null; |
| |
| if ((accelerator & SWT.ALT) != 0) { |
| modifierKeys.add(ModifierKey.ALT); |
| } |
| |
| if ((accelerator & SWT.COMMAND) != 0) { |
| modifierKeys.add(ModifierKey.COMMAND); |
| } |
| |
| if ((accelerator & SWT.CTRL) != 0) { |
| modifierKeys.add(ModifierKey.CTRL); |
| } |
| |
| 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.BREAK: |
| naturalKey = SpecialKey.BREAK; |
| break; |
| case SWT.CAPS_LOCK: |
| naturalKey = SpecialKey.CAPS_LOCK; |
| 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.KEYPAD_0: |
| naturalKey = SpecialKey.NUMPAD_0; |
| break; |
| case SWT.KEYPAD_1: |
| naturalKey = SpecialKey.NUMPAD_1; |
| break; |
| case SWT.KEYPAD_2: |
| naturalKey = SpecialKey.NUMPAD_2; |
| break; |
| case SWT.KEYPAD_3: |
| naturalKey = SpecialKey.NUMPAD_3; |
| break; |
| case SWT.KEYPAD_4: |
| naturalKey = SpecialKey.NUMPAD_4; |
| break; |
| case SWT.KEYPAD_5: |
| naturalKey = SpecialKey.NUMPAD_5; |
| break; |
| case SWT.KEYPAD_6: |
| naturalKey = SpecialKey.NUMPAD_6; |
| break; |
| case SWT.KEYPAD_7: |
| naturalKey = SpecialKey.NUMPAD_7; |
| break; |
| case SWT.KEYPAD_8: |
| naturalKey = SpecialKey.NUMPAD_8; |
| break; |
| case SWT.KEYPAD_9: |
| naturalKey = SpecialKey.NUMPAD_9; |
| break; |
| case SWT.KEYPAD_ADD: |
| naturalKey = SpecialKey.NUMPAD_ADD; |
| break; |
| case SWT.KEYPAD_CR: |
| naturalKey = SpecialKey.NUMPAD_ENTER; |
| break; |
| case SWT.KEYPAD_DECIMAL: |
| naturalKey = SpecialKey.NUMPAD_DECIMAL; |
| break; |
| case SWT.KEYPAD_DIVIDE: |
| naturalKey = SpecialKey.NUMPAD_DIVIDE; |
| break; |
| case SWT.KEYPAD_EQUAL: |
| naturalKey = SpecialKey.NUMPAD_EQUAL; |
| break; |
| case SWT.KEYPAD_MULTIPLY: |
| naturalKey = SpecialKey.NUMPAD_MULTIPLY; |
| break; |
| case SWT.KEYPAD_SUBTRACT: |
| naturalKey = SpecialKey.NUMPAD_SUBTRACT; |
| break; |
| case SWT.NUM_LOCK: |
| naturalKey = SpecialKey.NUM_LOCK; |
| break; |
| case SWT.PAGE_DOWN: |
| naturalKey = SpecialKey.PAGE_DOWN; |
| break; |
| case SWT.PAGE_UP: |
| naturalKey = SpecialKey.PAGE_UP; |
| break; |
| case SWT.PAUSE: |
| naturalKey = SpecialKey.PAUSE; |
| break; |
| case SWT.PRINT_SCREEN: |
| naturalKey = SpecialKey.PRINT_SCREEN; |
| break; |
| case SWT.SCROLL_LOCK: |
| naturalKey = SpecialKey.SCROLL_LOCK; |
| break; |
| default: |
| naturalKey = CharacterKey |
| .getInstance((char) (accelerator & 0xFFFF)); |
| } |
| } |
| |
| return KeyStroke.getInstance(modifierKeys, naturalKey); |
| } |
| |
| /** |
| * <p> |
| * 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. |
| * </p> |
| * <p> |
| * For example, on a standard US keyboard, "Ctrl+Shift+5" would be viewed as |
| * "Ctrl+Shift+%". |
| * </p> |
| * |
| * @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; |
| char character = topKey(event); |
| return modifiers + toUpperCase(character); |
| } |
| |
| /** |
| * <p> |
| * 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. |
| * </p> |
| * <p> |
| * For example, on a standard US keyboard, "Ctrl+Shift+5" would be viewed as |
| * "Ctrl+Shift+5". |
| * </p> |
| * |
| * @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) { |
| return convertEventToUnmodifiedAccelerator(event.stateMask, |
| event.keyCode); |
| } |
| |
| /** |
| * <p> |
| * Converts the given state mask and key code into an SWT accelerator value -- |
| * considering the unmodified character with all modifier keys. All |
| * alphabetic characters are considered as their uppercase equivalents. |
| * </p> |
| * <p> |
| * For example, on a standard US keyboard, "Ctrl+Shift+5" would be viewed as |
| * "Ctrl+Shift+5". |
| * </p> |
| * |
| * @param stateMask |
| * The integer mask of modifiers keys depressed when this was |
| * pressed. |
| * @param keyCode |
| * The key that was pressed, before being modified. |
| * @return The combination of the state mask and the unmodified character. |
| */ |
| private static int convertEventToUnmodifiedAccelerator(int stateMask, |
| int keyCode) { |
| int modifiers = stateMask & SWT.MODIFIER_MASK; |
| int character = keyCode; |
| return modifiers + toUpperCase(character); |
| } |
| |
| /** |
| * <p> |
| * 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. |
| * </p> |
| * <p> |
| * For example, on a standard US keyboard, "Ctrl+Shift+5" would be viewed as |
| * "Ctrl+%". |
| * </p> |
| * |
| * @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(KeyEvent event) { |
| return convertEventToUnmodifiedAccelerator(event.stateMask, |
| event.keyCode); |
| } |
| |
| /** |
| * 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. Key strokes with alphabetic |
| * natural keys are run through <code>convertEventToUnmodifiedAccelerator</code> |
| * |
| * @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) { |
| // Disregard alphabetic key strokes. |
| if (Character.isLetter((char) event.keyCode)) { |
| return convertEventToUnmodifiedAccelerator(event); |
| } |
| |
| int modifiers = event.stateMask & (SWT.MODIFIER_MASK ^ SWT.SHIFT); |
| char character = topKey(event); |
| return modifiers + toUpperCase(character); |
| } |
| |
| /** |
| * Given a key stroke, this method provides the equivalent SWT accelerator |
| * value. The functional inverse of <code>convertAcceleratorToKeyStroke</code>. |
| * |
| * @param keyStroke |
| * The key stroke to convert; must not be <code>null</code>. |
| * @return The SWT accelerator value |
| */ |
| public static final int convertKeyStrokeToAccelerator( |
| final KeyStroke keyStroke) { |
| int accelerator = 0; |
| final Iterator iterator = keyStroke.getModifierKeys().iterator(); |
| |
| while (iterator.hasNext()) { |
| final ModifierKey modifierKey = (ModifierKey) iterator.next(); |
| |
| if (modifierKey == ModifierKey.ALT) { |
| accelerator |= SWT.ALT; |
| } else if (modifierKey == ModifierKey.COMMAND) { |
| accelerator |= SWT.COMMAND; |
| } else if (modifierKey == ModifierKey.CTRL) { |
| accelerator |= SWT.CTRL; |
| } else if (modifierKey == ModifierKey.SHIFT) { |
| accelerator |= SWT.SHIFT; |
| } |
| } |
| |
| final NaturalKey naturalKey = keyStroke.getNaturalKey(); |
| |
| if (naturalKey instanceof CharacterKey) { |
| accelerator |= ((CharacterKey) naturalKey).getCharacter(); |
| } else if (naturalKey instanceof SpecialKey) { |
| final SpecialKey specialKey = (SpecialKey) naturalKey; |
| |
| if (specialKey == SpecialKey.ARROW_DOWN) { |
| accelerator |= SWT.ARROW_DOWN; |
| } else if (specialKey == SpecialKey.ARROW_LEFT) { |
| accelerator |= SWT.ARROW_LEFT; |
| } else if (specialKey == SpecialKey.ARROW_RIGHT) { |
| accelerator |= SWT.ARROW_RIGHT; |
| } else if (specialKey == SpecialKey.ARROW_UP) { |
| accelerator |= SWT.ARROW_UP; |
| } else if (specialKey == SpecialKey.END) { |
| accelerator |= SWT.END; |
| } else if (specialKey == SpecialKey.F1) { |
| accelerator |= SWT.F1; |
| } else if (specialKey == SpecialKey.F10) { |
| accelerator |= SWT.F10; |
| } else if (specialKey == SpecialKey.F11) { |
| accelerator |= SWT.F11; |
| } else if (specialKey == SpecialKey.F12) { |
| accelerator |= SWT.F12; |
| } else if (specialKey == SpecialKey.F2) { |
| accelerator |= SWT.F2; |
| } else if (specialKey == SpecialKey.F3) { |
| accelerator |= SWT.F3; |
| } else if (specialKey == SpecialKey.F4) { |
| accelerator |= SWT.F4; |
| } else if (specialKey == SpecialKey.F5) { |
| accelerator |= SWT.F5; |
| } else if (specialKey == SpecialKey.F6) { |
| accelerator |= SWT.F6; |
| } else if (specialKey == SpecialKey.F7) { |
| accelerator |= SWT.F7; |
| } else if (specialKey == SpecialKey.F8) { |
| accelerator |= SWT.F8; |
| } else if (specialKey == SpecialKey.F9) { |
| accelerator |= SWT.F9; |
| } else if (specialKey == SpecialKey.HOME) { |
| accelerator |= SWT.HOME; |
| } else if (specialKey == SpecialKey.INSERT) { |
| accelerator |= SWT.INSERT; |
| } else if (specialKey == SpecialKey.PAGE_DOWN) { |
| accelerator |= SWT.PAGE_DOWN; |
| } else if (specialKey == SpecialKey.PAGE_UP) { |
| accelerator |= SWT.PAGE_UP; |
| } |
| } |
| |
| return accelerator; |
| } |
| |
| private static final IKeyFormatter NATIVE_FORMATTER = new NativeKeyFormatter(); |
| |
| /** |
| * Provides an instance of <code>IKeyFormatter</code> appropriate for the |
| * current instance. |
| * |
| * @return an instance of <code>IKeyFormatter</code> appropriate for the |
| * current instance; never <code>null</code>. |
| */ |
| public static IKeyFormatter getKeyFormatterForPlatform() { |
| return NATIVE_FORMATTER; |
| } |
| |
| /** |
| * 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 char topKey(Event event) { |
| char character = event.character; |
| boolean ctrlDown = (event.stateMask & SWT.CTRL) != 0; |
| |
| if (ctrlDown && event.character != event.keyCode |
| && event.character < 0x20) { |
| character += 0x40; |
| } |
| |
| return character; |
| } |
| |
| /** |
| * Makes the given character uppercase if it is a letter. |
| * |
| * @param keyCode |
| * The character to convert. |
| * @return The uppercase equivalent, if any; otherwise, the character |
| * itself. |
| */ |
| private static int toUpperCase(int keyCode) { |
| // Will this key code be truncated? |
| if (keyCode > 0xFFFF) { |
| return keyCode; |
| } |
| |
| // Downcast in safety. Only make characters uppercase. |
| char character = (char) keyCode; |
| return Character.isLetter(character) ? Character.toUpperCase(character) |
| : keyCode; |
| } |
| |
| /** |
| * This class should never be instantiated. |
| */ |
| private SWTKeySupport() { |
| // This class should never be instantiated. |
| } |
| } |
