-
KeyEvent
-
isProxyActive: boolean
-
KEY_FIRST: int
-
KEY_LAST: int
-
KEY_TYPED: int
-
KEY_PRESSED: int
-
KEY_RELEASED: int
-
VK_ENTER: int
-
VK_BACK_SPACE: int
-
VK_TAB: int
-
VK_CANCEL: int
-
VK_CLEAR: int
-
VK_SHIFT: int
-
VK_CONTROL: int
-
VK_ALT: int
-
VK_PAUSE: int
-
VK_CAPS_LOCK: int
-
VK_ESCAPE: int
-
VK_SPACE: int
-
VK_PAGE_UP: int
-
VK_PAGE_DOWN: int
-
VK_END: int
-
VK_HOME: int
-
VK_LEFT: int
-
VK_UP: int
-
VK_RIGHT: int
-
VK_DOWN: int
-
VK_COMMA: int
-
VK_MINUS: int
-
VK_PERIOD: int
-
VK_SLASH: int
-
VK_0: int
-
VK_1: int
-
VK_2: int
-
VK_3: int
-
VK_4: int
-
VK_5: int
-
VK_6: int
-
VK_7: int
-
VK_8: int
-
VK_9: int
-
VK_SEMICOLON: int
-
VK_EQUALS: int
-
VK_A: int
-
VK_B: int
-
VK_C: int
-
VK_D: int
-
VK_E: int
-
VK_F: int
-
VK_G: int
-
VK_H: int
-
VK_I: int
-
VK_J: int
-
VK_K: int
-
VK_L: int
-
VK_M: int
-
VK_N: int
-
VK_O: int
-
VK_P: int
-
VK_Q: int
-
VK_R: int
-
VK_S: int
-
VK_T: int
-
VK_U: int
-
VK_V: int
-
VK_W: int
-
VK_X: int
-
VK_Y: int
-
VK_Z: int
-
VK_OPEN_BRACKET: int
-
VK_BACK_SLASH: int
-
VK_CLOSE_BRACKET: int
-
VK_NUMPAD0: int
-
VK_NUMPAD1: int
-
VK_NUMPAD2: int
-
VK_NUMPAD3: int
-
VK_NUMPAD4: int
-
VK_NUMPAD5: int
-
VK_NUMPAD6: int
-
VK_NUMPAD7: int
-
VK_NUMPAD8: int
-
VK_NUMPAD9: int
-
VK_MULTIPLY: int
-
VK_ADD: int
-
VK_SEPARATER: int
-
VK_SEPARATOR: int
-
VK_SUBTRACT: int
-
VK_DECIMAL: int
-
VK_DIVIDE: int
-
VK_DELETE: int
-
VK_NUM_LOCK: int
-
VK_SCROLL_LOCK: int
-
VK_F1: int
-
VK_F2: int
-
VK_F3: int
-
VK_F4: int
-
VK_F5: int
-
VK_F6: int
-
VK_F7: int
-
VK_F8: int
-
VK_F9: int
-
VK_F10: int
-
VK_F11: int
-
VK_F12: int
-
VK_F13: int
-
VK_F14: int
-
VK_F15: int
-
VK_F16: int
-
VK_F17: int
-
VK_F18: int
-
VK_F19: int
-
VK_F20: int
-
VK_F21: int
-
VK_F22: int
-
VK_F23: int
-
VK_F24: int
-
VK_PRINTSCREEN: int
-
VK_INSERT: int
-
VK_HELP: int
-
VK_META: int
-
VK_BACK_QUOTE: int
-
VK_QUOTE: int
-
VK_KP_UP: int
-
VK_KP_DOWN: int
-
VK_KP_LEFT: int
-
VK_KP_RIGHT: int
-
VK_DEAD_GRAVE: int
-
VK_DEAD_ACUTE: int
-
VK_DEAD_CIRCUMFLEX: int
-
VK_DEAD_TILDE: int
-
VK_DEAD_MACRON: int
-
VK_DEAD_BREVE: int
-
VK_DEAD_ABOVEDOT: int
-
VK_DEAD_DIAERESIS: int
-
VK_DEAD_ABOVERING: int
-
VK_DEAD_DOUBLEACUTE: int
-
VK_DEAD_CARON: int
-
VK_DEAD_CEDILLA: int
-
VK_DEAD_OGONEK: int
-
VK_DEAD_IOTA: int
-
VK_DEAD_VOICED_SOUND: int
-
VK_DEAD_SEMIVOICED_SOUND: int
-
VK_AMPERSAND: int
-
VK_ASTERISK: int
-
VK_QUOTEDBL: int
-
VK_LESS: int
-
VK_GREATER: int
-
VK_BRACELEFT: int
-
VK_BRACERIGHT: int
-
VK_AT: int
-
VK_COLON: int
-
VK_CIRCUMFLEX: int
-
VK_DOLLAR: int
-
VK_EURO_SIGN: int
-
VK_EXCLAMATION_MARK: int
-
VK_INVERTED_EXCLAMATION_MARK: int
-
VK_LEFT_PARENTHESIS: int
-
VK_NUMBER_SIGN: int
-
VK_PLUS: int
-
VK_RIGHT_PARENTHESIS: int
-
VK_UNDERSCORE: int
-
VK_WINDOWS: int
-
VK_CONTEXT_MENU: int
-
VK_FINAL: int
-
VK_CONVERT: int
-
VK_NONCONVERT: int
-
VK_ACCEPT: int
-
VK_MODECHANGE: int
-
VK_KANA: int
-
VK_KANJI: int
-
VK_ALPHANUMERIC: int
-
VK_KATAKANA: int
-
VK_HIRAGANA: int
-
VK_FULL_WIDTH: int
-
VK_HALF_WIDTH: int
-
VK_ROMAN_CHARACTERS: int
-
VK_ALL_CANDIDATES: int
-
VK_PREVIOUS_CANDIDATE: int
-
VK_CODE_INPUT: int
-
VK_JAPANESE_KATAKANA: int
-
VK_JAPANESE_HIRAGANA: int
-
VK_JAPANESE_ROMAN: int
-
VK_KANA_LOCK: int
-
VK_INPUT_METHOD_ON_OFF: int
-
VK_CUT: int
-
VK_COPY: int
-
VK_PASTE: int
-
VK_UNDO: int
-
VK_AGAIN: int
-
VK_FIND: int
-
VK_PROPS: int
-
VK_STOP: int
-
VK_COMPOSE: int
-
VK_ALT_GRAPH: int
-
VK_BEGIN: int
-
VK_UNDEFINED: int
-
CHAR_UNDEFINED: char
-
KEY_LOCATION_UNKNOWN: int
-
KEY_LOCATION_STANDARD: int
-
KEY_LOCATION_LEFT: int
-
KEY_LOCATION_RIGHT: int
-
KEY_LOCATION_NUMPAD: int
-
keyCode: int
-
keyChar: char
-
keyLocation: int
-
rawCode: long
-
primaryLevelUnicode: long
-
scancode: long
-
extendedKeyCode: long
-
serialVersionUID: long
-
static class initializer
-
$1
-
initIDs(): void
-
originalSource: Component
-
KeyEvent(Component, int, long, int, int, char, int, boolean): void
-
KeyEvent(Component, int, long, int, int, char, int): void
-
KeyEvent(Component, int, long, int, int, char): void
-
KeyEvent(Component, int, long, int, int): void
-
getKeyCode(): int
-
setKeyCode(int): void
-
getKeyChar(): char
-
setKeyChar(char): void
-
setModifiers(int): void
-
getKeyLocation(): int
-
getKeyText(int): String
-
getKeyModifiersText(int): String
-
isActionKey(): boolean
-
paramString(): String
-
getExtendedKeyCode(): int
-
getExtendedKeyCodeForChar(int): int
-
setNewModifiers(): void
-
setOldModifiers(): void
-
readObject(ObjectInputStream): void
-
/*
* Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.awt.event;
import java.awt.Component;
import java.awt.GraphicsEnvironment;
import java.awt.Toolkit;
import java.io.IOException;
import java.io.ObjectInputStream;
import sun.awt.AWTAccessor;
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. The getExtendedKeyCode method may also be used with many international keyboard layouts.
"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 and getExtendedKeyCode methods, which return 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):
KEY_PRESSED KEY_TYPED (is only generated if a valid Unicode character could be generated.) 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.
- The key that generates
VK_Q when using a U.S. keyboard layout also generates a unique code for Russian or Hebrew layout. There is no a VK_ constant for these and many other codes in various layouts. These codes may be obtained by using getExtendedKeyCode and are used whenever a VK_ constant is used. - 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. The platform steward reserves the right to change these values as needed
to accommodate a wider range of keyboards in the future.
An unspecified behavior will be caused if the id parameter of any particular KeyEvent instance is not in the range from KEY_FIRST to KEY_LAST.
Author: Carl Quinn, Amy Fowler, Norbert Lindenberg See Also: Since: 1.1
/**
* An event which indicates that a keystroke occurred in a component.
* <p>
* 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 {@code KeyListener}
* or {@code KeyAdapter} object which registered to receive such
* events using the component's {@code addKeyListener} method.
* ({@code KeyAdapter} objects implement the
* {@code KeyListener} interface.) Each such listener object
* gets this {@code KeyEvent} when the event occurs.
* <p>
* <em>"Key typed" events</em> 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.).
* <p>
* 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.
* <p>
* For key pressed and key released events, the getKeyCode method returns
* the event's keyCode. For key typed events, the getKeyCode method
* always returns {@code VK_UNDEFINED}. The {@code getExtendedKeyCode} method
* may also be used with many international keyboard layouts.
*
* <p>
* <em>"Key pressed" and "key released" events</em> 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 {@code getKeyCode} and {@code getExtendedKeyCode}
* methods, which return a virtual key code.
*
* <p>
* <em>Virtual key codes</em> 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").
*
* <p>
* 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.
*
* <p>
* Pressing and releasing a key on the keyboard results in the generating
* the following key events (in order):
* <PRE>
* {@code KEY_PRESSED}
* {@code KEY_TYPED} (is only generated if a valid Unicode character could be generated.)
* {@code KEY_RELEASED}
* </PRE>
*
* But in some cases (e.g. auto-repeat or input method is activated) the order
* could be different (and platform dependent).
*
* <p>
* Notes:
* <ul>
* <li>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.
* <li>Not all keyboards or systems are capable of generating all
* virtual key codes. No attempt is made in Java to generate these keys
* artificially.
* <li>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.
* <li>The key that generates {@code VK_Q} when using a U.S. keyboard layout also
* generates a unique code for Russian or Hebrew layout. There is no a
* {@code VK_} constant for these and many other codes in various layouts. These codes
* may be obtained by using {@code getExtendedKeyCode} and are used whenever
* a {@code VK_} constant is used.
* <li>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.
* <li>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.
* <li>As specified in <a href="../doc-files/FocusSpec.html">Focus Specification</a>
* key events are dispatched to the focus owner by default.
* </ul>
*
* <p>
* 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. The platform steward reserves the right to change these values as needed
* to accommodate a wider range of keyboards in the future.
* <p>
* An unspecified behavior will be caused if the {@code id} parameter
* of any particular {@code KeyEvent} instance is not
* in the range from {@code KEY_FIRST} to {@code KEY_LAST}.
*
* @author Carl Quinn
* @author Amy Fowler
* @author Norbert Lindenberg
*
* @see KeyAdapter
* @see KeyListener
* @see <a href="http://docs.oracle.com/javase/tutorial/uiswing/events/keylistener.html">Tutorial: Writing a Key Listener</a>
*
* @since 1.1
*/
public class KeyEvent extends InputEvent {
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
/**
* 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
*/
private boolean isProxyActive = false;
The first number in the range of ids used for key events.
/**
* The first number in the range of ids used for key events.
*/
public static final int KEY_FIRST = 400;
The last number in the range of ids used for key events.
/**
* The last number in the range of ids used for key events.
*/
public static final int KEY_LAST = 402;
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.
/**
* 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_TYPED = KEY_FIRST;
The "key pressed" event. This event is generated when a key
is pushed down.
/**
* The "key pressed" event. This event is generated when a key
* is pushed down.
*/
public static final int KEY_PRESSED = 1 + KEY_FIRST; //Event.KEY_PRESS
The "key released" event. This event is generated when a key
is let up.
/**
* The "key released" event. This event is generated when a key
* is let up.
*/
public static final int KEY_RELEASED = 2 + KEY_FIRST; //Event.KEY_RELEASE
/* Virtual key codes. */
Constant for the ENTER virtual key. /** Constant for the ENTER virtual key. */
public static final int VK_ENTER = '\n';
Constant for the BACK_SPACE virtual key. /** Constant for the BACK_SPACE virtual key. */
public static final int VK_BACK_SPACE = '\b';
Constant for the TAB virtual key. /** Constant for the TAB virtual key. */
public static final int VK_TAB = '\t';
Constant for the CANCEL virtual key. /** Constant for the CANCEL virtual key. */
public static final int VK_CANCEL = 0x03;
Constant for the CLEAR virtual key. /** Constant for the CLEAR virtual key. */
public static final int VK_CLEAR = 0x0C;
Constant for the SHIFT virtual key. /** Constant for the SHIFT virtual key. */
public static final int VK_SHIFT = 0x10;
Constant for the CONTROL virtual key. /** Constant for the CONTROL virtual key. */
public static final int VK_CONTROL = 0x11;
Constant for the ALT virtual key. /** Constant for the ALT virtual key. */
public static final int VK_ALT = 0x12;
Constant for the PAUSE virtual key. /** Constant for the PAUSE virtual key. */
public static final int VK_PAUSE = 0x13;
Constant for the CAPS_LOCK virtual key. /** Constant for the CAPS_LOCK virtual key. */
public static final int VK_CAPS_LOCK = 0x14;
Constant for the ESCAPE virtual key. /** Constant for the ESCAPE virtual key. */
public static final int VK_ESCAPE = 0x1B;
Constant for the SPACE virtual key. /** Constant for the SPACE virtual key. */
public static final int VK_SPACE = 0x20;
Constant for the PAGE_UP virtual key. /** Constant for the PAGE_UP virtual key. */
public static final int VK_PAGE_UP = 0x21;
Constant for the PAGE_DOWN virtual key. /** Constant for the PAGE_DOWN virtual key. */
public static final int VK_PAGE_DOWN = 0x22;
Constant for the END virtual key. /** Constant for the END virtual key. */
public static final int VK_END = 0x23;
Constant for the HOME virtual key. /** Constant for the HOME virtual key. */
public static final int VK_HOME = 0x24;
Constant for the non-numpad left arrow key.
See Also: - VK_KP_LEFT
/**
* Constant for the non-numpad <b>left</b> arrow key.
* @see #VK_KP_LEFT
*/
public static final int VK_LEFT = 0x25;
Constant for the non-numpad up arrow key.
See Also: - VK_KP_UP
/**
* Constant for the non-numpad <b>up</b> arrow key.
* @see #VK_KP_UP
*/
public static final int VK_UP = 0x26;
Constant for the non-numpad right arrow key.
See Also: - VK_KP_RIGHT
/**
* Constant for the non-numpad <b>right</b> arrow key.
* @see #VK_KP_RIGHT
*/
public static final int VK_RIGHT = 0x27;
Constant for the non-numpad down arrow key.
See Also: - VK_KP_DOWN
/**
* Constant for the non-numpad <b>down</b> arrow key.
* @see #VK_KP_DOWN
*/
public static final int VK_DOWN = 0x28;
Constant for the comma key, ","
/**
* Constant for the comma key, ","
*/
public static final int VK_COMMA = 0x2C;
Constant for the minus key, "-"
Since: 1.2
/**
* Constant for the minus key, "-"
* @since 1.2
*/
public static final int VK_MINUS = 0x2D;
Constant for the period key, "."
/**
* Constant for the period key, "."
*/
public static final int VK_PERIOD = 0x2E;
Constant for the forward slash key, "/"
/**
* Constant for the forward slash key, "/"
*/
public static final int VK_SLASH = 0x2F;
/** VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
Constant for the "0" key. /** Constant for the "0" key. */
public static final int VK_0 = 0x30;
Constant for the "1" key. /** Constant for the "1" key. */
public static final int VK_1 = 0x31;
Constant for the "2" key. /** Constant for the "2" key. */
public static final int VK_2 = 0x32;
Constant for the "3" key. /** Constant for the "3" key. */
public static final int VK_3 = 0x33;
Constant for the "4" key. /** Constant for the "4" key. */
public static final int VK_4 = 0x34;
Constant for the "5" key. /** Constant for the "5" key. */
public static final int VK_5 = 0x35;
Constant for the "6" key. /** Constant for the "6" key. */
public static final int VK_6 = 0x36;
Constant for the "7" key. /** Constant for the "7" key. */
public static final int VK_7 = 0x37;
Constant for the "8" key. /** Constant for the "8" key. */
public static final int VK_8 = 0x38;
Constant for the "9" key. /** Constant for the "9" key. */
public static final int VK_9 = 0x39;
Constant for the semicolon key, ";"
/**
* Constant for the semicolon key, ";"
*/
public static final int VK_SEMICOLON = 0x3B;
Constant for the equals key, "="
/**
* Constant for the equals key, "="
*/
public static final int VK_EQUALS = 0x3D;
/** VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
Constant for the "A" key. /** Constant for the "A" key. */
public static final int VK_A = 0x41;
Constant for the "B" key. /** Constant for the "B" key. */
public static final int VK_B = 0x42;
Constant for the "C" key. /** Constant for the "C" key. */
public static final int VK_C = 0x43;
Constant for the "D" key. /** Constant for the "D" key. */
public static final int VK_D = 0x44;
Constant for the "E" key. /** Constant for the "E" key. */
public static final int VK_E = 0x45;
Constant for the "F" key. /** Constant for the "F" key. */
public static final int VK_F = 0x46;
Constant for the "G" key. /** Constant for the "G" key. */
public static final int VK_G = 0x47;
Constant for the "H" key. /** Constant for the "H" key. */
public static final int VK_H = 0x48;
Constant for the "I" key. /** Constant for the "I" key. */
public static final int VK_I = 0x49;
Constant for the "J" key. /** Constant for the "J" key. */
public static final int VK_J = 0x4A;
Constant for the "K" key. /** Constant for the "K" key. */
public static final int VK_K = 0x4B;
Constant for the "L" key. /** Constant for the "L" key. */
public static final int VK_L = 0x4C;
Constant for the "M" key. /** Constant for the "M" key. */
public static final int VK_M = 0x4D;
Constant for the "N" key. /** Constant for the "N" key. */
public static final int VK_N = 0x4E;
Constant for the "O" key. /** Constant for the "O" key. */
public static final int VK_O = 0x4F;
Constant for the "P" key. /** Constant for the "P" key. */
public static final int VK_P = 0x50;
Constant for the "Q" key. /** Constant for the "Q" key. */
public static final int VK_Q = 0x51;
Constant for the "R" key. /** Constant for the "R" key. */
public static final int VK_R = 0x52;
Constant for the "S" key. /** Constant for the "S" key. */
public static final int VK_S = 0x53;
Constant for the "T" key. /** Constant for the "T" key. */
public static final int VK_T = 0x54;
Constant for the "U" key. /** Constant for the "U" key. */
public static final int VK_U = 0x55;
Constant for the "V" key. /** Constant for the "V" key. */
public static final int VK_V = 0x56;
Constant for the "W" key. /** Constant for the "W" key. */
public static final int VK_W = 0x57;
Constant for the "X" key. /** Constant for the "X" key. */
public static final int VK_X = 0x58;
Constant for the "Y" key. /** Constant for the "Y" key. */
public static final int VK_Y = 0x59;
Constant for the "Z" key. /** Constant for the "Z" key. */
public static final int VK_Z = 0x5A;
Constant for the open bracket key, "["
/**
* Constant for the open bracket key, "["
*/
public static final int VK_OPEN_BRACKET = 0x5B;
Constant for the back slash key, "\"
/**
* Constant for the back slash key, "\"
*/
public static final int VK_BACK_SLASH = 0x5C;
Constant for the close bracket key, "]"
/**
* Constant for the close bracket key, "]"
*/
public static final int VK_CLOSE_BRACKET = 0x5D;
Constant for the number pad "0" key. /** Constant for the number pad "0" key. */
public static final int VK_NUMPAD0 = 0x60;
Constant for the number pad "1" key. /** Constant for the number pad "1" key. */
public static final int VK_NUMPAD1 = 0x61;
Constant for the number pad "2" key. /** Constant for the number pad "2" key. */
public static final int VK_NUMPAD2 = 0x62;
Constant for the number pad "3" key. /** Constant for the number pad "3" key. */
public static final int VK_NUMPAD3 = 0x63;
Constant for the number pad "4" key. /** Constant for the number pad "4" key. */
public static final int VK_NUMPAD4 = 0x64;
Constant for the number pad "5" key. /** Constant for the number pad "5" key. */
public static final int VK_NUMPAD5 = 0x65;
Constant for the number pad "6" key. /** Constant for the number pad "6" key. */
public static final int VK_NUMPAD6 = 0x66;
Constant for the number pad "7" key. /** Constant for the number pad "7" key. */
public static final int VK_NUMPAD7 = 0x67;
Constant for the number pad "8" key. /** Constant for the number pad "8" key. */
public static final int VK_NUMPAD8 = 0x68;
Constant for the number pad "9" key. /** Constant for the number pad "9" key. */
public static final int VK_NUMPAD9 = 0x69;
Constant for the number pad multiply key. /** Constant for the number pad multiply key. */
public static final int VK_MULTIPLY = 0x6A;
Constant for the number pad add key. /** Constant for the number pad add key. */
public static final int VK_ADD = 0x6B;
This constant is obsolete, and is included only for backwards
compatibility.
See Also: - VK_SEPARATOR
/**
* This constant is obsolete, and is included only for backwards
* compatibility.
* @see #VK_SEPARATOR
*/
public static final int VK_SEPARATER = 0x6C;
Constant for the Numpad Separator key.
Since: 1.4
/**
* Constant for the Numpad Separator key.
* @since 1.4
*/
public static final int VK_SEPARATOR = VK_SEPARATER;
Constant for the number pad subtract key. /** Constant for the number pad subtract key. */
public static final int VK_SUBTRACT = 0x6D;
Constant for the number pad decimal point key. /** Constant for the number pad decimal point key. */
public static final int VK_DECIMAL = 0x6E;
Constant for the number pad divide key. /** Constant for the number pad divide key. */
public static final int VK_DIVIDE = 0x6F;
Constant for the delete key. /** Constant for the delete key. */
public static final int VK_DELETE = 0x7F; /* ASCII DEL */
Constant for the NUM_LOCK key. /** Constant for the NUM_LOCK key. */
public static final int VK_NUM_LOCK = 0x90;
Constant for the SCROLL_LOCK key. /** Constant for the SCROLL_LOCK key. */
public static final int VK_SCROLL_LOCK = 0x91;
Constant for the F1 function key. /** Constant for the F1 function key. */
public static final int VK_F1 = 0x70;
Constant for the F2 function key. /** Constant for the F2 function key. */
public static final int VK_F2 = 0x71;
Constant for the F3 function key. /** Constant for the F3 function key. */
public static final int VK_F3 = 0x72;
Constant for the F4 function key. /** Constant for the F4 function key. */
public static final int VK_F4 = 0x73;
Constant for the F5 function key. /** Constant for the F5 function key. */
public static final int VK_F5 = 0x74;
Constant for the F6 function key. /** Constant for the F6 function key. */
public static final int VK_F6 = 0x75;
Constant for the F7 function key. /** Constant for the F7 function key. */
public static final int VK_F7 = 0x76;
Constant for the F8 function key. /** Constant for the F8 function key. */
public static final int VK_F8 = 0x77;
Constant for the F9 function key. /** Constant for the F9 function key. */
public static final int VK_F9 = 0x78;
Constant for the F10 function key. /** Constant for the F10 function key. */
public static final int VK_F10 = 0x79;
Constant for the F11 function key. /** Constant for the F11 function key. */
public static final int VK_F11 = 0x7A;
Constant for the F12 function key. /** Constant for the F12 function key. */
public static final int VK_F12 = 0x7B;
Constant for the F13 function key.
Since: 1.2
/**
* Constant for the F13 function key.
* @since 1.2
*/
/* F13 - F24 are used on IBM 3270 keyboard; use random range for constants. */
public static final int VK_F13 = 0xF000;
Constant for the F14 function key.
Since: 1.2
/**
* Constant for the F14 function key.
* @since 1.2
*/
public static final int VK_F14 = 0xF001;
Constant for the F15 function key.
Since: 1.2
/**
* Constant for the F15 function key.
* @since 1.2
*/
public static final int VK_F15 = 0xF002;
Constant for the F16 function key.
Since: 1.2
/**
* Constant for the F16 function key.
* @since 1.2
*/
public static final int VK_F16 = 0xF003;
Constant for the F17 function key.
Since: 1.2
/**
* Constant for the F17 function key.
* @since 1.2
*/
public static final int VK_F17 = 0xF004;
Constant for the F18 function key.
Since: 1.2
/**
* Constant for the F18 function key.
* @since 1.2
*/
public static final int VK_F18 = 0xF005;
Constant for the F19 function key.
Since: 1.2
/**
* Constant for the F19 function key.
* @since 1.2
*/
public static final int VK_F19 = 0xF006;
Constant for the F20 function key.
Since: 1.2
/**
* Constant for the F20 function key.
* @since 1.2
*/
public static final int VK_F20 = 0xF007;
Constant for the F21 function key.
Since: 1.2
/**
* Constant for the F21 function key.
* @since 1.2
*/
public static final int VK_F21 = 0xF008;
Constant for the F22 function key.
Since: 1.2
/**
* Constant for the F22 function key.
* @since 1.2
*/
public static final int VK_F22 = 0xF009;
Constant for the F23 function key.
Since: 1.2
/**
* Constant for the F23 function key.
* @since 1.2
*/
public static final int VK_F23 = 0xF00A;
Constant for the F24 function key.
Since: 1.2
/**
* Constant for the F24 function key.
* @since 1.2
*/
public static final int VK_F24 = 0xF00B;
Constant for the PRINTSCREEN key. /** Constant for the PRINTSCREEN key. */
public static final int VK_PRINTSCREEN = 0x9A;
Constant for the INSERT key. /** Constant for the INSERT key. */
public static final int VK_INSERT = 0x9B;
Constant for the HELP key. /** Constant for the HELP key. */
public static final int VK_HELP = 0x9C;
Constant for the META key. /** Constant for the META key. */
public static final int VK_META = 0x9D;
Constant for the BACK_QUOTE key. /** Constant for the BACK_QUOTE key. */
public static final int VK_BACK_QUOTE = 0xC0;
Constant for the QUOTE key. /** Constant for the QUOTE key. */
public static final int VK_QUOTE = 0xDE;
Constant for the numeric keypad up arrow key.
See Also: - VK_UP
Since: 1.2
/**
* Constant for the numeric keypad <b>up</b> arrow key.
* @see #VK_UP
* @since 1.2
*/
public static final int VK_KP_UP = 0xE0;
Constant for the numeric keypad down arrow key.
See Also: - VK_DOWN
Since: 1.2
/**
* Constant for the numeric keypad <b>down</b> arrow key.
* @see #VK_DOWN
* @since 1.2
*/
public static final int VK_KP_DOWN = 0xE1;
Constant for the numeric keypad left arrow key.
See Also: - VK_LEFT
Since: 1.2
/**
* Constant for the numeric keypad <b>left</b> arrow key.
* @see #VK_LEFT
* @since 1.2
*/
public static final int VK_KP_LEFT = 0xE2;
Constant for the numeric keypad right arrow key.
See Also: - VK_RIGHT
Since: 1.2
/**
* Constant for the numeric keypad <b>right</b> arrow key.
* @see #VK_RIGHT
* @since 1.2
*/
public static final int VK_KP_RIGHT = 0xE3;
/* For European keyboards */
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_GRAVE = 0x80;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_ACUTE = 0x81;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_CIRCUMFLEX = 0x82;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_TILDE = 0x83;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_MACRON = 0x84;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_BREVE = 0x85;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_ABOVEDOT = 0x86;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_DIAERESIS = 0x87;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_ABOVERING = 0x88;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_DOUBLEACUTE = 0x89;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_CARON = 0x8a;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_CEDILLA = 0x8b;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_OGONEK = 0x8c;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_IOTA = 0x8d;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_VOICED_SOUND = 0x8e;
Since: 1.2
/** @since 1.2 */
public static final int VK_DEAD_SEMIVOICED_SOUND = 0x8f;
Since: 1.2
/** @since 1.2 */
public static final int VK_AMPERSAND = 0x96;
Since: 1.2
/** @since 1.2 */
public static final int VK_ASTERISK = 0x97;
Since: 1.2
/** @since 1.2 */
public static final int VK_QUOTEDBL = 0x98;
Since: 1.2
/** @since 1.2 */
public static final int VK_LESS = 0x99;
Since: 1.2
/** @since 1.2 */
public static final int VK_GREATER = 0xa0;
Since: 1.2
/** @since 1.2 */
public static final int VK_BRACELEFT = 0xa1;
Since: 1.2
/** @since 1.2 */
public static final int VK_BRACERIGHT = 0xa2;
Constant for the "@" key.
Since: 1.2
/**
* Constant for the "@" key.
* @since 1.2
*/
public static final int VK_AT = 0x0200;
Constant for the ":" key.
Since: 1.2
/**
* Constant for the ":" key.
* @since 1.2
*/
public static final int VK_COLON = 0x0201;
Constant for the "^" key.
Since: 1.2
/**
* Constant for the "^" key.
* @since 1.2
*/
public static final int VK_CIRCUMFLEX = 0x0202;
Constant for the "$" key.
Since: 1.2
/**
* Constant for the "$" key.
* @since 1.2
*/
public static final int VK_DOLLAR = 0x0203;
Constant for the Euro currency sign key.
Since: 1.2
/**
* Constant for the Euro currency sign key.
* @since 1.2
*/
public static final int VK_EURO_SIGN = 0x0204;
Constant for the "!" key.
Since: 1.2
/**
* Constant for the "!" key.
* @since 1.2
*/
public static final int VK_EXCLAMATION_MARK = 0x0205;
Constant for the inverted exclamation mark key.
Since: 1.2
/**
* Constant for the inverted exclamation mark key.
* @since 1.2
*/
public static final int VK_INVERTED_EXCLAMATION_MARK = 0x0206;
Constant for the "(" key.
Since: 1.2
/**
* Constant for the "(" key.
* @since 1.2
*/
public static final int VK_LEFT_PARENTHESIS = 0x0207;
Constant for the "#" key.
Since: 1.2
/**
* Constant for the "#" key.
* @since 1.2
*/
public static final int VK_NUMBER_SIGN = 0x0208;
Constant for the "+" key.
Since: 1.2
/**
* Constant for the "+" key.
* @since 1.2
*/
public static final int VK_PLUS = 0x0209;
Constant for the ")" key.
Since: 1.2
/**
* Constant for the ")" key.
* @since 1.2
*/
public static final int VK_RIGHT_PARENTHESIS = 0x020A;
Constant for the "_" key.
Since: 1.2
/**
* Constant for the "_" key.
* @since 1.2
*/
public static final int VK_UNDERSCORE = 0x020B;
Constant for the Microsoft Windows "Windows" key.
It is used for both the left and right version of the key.
See Also: - getKeyLocation()
Since: 1.5
/**
* Constant for the Microsoft Windows "Windows" key.
* It is used for both the left and right version of the key.
* @see #getKeyLocation()
* @since 1.5
*/
public static final int VK_WINDOWS = 0x020C;
Constant for the Microsoft Windows Context Menu key.
Since: 1.5
/**
* Constant for the Microsoft Windows Context Menu key.
* @since 1.5
*/
public static final int VK_CONTEXT_MENU = 0x020D;
/* for input method support on Asian Keyboards */
/* not clear what this means - listed in Microsoft Windows API */
Constant for the FINAL key. /** Constant for the FINAL key. */
public static final int VK_FINAL = 0x0018;
Constant for the Convert function key. /** Constant for the Convert function key. */
/* Japanese PC 106 keyboard, Japanese Solaris keyboard: henkan */
public static final int VK_CONVERT = 0x001C;
Constant for the Don't Convert function key. /** Constant for the Don't Convert function key. */
/* Japanese PC 106 keyboard: muhenkan */
public static final int VK_NONCONVERT = 0x001D;
Constant for the Accept or Commit function key. /** Constant for the Accept or Commit function key. */
/* Japanese Solaris keyboard: kakutei */
public static final int VK_ACCEPT = 0x001E;
/* not clear what this means - listed in Microsoft Windows API */
Constant for the MODECHANGE key. /** Constant for the MODECHANGE key. */
public static final int VK_MODECHANGE = 0x001F;
/* replaced by VK_KANA_LOCK for Microsoft Windows and Solaris;
might still be used on other platforms */
Constant for the KANA lock key.
See Also: - VK_KANA_LOCK
/**
* Constant for the KANA lock key.
* @see #VK_KANA_LOCK
**/
public static final int VK_KANA = 0x0015;
/* replaced by VK_INPUT_METHOD_ON_OFF for Microsoft Windows and Solaris;
might still be used for other platforms */
Constant for KANJI.
See Also: - VK_INPUT_METHOD_ON_OFF
/**
* Constant for KANJI.
* @see #VK_INPUT_METHOD_ON_OFF
*/
public static final int VK_KANJI = 0x0019;
Constant for the Alphanumeric function key.
Since: 1.2
/**
* Constant for the Alphanumeric function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard: eisuu */
public static final int VK_ALPHANUMERIC = 0x00F0;
Constant for the Katakana function key.
Since: 1.2
/**
* Constant for the Katakana function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard: katakana */
public static final int VK_KATAKANA = 0x00F1;
Constant for the Hiragana function key.
Since: 1.2
/**
* Constant for the Hiragana function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard: hiragana */
public static final int VK_HIRAGANA = 0x00F2;
Constant for the Full-Width Characters function key.
Since: 1.2
/**
* Constant for the Full-Width Characters function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard: zenkaku */
public static final int VK_FULL_WIDTH = 0x00F3;
Constant for the Half-Width Characters function key.
Since: 1.2
/**
* Constant for the Half-Width Characters function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard: hankaku */
public static final int VK_HALF_WIDTH = 0x00F4;
Constant for the Roman Characters function key.
Since: 1.2
/**
* Constant for the Roman Characters function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard: roumaji */
public static final int VK_ROMAN_CHARACTERS = 0x00F5;
Constant for the All Candidates function key.
Since: 1.2
/**
* Constant for the All Candidates function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard - VK_CONVERT + ALT: zenkouho */
public static final int VK_ALL_CANDIDATES = 0x0100;
Constant for the Previous Candidate function key.
Since: 1.2
/**
* Constant for the Previous Candidate function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard - VK_CONVERT + SHIFT: maekouho */
public static final int VK_PREVIOUS_CANDIDATE = 0x0101;
Constant for the Code Input function key.
Since: 1.2
/**
* Constant for the Code Input function key.
* @since 1.2
*/
/* Japanese PC 106 keyboard - VK_ALPHANUMERIC + ALT: kanji bangou */
public static final int VK_CODE_INPUT = 0x0102;
Constant for the Japanese-Katakana function key.
This key switches to a Japanese input method and selects its Katakana input mode.
Since: 1.2
/**
* Constant for the Japanese-Katakana function key.
* This key switches to a Japanese input method and selects its Katakana input mode.
* @since 1.2
*/
/* Japanese Macintosh keyboard - VK_JAPANESE_HIRAGANA + SHIFT */
public static final int VK_JAPANESE_KATAKANA = 0x0103;
Constant for the Japanese-Hiragana function key.
This key switches to a Japanese input method and selects its Hiragana input mode.
Since: 1.2
/**
* Constant for the Japanese-Hiragana function key.
* This key switches to a Japanese input method and selects its Hiragana input mode.
* @since 1.2
*/
/* Japanese Macintosh keyboard */
public static final int VK_JAPANESE_HIRAGANA = 0x0104;
Constant for the Japanese-Roman function key.
This key switches to a Japanese input method and selects its Roman-Direct input mode.
Since: 1.2
/**
* Constant for the Japanese-Roman function key.
* This key switches to a Japanese input method and selects its Roman-Direct input mode.
* @since 1.2
*/
/* Japanese Macintosh keyboard */
public static final int VK_JAPANESE_ROMAN = 0x0105;
Constant for the locking Kana function key.
This key locks the keyboard into a Kana layout.
Since: 1.3
/**
* Constant for the locking Kana function key.
* This key locks the keyboard into a Kana layout.
* @since 1.3
*/
/* Japanese PC 106 keyboard with special Windows driver - eisuu + Control; Japanese Solaris keyboard: kana */
public static final int VK_KANA_LOCK = 0x0106;
Constant for the input method on/off key.
Since: 1.3
/**
* Constant for the input method on/off key.
* @since 1.3
*/
/* Japanese PC 106 keyboard: kanji. Japanese Solaris keyboard: nihongo */
public static final int VK_INPUT_METHOD_ON_OFF = 0x0107;
/* for Sun keyboards */
Since: 1.2
/** @since 1.2 */
public static final int VK_CUT = 0xFFD1;
Since: 1.2
/** @since 1.2 */
public static final int VK_COPY = 0xFFCD;
Since: 1.2
/** @since 1.2 */
public static final int VK_PASTE = 0xFFCF;
Since: 1.2
/** @since 1.2 */
public static final int VK_UNDO = 0xFFCB;
Since: 1.2
/** @since 1.2 */
public static final int VK_AGAIN = 0xFFC9;
Since: 1.2
/** @since 1.2 */
public static final int VK_FIND = 0xFFD0;
Since: 1.2
/** @since 1.2 */
public static final int VK_PROPS = 0xFFCA;
Since: 1.2
/** @since 1.2 */
public static final int VK_STOP = 0xFFC8;
Constant for the Compose function key.
Since: 1.2
/**
* Constant for the Compose function key.
* @since 1.2
*/
public static final int VK_COMPOSE = 0xFF20;
Constant for the AltGraph function key.
Since: 1.2
/**
* Constant for the AltGraph function key.
* @since 1.2
*/
public static final int VK_ALT_GRAPH = 0xFF7E;
Constant for the Begin key.
Since: 1.5
/**
* Constant for the Begin key.
* @since 1.5
*/
public static final int VK_BEGIN = 0xFF58;
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.
/**
* 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 int VK_UNDEFINED = 0x0;
KEY_PRESSED and KEY_RELEASED events which do not map to a
valid Unicode character use this for the keyChar value.
/**
* KEY_PRESSED and KEY_RELEASED events which do not map to a
* valid Unicode character use this for the keyChar value.
*/
public static final char CHAR_UNDEFINED = 0xFFFF;
A constant indicating that the keyLocation is indeterminate or not relevant. KEY_TYPED events do not have a keyLocation; this value is used instead. Since: 1.4
/**
* A constant indicating that the keyLocation is indeterminate
* or not relevant.
* {@code KEY_TYPED} events do not have a keyLocation; this value
* is used instead.
* @since 1.4
*/
public static final int KEY_LOCATION_UNKNOWN = 0;
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).
Since: 1.4
/**
* 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).
* @since 1.4
*/
public static final int KEY_LOCATION_STANDARD = 1;
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.
Since: 1.4
/**
* 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.
* @since 1.4
*/
public static final int KEY_LOCATION_LEFT = 2;
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.
Since: 1.4
/**
* 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.
* @since 1.4
*/
public static final int KEY_LOCATION_RIGHT = 3;
A constant indicating that the key event originated on the
numeric keypad or with a virtual key corresponding to the
numeric keypad.
Since: 1.4
/**
* A constant indicating that the key event originated on the
* numeric keypad or with a virtual key corresponding to the
* numeric keypad.
* @since 1.4
*/
public static final int KEY_LOCATION_NUMPAD = 4;
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.
See Also: @serial
/**
* 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.
*
* @serial
* @see #getKeyCode()
* @see #setKeyCode(int)
*/
int keyCode;
keyChar is a valid unicode character that is fired by a key or a key combination on a keyboard. See Also: @serial
/**
* {@code keyChar} is a valid unicode character
* that is fired by a key or a key combination on
* a keyboard.
*
* @serial
* @see #getKeyChar()
* @see #setKeyChar(char)
*/
char keyChar;
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. See Also: @serial
/**
* 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 {@code KEY_LOCATION_UNKNOWN},
* {@code KEY_LOCATION_STANDARD}, {@code KEY_LOCATION_LEFT},
* {@code KEY_LOCATION_RIGHT}, and {@code KEY_LOCATION_NUMPAD}.
*
* @serial
* @see #getKeyLocation()
*/
int keyLocation;
//set from native code.
private transient long rawCode = 0;
private transient long primaryLevelUnicode = 0;
private transient long scancode = 0; // for MS Windows only
private transient long extendedKeyCode = 0;
/*
* JDK 1.1 serialVersionUID
*/
private static final long serialVersionUID = -2352130953028126954L;
static {
/* ensure that the necessary native libraries are loaded */
NativeLibLoader.loadLibraries();
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setKeyEventAccessor(
new AWTAccessor.KeyEventAccessor() {
public void setRawCode(KeyEvent ev, long rawCode) {
ev.rawCode = rawCode;
}
public void setPrimaryLevelUnicode(KeyEvent ev,
long primaryLevelUnicode) {
ev.primaryLevelUnicode = primaryLevelUnicode;
}
public void setExtendedKeyCode(KeyEvent ev,
long extendedKeyCode) {
ev.extendedKeyCode = extendedKeyCode;
}
public Component getOriginalSource( KeyEvent ev ) {
return ev.originalSource;
}
@Override
public boolean isProxyActive(KeyEvent ev) {
return ev.isProxyActive;
}
});
}
Initialize JNI field and method IDs for fields that may be
accessed from C.
/**
* Initialize JNI field and method IDs for fields that may be
* accessed from C.
*/
private static native void initIDs();
The original event source.
Event source can be changed during processing, but in some cases
we need to be able to obtain original source.
Since: 1.8
/**
* The original event source.
*
* Event source can be changed during processing, but in some cases
* we need to be able to obtain original source.
*
* @since 1.8
*/
private Component originalSource;
private KeyEvent(Component source, int id, long when, int modifiers,
int keyCode, char keyChar, int keyLocation, boolean isProxyActive) {
this(source, id, when, modifiers, keyCode, keyChar, keyLocation);
this.isProxyActive = isProxyActive;
}
Constructs a KeyEvent object. This method throws an IllegalArgumentException if source is null.
Params: - source – The
Component that originated the event - id – An integer indicating the type of event. For information on allowable values, see the class description for
KeyEvent - when – A long integer that specifies the time the event
occurred.
Passing negative or zero value
is not recommended
- modifiers – The modifier keys down during event (shift, ctrl,
alt, meta).
Passing negative value
is not recommended.
Zero value means that no modifiers were passed.
Use either an extended _DOWN_MASK or old _MASK modifiers,
however do not mix models in the one event.
The extended modifiers are preferred for using
- keyCode – The integer code for an actual key, or VK_UNDEFINED
(for a key-typed event)
- 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)
- 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. - IllegalArgumentException – if
source is null
See Also: Since: 1.4
/**
* Constructs a {@code KeyEvent} object.
* <p>This method throws an
* {@code IllegalArgumentException} if {@code source}
* is {@code null}.
*
* @param source The {@code Component} that originated the event
* @param id An integer indicating the type of event.
* For information on allowable values, see
* the class description for {@link KeyEvent}
* @param when A long integer that specifies the time the event
* occurred.
* Passing negative or zero value
* is not recommended
* @param modifiers The modifier keys down during event (shift, ctrl,
* alt, meta).
* Passing negative value
* is not recommended.
* Zero value means that no modifiers were passed.
* Use either an extended _DOWN_MASK or old _MASK modifiers,
* however do not mix models in the one event.
* The extended modifiers are preferred for using
* @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 {@code KEY_LOCATION_UNKNOWN},
* {@code KEY_LOCATION_STANDARD}, {@code KEY_LOCATION_LEFT},
* {@code KEY_LOCATION_RIGHT}, and {@code KEY_LOCATION_NUMPAD}.
* @throws IllegalArgumentException
* if {@code id} is {@code KEY_TYPED} and
* {@code keyChar} is {@code CHAR_UNDEFINED};
* or if {@code id} is {@code KEY_TYPED} and
* {@code keyCode} is not {@code VK_UNDEFINED};
* or if {@code id} is {@code KEY_TYPED} and
* {@code keyLocation} is not {@code KEY_LOCATION_UNKNOWN};
* or if {@code keyLocation} is not one of the legal
* values enumerated above.
* @throws IllegalArgumentException if {@code source} is null
* @see #getSource()
* @see #getID()
* @see #getWhen()
* @see #getModifiers()
* @see #getKeyCode()
* @see #getKeyChar()
* @see #getKeyLocation()
* @since 1.4
*/
@SuppressWarnings("deprecation")
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();
}
originalSource = source;
}
Constructs a KeyEvent object. This method throws an IllegalArgumentException if source is null.
Params: - source – The
Component that originated the event - id – An integer indicating the type of event. For information on allowable values, see the class description for
KeyEvent - when – A long integer that specifies the time the event
occurred.
Passing negative or zero value
is not recommended
- modifiers – The modifier keys down during event (shift, ctrl,
alt, meta).
Passing negative value
is not recommended.
Zero value means that no modifiers were passed.
Use either an extended _DOWN_MASK or old _MASK modifiers,
however do not mix models in the one event.
The extended modifiers are preferred for using
- keyCode – The integer code for an actual key, or VK_UNDEFINED
(for a key-typed event)
- 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 - IllegalArgumentException – if
source is null
See Also:
/**
* Constructs a {@code KeyEvent} object.
* <p> This method throws an
* {@code IllegalArgumentException} if {@code source}
* is {@code null}.
*
* @param source The {@code Component} that originated the event
* @param id An integer indicating the type of event.
* For information on allowable values, see
* the class description for {@link KeyEvent}
* @param when A long integer that specifies the time the event
* occurred.
* Passing negative or zero value
* is not recommended
* @param modifiers The modifier keys down during event (shift, ctrl,
* alt, meta).
* Passing negative value
* is not recommended.
* Zero value means that no modifiers were passed.
* Use either an extended _DOWN_MASK or old _MASK modifiers,
* however do not mix models in the one event.
* The extended modifiers are preferred for using
* @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 {@code id} is
* {@code KEY_TYPED} and {@code keyChar} is
* {@code CHAR_UNDEFINED}; or if {@code id} is
* {@code KEY_TYPED} and {@code keyCode} is not
* {@code VK_UNDEFINED}
* @throws IllegalArgumentException if {@code source} is null
* @see #getSource()
* @see #getID()
* @see #getWhen()
* @see #getModifiers()
* @see #getKeyCode()
* @see #getKeyChar()
*/
public KeyEvent(Component source, int id, long when, int modifiers,
int keyCode, char keyChar) {
this(source, id, when, modifiers, keyCode, keyChar,
KEY_LOCATION_UNKNOWN);
}
Params: - source – The
Component that originated the event - id – An integer indicating the type of event. For information on allowable values, see the class description for
KeyEvent - when – A long integer that specifies the time the event
occurred.
Passing negative or zero value
is not recommended
- modifiers – The modifier keys down during event (shift, ctrl,
alt, meta).
Passing negative value
is not recommended.
Zero value means that no modifiers were passed.
Use either an extended _DOWN_MASK or old _MASK modifiers,
however do not mix models in the one event.
The extended modifiers are preferred for using
- keyCode – The integer code for an actual key, or VK_UNDEFINED
(for a key-typed event)
Deprecated: as of JDK1.1; use KeyEvent(Component, int, long, int, int, char) instead
/**
* @deprecated as of JDK1.1; use {@link #KeyEvent(Component, int, long, int, int, char)} instead
* @param source The {@code Component} that originated the event
* @param id An integer indicating the type of event.
* For information on allowable values, see
* the class description for {@link KeyEvent}
* @param when A long integer that specifies the time the event
* occurred.
* Passing negative or zero value
* is not recommended
* @param modifiers The modifier keys down during event (shift, ctrl,
* alt, meta).
* Passing negative value
* is not recommended.
* Zero value means that no modifiers were passed.
* Use either an extended _DOWN_MASK or old _MASK modifiers,
* however do not mix models in the one event.
* The extended modifiers are preferred for using
* @param keyCode The integer code for an actual key, or VK_UNDEFINED
* (for a key-typed event)
*/
@Deprecated
public KeyEvent(Component source, int id, long when, int modifiers,
int keyCode) {
this(source, id, when, modifiers, keyCode, (char)keyCode);
}
Returns the integer keyCode associated with the key in this event.
Returns: the integer code for an actual key on the keyboard. (For KEY_TYPED events, the keyCode is VK_UNDEFINED.)
/**
* Returns the integer keyCode associated with the key in this event.
*
* @return the integer code for an actual key on the keyboard.
* (For {@code KEY_TYPED} events, the keyCode is
* {@code VK_UNDEFINED}.)
*/
public int getKeyCode() {
return keyCode;
}
Set the keyCode value to indicate a physical key.
Params: - keyCode – an integer corresponding to an actual key on the keyboard.
/**
* Set the keyCode value to indicate a physical key.
*
* @param keyCode an integer corresponding to an actual key on the keyboard.
*/
public void setKeyCode(int keyCode) {
this.keyCode = keyCode;
}
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.
Returns: the Unicode character defined for this key event. If no valid Unicode character exists for this key event, CHAR_UNDEFINED is returned.
/**
* Returns the character associated with the key in this event.
* For example, the {@code KEY_TYPED} event for shift + "a"
* returns the value for "A".
* <p>
* {@code KEY_PRESSED} and {@code 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 {@code KEY_TYPED} events.
*
* @return the Unicode character defined for this key event.
* If no valid Unicode character exists for this key event,
* {@code CHAR_UNDEFINED} is returned.
*/
public char getKeyChar() {
return keyChar;
}
Set the keyChar value to indicate a logical character.
Params: - keyChar – a char corresponding to the combination of keystrokes
that make up this event.
/**
* Set the keyChar value to indicate a logical character.
*
* @param keyChar a char corresponding to the combination of keystrokes
* that make up this event.
*/
public void setKeyChar(char keyChar) {
this.keyChar = keyChar;
}
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.
Params: - modifiers – an integer combination of the modifier constants.
See Also: Deprecated: as of JDK1.1.4
/**
* Set the modifiers to indicate additional keys that were held down
* (e.g. shift, ctrl, alt, meta) defined as part of InputEvent.
* <p>
* NOTE: use of this method is not recommended, because many AWT
* implementations do not recognize modifier changes. This is
* especially true for {@code 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
*/
@Deprecated
public void setModifiers(int modifiers) {
this.modifiers = modifiers;
if ((getModifiers() != 0) && (getModifiersEx() == 0)) {
setNewModifiers();
} else if ((getModifiers() == 0) && (getModifiersEx() != 0)) {
setOldModifiers();
}
}
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.
Returns: the location of the key that was pressed or released. Always returns KEY_LOCATION_UNKNOWN for KEY_TYPED events. Since: 1.4
/**
* 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 {@code KEY_LOCATION_UNKNOWN} for
* {@code KEY_TYPED} events.
* @since 1.4
*/
public int getKeyLocation() {
return keyLocation;
}
Returns a String describing the keyCode, such as "HOME", "F1" or "A".
These strings can be localized by changing the awt.properties file.
Params: - keyCode – the key whose description is to be returned
Returns: a string containing a text description for a physical key,
identified by its keyCode
/**
* Returns a String describing the keyCode, such as "HOME", "F1" or "A".
* These strings can be localized by changing the awt.properties file.
*
* @param keyCode the key whose description is to be returned
* @return a string containing a text description for a physical key,
* identified by its keyCode
*/
public static String getKeyText(int 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;
}
if ((keyCode & 0x01000000) != 0) {
return String.valueOf((char)(keyCode ^ 0x01000000 ));
}
String unknown = Toolkit.getProperty("AWT.unknown", "Unknown");
return unknown + " keyCode: 0x" + Integer.toString(keyCode, 16);
}
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.
Params: - modifiers – the modifier mask to be processed
See Also: Returns: string a text description of the combination of modifier
keys that were held down during the event Deprecated: It is recommended that extended modifier keys and InputEvent.getModifiersExText(int) be used instead
/**
* Returns a {@code String} describing the modifier key(s),
* such as "Shift", or "Ctrl+Shift". These strings can be
* localized by changing the {@code awt.properties} file.
* <p>
* Note that {@code InputEvent.ALT_MASK} and
* {@code InputEvent.BUTTON2_MASK} have the same value,
* so the string "Alt" is returned for both modifiers. Likewise,
* {@code InputEvent.META_MASK} and
* {@code InputEvent.BUTTON3_MASK} have the same value,
* so the string "Meta" is returned for both modifiers.
*
* @param modifiers the modifier mask to be processed
* @return string a text description of the combination of modifier
* keys that were held down during the event
* @see InputEvent#getModifiersExText(int)
* @deprecated It is recommended that extended modifier keys and
* {@link InputEvent#getModifiersExText(int)} be used instead
*/
@Deprecated(since = "9")
public static String getKeyModifiersText(int modifiers) {
StringBuilder buf = new StringBuilder();
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();
}
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.
Returns: true if the key is an "action" key, false otherwise
/**
* 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 {@code true} if the key is an "action" key,
* {@code false} otherwise
*/
public boolean isActionKey() {
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;
}
Returns a parameter string identifying this event.
This method is useful for event logging and for debugging.
Returns: a string identifying the event and its attributes
/**
* 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
*/
@SuppressWarnings("deprecation")
public String paramString() {
StringBuilder str = new StringBuilder(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;
}
str.append(",rawCode=").append(rawCode);
str.append(",primaryLevelUnicode=").append(primaryLevelUnicode);
str.append(",scancode=").append(scancode);
str.append(",extendedKeyCode=0x").append(Long.toHexString(extendedKeyCode));
return str.toString();
}
Returns an extended key code for the event. The extended key code is a unique id assigned to a key on the keyboard just like keyCode. However, unlike keyCode, this value depends on the current keyboard layout. For instance, pressing the left topmost letter key in a common English layout produces the same value as keyCode, VK_Q. Pressing the same key in a regular Russian layout gives another code, unique for the letter "Cyrillic I short". Returns: an extended key code for the event Since: 1.7
/**
* Returns an extended key code for the event.
* The extended key code is a unique id assigned to a key on the keyboard
* just like {@code keyCode}. However, unlike {@code keyCode}, this value depends on the
* current keyboard layout. For instance, pressing the left topmost letter key
* in a common English layout produces the same value as {@code keyCode}, {@code VK_Q}.
* Pressing the same key in a regular Russian layout gives another code, unique for the
* letter "Cyrillic I short".
*
* @return an extended key code for the event
* @since 1.7
*/
public int getExtendedKeyCode() {
return (int)extendedKeyCode;
}
Returns an extended key code for a unicode character.
Params: - c – the unicode character to be processed
Returns: for a unicode character with a corresponding VK_ constant -- this VK_ constant; for a character appearing on the primary level of a known keyboard layout -- a unique integer. If a character does not appear on the primary level of a known keyboard, VK_UNDEFINED is returned. Since: 1.7
/**
* Returns an extended key code for a unicode character.
*
* @param c the unicode character to be processed
* @return for a unicode character with a corresponding {@code VK_} constant -- this
* {@code VK_} constant; for a character appearing on the primary
* level of a known keyboard layout -- a unique integer.
* If a character does not appear on the primary level of a known keyboard,
* {@code VK_UNDEFINED} is returned.
*
* @since 1.7
*/
public static int getExtendedKeyCodeForChar(int c) {
// Return a keycode (if any) associated with a character.
return sun.awt.ExtendedKeyCodes.getExtendedKeyCodeForChar(c);
}
Sets new modifiers by the old ones. The key modifiers
override overlapping mouse modifiers.
/**
* Sets new modifiers by the old ones. The key modifiers
* override overlapping mouse modifiers.
*/
@SuppressWarnings("deprecation")
private void setNewModifiers() {
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;
}
}
Sets old modifiers by the new ones.
/**
* Sets old modifiers by the new ones.
*/
@SuppressWarnings("deprecation")
private void setOldModifiers() {
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;
}
}
Sets new modifiers by the old ones. The key modifiers
override overlapping mouse modifiers.
@serial
/**
* Sets new modifiers by the old ones. The key modifiers
* override overlapping mouse modifiers.
* @serial
*/
@SuppressWarnings("deprecation")
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
if (getModifiers() != 0 && getModifiersEx() == 0) {
setNewModifiers();
}
}
}