JDK自带了Robot类，此类用于为测试自动化、自运行演示程序和其他需要控制鼠标和键盘的应用程序生成本机系统输入事件。Robot 的主要目的是便于 Java 平台实现自动测试。
详情可查看jdk1.6中文手册Robot类
例子：打开win7的任务管理器，快捷键是ctrl+shift+esc
import java.io.*;import java.awt.*;import java.util.*;import java.awt.event.*;/** *@author:HaxtraZ *@date:2014年9月25日 22:44:01 *@descripion:模拟键盘事件 * 通过调用jdk的Robot类的keyPress和keyRelease方法实现 **/public class J_Keydown{ public static void main(String[] args) throws AWTException { Robot r=new Robot();//创建自动化工具对象 r.keyPress(KeyEvent.VK_CONTROL);//按下左Contrl keycode为17 r.keyPress(KeyEvent.VK_SHIFT); r.keyPress(KeyEvent.VK_ESCAPE); r.keyRelease(KeyEvent.VK_ESCAPE); r.keyRelease(KeyEvent.VK_SHIFT); r.keyRelease(KeyEvent.VK_CONTROL);//释放左Control键 }}
这里用到的按键代号有点烦，主要是VK_XXX的形式的，或者用keycode。
按键常量(KeyEvent量)
VK_HOME Home键 VK_CONTROL 控制键
VK_END End键 VK_SHIFT shift键VK_PGUP page up键 VK_BACK_SPACE 退格键VK_PGDN page down键 VK_CAPS_LOCK 大小写锁定键VK_UP 上箭头 VK_NUM_LOCK 小键盘锁定键VK_DOWN 下箭头 VK_ENTER 回车键VK_LEFT 左箭头 VK_UNDEFINED 未知键VK_RIGHT 右箭头 VK_F1--VK_F12 F1 -- F12VK_ESCAPE Esc键 VK_0 --VK_9 0 --- 9VK_TAB Tab键 VK_A --VK_Z A----Z event.keyCode键值表keycode 0 = keycode 1 = keycode 2 = keycode 3 = keycode 4 = keycode 5 = keycode 6 = keycode 7 = keycode 8 = BackSpace BackSpace keycode 9 = Tab Tab keycode 10 = keycode 11 = keycode 12 = Clear keycode 13 = Enter keycode 14 = keycode 15 = keycode 16 = Shift_L keycode 17 = Control_L keycode 18 = Alt_L keycode 19 = Pause keycode 20 = Caps_Lock keycode 21 = keycode 22 = keycode 23 = keycode 24 = keycode 25 = keycode 26 = keycode 27 = Escape Escape keycode 28 = keycode 29 = keycode 30 = keycode 31 = keycode 32 = space space keycode 33 = Prior keycode 34 = Next keycode 35 = End keycode 36 = Home keycode 37 = Left keycode 38 = Up keycode 39 = Right keycode 40 = Down keycode 41 = Select keycode 42 = Print keycode 43 = Execute keycode 44 = keycode 45 = Insert keycode 46 = Delete keycode 47 = Help keycode 48 = 0 equal braceright keycode 49 = 1 exclam onesuperior keycode 50 = 2 quotedbl twosuperior keycode 51 = 3 section threesuperior keycode 52 = 4 dollar keycode 53 = 5 percent keycode 54 = 6 ampersand keycode 55 = 7 slash braceleft keycode 56 = 8 parenleft bracketleft keycode 57 = 9 parenright bracketright keycode 58 = keycode 59 = keycode 60 = keycode 61 = keycode 62 = keycode 63 = keycode 64 = keycode 65 = a A keycode 66 = b B keycode 67 = c C keycode 68 = d D keycode 69 = e E EuroSign keycode 70 = f F keycode 71 = g G keycode 72 = h H keycode 73 = i I keycode 74 = j J keycode 75 = k K keycode 76 = l L keycode 77 = m M mu keycode 78 = n N keycode 79 = o O keycode 80 = p P keycode 81 = q Q at keycode 82 = r R keycode 83 = s S keycode 84 = t T keycode 85 = u U keycode 86 = v V keycode 87 = w W keycode 88 = x X keycode 89 = y Y keycode 90 = z Z keycode 91 = keycode 92 = keycode 93 = keycode 94 = keycode 95 = keycode 96 = KP_0 KP_0 keycode 97 = KP_1 KP_1 keycode 98 = KP_2 KP_2 keycode 99 = KP_3 KP_3 keycode 100 = KP_4 KP_4 keycode 101 = KP_5 KP_5 keycode 102 = KP_6 KP_6 keycode 103 = KP_7 KP_7 keycode 104 = KP_8 KP_8 keycode 105 = KP_9 KP_9 keycode 106 = KP_Multiply KP_Multiply keycode 107 = KP_Add KP_Add keycode 108 = KP_Separator KP_Separator keycode 109 = KP_Subtract KP_Subtract keycode 110 = KP_Decimal KP_Decimal keycode 111 = KP_Divide KP_Divide keycode 112 = F1 keycode 113 = F2 keycode 114 = F3 keycode 115 = F4 keycode 116 = F5 keycode 117 = F6 keycode 118 = F7 keycode 119 = F8 keycode 120 = F9 keycode 121 = F10 keycode 122 = F11 keycode 123 = F12 keycode 124 = F13 keycode 125 = F14 keycode 126 = F15 keycode 127 = F16 keycode 128 = F17 keycode 129 = F18 keycode 130 = F19 keycode 131 = F20 keycode 132 = F21 keycode 133 = F22 keycode 134 = F23 keycode 135 = F24 keycode 136 = Num_Lock keycode 137 = Scroll_Lock keycode 138 = keycode 139 = keycode 140 = keycode 141 = keycode 142 = keycode 143 = keycode 144 = keycode 145 = keycode 146 = keycode 147 = keycode 148 = keycode 149 = keycode 150 = keycode 151 = keycode 152 = keycode 153 = keycode 154 = keycode 155 = keycode 156 = keycode 157 = keycode 158 = keycode 159 = keycode 160 = keycode 161 = keycode 162 = keycode 163 = keycode 164 = keycode 165 = keycode 166 = keycode 167 = keycode 168 = keycode 169 = keycode 170 = keycode 171 = keycode 172 = keycode 173 = keycode 174 = keycode 175 = keycode 176 = keycode 177 = keycode 178 = keycode 179 = keycode 180 = keycode 181 = keycode 182 = keycode 183 = keycode 184 = keycode 185 = keycode 186 = keycode 187 = acute grave keycode 188 = comma semicolon keycode 189 = minus underscore keycode 190 = period colon keycode 191 = keycode 192 = numbersign apostrophe keycode 193 = keycode 194 = keycode 195 = keycode 196 = keycode 197 = keycode 198 = keycode 199 = keycode 200 = keycode 201 = keycode 202 = keycode 203 = keycode 204 = keycode 205 = keycode 206 = keycode 207 = keycode 208 = keycode 209 = keycode 210 = plusminus hyphen macron keycode 211 = keycode 212 = copyright registered keycode 213 = guillemotleft guillemotright keycode 214 = masculine ordfeminine keycode 215 = ae AE keycode 216 = cent yen keycode 217 = questiondown exclamdown keycode 218 = onequarter onehalf threequarters keycode 219 = keycode 220 = less greater bar keycode 221 = plus asterisk asciitilde keycode 222 = keycode 223 = keycode 224 = keycode 225 = keycode 226 = keycode 227 = multiply division keycode 228 = acircumflex Acircumflex keycode 229 = ecircumflex Ecircumflex keycode 230 = icircumflex Icircumflex keycode 231 = ocircumflex Ocircumflex keycode 232 = ucircumflex Ucircumflex keycode 233 = ntilde Ntilde keycode 234 = yacute Yacute keycode 235 = oslash Ooblique keycode 236 = aring Aring keycode 237 = ccedilla Ccedilla keycode 238 = thorn THORN keycode 239 = eth ETH keycode 240 = diaeresis cedilla currency keycode 241 = agrave Agrave atilde Atilde keycode 242 = egrave Egrave keycode 243 = igrave Igrave keycode 244 = ograve Ograve otilde Otilde keycode 245 = ugrave Ugrave keycode 246 = adiaeresis Adiaeresis keycode 247 = ediaeresis Ediaeresis keycode 248 = idiaeresis Idiaeresis keycode 249 = odiaeresis Odiaeresis keycode 250 = udiaeresis Udiaeresis keycode 251 = ssharp question backslash keycode 252 = asciicircum degree keycode 253 = 3 sterling keycode 254 = Mode_switch
或者更全一点直接看java源码中java.awt.event.KeyEvent代码好了，列举了各种VK_XXX和keycode的映射
/* * Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */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* orKeyAdapterobject which registered to receive such * events using the component'saddKeyListenermethod. * (KeyAdapterobjects implement the *KeyListenerinterface.) Each such listener object * gets thisKeyEventwhen 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 {
@code VK_UNDEFINED}. The { @code 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 {
@code getKeyCode} and { @code 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): *
* { @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. *
- 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. *
- 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. *
* 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 Tutorial: Writing a Key Listener * * @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 */ private boolean isProxyActive = false; /** * 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. */ 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. */ public static final int KEY_TYPED = KEY_FIRST; /** * 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. */ public static final int KEY_RELEASED = 2 + KEY_FIRST; //Event.KEY_RELEASE /* Virtual key codes. */ public static final int VK_ENTER = '\n'; public static final int VK_BACK_SPACE = '\b'; public static final int VK_TAB = '\t'; public static final int VK_CANCEL = 0x03; public static final int VK_CLEAR = 0x0C; public static final int VK_SHIFT = 0x10; public static final int VK_CONTROL = 0x11; public static final int VK_ALT = 0x12; public static final int VK_PAUSE = 0x13; public static final int VK_CAPS_LOCK = 0x14; public static final int VK_ESCAPE = 0x1B; public static final int VK_SPACE = 0x20; public static final int VK_PAGE_UP = 0x21; public static final int VK_PAGE_DOWN = 0x22; public static final int VK_END = 0x23; public static final int VK_HOME = 0x24; /** * Constant for the non-numpad left arrow key. * @see #VK_KP_LEFT */ public static final int VK_LEFT = 0x25; /** * Constant for the non-numpad up arrow key. * @see #VK_KP_UP */ public static final int VK_UP = 0x26; /** * Constant for the non-numpad right arrow key. * @see #VK_KP_RIGHT */ public static final int VK_RIGHT = 0x27; /** * Constant for the non-numpad down arrow key. * @see #VK_KP_DOWN */ public static final int VK_DOWN = 0x28; /** * Constant for the comma key, "," */ public static final int VK_COMMA = 0x2C; /** * Constant for the minus key, "-" * @since 1.2 */ public static final int VK_MINUS = 0x2D; /** * Constant for the period key, "." */ public static final int VK_PERIOD = 0x2E; /** * 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) */ public static final int VK_0 = 0x30; public static final int VK_1 = 0x31; public static final int VK_2 = 0x32; public static final int VK_3 = 0x33; public static final int VK_4 = 0x34; public static final int VK_5 = 0x35; public static final int VK_6 = 0x36; public static final int VK_7 = 0x37; public static final int VK_8 = 0x38; public static final int VK_9 = 0x39; /** * Constant for the semicolon key, ";" */ public static final int VK_SEMICOLON = 0x3B; /** * 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) */ public static final int VK_A = 0x41; public static final int VK_B = 0x42; public static final int VK_C = 0x43; public static final int VK_D = 0x44; public static final int VK_E = 0x45; public static final int VK_F = 0x46; public static final int VK_G = 0x47; public static final int VK_H = 0x48; public static final int VK_I = 0x49; public static final int VK_J = 0x4A; public static final int VK_K = 0x4B; public static final int VK_L = 0x4C; public static final int VK_M = 0x4D; public static final int VK_N = 0x4E; public static final int VK_O = 0x4F; public static final int VK_P = 0x50; public static final int VK_Q = 0x51; public static final int VK_R = 0x52; public static final int VK_S = 0x53; public static final int VK_T = 0x54; public static final int VK_U = 0x55; public static final int VK_V = 0x56; public static final int VK_W = 0x57; public static final int VK_X = 0x58; public static final int VK_Y = 0x59; public static final int VK_Z = 0x5A; /** * Constant for the open bracket key, "[" */ public static final int VK_OPEN_BRACKET = 0x5B; /** * Constant for the back slash key, "\" */ public static final int VK_BACK_SLASH = 0x5C; /** * Constant for the close bracket key, "]" */ public static final int VK_CLOSE_BRACKET = 0x5D; public static final int VK_NUMPAD0 = 0x60; public static final int VK_NUMPAD1 = 0x61; public static final int VK_NUMPAD2 = 0x62; public static final int VK_NUMPAD3 = 0x63; public static final int VK_NUMPAD4 = 0x64; public static final int VK_NUMPAD5 = 0x65; public static final int VK_NUMPAD6 = 0x66; public static final int VK_NUMPAD7 = 0x67; public static final int VK_NUMPAD8 = 0x68; public static final int VK_NUMPAD9 = 0x69; public static final int VK_MULTIPLY = 0x6A; public static final int VK_ADD = 0x6B; /** * 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 */ public static final int VK_SEPARATOR = VK_SEPARATER; public static final int VK_SUBTRACT = 0x6D; public static final int VK_DECIMAL = 0x6E; public static final int VK_DIVIDE = 0x6F; public static final int VK_DELETE = 0x7F; /* ASCII DEL */ public static final int VK_NUM_LOCK = 0x90; public static final int VK_SCROLL_LOCK = 0x91; /** Constant for the F1 function key. */ public static final int VK_F1 = 0x70; /** Constant for the F2 function key. */ public static final int VK_F2 = 0x71; /** Constant for the F3 function key. */ public static final int VK_F3 = 0x72; /** Constant for the F4 function key. */ public static final int VK_F4 = 0x73; /** Constant for the F5 function key. */ public static final int VK_F5 = 0x74; /** Constant for the F6 function key. */ public static final int VK_F6 = 0x75; /** Constant for the F7 function key. */ public static final int VK_F7 = 0x76; /** Constant for the F8 function key. */ public static final int VK_F8 = 0x77; /** Constant for the F9 function key. */ public static final int VK_F9 = 0x78; /** Constant for the F10 function key. */ public static final int VK_F10 = 0x79; /** Constant for the F11 function key. */ public static final int VK_F11 = 0x7A; /** Constant for the F12 function key. */ public static final int VK_F12 = 0x7B; /** * 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 */ public static final int VK_F14 = 0xF001; /** * 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 */ public static final int VK_F16 = 0xF003; /** * 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 */ public static final int VK_F18 = 0xF005; /** * 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 */ public static final int VK_F20 = 0xF007; /** * 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 */ public static final int VK_F22 = 0xF009; /** * 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 */ public static final int VK_F24 = 0xF00B; public static final int VK_PRINTSCREEN = 0x9A; public static final int VK_INSERT = 0x9B; public static final int VK_HELP = 0x9C; public static final int VK_META = 0x9D; public static final int VK_BACK_QUOTE = 0xC0; public static final int VK_QUOTE = 0xDE; /** * Constant for the numeric keypad up 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 #VK_DOWN * @since 1.2 */ public static final int VK_KP_DOWN = 0xE1; /** * Constant for the numeric keypad left 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 #VK_RIGHT * @since 1.2 */ public static final int VK_KP_RIGHT = 0xE3; /* For European keyboards */ /** @since 1.2 */ public static final int VK_DEAD_GRAVE = 0x80; /** @since 1.2 */ public static final int VK_DEAD_ACUTE = 0x81; /** @since 1.2 */ public static final int VK_DEAD_CIRCUMFLEX = 0x82; /** @since 1.2 */ public static final int VK_DEAD_TILDE = 0x83; /** @since 1.2 */ public static final int VK_DEAD_MACRON = 0x84; /** @since 1.2 */ public static final int VK_DEAD_BREVE = 0x85; /** @since 1.2 */ public static final int VK_DEAD_ABOVEDOT = 0x86; /** @since 1.2 */ public static final int VK_DEAD_DIAERESIS = 0x87; /** @since 1.2 */ public static final int VK_DEAD_ABOVERING = 0x88; /** @since 1.2 */ public static final int VK_DEAD_DOUBLEACUTE = 0x89; /** @since 1.2 */ public static final int VK_DEAD_CARON = 0x8a; /** @since 1.2 */ public static final int VK_DEAD_CEDILLA = 0x8b; /** @since 1.2 */ public static final int VK_DEAD_OGONEK = 0x8c; /** @since 1.2 */ public static final int VK_DEAD_IOTA = 0x8d; /** @since 1.2 */ public static final int VK_DEAD_VOICED_SOUND = 0x8e; /** @since 1.2 */ public static final int VK_DEAD_SEMIVOICED_SOUND = 0x8f; /** @since 1.2 */ public static final int VK_AMPERSAND = 0x96; /** @since 1.2 */ public static final int VK_ASTERISK = 0x97; /** @since 1.2 */ public static final int VK_QUOTEDBL = 0x98; /** @since 1.2 */ public static final int VK_LESS = 0x99; /** @since 1.2 */ public static final int VK_GREATER = 0xa0; /** @since 1.2 */ public static final int VK_BRACELEFT = 0xa1; /** @since 1.2 */ public static final int VK_BRACERIGHT = 0xa2; /** * Constant for the "@" key. * @since 1.2 */ public static final int VK_AT = 0x0200; /** * Constant for the ":" key. * @since 1.2 */ public static final int VK_COLON = 0x0201; /** * Constant for the "^" key. * @since 1.2 */ public static final int VK_CIRCUMFLEX = 0x0202; /** * Constant for the "$" key. * @since 1.2 */ public static final int VK_DOLLAR = 0x0203; /** * 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 */ public static final int VK_EXCLAMATION_MARK = 0x0205; /** * 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 */ public static final int VK_LEFT_PARENTHESIS = 0x0207; /** * Constant for the "#" key. * @since 1.2 */ public static final int VK_NUMBER_SIGN = 0x0208; /** * Constant for the "+" key. * @since 1.2 */ public static final int VK_PLUS = 0x0209; /** * Constant for the ")" key. * @since 1.2 */ public static final int VK_RIGHT_PARENTHESIS = 0x020A; /** * 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 #getKeyLocation() * @since 1.5 */ public static final int VK_WINDOWS = 0x020C; /** * 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 */ public static final int VK_FINAL = 0x0018; /** 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. */ /* Japanese PC 106 keyboard: muhenkan */ public static final int VK_NONCONVERT = 0x001D; /** 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 */ public static final int VK_MODECHANGE = 0x001F; /* replaced by VK_KANA_LOCK for Microsoft Windows and Solaris; might still be used on other platforms */ 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 */ public static final int VK_KANJI = 0x0019; /** * 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 */ /* Japanese PC 106 keyboard: katakana */ public static final int VK_KATAKANA = 0x00F1; /** * 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 */ /* Japanese PC 106 keyboard: zenkaku */ public static final int VK_FULL_WIDTH = 0x00F3; /** * 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 */ /* Japanese PC 106 keyboard: roumaji */ public static final int VK_ROMAN_CHARACTERS = 0x00F5; /** * 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 */ /* 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 */ /* 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 */ /* 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 */ /* 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 */ /* 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 */ /* 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 */ /* 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 */ public static final int VK_CUT = 0xFFD1; /** @since 1.2 */ public static final int VK_COPY = 0xFFCD; /** @since 1.2 */ public static final int VK_PASTE = 0xFFCF; /** @since 1.2 */ public static final int VK_UNDO = 0xFFCB; /** @since 1.2 */ public static final int VK_AGAIN = 0xFFC9; /** @since 1.2 */ public static final int VK_FIND = 0xFFD0; /** @since 1.2 */ public static final int VK_PROPS = 0xFFCA; /** @since 1.2 */ public static final int VK_STOP = 0xFFC8; /** * 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 */ public static final int VK_ALT_GRAPH = 0xFF7E; /** * 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. */ 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. */ 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 */ 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 */ 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 */ 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 */ 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 */ 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. * * @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. * * @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. * * @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; } }); } /** * Initialize JNI field and method IDs for fields that may be * accessed from C. */ private static native void initIDs(); 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. * * @param source The Component that originated the event * @param id An integer indicating the type of event. * For information on allowable values, see * the class description for {
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 * @see #getSource() * @see #getID() * @see #getWhen() * @see #getModifiers() * @see #getKeyCode() * @see #getKeyChar() * @see #getKeyLocation() * @since 1.4 */ 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(); } } /** * Constructs a KeyEvent object. * This method throws an * IllegalArgumentException if source * is null. * * @param source The Component that originated the event * @param id An integer indicating the type of event. * For information on allowable values, see * the class description for {
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 * @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); } /** * @deprecated as of JDK1.1 */ @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. * * @return the integer code for an actual key on the keyboard. * (For KEY_TYPED events, the keyCode is * VK_UNDEFINED.) */ public int getKeyCode() { return keyCode; } /** * 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. * * @return the Unicode character defined for this key event. * If no valid Unicode character exists for this key event, * CHAR_UNDEFINED is returned. */ public char getKeyChar() { return 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. */ 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. * * @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. * * @return the location of the key that was pressed or released. * Always returns KEY_LOCATION_UNKNOWN for * 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. * * @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. * * @return string a text description of the combination of modifier * keys that were held down during the event * @see InputEvent#getModifiersExText(int) */ 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. * * @return true if the key is an "action" key, * 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. * * @return a string identifying the event and its attributes */ 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 {