FileDocCategorySizeDatePackage
KeyEvent.javaAPI DocJava SE 6 API60172Tue Jun 10 00:25:24 BST 2008java.awt.event

KeyEvent

public class KeyEvent extends InputEvent
An event which indicates that a keystroke occurred in a component.

This low-level event is generated by a component object (such as a text field) when a key is pressed, released, or typed. The event is passed to every KeyListener or KeyAdapter object which registered to receive such events using the component's addKeyListener method. (KeyAdapter objects implement the KeyListener interface.) Each such listener object gets this KeyEvent when the event occurs.

"Key typed" events are higher-level and generally do not depend on the platform or keyboard layout. They are generated when a Unicode character is entered, and are the preferred way to find out about character input. In the simplest case, a key typed event is produced by a single key press (e.g., 'a'). Often, however, characters are produced by series of key presses (e.g., 'shift' + 'a'), and the mapping from key pressed events to key typed events may be many-to-one or many-to-many. Key releases are not usually necessary to generate a key typed event, but there are some cases where the key typed event is not generated until a key is released (e.g., entering ASCII sequences via the Alt-Numpad method in Windows). No key typed events are generated for keys that don't generate Unicode characters (e.g., action keys, modifier keys, etc.).

The getKeyChar method always returns a valid Unicode character or CHAR_UNDEFINED. Character input is reported by KEY_TYPED events: KEY_PRESSED and KEY_RELEASED events are not necessarily associated with character input. Therefore, the result of the getKeyChar method is guaranteed to be meaningful only for KEY_TYPED events.

For key pressed and key released events, the getKeyCode method returns the event's keyCode. For key typed events, the getKeyCode method always returns VK_UNDEFINED.

"Key pressed" and "key released" events are lower-level and depend on the platform and keyboard layout. They are generated whenever a key is pressed or released, and are the only way to find out about keys that don't generate character input (e.g., action keys, modifier keys, etc.). The key being pressed or released is indicated by the getKeyCode method, which returns a virtual key code.

Virtual key codes are used to report which keyboard key has been pressed, rather than a character generated by the combination of one or more keystrokes (such as "A", which comes from shift and "a").

For example, pressing the Shift key will cause a KEY_PRESSED event with a VK_SHIFT keyCode, while pressing the 'a' key will result in a VK_A keyCode. After the 'a' key is released, a KEY_RELEASED event will be fired with VK_A. Separately, a KEY_TYPED event with a keyChar value of 'A' is generated.

Pressing and releasing a key on the keyboard results in the generating the following key events (in order): 

{@code KEY_PRESSED}
{@code KEY_TYPED} (is only generated if a valid Unicode character could be generated.)
{@code KEY_RELEASED}
But in some cases (e.g. auto-repeat or input method is activated) the order could be different (and platform dependent).

Notes:

  • Key combinations which do not result in Unicode characters, such as action keys like F1 and the HELP key, do not generate KEY_TYPED events.
  • Not all keyboards or systems are capable of generating all virtual key codes. No attempt is made in Java to generate these keys artificially.
  • Virtual key codes do not identify a physical key: they depend on the platform and keyboard layout. For example, the key that generates VK_Q when using a U.S. keyboard layout will generate VK_A when using a French keyboard layout.
  • Not all characters have a keycode associated with them. For example, there is no keycode for the question mark because there is no keyboard for which it appears on the primary layer.
  • In order to support the platform-independent handling of action keys, the Java platform uses a few additional virtual key constants for functions that would otherwise have to be recognized by interpreting virtual key codes and modifiers. For example, for Japanese Windows keyboards, VK_ALL_CANDIDATES is returned instead of VK_CONVERT with the ALT modifier.
  • As specified in Focus Specification key events are dispatched to the focus owner by default.

WARNING: Aside from those keys that are defined by the Java language (VK_ENTER, VK_BACK_SPACE, and VK_TAB), do not rely on the values of the VK_ constants. Sun reserves the right to change these values as needed to accomodate a wider range of keyboards in the future.

author
Carl Quinn
author
Amy Fowler
author
Norbert Lindenberg
version
1.79 10/19/06
see
KeyAdapter
see
KeyListener
see
Tutorial: Writing a Key Listener
since
1.1

Fields Summary
private boolean
isProxyActive
Stores the state of native event dispatching system - true, if when the event was created event proxying mechanism was active - false, if it was inactive Used in Component.dispatchEventImpl to correctly dispatch events when proxy is active
public static final int
KEY_FIRST
The first number in the range of ids used for key events.
public static final int
KEY_LAST
The last number in the range of ids used for key events.
public static final int
KEY_TYPED
The "key typed" event. This event is generated when a character is entered. In the simplest case, it is produced by a single key press. Often, however, characters are produced by series of key presses, and the mapping from key pressed events to key typed events may be many-to-one or many-to-many.
public static final int
KEY_PRESSED
The "key pressed" event. This event is generated when a key is pushed down.
public static final int
KEY_RELEASED
The "key released" event. This event is generated when a key is let up.
public static final int
VK_ENTER
public static final int
VK_BACK_SPACE
public static final int
VK_TAB
public static final int
VK_CANCEL
public static final int
VK_CLEAR
public static final int
VK_SHIFT
public static final int
VK_CONTROL
public static final int
VK_ALT
public static final int
VK_PAUSE
public static final int
VK_CAPS_LOCK
public static final int
VK_ESCAPE
public static final int
VK_SPACE
public static final int
VK_PAGE_UP
public static final int
VK_PAGE_DOWN
public static final int
VK_END
public static final int
VK_HOME
public static final int
VK_LEFT
Constant for the non-numpad left arrow key.
public static final int
VK_UP
Constant for the non-numpad up arrow key.
public static final int
VK_RIGHT
Constant for the non-numpad right arrow key.
public static final int
VK_DOWN
Constant for the non-numpad down arrow key.
public static final int
VK_COMMA
Constant for the comma key, ","
public static final int
VK_MINUS
Constant for the minus key, "-"
public static final int
VK_PERIOD
Constant for the period key, "."
public static final int
VK_SLASH
Constant for the forward slash key, "/"
public static final int
VK_0
VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39)
public static final int
VK_1
public static final int
VK_2
public static final int
VK_3
public static final int
VK_4
public static final int
VK_5
public static final int
VK_6
public static final int
VK_7
public static final int
VK_8
public static final int
VK_9
public static final int
VK_SEMICOLON
Constant for the semicolon key, ";"
public static final int
VK_EQUALS
Constant for the equals key, "="
public static final int
VK_A
VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A)
public static final int
VK_B
public static final int
VK_C
public static final int
VK_D
public static final int
VK_E
public static final int
VK_F
public static final int
VK_G
public static final int
VK_H
public static final int
VK_I
public static final int
VK_J
public static final int
VK_K
public static final int
VK_L
public static final int
VK_M
public static final int
VK_N
public static final int
VK_O
public static final int
VK_P
public static final int
VK_Q
public static final int
VK_R
public static final int
VK_S
public static final int
VK_T
public static final int
VK_U
public static final int
VK_V
public static final int
VK_W
public static final int
VK_X
public static final int
VK_Y
public static final int
VK_Z
public static final int
VK_OPEN_BRACKET
Constant for the open bracket key, "["
public static final int
VK_BACK_SLASH
Constant for the back slash key, "\"
public static final int
VK_CLOSE_BRACKET
Constant for the close bracket key, "]"
public static final int
VK_NUMPAD0
public static final int
VK_NUMPAD1
public static final int
VK_NUMPAD2
public static final int
VK_NUMPAD3
public static final int
VK_NUMPAD4
public static final int
VK_NUMPAD5
public static final int
VK_NUMPAD6
public static final int
VK_NUMPAD7
public static final int
VK_NUMPAD8
public static final int
VK_NUMPAD9
public static final int
VK_MULTIPLY
public static final int
VK_ADD
public static final int
VK_SEPARATER
This constant is obsolete, and is included only for backwards compatibility.
public static final int
VK_SEPARATOR
Constant for the Numpad Separator key.
public static final int
VK_SUBTRACT
public static final int
VK_DECIMAL
public static final int
VK_DIVIDE
public static final int
VK_DELETE
public static final int
VK_NUM_LOCK
public static final int
VK_SCROLL_LOCK
public static final int
VK_F1
Constant for the F1 function key.
public static final int
VK_F2
Constant for the F2 function key.
public static final int
VK_F3
Constant for the F3 function key.
public static final int
VK_F4
Constant for the F4 function key.
public static final int
VK_F5
Constant for the F5 function key.
public static final int
VK_F6
Constant for the F6 function key.
public static final int
VK_F7
Constant for the F7 function key.
public static final int
VK_F8
Constant for the F8 function key.
public static final int
VK_F9
Constant for the F9 function key.
public static final int
VK_F10
Constant for the F10 function key.
public static final int
VK_F11
Constant for the F11 function key.
public static final int
VK_F12
Constant for the F12 function key.
public static final int
VK_F13
Constant for the F13 function key.
public static final int
VK_F14
Constant for the F14 function key.
public static final int
VK_F15
Constant for the F15 function key.
public static final int
VK_F16
Constant for the F16 function key.
public static final int
VK_F17
Constant for the F17 function key.
public static final int
VK_F18
Constant for the F18 function key.
public static final int
VK_F19
Constant for the F19 function key.
public static final int
VK_F20
Constant for the F20 function key.
public static final int
VK_F21
Constant for the F21 function key.
public static final int
VK_F22
Constant for the F22 function key.
public static final int
VK_F23
Constant for the F23 function key.
public static final int
VK_F24
Constant for the F24 function key.
public static final int
VK_PRINTSCREEN
public static final int
VK_INSERT
public static final int
VK_HELP
public static final int
VK_META
public static final int
VK_BACK_QUOTE
public static final int
VK_QUOTE
public static final int
VK_KP_UP
Constant for the numeric keypad up arrow key.
public static final int
VK_KP_DOWN
Constant for the numeric keypad down arrow key.
public static final int
VK_KP_LEFT
Constant for the numeric keypad left arrow key.
public static final int
VK_KP_RIGHT
Constant for the numeric keypad right arrow key.
public static final int
VK_DEAD_GRAVE
public static final int
VK_DEAD_ACUTE
public static final int
VK_DEAD_CIRCUMFLEX
public static final int
VK_DEAD_TILDE
public static final int
VK_DEAD_MACRON
public static final int
VK_DEAD_BREVE
public static final int
VK_DEAD_ABOVEDOT
public static final int
VK_DEAD_DIAERESIS
public static final int
VK_DEAD_ABOVERING
public static final int
VK_DEAD_DOUBLEACUTE
public static final int
VK_DEAD_CARON
public static final int
VK_DEAD_CEDILLA
public static final int
VK_DEAD_OGONEK
public static final int
VK_DEAD_IOTA
public static final int
VK_DEAD_VOICED_SOUND
public static final int
VK_DEAD_SEMIVOICED_SOUND
public static final int
VK_AMPERSAND
public static final int
VK_ASTERISK
public static final int
VK_QUOTEDBL
public static final int
VK_LESS
public static final int
VK_GREATER
public static final int
VK_BRACELEFT
public static final int
VK_BRACERIGHT
public static final int
VK_AT
Constant for the "@" key.
public static final int
VK_COLON
Constant for the ":" key.
public static final int
VK_CIRCUMFLEX
Constant for the "^" key.
public static final int
VK_DOLLAR
Constant for the "$" key.
public static final int
VK_EURO_SIGN
Constant for the Euro currency sign key.
public static final int
VK_EXCLAMATION_MARK
Constant for the "!" key.
public static final int
VK_INVERTED_EXCLAMATION_MARK
Constant for the inverted exclamation mark key.
public static final int
VK_LEFT_PARENTHESIS
Constant for the "(" key.
public static final int
VK_NUMBER_SIGN
Constant for the "#" key.
public static final int
VK_PLUS
Constant for the "+" key.
public static final int
VK_RIGHT_PARENTHESIS
Constant for the ")" key.
public static final int
VK_UNDERSCORE
Constant for the "_" key.
public static final int
VK_WINDOWS
Constant for the Microsoft Windows "Windows" key. It is used for both the left and right version of the key.
public static final int
VK_CONTEXT_MENU
Constant for the Microsoft Windows Context Menu key.
public static final int
VK_FINAL
public static final int
VK_CONVERT
Constant for the Convert function key.
public static final int
VK_NONCONVERT
Constant for the Don't Convert function key.
public static final int
VK_ACCEPT
Constant for the Accept or Commit function key.
public static final int
VK_MODECHANGE
public static final int
VK_KANA
public static final int
VK_KANJI
public static final int
VK_ALPHANUMERIC
Constant for the Alphanumeric function key.
public static final int
VK_KATAKANA
Constant for the Katakana function key.
public static final int
VK_HIRAGANA
Constant for the Hiragana function key.
public static final int
VK_FULL_WIDTH
Constant for the Full-Width Characters function key.
public static final int
VK_HALF_WIDTH
Constant for the Half-Width Characters function key.
public static final int
VK_ROMAN_CHARACTERS
Constant for the Roman Characters function key.
public static final int
VK_ALL_CANDIDATES
Constant for the All Candidates function key.
public static final int
VK_PREVIOUS_CANDIDATE
Constant for the Previous Candidate function key.
public static final int
VK_CODE_INPUT
Constant for the Code Input function key.
public static final int
VK_JAPANESE_KATAKANA
Constant for the Japanese-Katakana function key. This key switches to a Japanese input method and selects its Katakana input mode.
public static final int
VK_JAPANESE_HIRAGANA
Constant for the Japanese-Hiragana function key. This key switches to a Japanese input method and selects its Hiragana input mode.
public static final int
VK_JAPANESE_ROMAN
Constant for the Japanese-Roman function key. This key switches to a Japanese input method and selects its Roman-Direct input mode.
public static final int
VK_KANA_LOCK
Constant for the locking Kana function key. This key locks the keyboard into a Kana layout.
public static final int
VK_INPUT_METHOD_ON_OFF
Constant for the input method on/off key.
public static final int
VK_CUT
public static final int
VK_COPY
public static final int
VK_PASTE
public static final int
VK_UNDO
public static final int
VK_AGAIN
public static final int
VK_FIND
public static final int
VK_PROPS
public static final int
VK_STOP
public static final int
VK_COMPOSE
Constant for the Compose function key.
public static final int
VK_ALT_GRAPH
Constant for the AltGraph function key.
public static final int
VK_BEGIN
Constant for the Begin key.
public static final int
VK_UNDEFINED
This value is used to indicate that the keyCode is unknown. KEY_TYPED events do not have a keyCode value; this value is used instead.
public static final char
CHAR_UNDEFINED
KEY_PRESSED and KEY_RELEASED events which do not map to a valid Unicode character use this for the keyChar value.
public static final int
KEY_LOCATION_UNKNOWN
A constant indicating that the keyLocation is indeterminate or not relevant. KEY_TYPED events do not have a keyLocation; this value is used instead.
public static final int
KEY_LOCATION_STANDARD
A constant indicating that the key pressed or released is not distinguished as the left or right version of a key, and did not originate on the numeric keypad (or did not originate with a virtual key corresponding to the numeric keypad).
public static final int
KEY_LOCATION_LEFT
A constant indicating that the key pressed or released is in the left key location (there is more than one possible location for this key). Example: the left shift key.
public static final int
KEY_LOCATION_RIGHT
A constant indicating that the key pressed or released is in the right key location (there is more than one possible location for this key). Example: the right shift key.
public static final int
KEY_LOCATION_NUMPAD
A constant indicating that the key event originated on the numeric keypad or with a virtual key corresponding to the numeric keypad.
int
keyCode
The unique value assigned to each of the keys on the keyboard. There is a common set of key codes that can be fired by most keyboards. The symbolic name for a key code should be used rather than the code value itself.
char
keyChar
keyChar is a valid unicode character that is fired by a key or a key combination on a keyboard.
int
keyLocation
The location of the key on the keyboard. Some keys occur more than once on a keyboard, e.g. the left and right shift keys. Additionally, some keys occur on the numeric keypad. This variable is used to distinguish such keys. The only legal values are KEY_LOCATION_UNKNOWN, KEY_LOCATION_STANDARD, KEY_LOCATION_LEFT, KEY_LOCATION_RIGHT, and KEY_LOCATION_NUMPAD.
private static final long
serialVersionUID
Constructors Summary
private KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar, int keyLocation, boolean isProxyActive)
Constructs a KeyEvent object.

Note that passing in an invalid id results in unspecified behavior. This method throws an IllegalArgumentException if source is null.

param
source the Component that originated the event
param
id an integer identifying the type of event
param
when a long integer that specifies the time the event occurred
param
modifiers the modifier keys down during event (shift, ctrl, alt, meta) Either extended _DOWN_MASK or old _MASK modifiers should be used, but both models should not be mixed in one event. Use of the extended modifiers is preferred.
param
keyCode the integer code for an actual key, or VK_UNDEFINED (for a key-typed event)
param
keyChar the Unicode character generated by this event, or CHAR_UNDEFINED (for key-pressed and key-released events which do not map to a valid Unicode character)
param
keyLocation identifies the key location. The only legal values are KEY_LOCATION_UNKNOWN, KEY_LOCATION_STANDARD, KEY_LOCATION_LEFT, KEY_LOCATION_RIGHT, and KEY_LOCATION_NUMPAD.
throws
IllegalArgumentException if id is KEY_TYPED and keyChar is CHAR_UNDEFINED; or if id is KEY_TYPED and keyCode is not VK_UNDEFINED; or if id is KEY_TYPED and keyLocation is not KEY_LOCATION_UNKNOWN; or if keyLocation is not one of the legal values enumerated above.
throws
IllegalArgumentException if source is null
since
1.4


     
        /* ensure that the necessary native libraries are loaded */
	NativeLibLoader.loadLibraries();
        if (!GraphicsEnvironment.isHeadless()) {
            initIDs();
        }
    
        this(source, id, when, modifiers, keyCode, keyChar, keyLocation);
        this.isProxyActive = isProxyActive;
public KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar, int keyLocation)

        super(source, id, when, modifiers);
        if (id == KEY_TYPED) {
            if (keyChar == CHAR_UNDEFINED) {
                throw new IllegalArgumentException("invalid keyChar");
            }
            if (keyCode != VK_UNDEFINED) {
                throw new IllegalArgumentException("invalid keyCode");
            }
            if (keyLocation != KEY_LOCATION_UNKNOWN) {
                throw new IllegalArgumentException("invalid keyLocation");
            }
        }

        this.keyCode = keyCode;
        this.keyChar = keyChar;

        if ((keyLocation < KEY_LOCATION_UNKNOWN) ||
            (keyLocation > KEY_LOCATION_NUMPAD)) {
            throw new IllegalArgumentException("invalid keyLocation");
        }
        this.keyLocation = keyLocation;
        if ((getModifiers() != 0) && (getModifiersEx() == 0)) {
	    setNewModifiers();    
	} else if ((getModifiers() == 0) && (getModifiersEx() != 0)) {
	    setOldModifiers();
	}
public KeyEvent(Component source, int id, long when, int modifiers, int keyCode, char keyChar)
Constructs a KeyEvent object.

Note that passing in an invalid id results in unspecified behavior. This method throws an IllegalArgumentException if source is null.

param
source the Component that originated the event
param
id an integer identifying the type of event
param
when a long integer that specifies the time the event occurred
param
modifiers the modifier keys down during event (shift, ctrl, alt, meta) Either extended _DOWN_MASK or old _MASK modifiers should be used, but both models should not be mixed in one event. Use of the extended modifiers is preferred.
param
keyCode the integer code for an actual key, or VK_UNDEFINED (for a key-typed event)
param
keyChar the Unicode character generated by this event, or CHAR_UNDEFINED (for key-pressed and key-released events which do not map to a valid Unicode character)
throws
IllegalArgumentException if id is KEY_TYPED and keyChar is CHAR_UNDEFINED; or if id is KEY_TYPED and keyCode is not VK_UNDEFINED
throws
IllegalArgumentException if source is null

        this(source, id, when, modifiers, keyCode, keyChar,
          KEY_LOCATION_UNKNOWN);
public KeyEvent(Component source, int id, long when, int modifiers, int keyCode)

deprecated
as of JDK1.1

        this(source, id, when, modifiers, keyCode, (char)keyCode);
Methods Summary
public chargetKeyChar()
Returns the character associated with the key in this event. For example, the KEY_TYPED event for shift + "a" returns the value for "A".

KEY_PRESSED and KEY_RELEASED events are not intended for reporting of character input. Therefore, the values returned by this method are guaranteed to be meaningful only for KEY_TYPED events.

return
the Unicode character defined for this key event. If no valid Unicode character exists for this key event, CHAR_UNDEFINED is returned.

        return keyChar;
public intgetKeyCode()
Returns the integer keyCode associated with the key in this event.

return
the integer code for an actual key on the keyboard. (For KEY_TYPED events, the keyCode is VK_UNDEFINED.)

        return keyCode;
public intgetKeyLocation()
Returns the location of the key that originated this key event. Some keys occur more than once on a keyboard, e.g. the left and right shift keys. Additionally, some keys occur on the numeric keypad. This provides a way of distinguishing such keys.

return
the location of the key that was pressed or released. Always returns KEY_LOCATION_UNKNOWN for KEY_TYPED events.
since
1.4

        return keyLocation;
public static java.lang.StringgetKeyModifiersText(int modifiers)
Returns a String describing the modifier key(s), such as "Shift", or "Ctrl+Shift". These strings can be localized by changing the awt.properties file.

Note that InputEvent.ALT_MASK and InputEvent.BUTTON2_MASK have the same value, so the string "Alt" is returned for both modifiers. Likewise, InputEvent.META_MASK and InputEvent.BUTTON3_MASK have the same value, so the string "Meta" is returned for both modifiers.

return
string a text description of the combination of modifier keys that were held down during the event
see
InputEvent#getModifiersExText(int)

        StringBuffer buf = new StringBuffer();
        if ((modifiers & InputEvent.META_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.meta", "Meta"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.CTRL_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.control", "Ctrl"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.ALT_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.alt", "Alt"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.SHIFT_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.shift", "Shift"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.altGraph", "Alt Graph"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.BUTTON1_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.button1", "Button1"));
            buf.append("+");
        }
        if (buf.length() > 0) {
            buf.setLength(buf.length()-1); // remove trailing '+'
        }
        return buf.toString();
public static java.lang.StringgetKeyText(int keyCode)
Returns a String describing the keyCode, such as "HOME", "F1" or "A". These strings can be localized by changing the awt.properties file.

return
a string containing a text description for a physical key, identified by its keyCode

        if (keyCode >= VK_0 && keyCode <= VK_9 || 
            keyCode >= VK_A && keyCode <= VK_Z) {
            return String.valueOf((char)keyCode);
        }

        switch(keyCode) {
          case VK_ENTER: return Toolkit.getProperty("AWT.enter", "Enter");
          case VK_BACK_SPACE: return Toolkit.getProperty("AWT.backSpace", "Backspace");
          case VK_TAB: return Toolkit.getProperty("AWT.tab", "Tab");
          case VK_CANCEL: return Toolkit.getProperty("AWT.cancel", "Cancel");
          case VK_CLEAR: return Toolkit.getProperty("AWT.clear", "Clear");
          case VK_COMPOSE: return Toolkit.getProperty("AWT.compose", "Compose");
          case VK_PAUSE: return Toolkit.getProperty("AWT.pause", "Pause");
          case VK_CAPS_LOCK: return Toolkit.getProperty("AWT.capsLock", "Caps Lock");
          case VK_ESCAPE: return Toolkit.getProperty("AWT.escape", "Escape");
          case VK_SPACE: return Toolkit.getProperty("AWT.space", "Space");
          case VK_PAGE_UP: return Toolkit.getProperty("AWT.pgup", "Page Up");
          case VK_PAGE_DOWN: return Toolkit.getProperty("AWT.pgdn", "Page Down");
          case VK_END: return Toolkit.getProperty("AWT.end", "End");
          case VK_HOME: return Toolkit.getProperty("AWT.home", "Home");
          case VK_LEFT: return Toolkit.getProperty("AWT.left", "Left");
          case VK_UP: return Toolkit.getProperty("AWT.up", "Up");
          case VK_RIGHT: return Toolkit.getProperty("AWT.right", "Right");
          case VK_DOWN: return Toolkit.getProperty("AWT.down", "Down");
          case VK_BEGIN: return Toolkit.getProperty("AWT.begin", "Begin");

          // modifiers 
          case VK_SHIFT: return Toolkit.getProperty("AWT.shift", "Shift");
          case VK_CONTROL: return Toolkit.getProperty("AWT.control", "Control");
          case VK_ALT: return Toolkit.getProperty("AWT.alt", "Alt");
          case VK_META: return Toolkit.getProperty("AWT.meta", "Meta");
          case VK_ALT_GRAPH: return Toolkit.getProperty("AWT.altGraph", "Alt Graph");

          // punctuation
          case VK_COMMA: return Toolkit.getProperty("AWT.comma", "Comma");
          case VK_PERIOD: return Toolkit.getProperty("AWT.period", "Period");
          case VK_SLASH: return Toolkit.getProperty("AWT.slash", "Slash");
          case VK_SEMICOLON: return Toolkit.getProperty("AWT.semicolon", "Semicolon");
          case VK_EQUALS: return Toolkit.getProperty("AWT.equals", "Equals");
          case VK_OPEN_BRACKET: return Toolkit.getProperty("AWT.openBracket", "Open Bracket");
          case VK_BACK_SLASH: return Toolkit.getProperty("AWT.backSlash", "Back Slash");
          case VK_CLOSE_BRACKET: return Toolkit.getProperty("AWT.closeBracket", "Close Bracket");

          // numpad numeric keys handled below
          case VK_MULTIPLY: return Toolkit.getProperty("AWT.multiply", "NumPad *");
          case VK_ADD: return Toolkit.getProperty("AWT.add", "NumPad +");
          case VK_SEPARATOR: return Toolkit.getProperty("AWT.separator", "NumPad ,");
          case VK_SUBTRACT: return Toolkit.getProperty("AWT.subtract", "NumPad -");
          case VK_DECIMAL: return Toolkit.getProperty("AWT.decimal", "NumPad .");
          case VK_DIVIDE: return Toolkit.getProperty("AWT.divide", "NumPad /");
          case VK_DELETE: return Toolkit.getProperty("AWT.delete", "Delete");
          case VK_NUM_LOCK: return Toolkit.getProperty("AWT.numLock", "Num Lock");
          case VK_SCROLL_LOCK: return Toolkit.getProperty("AWT.scrollLock", "Scroll Lock");

          case VK_WINDOWS: return Toolkit.getProperty("AWT.windows", "Windows");
          case VK_CONTEXT_MENU: return Toolkit.getProperty("AWT.context", "Context Menu");

          case VK_F1: return Toolkit.getProperty("AWT.f1", "F1");
          case VK_F2: return Toolkit.getProperty("AWT.f2", "F2");
          case VK_F3: return Toolkit.getProperty("AWT.f3", "F3");
          case VK_F4: return Toolkit.getProperty("AWT.f4", "F4");
          case VK_F5: return Toolkit.getProperty("AWT.f5", "F5");
          case VK_F6: return Toolkit.getProperty("AWT.f6", "F6");
          case VK_F7: return Toolkit.getProperty("AWT.f7", "F7");
          case VK_F8: return Toolkit.getProperty("AWT.f8", "F8");
          case VK_F9: return Toolkit.getProperty("AWT.f9", "F9");
          case VK_F10: return Toolkit.getProperty("AWT.f10", "F10");
          case VK_F11: return Toolkit.getProperty("AWT.f11", "F11");
          case VK_F12: return Toolkit.getProperty("AWT.f12", "F12");
          case VK_F13: return Toolkit.getProperty("AWT.f13", "F13");
          case VK_F14: return Toolkit.getProperty("AWT.f14", "F14");
          case VK_F15: return Toolkit.getProperty("AWT.f15", "F15");
          case VK_F16: return Toolkit.getProperty("AWT.f16", "F16");
          case VK_F17: return Toolkit.getProperty("AWT.f17", "F17");
          case VK_F18: return Toolkit.getProperty("AWT.f18", "F18");
          case VK_F19: return Toolkit.getProperty("AWT.f19", "F19");
          case VK_F20: return Toolkit.getProperty("AWT.f20", "F20");
          case VK_F21: return Toolkit.getProperty("AWT.f21", "F21");
          case VK_F22: return Toolkit.getProperty("AWT.f22", "F22");
          case VK_F23: return Toolkit.getProperty("AWT.f23", "F23");
          case VK_F24: return Toolkit.getProperty("AWT.f24", "F24");

          case VK_PRINTSCREEN: return Toolkit.getProperty("AWT.printScreen", "Print Screen");
          case VK_INSERT: return Toolkit.getProperty("AWT.insert", "Insert");
          case VK_HELP: return Toolkit.getProperty("AWT.help", "Help");
          case VK_BACK_QUOTE: return Toolkit.getProperty("AWT.backQuote", "Back Quote");
          case VK_QUOTE: return Toolkit.getProperty("AWT.quote", "Quote");
			 
          case VK_KP_UP: return Toolkit.getProperty("AWT.up", "Up");
          case VK_KP_DOWN: return Toolkit.getProperty("AWT.down", "Down");
          case VK_KP_LEFT: return Toolkit.getProperty("AWT.left", "Left");
          case VK_KP_RIGHT: return Toolkit.getProperty("AWT.right", "Right");

          case VK_DEAD_GRAVE: return Toolkit.getProperty("AWT.deadGrave", "Dead Grave");
          case VK_DEAD_ACUTE: return Toolkit.getProperty("AWT.deadAcute", "Dead Acute");
          case VK_DEAD_CIRCUMFLEX: return Toolkit.getProperty("AWT.deadCircumflex", "Dead Circumflex");
          case VK_DEAD_TILDE: return Toolkit.getProperty("AWT.deadTilde", "Dead Tilde");
          case VK_DEAD_MACRON: return Toolkit.getProperty("AWT.deadMacron", "Dead Macron");
          case VK_DEAD_BREVE: return Toolkit.getProperty("AWT.deadBreve", "Dead Breve");
          case VK_DEAD_ABOVEDOT: return Toolkit.getProperty("AWT.deadAboveDot", "Dead Above Dot");
          case VK_DEAD_DIAERESIS: return Toolkit.getProperty("AWT.deadDiaeresis", "Dead Diaeresis");
          case VK_DEAD_ABOVERING: return Toolkit.getProperty("AWT.deadAboveRing", "Dead Above Ring");
          case VK_DEAD_DOUBLEACUTE: return Toolkit.getProperty("AWT.deadDoubleAcute", "Dead Double Acute");
          case VK_DEAD_CARON: return Toolkit.getProperty("AWT.deadCaron", "Dead Caron");
          case VK_DEAD_CEDILLA: return Toolkit.getProperty("AWT.deadCedilla", "Dead Cedilla");
          case VK_DEAD_OGONEK: return Toolkit.getProperty("AWT.deadOgonek", "Dead Ogonek");
          case VK_DEAD_IOTA: return Toolkit.getProperty("AWT.deadIota", "Dead Iota");
          case VK_DEAD_VOICED_SOUND: return Toolkit.getProperty("AWT.deadVoicedSound", "Dead Voiced Sound");
          case VK_DEAD_SEMIVOICED_SOUND: return Toolkit.getProperty("AWT.deadSemivoicedSound", "Dead Semivoiced Sound");

          case VK_AMPERSAND: return Toolkit.getProperty("AWT.ampersand", "Ampersand");
          case VK_ASTERISK: return Toolkit.getProperty("AWT.asterisk", "Asterisk");
          case VK_QUOTEDBL: return Toolkit.getProperty("AWT.quoteDbl", "Double Quote");
          case VK_LESS: return Toolkit.getProperty("AWT.Less", "Less");
          case VK_GREATER: return Toolkit.getProperty("AWT.greater", "Greater");
          case VK_BRACELEFT: return Toolkit.getProperty("AWT.braceLeft", "Left Brace");
          case VK_BRACERIGHT: return Toolkit.getProperty("AWT.braceRight", "Right Brace");
          case VK_AT: return Toolkit.getProperty("AWT.at", "At");
          case VK_COLON: return Toolkit.getProperty("AWT.colon", "Colon");
          case VK_CIRCUMFLEX: return Toolkit.getProperty("AWT.circumflex", "Circumflex");
          case VK_DOLLAR: return Toolkit.getProperty("AWT.dollar", "Dollar");
          case VK_EURO_SIGN: return Toolkit.getProperty("AWT.euro", "Euro");
          case VK_EXCLAMATION_MARK: return Toolkit.getProperty("AWT.exclamationMark", "Exclamation Mark");
          case VK_INVERTED_EXCLAMATION_MARK: return Toolkit.getProperty("AWT.invertedExclamationMark", "Inverted Exclamation Mark");
          case VK_LEFT_PARENTHESIS: return Toolkit.getProperty("AWT.leftParenthesis", "Left Parenthesis");
          case VK_NUMBER_SIGN: return Toolkit.getProperty("AWT.numberSign", "Number Sign");
          case VK_MINUS: return Toolkit.getProperty("AWT.minus", "Minus");
          case VK_PLUS: return Toolkit.getProperty("AWT.plus", "Plus");
          case VK_RIGHT_PARENTHESIS: return Toolkit.getProperty("AWT.rightParenthesis", "Right Parenthesis");
          case VK_UNDERSCORE: return Toolkit.getProperty("AWT.underscore", "Underscore");

          case VK_FINAL: return Toolkit.getProperty("AWT.final", "Final");
          case VK_CONVERT: return Toolkit.getProperty("AWT.convert", "Convert");
          case VK_NONCONVERT: return Toolkit.getProperty("AWT.noconvert", "No Convert");
          case VK_ACCEPT: return Toolkit.getProperty("AWT.accept", "Accept");
          case VK_MODECHANGE: return Toolkit.getProperty("AWT.modechange", "Mode Change");
	  case VK_KANA: return Toolkit.getProperty("AWT.kana", "Kana");
	  case VK_KANJI: return Toolkit.getProperty("AWT.kanji", "Kanji");
          case VK_ALPHANUMERIC: return Toolkit.getProperty("AWT.alphanumeric", "Alphanumeric");
	  case VK_KATAKANA: return Toolkit.getProperty("AWT.katakana", "Katakana");
	  case VK_HIRAGANA: return Toolkit.getProperty("AWT.hiragana", "Hiragana");
	  case VK_FULL_WIDTH: return Toolkit.getProperty("AWT.fullWidth", "Full-Width");
	  case VK_HALF_WIDTH: return Toolkit.getProperty("AWT.halfWidth", "Half-Width");
	  case VK_ROMAN_CHARACTERS: return Toolkit.getProperty("AWT.romanCharacters", "Roman Characters");
	  case VK_ALL_CANDIDATES: return Toolkit.getProperty("AWT.allCandidates", "All Candidates");
	  case VK_PREVIOUS_CANDIDATE: return Toolkit.getProperty("AWT.previousCandidate", "Previous Candidate");
	  case VK_CODE_INPUT: return Toolkit.getProperty("AWT.codeInput", "Code Input");
	  case VK_JAPANESE_KATAKANA: return Toolkit.getProperty("AWT.japaneseKatakana", "Japanese Katakana");
	  case VK_JAPANESE_HIRAGANA: return Toolkit.getProperty("AWT.japaneseHiragana", "Japanese Hiragana");
	  case VK_JAPANESE_ROMAN: return Toolkit.getProperty("AWT.japaneseRoman", "Japanese Roman");
	  case VK_KANA_LOCK: return Toolkit.getProperty("AWT.kanaLock", "Kana Lock");
	  case VK_INPUT_METHOD_ON_OFF: return Toolkit.getProperty("AWT.inputMethodOnOff", "Input Method On/Off");

          case VK_AGAIN: return Toolkit.getProperty("AWT.again", "Again");
          case VK_UNDO: return Toolkit.getProperty("AWT.undo", "Undo");
          case VK_COPY: return Toolkit.getProperty("AWT.copy", "Copy");
          case VK_PASTE: return Toolkit.getProperty("AWT.paste", "Paste");
          case VK_CUT: return Toolkit.getProperty("AWT.cut", "Cut");
          case VK_FIND: return Toolkit.getProperty("AWT.find", "Find");
          case VK_PROPS: return Toolkit.getProperty("AWT.props", "Props");
          case VK_STOP: return Toolkit.getProperty("AWT.stop", "Stop");
        }

        if (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) {
            String numpad = Toolkit.getProperty("AWT.numpad", "NumPad");
	    char c = (char)(keyCode - VK_NUMPAD0 + '0");
            return numpad + "-" + c;
        }

        String unknown = Toolkit.getProperty("AWT.unknown", "Unknown");
        return unknown + " keyCode: 0x" + Integer.toString(keyCode, 16);
private static native voidinitIDs()
Initialize JNI field and method IDs for fields that may be accessed from C.

public booleanisActionKey()
Returns whether the key in this event is an "action" key.
Typically an action key does not fire a unicode character and is
not a modifier key.
return
true if the key is an "action" key,
false otherwise
        switch (keyCode) {
          case VK_HOME:
          case VK_END:
          case VK_PAGE_UP:
          case VK_PAGE_DOWN:
          case VK_UP:
          case VK_DOWN:
          case VK_LEFT:
          case VK_RIGHT:
          case VK_BEGIN:

	  case VK_KP_LEFT: 
	  case VK_KP_UP: 
	  case VK_KP_RIGHT: 
	  case VK_KP_DOWN: 

          case VK_F1:
          case VK_F2:
          case VK_F3:
          case VK_F4:
          case VK_F5:
          case VK_F6:
          case VK_F7:
          case VK_F8:
          case VK_F9:
          case VK_F10:
          case VK_F11:
          case VK_F12:
          case VK_F13:
          case VK_F14:
          case VK_F15:
          case VK_F16:
          case VK_F17:
          case VK_F18:
          case VK_F19:
          case VK_F20:
          case VK_F21:
          case VK_F22:
          case VK_F23:
          case VK_F24:
          case VK_PRINTSCREEN:
          case VK_SCROLL_LOCK:
          case VK_CAPS_LOCK:
          case VK_NUM_LOCK:
          case VK_PAUSE:
          case VK_INSERT:

          case VK_FINAL:
          case VK_CONVERT:
          case VK_NONCONVERT:
          case VK_ACCEPT:
          case VK_MODECHANGE:
	  case VK_KANA:
	  case VK_KANJI:
          case VK_ALPHANUMERIC:
	  case VK_KATAKANA:
	  case VK_HIRAGANA:
	  case VK_FULL_WIDTH:
	  case VK_HALF_WIDTH:
	  case VK_ROMAN_CHARACTERS:
	  case VK_ALL_CANDIDATES:
	  case VK_PREVIOUS_CANDIDATE:
	  case VK_CODE_INPUT:
	  case VK_JAPANESE_KATAKANA:
	  case VK_JAPANESE_HIRAGANA:
	  case VK_JAPANESE_ROMAN:
	  case VK_KANA_LOCK:
	  case VK_INPUT_METHOD_ON_OFF:

          case VK_AGAIN:
          case VK_UNDO:
          case VK_COPY:
          case VK_PASTE:
          case VK_CUT:
          case VK_FIND:
          case VK_PROPS:
          case VK_STOP:

          case VK_HELP:
          case VK_WINDOWS:
          case VK_CONTEXT_MENU:
              return true;
        }
        return false;
    
public java.lang.StringparamString()
Returns a parameter string identifying this event.
This method is useful for event logging and for debugging.
return
a string identifying the event and its attributes
        StringBuffer str = new StringBuffer(100);

        switch (id) {
          case KEY_PRESSED:
            str.append("KEY_PRESSED");
            break;
          case KEY_RELEASED:
            str.append("KEY_RELEASED");
            break;
          case KEY_TYPED:
            str.append("KEY_TYPED");
            break;
          default:
            str.append("unknown type");
            break;
        }

        str.append(",keyCode=").append(keyCode); 
        str.append(",keyText=").append(getKeyText(keyCode));

        /* Some keychars don't print well, e.g. escape, backspace,
         * tab, return, delete, cancel.  Get keyText for the keyCode 
         * instead of the keyChar.  
         */
        str.append(",keyChar=");
        switch (keyChar) {
          case '\b":
            str.append(getKeyText(VK_BACK_SPACE));
            break;
          case '\t":
            str.append(getKeyText(VK_TAB));
            break;
          case '\n":
            str.append(getKeyText(VK_ENTER));
            break;
          case '\u0018":
            str.append(getKeyText(VK_CANCEL));
            break;
          case '\u001b":
            str.append(getKeyText(VK_ESCAPE));
            break;
          case '\u007f":
            str.append(getKeyText(VK_DELETE));
            break;
          case CHAR_UNDEFINED:
            str.append(Toolkit.getProperty("AWT.undefined", "Undefined"));
            str.append(" keyChar");
            break;
          default:
            str.append("'").append(keyChar).append("'");
            break;
        }

        if (getModifiers() != 0) {
            str.append(",modifiers=").append(getKeyModifiersText(modifiers));
        }
        if (getModifiersEx() != 0) {
            str.append(",extModifiers=").append(getModifiersExText(modifiers));
        }

        str.append(",keyLocation="); 
        switch (keyLocation) {
          case KEY_LOCATION_UNKNOWN:
            str.append("KEY_LOCATION_UNKNOWN");
            break;
          case KEY_LOCATION_STANDARD:
            str.append("KEY_LOCATION_STANDARD");
            break;
          case KEY_LOCATION_LEFT:
            str.append("KEY_LOCATION_LEFT");
            break;
          case KEY_LOCATION_RIGHT:
            str.append("KEY_LOCATION_RIGHT");
            break;
          case KEY_LOCATION_NUMPAD:
            str.append("KEY_LOCATION_NUMPAD");
            break;
          default:
            str.append("KEY_LOCATION_UNKNOWN");
            break;
        }

        return str.toString();
    
private voidreadObject(java.io.ObjectInputStream s)
Sets new modifiers by the old ones. The key modifiers
override overlaping mouse modifiers.
serial
	s.defaultReadObject();
        if (getModifiers() != 0 && getModifiersEx() == 0) {
	    setNewModifiers();    
	}
    
public voidsetKeyChar(char keyChar)
Set the keyChar value to indicate a logical character.
param
keyChar a char corresponding to to the combination of keystrokes
that make up this event.
        this.keyChar = keyChar;
    
public voidsetKeyCode(int keyCode)
Set the keyCode value to indicate a physical key.
param
keyCode an integer corresponding to an actual key on the keyboard.
        this.keyCode = keyCode;
    
public voidsetModifiers(int modifiers)
Set the modifiers to indicate additional keys that were held down
(e.g. shift, ctrl, alt, meta) defined as part of InputEvent.


NOTE: use of this method is not recommended, because many AWT
implementations do not recognize modifier changes. This is
especially true for KEY_TYPED events where the shift
modifier is changed.
param
modifiers an integer combination of the modifier constants.
see
InputEvent
deprecated
as of JDK1.1.4
        this.modifiers = modifiers;
        if ((getModifiers() != 0) && (getModifiersEx() == 0)) {
	    setNewModifiers();    
	} else if ((getModifiers() == 0) && (getModifiersEx() != 0)) {
	    setOldModifiers();
	}
    
private voidsetNewModifiers()
Sets new modifiers by the old ones. The key modifiers
override overlaping mouse modifiers.
	if ((modifiers & SHIFT_MASK) != 0) {
	    modifiers |= SHIFT_DOWN_MASK;
	}
	if ((modifiers & ALT_MASK) != 0) {
	    modifiers |= ALT_DOWN_MASK;
	}
	if ((modifiers & CTRL_MASK) != 0) {
	    modifiers |= CTRL_DOWN_MASK;
	}
	if ((modifiers & META_MASK) != 0) {
	    modifiers |= META_DOWN_MASK;
	}
	if ((modifiers & ALT_GRAPH_MASK) != 0) {
	    modifiers |= ALT_GRAPH_DOWN_MASK;
	}
	if ((modifiers & BUTTON1_MASK) != 0) {
	    modifiers |= BUTTON1_DOWN_MASK;
	}
    
private voidsetOldModifiers()
Sets old modifiers by the new ones.
	if ((modifiers & SHIFT_DOWN_MASK) != 0) {
	    modifiers |= SHIFT_MASK;
	}
	if ((modifiers & ALT_DOWN_MASK) != 0) {
	    modifiers |= ALT_MASK;
	}
	if ((modifiers & CTRL_DOWN_MASK) != 0) {
	    modifiers |= CTRL_MASK;
	}
	if ((modifiers & META_DOWN_MASK) != 0) {
	    modifiers |= META_MASK;
	}
	if ((modifiers & ALT_GRAPH_DOWN_MASK) != 0) {
	    modifiers |= ALT_GRAPH_MASK;
	}
	if ((modifiers & BUTTON1_DOWN_MASK) != 0) {
	    modifiers |= BUTTON1_MASK;
	}