1 /* 2 * Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.awt.event; 27 28 import java.awt.Component; 29 import java.awt.GraphicsEnvironment; 30 import java.awt.Toolkit; 31 import java.io.IOException; 32 import java.io.ObjectInputStream; 33 import sun.awt.AWTAccessor; 34 35 /** 36 * An event which indicates that a keystroke occurred in a component. 37 * <p> 38 * This low-level event is generated by a component object (such as a text 39 * field) when a key is pressed, released, or typed. 40 * The event is passed to every <code>KeyListener</code> 41 * or <code>KeyAdapter</code> object which registered to receive such 42 * events using the component's <code>addKeyListener</code> method. 43 * (<code>KeyAdapter</code> objects implement the 44 * <code>KeyListener</code> interface.) Each such listener object 45 * gets this <code>KeyEvent</code> when the event occurs. 46 * <p> 47 * <em>"Key typed" events</em> are higher-level and generally do not depend on 48 * the platform or keyboard layout. They are generated when a Unicode character 49 * is entered, and are the preferred way to find out about character input. 50 * In the simplest case, a key typed event is produced by a single key press 51 * (e.g., 'a'). Often, however, characters are produced by series of key 52 * presses (e.g., 'shift' + 'a'), and the mapping from key pressed events to 53 * key typed events may be many-to-one or many-to-many. Key releases are not 54 * usually necessary to generate a key typed event, but there are some cases 55 * where the key typed event is not generated until a key is released (e.g., 56 * entering ASCII sequences via the Alt-Numpad method in Windows). 57 * No key typed events are generated for keys that don't generate Unicode 58 * characters (e.g., action keys, modifier keys, etc.). 59 * <p> 60 * The getKeyChar method always returns a valid Unicode character or 61 * CHAR_UNDEFINED. Character input is reported by KEY_TYPED events: 62 * KEY_PRESSED and KEY_RELEASED events are not necessarily associated 63 * with character input. Therefore, the result of the getKeyChar method 64 * is guaranteed to be meaningful only for KEY_TYPED events. 65 * <p> 66 * For key pressed and key released events, the getKeyCode method returns 67 * the event's keyCode. For key typed events, the getKeyCode method 68 * always returns {@code VK_UNDEFINED}. The {@code getExtendedKeyCode} method 69 * may also be used with many international keyboard layouts. 70 * 71 * <p> 72 * <em>"Key pressed" and "key released" events</em> are lower-level and depend 73 * on the platform and keyboard layout. They are generated whenever a key is 74 * pressed or released, and are the only way to find out about keys that don't 75 * generate character input (e.g., action keys, modifier keys, etc.). The key 76 * being pressed or released is indicated by the {@code getKeyCode} and {@code getExtendedKeyCode} 77 * methods, which return a virtual key code. 78 * 79 * <p> 80 * <em>Virtual key codes</em> are used to report which keyboard key has 81 * been pressed, rather than a character generated by the combination 82 * of one or more keystrokes (such as "A", which comes from shift and "a"). 83 * 84 * <p> 85 * For example, pressing the Shift key will cause a KEY_PRESSED event 86 * with a VK_SHIFT keyCode, while pressing the 'a' key will result in 87 * a VK_A keyCode. After the 'a' key is released, a KEY_RELEASED event 88 * will be fired with VK_A. Separately, a KEY_TYPED event with a keyChar 89 * value of 'A' is generated. 90 * 91 * <p> 92 * Pressing and releasing a key on the keyboard results in the generating 93 * the following key events (in order): 94 * <PRE> 95 * {@code KEY_PRESSED} 96 * {@code KEY_TYPED} (is only generated if a valid Unicode character could be generated.) 97 * {@code KEY_RELEASED} 98 * </PRE> 99 * 100 * But in some cases (e.g. auto-repeat or input method is activated) the order 101 * could be different (and platform dependent). 102 * 103 * <p> 104 * Notes: 105 * <ul> 106 * <li>Key combinations which do not result in Unicode characters, such as action 107 * keys like F1 and the HELP key, do not generate KEY_TYPED events. 108 * <li>Not all keyboards or systems are capable of generating all 109 * virtual key codes. No attempt is made in Java to generate these keys 110 * artificially. 111 * <li>Virtual key codes do not identify a physical key: they depend on the 112 * platform and keyboard layout. For example, the key that generates VK_Q 113 * when using a U.S. keyboard layout will generate VK_A when using a French 114 * keyboard layout. 115 * <li>The key that generates {@code VK_Q} when using a U.S. keyboard layout also 116 * generates a unique code for Russian or Hebrew layout. There is no a 117 * {@code VK_} constant for these and many other codes in various layouts. These codes 118 * may be obtained by using {@code getExtendedKeyCode} and are used whenever 119 * a {@code VK_} constant is used. 120 * <li>Not all characters have a keycode associated with them. For example, 121 * there is no keycode for the question mark because there is no keyboard 122 * for which it appears on the primary layer. 123 * <li>In order to support the platform-independent handling of action keys, 124 * the Java platform uses a few additional virtual key constants for functions 125 * that would otherwise have to be recognized by interpreting virtual key codes 126 * and modifiers. For example, for Japanese Windows keyboards, VK_ALL_CANDIDATES 127 * is returned instead of VK_CONVERT with the ALT modifier. 128 * <li>As specified in <a href="../doc-files/FocusSpec.html">Focus Specification</a> 129 * key events are dispatched to the focus owner by default. 130 * </ul> 131 * 132 * <p> 133 * WARNING: Aside from those keys that are defined by the Java language 134 * (VK_ENTER, VK_BACK_SPACE, and VK_TAB), do not rely on the values of the VK_ 135 * constants. Sun reserves the right to change these values as needed 136 * to accomodate a wider range of keyboards in the future. 137 * <p> 138 * An unspecified behavior will be caused if the {@code id} parameter 139 * of any particular {@code KeyEvent} instance is not 140 * in the range from {@code KEY_FIRST} to {@code KEY_LAST}. 141 * 142 * @author Carl Quinn 143 * @author Amy Fowler 144 * @author Norbert Lindenberg 145 * 146 * @see KeyAdapter 147 * @see KeyListener 148 * @see <a href="http://java.sun.com/docs/books/tutorial/post1.0/ui/keylistener.html">Tutorial: Writing a Key Listener</a> 149 * 150 * @since 1.1 151 */ 152 public class KeyEvent extends InputEvent { 153 154 /** 155 * Stores the state of native event dispatching system 156 * - true, if when the event was created event proxying 157 * mechanism was active 158 * - false, if it was inactive 159 * Used in Component.dispatchEventImpl to correctly dispatch 160 * events when proxy is active 161 */ 162 private boolean isProxyActive = false; 163 164 /** 165 * The first number in the range of ids used for key events. 166 */ 167 public static final int KEY_FIRST = 400; 168 169 /** 170 * The last number in the range of ids used for key events. 171 */ 172 public static final int KEY_LAST = 402; 173 174 /** 175 * The "key typed" event. This event is generated when a character is 176 * entered. In the simplest case, it is produced by a single key press. 177 * Often, however, characters are produced by series of key presses, and 178 * the mapping from key pressed events to key typed events may be 179 * many-to-one or many-to-many. 180 */ 181 public static final int KEY_TYPED = KEY_FIRST; 182 183 /** 184 * The "key pressed" event. This event is generated when a key 185 * is pushed down. 186 */ 187 public static final int KEY_PRESSED = 1 + KEY_FIRST; //Event.KEY_PRESS 188 189 /** 190 * The "key released" event. This event is generated when a key 191 * is let up. 192 */ 193 public static final int KEY_RELEASED = 2 + KEY_FIRST; //Event.KEY_RELEASE 194 195 /* Virtual key codes. */ 196 197 public static final int VK_ENTER = '\n'; 198 public static final int VK_BACK_SPACE = '\b'; 199 public static final int VK_TAB = '\t'; 200 public static final int VK_CANCEL = 0x03; 201 public static final int VK_CLEAR = 0x0C; 202 public static final int VK_SHIFT = 0x10; 203 public static final int VK_CONTROL = 0x11; 204 public static final int VK_ALT = 0x12; 205 public static final int VK_PAUSE = 0x13; 206 public static final int VK_CAPS_LOCK = 0x14; 207 public static final int VK_ESCAPE = 0x1B; 208 public static final int VK_SPACE = 0x20; 209 public static final int VK_PAGE_UP = 0x21; 210 public static final int VK_PAGE_DOWN = 0x22; 211 public static final int VK_END = 0x23; 212 public static final int VK_HOME = 0x24; 213 214 /** 215 * Constant for the non-numpad <b>left</b> arrow key. 216 * @see #VK_KP_LEFT 217 */ 218 public static final int VK_LEFT = 0x25; 219 220 /** 221 * Constant for the non-numpad <b>up</b> arrow key. 222 * @see #VK_KP_UP 223 */ 224 public static final int VK_UP = 0x26; 225 226 /** 227 * Constant for the non-numpad <b>right</b> arrow key. 228 * @see #VK_KP_RIGHT 229 */ 230 public static final int VK_RIGHT = 0x27; 231 232 /** 233 * Constant for the non-numpad <b>down</b> arrow key. 234 * @see #VK_KP_DOWN 235 */ 236 public static final int VK_DOWN = 0x28; 237 238 /** 239 * Constant for the comma key, "," 240 */ 241 public static final int VK_COMMA = 0x2C; 242 243 /** 244 * Constant for the minus key, "-" 245 * @since 1.2 246 */ 247 public static final int VK_MINUS = 0x2D; 248 249 /** 250 * Constant for the period key, "." 251 */ 252 public static final int VK_PERIOD = 0x2E; 253 254 /** 255 * Constant for the forward slash key, "/" 256 */ 257 public static final int VK_SLASH = 0x2F; 258 259 /** VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */ 260 public static final int VK_0 = 0x30; 261 public static final int VK_1 = 0x31; 262 public static final int VK_2 = 0x32; 263 public static final int VK_3 = 0x33; 264 public static final int VK_4 = 0x34; 265 public static final int VK_5 = 0x35; 266 public static final int VK_6 = 0x36; 267 public static final int VK_7 = 0x37; 268 public static final int VK_8 = 0x38; 269 public static final int VK_9 = 0x39; 270 271 /** 272 * Constant for the semicolon key, ";" 273 */ 274 public static final int VK_SEMICOLON = 0x3B; 275 276 /** 277 * Constant for the equals key, "=" 278 */ 279 public static final int VK_EQUALS = 0x3D; 280 281 /** VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */ 282 public static final int VK_A = 0x41; 283 public static final int VK_B = 0x42; 284 public static final int VK_C = 0x43; 285 public static final int VK_D = 0x44; 286 public static final int VK_E = 0x45; 287 public static final int VK_F = 0x46; 288 public static final int VK_G = 0x47; 289 public static final int VK_H = 0x48; 290 public static final int VK_I = 0x49; 291 public static final int VK_J = 0x4A; 292 public static final int VK_K = 0x4B; 293 public static final int VK_L = 0x4C; 294 public static final int VK_M = 0x4D; 295 public static final int VK_N = 0x4E; 296 public static final int VK_O = 0x4F; 297 public static final int VK_P = 0x50; 298 public static final int VK_Q = 0x51; 299 public static final int VK_R = 0x52; 300 public static final int VK_S = 0x53; 301 public static final int VK_T = 0x54; 302 public static final int VK_U = 0x55; 303 public static final int VK_V = 0x56; 304 public static final int VK_W = 0x57; 305 public static final int VK_X = 0x58; 306 public static final int VK_Y = 0x59; 307 public static final int VK_Z = 0x5A; 308 309 /** 310 * Constant for the open bracket key, "[" 311 */ 312 public static final int VK_OPEN_BRACKET = 0x5B; 313 314 /** 315 * Constant for the back slash key, "\" 316 */ 317 public static final int VK_BACK_SLASH = 0x5C; 318 319 /** 320 * Constant for the close bracket key, "]" 321 */ 322 public static final int VK_CLOSE_BRACKET = 0x5D; 323 324 public static final int VK_NUMPAD0 = 0x60; 325 public static final int VK_NUMPAD1 = 0x61; 326 public static final int VK_NUMPAD2 = 0x62; 327 public static final int VK_NUMPAD3 = 0x63; 328 public static final int VK_NUMPAD4 = 0x64; 329 public static final int VK_NUMPAD5 = 0x65; 330 public static final int VK_NUMPAD6 = 0x66; 331 public static final int VK_NUMPAD7 = 0x67; 332 public static final int VK_NUMPAD8 = 0x68; 333 public static final int VK_NUMPAD9 = 0x69; 334 public static final int VK_MULTIPLY = 0x6A; 335 public static final int VK_ADD = 0x6B; 336 337 /** 338 * This constant is obsolete, and is included only for backwards 339 * compatibility. 340 * @see #VK_SEPARATOR 341 */ 342 public static final int VK_SEPARATER = 0x6C; 343 344 /** 345 * Constant for the Numpad Separator key. 346 * @since 1.4 347 */ 348 public static final int VK_SEPARATOR = VK_SEPARATER; 349 350 public static final int VK_SUBTRACT = 0x6D; 351 public static final int VK_DECIMAL = 0x6E; 352 public static final int VK_DIVIDE = 0x6F; 353 public static final int VK_DELETE = 0x7F; /* ASCII DEL */ 354 public static final int VK_NUM_LOCK = 0x90; 355 public static final int VK_SCROLL_LOCK = 0x91; 356 357 /** Constant for the F1 function key. */ 358 public static final int VK_F1 = 0x70; 359 360 /** Constant for the F2 function key. */ 361 public static final int VK_F2 = 0x71; 362 363 /** Constant for the F3 function key. */ 364 public static final int VK_F3 = 0x72; 365 366 /** Constant for the F4 function key. */ 367 public static final int VK_F4 = 0x73; 368 369 /** Constant for the F5 function key. */ 370 public static final int VK_F5 = 0x74; 371 372 /** Constant for the F6 function key. */ 373 public static final int VK_F6 = 0x75; 374 375 /** Constant for the F7 function key. */ 376 public static final int VK_F7 = 0x76; 377 378 /** Constant for the F8 function key. */ 379 public static final int VK_F8 = 0x77; 380 381 /** Constant for the F9 function key. */ 382 public static final int VK_F9 = 0x78; 383 384 /** Constant for the F10 function key. */ 385 public static final int VK_F10 = 0x79; 386 387 /** Constant for the F11 function key. */ 388 public static final int VK_F11 = 0x7A; 389 390 /** Constant for the F12 function key. */ 391 public static final int VK_F12 = 0x7B; 392 393 /** 394 * Constant for the F13 function key. 395 * @since 1.2 396 */ 397 /* F13 - F24 are used on IBM 3270 keyboard; use random range for constants. */ 398 public static final int VK_F13 = 0xF000; 399 400 /** 401 * Constant for the F14 function key. 402 * @since 1.2 403 */ 404 public static final int VK_F14 = 0xF001; 405 406 /** 407 * Constant for the F15 function key. 408 * @since 1.2 409 */ 410 public static final int VK_F15 = 0xF002; 411 412 /** 413 * Constant for the F16 function key. 414 * @since 1.2 415 */ 416 public static final int VK_F16 = 0xF003; 417 418 /** 419 * Constant for the F17 function key. 420 * @since 1.2 421 */ 422 public static final int VK_F17 = 0xF004; 423 424 /** 425 * Constant for the F18 function key. 426 * @since 1.2 427 */ 428 public static final int VK_F18 = 0xF005; 429 430 /** 431 * Constant for the F19 function key. 432 * @since 1.2 433 */ 434 public static final int VK_F19 = 0xF006; 435 436 /** 437 * Constant for the F20 function key. 438 * @since 1.2 439 */ 440 public static final int VK_F20 = 0xF007; 441 442 /** 443 * Constant for the F21 function key. 444 * @since 1.2 445 */ 446 public static final int VK_F21 = 0xF008; 447 448 /** 449 * Constant for the F22 function key. 450 * @since 1.2 451 */ 452 public static final int VK_F22 = 0xF009; 453 454 /** 455 * Constant for the F23 function key. 456 * @since 1.2 457 */ 458 public static final int VK_F23 = 0xF00A; 459 460 /** 461 * Constant for the F24 function key. 462 * @since 1.2 463 */ 464 public static final int VK_F24 = 0xF00B; 465 466 public static final int VK_PRINTSCREEN = 0x9A; 467 public static final int VK_INSERT = 0x9B; 468 public static final int VK_HELP = 0x9C; 469 public static final int VK_META = 0x9D; 470 471 public static final int VK_BACK_QUOTE = 0xC0; 472 public static final int VK_QUOTE = 0xDE; 473 474 /** 475 * Constant for the numeric keypad <b>up</b> arrow key. 476 * @see #VK_UP 477 * @since 1.2 478 */ 479 public static final int VK_KP_UP = 0xE0; 480 481 /** 482 * Constant for the numeric keypad <b>down</b> arrow key. 483 * @see #VK_DOWN 484 * @since 1.2 485 */ 486 public static final int VK_KP_DOWN = 0xE1; 487 488 /** 489 * Constant for the numeric keypad <b>left</b> arrow key. 490 * @see #VK_LEFT 491 * @since 1.2 492 */ 493 public static final int VK_KP_LEFT = 0xE2; 494 495 /** 496 * Constant for the numeric keypad <b>right</b> arrow key. 497 * @see #VK_RIGHT 498 * @since 1.2 499 */ 500 public static final int VK_KP_RIGHT = 0xE3; 501 502 /* For European keyboards */ 503 /** @since 1.2 */ 504 public static final int VK_DEAD_GRAVE = 0x80; 505 /** @since 1.2 */ 506 public static final int VK_DEAD_ACUTE = 0x81; 507 /** @since 1.2 */ 508 public static final int VK_DEAD_CIRCUMFLEX = 0x82; 509 /** @since 1.2 */ 510 public static final int VK_DEAD_TILDE = 0x83; 511 /** @since 1.2 */ 512 public static final int VK_DEAD_MACRON = 0x84; 513 /** @since 1.2 */ 514 public static final int VK_DEAD_BREVE = 0x85; 515 /** @since 1.2 */ 516 public static final int VK_DEAD_ABOVEDOT = 0x86; 517 /** @since 1.2 */ 518 public static final int VK_DEAD_DIAERESIS = 0x87; 519 /** @since 1.2 */ 520 public static final int VK_DEAD_ABOVERING = 0x88; 521 /** @since 1.2 */ 522 public static final int VK_DEAD_DOUBLEACUTE = 0x89; 523 /** @since 1.2 */ 524 public static final int VK_DEAD_CARON = 0x8a; 525 /** @since 1.2 */ 526 public static final int VK_DEAD_CEDILLA = 0x8b; 527 /** @since 1.2 */ 528 public static final int VK_DEAD_OGONEK = 0x8c; 529 /** @since 1.2 */ 530 public static final int VK_DEAD_IOTA = 0x8d; 531 /** @since 1.2 */ 532 public static final int VK_DEAD_VOICED_SOUND = 0x8e; 533 /** @since 1.2 */ 534 public static final int VK_DEAD_SEMIVOICED_SOUND = 0x8f; 535 536 /** @since 1.2 */ 537 public static final int VK_AMPERSAND = 0x96; 538 /** @since 1.2 */ 539 public static final int VK_ASTERISK = 0x97; 540 /** @since 1.2 */ 541 public static final int VK_QUOTEDBL = 0x98; 542 /** @since 1.2 */ 543 public static final int VK_LESS = 0x99; 544 545 /** @since 1.2 */ 546 public static final int VK_GREATER = 0xa0; 547 /** @since 1.2 */ 548 public static final int VK_BRACELEFT = 0xa1; 549 /** @since 1.2 */ 550 public static final int VK_BRACERIGHT = 0xa2; 551 552 /** 553 * Constant for the "@" key. 554 * @since 1.2 555 */ 556 public static final int VK_AT = 0x0200; 557 558 /** 559 * Constant for the ":" key. 560 * @since 1.2 561 */ 562 public static final int VK_COLON = 0x0201; 563 564 /** 565 * Constant for the "^" key. 566 * @since 1.2 567 */ 568 public static final int VK_CIRCUMFLEX = 0x0202; 569 570 /** 571 * Constant for the "$" key. 572 * @since 1.2 573 */ 574 public static final int VK_DOLLAR = 0x0203; 575 576 /** 577 * Constant for the Euro currency sign key. 578 * @since 1.2 579 */ 580 public static final int VK_EURO_SIGN = 0x0204; 581 582 /** 583 * Constant for the "!" key. 584 * @since 1.2 585 */ 586 public static final int VK_EXCLAMATION_MARK = 0x0205; 587 588 /** 589 * Constant for the inverted exclamation mark key. 590 * @since 1.2 591 */ 592 public static final int VK_INVERTED_EXCLAMATION_MARK = 0x0206; 593 594 /** 595 * Constant for the "(" key. 596 * @since 1.2 597 */ 598 public static final int VK_LEFT_PARENTHESIS = 0x0207; 599 600 /** 601 * Constant for the "#" key. 602 * @since 1.2 603 */ 604 public static final int VK_NUMBER_SIGN = 0x0208; 605 606 /** 607 * Constant for the "+" key. 608 * @since 1.2 609 */ 610 public static final int VK_PLUS = 0x0209; 611 612 /** 613 * Constant for the ")" key. 614 * @since 1.2 615 */ 616 public static final int VK_RIGHT_PARENTHESIS = 0x020A; 617 618 /** 619 * Constant for the "_" key. 620 * @since 1.2 621 */ 622 public static final int VK_UNDERSCORE = 0x020B; 623 624 /** 625 * Constant for the Microsoft Windows "Windows" key. 626 * It is used for both the left and right version of the key. 627 * @see #getKeyLocation() 628 * @since 1.5 629 */ 630 public static final int VK_WINDOWS = 0x020C; 631 632 /** 633 * Constant for the Microsoft Windows Context Menu key. 634 * @since 1.5 635 */ 636 public static final int VK_CONTEXT_MENU = 0x020D; 637 638 /* for input method support on Asian Keyboards */ 639 640 /* not clear what this means - listed in Microsoft Windows API */ 641 public static final int VK_FINAL = 0x0018; 642 643 /** Constant for the Convert function key. */ 644 /* Japanese PC 106 keyboard, Japanese Solaris keyboard: henkan */ 645 public static final int VK_CONVERT = 0x001C; 646 647 /** Constant for the Don't Convert function key. */ 648 /* Japanese PC 106 keyboard: muhenkan */ 649 public static final int VK_NONCONVERT = 0x001D; 650 651 /** Constant for the Accept or Commit function key. */ 652 /* Japanese Solaris keyboard: kakutei */ 653 public static final int VK_ACCEPT = 0x001E; 654 655 /* not clear what this means - listed in Microsoft Windows API */ 656 public static final int VK_MODECHANGE = 0x001F; 657 658 /* replaced by VK_KANA_LOCK for Microsoft Windows and Solaris; 659 might still be used on other platforms */ 660 public static final int VK_KANA = 0x0015; 661 662 /* replaced by VK_INPUT_METHOD_ON_OFF for Microsoft Windows and Solaris; 663 might still be used for other platforms */ 664 public static final int VK_KANJI = 0x0019; 665 666 /** 667 * Constant for the Alphanumeric function key. 668 * @since 1.2 669 */ 670 /* Japanese PC 106 keyboard: eisuu */ 671 public static final int VK_ALPHANUMERIC = 0x00F0; 672 673 /** 674 * Constant for the Katakana function key. 675 * @since 1.2 676 */ 677 /* Japanese PC 106 keyboard: katakana */ 678 public static final int VK_KATAKANA = 0x00F1; 679 680 /** 681 * Constant for the Hiragana function key. 682 * @since 1.2 683 */ 684 /* Japanese PC 106 keyboard: hiragana */ 685 public static final int VK_HIRAGANA = 0x00F2; 686 687 /** 688 * Constant for the Full-Width Characters function key. 689 * @since 1.2 690 */ 691 /* Japanese PC 106 keyboard: zenkaku */ 692 public static final int VK_FULL_WIDTH = 0x00F3; 693 694 /** 695 * Constant for the Half-Width Characters function key. 696 * @since 1.2 697 */ 698 /* Japanese PC 106 keyboard: hankaku */ 699 public static final int VK_HALF_WIDTH = 0x00F4; 700 701 /** 702 * Constant for the Roman Characters function key. 703 * @since 1.2 704 */ 705 /* Japanese PC 106 keyboard: roumaji */ 706 public static final int VK_ROMAN_CHARACTERS = 0x00F5; 707 708 /** 709 * Constant for the All Candidates function key. 710 * @since 1.2 711 */ 712 /* Japanese PC 106 keyboard - VK_CONVERT + ALT: zenkouho */ 713 public static final int VK_ALL_CANDIDATES = 0x0100; 714 715 /** 716 * Constant for the Previous Candidate function key. 717 * @since 1.2 718 */ 719 /* Japanese PC 106 keyboard - VK_CONVERT + SHIFT: maekouho */ 720 public static final int VK_PREVIOUS_CANDIDATE = 0x0101; 721 722 /** 723 * Constant for the Code Input function key. 724 * @since 1.2 725 */ 726 /* Japanese PC 106 keyboard - VK_ALPHANUMERIC + ALT: kanji bangou */ 727 public static final int VK_CODE_INPUT = 0x0102; 728 729 /** 730 * Constant for the Japanese-Katakana function key. 731 * This key switches to a Japanese input method and selects its Katakana input mode. 732 * @since 1.2 733 */ 734 /* Japanese Macintosh keyboard - VK_JAPANESE_HIRAGANA + SHIFT */ 735 public static final int VK_JAPANESE_KATAKANA = 0x0103; 736 737 /** 738 * Constant for the Japanese-Hiragana function key. 739 * This key switches to a Japanese input method and selects its Hiragana input mode. 740 * @since 1.2 741 */ 742 /* Japanese Macintosh keyboard */ 743 public static final int VK_JAPANESE_HIRAGANA = 0x0104; 744 745 /** 746 * Constant for the Japanese-Roman function key. 747 * This key switches to a Japanese input method and selects its Roman-Direct input mode. 748 * @since 1.2 749 */ 750 /* Japanese Macintosh keyboard */ 751 public static final int VK_JAPANESE_ROMAN = 0x0105; 752 753 /** 754 * Constant for the locking Kana function key. 755 * This key locks the keyboard into a Kana layout. 756 * @since 1.3 757 */ 758 /* Japanese PC 106 keyboard with special Windows driver - eisuu + Control; Japanese Solaris keyboard: kana */ 759 public static final int VK_KANA_LOCK = 0x0106; 760 761 /** 762 * Constant for the input method on/off key. 763 * @since 1.3 764 */ 765 /* Japanese PC 106 keyboard: kanji. Japanese Solaris keyboard: nihongo */ 766 public static final int VK_INPUT_METHOD_ON_OFF = 0x0107; 767 768 /* for Sun keyboards */ 769 /** @since 1.2 */ 770 public static final int VK_CUT = 0xFFD1; 771 /** @since 1.2 */ 772 public static final int VK_COPY = 0xFFCD; 773 /** @since 1.2 */ 774 public static final int VK_PASTE = 0xFFCF; 775 /** @since 1.2 */ 776 public static final int VK_UNDO = 0xFFCB; 777 /** @since 1.2 */ 778 public static final int VK_AGAIN = 0xFFC9; 779 /** @since 1.2 */ 780 public static final int VK_FIND = 0xFFD0; 781 /** @since 1.2 */ 782 public static final int VK_PROPS = 0xFFCA; 783 /** @since 1.2 */ 784 public static final int VK_STOP = 0xFFC8; 785 786 /** 787 * Constant for the Compose function key. 788 * @since 1.2 789 */ 790 public static final int VK_COMPOSE = 0xFF20; 791 792 /** 793 * Constant for the AltGraph function key. 794 * @since 1.2 795 */ 796 public static final int VK_ALT_GRAPH = 0xFF7E; 797 798 /** 799 * Constant for the Begin key. 800 * @since 1.5 801 */ 802 public static final int VK_BEGIN = 0xFF58; 803 804 /** 805 * This value is used to indicate that the keyCode is unknown. 806 * KEY_TYPED events do not have a keyCode value; this value 807 * is used instead. 808 */ 809 public static final int VK_UNDEFINED = 0x0; 810 811 /** 812 * KEY_PRESSED and KEY_RELEASED events which do not map to a 813 * valid Unicode character use this for the keyChar value. 814 */ 815 public static final char CHAR_UNDEFINED = 0xFFFF; 816 817 /** 818 * A constant indicating that the keyLocation is indeterminate 819 * or not relevant. 820 * <code>KEY_TYPED</code> events do not have a keyLocation; this value 821 * is used instead. 822 * @since 1.4 823 */ 824 public static final int KEY_LOCATION_UNKNOWN = 0; 825 826 /** 827 * A constant indicating that the key pressed or released 828 * is not distinguished as the left or right version of a key, 829 * and did not originate on the numeric keypad (or did not 830 * originate with a virtual key corresponding to the numeric 831 * keypad). 832 * @since 1.4 833 */ 834 public static final int KEY_LOCATION_STANDARD = 1; 835 836 /** 837 * A constant indicating that the key pressed or released is in 838 * the left key location (there is more than one possible location 839 * for this key). Example: the left shift key. 840 * @since 1.4 841 */ 842 public static final int KEY_LOCATION_LEFT = 2; 843 844 /** 845 * A constant indicating that the key pressed or released is in 846 * the right key location (there is more than one possible location 847 * for this key). Example: the right shift key. 848 * @since 1.4 849 */ 850 public static final int KEY_LOCATION_RIGHT = 3; 851 852 /** 853 * A constant indicating that the key event originated on the 854 * numeric keypad or with a virtual key corresponding to the 855 * numeric keypad. 856 * @since 1.4 857 */ 858 public static final int KEY_LOCATION_NUMPAD = 4; 859 860 /** 861 * The unique value assigned to each of the keys on the 862 * keyboard. There is a common set of key codes that 863 * can be fired by most keyboards. 864 * The symbolic name for a key code should be used rather 865 * than the code value itself. 866 * 867 * @serial 868 * @see #getKeyCode() 869 * @see #setKeyCode(int) 870 */ 871 int keyCode; 872 873 /** 874 * <code>keyChar</code> is a valid unicode character 875 * that is fired by a key or a key combination on 876 * a keyboard. 877 * 878 * @serial 879 * @see #getKeyChar() 880 * @see #setKeyChar(char) 881 */ 882 char keyChar; 883 884 /** 885 * The location of the key on the keyboard. 886 * 887 * Some keys occur more than once on a keyboard, e.g. the left and 888 * right shift keys. Additionally, some keys occur on the numeric 889 * keypad. This variable is used to distinguish such keys. 890 * 891 * The only legal values are <code>KEY_LOCATION_UNKNOWN</code>, 892 * <code>KEY_LOCATION_STANDARD</code>, <code>KEY_LOCATION_LEFT</code>, 893 * <code>KEY_LOCATION_RIGHT</code>, and <code>KEY_LOCATION_NUMPAD</code>. 894 * 895 * @serial 896 * @see #getKeyLocation() 897 */ 898 int keyLocation; 899 900 //set from native code. 901 private transient long rawCode = 0; 902 private transient long primaryLevelUnicode = 0; 903 private transient long scancode = 0; // for MS Windows only 904 private transient long extendedKeyCode = 0; 905 906 /* 907 * JDK 1.1 serialVersionUID 908 */ 909 private static final long serialVersionUID = -2352130953028126954L; 910 911 static { 912 /* ensure that the necessary native libraries are loaded */ 913 NativeLibLoader.loadLibraries(); 914 if (!GraphicsEnvironment.isHeadless()) { 915 initIDs(); 916 } 917 918 AWTAccessor.setKeyEventAccessor( 919 new AWTAccessor.KeyEventAccessor() { 920 public void setRawCode(KeyEvent ev, long rawCode) { 921 ev.rawCode = rawCode; 922 } 923 924 public void setPrimaryLevelUnicode(KeyEvent ev, 925 long primaryLevelUnicode) { 926 ev.primaryLevelUnicode = primaryLevelUnicode; 927 } 928 929 public void setExtendedKeyCode(KeyEvent ev, 930 long extendedKeyCode) { 931 ev.extendedKeyCode = extendedKeyCode; 932 } 933 934 public Component getOriginalSource( KeyEvent ev ) { 935 return ev.originalSource; 936 } 937 }); 938 } 939 940 /** 941 * Initialize JNI field and method IDs for fields that may be 942 * accessed from C. 943 */ 944 private static native void initIDs(); 945 946 /** 947 * The original event source. 948 * 949 * Event source can be changed during processing, but in some cases 950 * we need to be able to obtain original source. 951 */ 952 private Component originalSource; 953 954 private KeyEvent(Component source, int id, long when, int modifiers, 955 int keyCode, char keyChar, int keyLocation, boolean isProxyActive) { 956 this(source, id, when, modifiers, keyCode, keyChar, keyLocation); 957 this.isProxyActive = isProxyActive; 958 } 959 960 /** 961 * Constructs a <code>KeyEvent</code> object. 962 * <p>This method throws an 963 * <code>IllegalArgumentException</code> if <code>source</code> 964 * is <code>null</code>. 965 * 966 * @param source The <code>Component</code> that originated the event 967 * @param id An integer indicating the type of event. 968 * For information on allowable values, see 969 * the class description for {@link KeyEvent} 970 * @param when A long integer that specifies the time the event 971 * occurred. 972 * Passing negative or zero value 973 * is not recommended 974 * @param modifiers The modifier keys down during event (shift, ctrl, 975 * alt, meta). 976 * Passing negative value 977 * is not recommended. 978 * Zero value means that no modifiers were passed. 979 * Use either an extended _DOWN_MASK or old _MASK modifiers, 980 * however do not mix models in the one event. 981 * The extended modifiers are preferred for using 982 * @param keyCode The integer code for an actual key, or VK_UNDEFINED 983 * (for a key-typed event) 984 * @param keyChar The Unicode character generated by this event, or 985 * CHAR_UNDEFINED (for key-pressed and key-released 986 * events which do not map to a valid Unicode character) 987 * @param keyLocation Identifies the key location. The only legal 988 * values are <code>KEY_LOCATION_UNKNOWN</code>, 989 * <code>KEY_LOCATION_STANDARD</code>, <code>KEY_LOCATION_LEFT</code>, 990 * <code>KEY_LOCATION_RIGHT</code>, and <code>KEY_LOCATION_NUMPAD</code>. 991 * @throws IllegalArgumentException 992 * if <code>id</code> is <code>KEY_TYPED</code> and 993 * <code>keyChar</code> is <code>CHAR_UNDEFINED</code>; 994 * or if <code>id</code> is <code>KEY_TYPED</code> and 995 * <code>keyCode</code> is not <code>VK_UNDEFINED</code>; 996 * or if <code>id</code> is <code>KEY_TYPED</code> and 997 * <code>keyLocation</code> is not <code>KEY_LOCATION_UNKNOWN</code>; 998 * or if <code>keyLocation</code> is not one of the legal 999 * values enumerated above. 1000 * @throws IllegalArgumentException if <code>source</code> is null 1001 * @see #getSource() 1002 * @see #getID() 1003 * @see #getWhen() 1004 * @see #getModifiers() 1005 * @see #getKeyCode() 1006 * @see #getKeyChar() 1007 * @see #getKeyLocation() 1008 * @since 1.4 1009 */ 1010 public KeyEvent(Component source, int id, long when, int modifiers, 1011 int keyCode, char keyChar, int keyLocation) { 1012 super(source, id, when, modifiers); 1013 if (id == KEY_TYPED) { 1014 if (keyChar == CHAR_UNDEFINED) { 1015 throw new IllegalArgumentException("invalid keyChar"); 1016 } 1017 if (keyCode != VK_UNDEFINED) { 1018 throw new IllegalArgumentException("invalid keyCode"); 1019 } 1020 if (keyLocation != KEY_LOCATION_UNKNOWN) { 1021 throw new IllegalArgumentException("invalid keyLocation"); 1022 } 1023 } 1024 1025 this.keyCode = keyCode; 1026 this.keyChar = keyChar; 1027 1028 if ((keyLocation < KEY_LOCATION_UNKNOWN) || 1029 (keyLocation > KEY_LOCATION_NUMPAD)) { 1030 throw new IllegalArgumentException("invalid keyLocation"); 1031 } 1032 this.keyLocation = keyLocation; 1033 if ((getModifiers() != 0) && (getModifiersEx() == 0)) { 1034 setNewModifiers(); 1035 } else if ((getModifiers() == 0) && (getModifiersEx() != 0)) { 1036 setOldModifiers(); 1037 } 1038 originalSource = source; 1039 } 1040 1041 /** 1042 * Constructs a <code>KeyEvent</code> object. 1043 * <p> This method throws an 1044 * <code>IllegalArgumentException</code> if <code>source</code> 1045 * is <code>null</code>. 1046 * 1047 * @param source The <code>Component</code> that originated the event 1048 * @param id An integer indicating the type of event. 1049 * For information on allowable values, see 1050 * the class description for {@link KeyEvent} 1051 * @param when A long integer that specifies the time the event 1052 * occurred. 1053 * Passing negative or zero value 1054 * is not recommended 1055 * @param modifiers The modifier keys down during event (shift, ctrl, 1056 * alt, meta). 1057 * Passing negative value 1058 * is not recommended. 1059 * Zero value means that no modifiers were passed. 1060 * Use either an extended _DOWN_MASK or old _MASK modifiers, 1061 * however do not mix models in the one event. 1062 * The extended modifiers are preferred for using 1063 * @param keyCode The integer code for an actual key, or VK_UNDEFINED 1064 * (for a key-typed event) 1065 * @param keyChar The Unicode character generated by this event, or 1066 * CHAR_UNDEFINED (for key-pressed and key-released 1067 * events which do not map to a valid Unicode character) 1068 * @throws IllegalArgumentException if <code>id</code> is 1069 * <code>KEY_TYPED</code> and <code>keyChar</code> is 1070 * <code>CHAR_UNDEFINED</code>; or if <code>id</code> is 1071 * <code>KEY_TYPED</code> and <code>keyCode</code> is not 1072 * <code>VK_UNDEFINED</code> 1073 * @throws IllegalArgumentException if <code>source</code> is null 1074 * @see #getSource() 1075 * @see #getID() 1076 * @see #getWhen() 1077 * @see #getModifiers() 1078 * @see #getKeyCode() 1079 * @see #getKeyChar() 1080 */ 1081 public KeyEvent(Component source, int id, long when, int modifiers, 1082 int keyCode, char keyChar) { 1083 this(source, id, when, modifiers, keyCode, keyChar, 1084 KEY_LOCATION_UNKNOWN); 1085 } 1086 1087 /** 1088 * @deprecated as of JDK1.1 1089 */ 1090 @Deprecated 1091 public KeyEvent(Component source, int id, long when, int modifiers, 1092 int keyCode) { 1093 this(source, id, when, modifiers, keyCode, (char)keyCode); 1094 } 1095 1096 /** 1097 * Returns the integer keyCode associated with the key in this event. 1098 * 1099 * @return the integer code for an actual key on the keyboard. 1100 * (For <code>KEY_TYPED</code> events, the keyCode is 1101 * <code>VK_UNDEFINED</code>.) 1102 */ 1103 public int getKeyCode() { 1104 return keyCode; 1105 } 1106 1107 /** 1108 * Set the keyCode value to indicate a physical key. 1109 * 1110 * @param keyCode an integer corresponding to an actual key on the keyboard. 1111 */ 1112 public void setKeyCode(int keyCode) { 1113 this.keyCode = keyCode; 1114 } 1115 1116 /** 1117 * Returns the character associated with the key in this event. 1118 * For example, the <code>KEY_TYPED</code> event for shift + "a" 1119 * returns the value for "A". 1120 * <p> 1121 * <code>KEY_PRESSED</code> and <code>KEY_RELEASED</code> events 1122 * are not intended for reporting of character input. Therefore, 1123 * the values returned by this method are guaranteed to be 1124 * meaningful only for <code>KEY_TYPED</code> events. 1125 * 1126 * @return the Unicode character defined for this key event. 1127 * If no valid Unicode character exists for this key event, 1128 * <code>CHAR_UNDEFINED</code> is returned. 1129 */ 1130 public char getKeyChar() { 1131 return keyChar; 1132 } 1133 1134 /** 1135 * Set the keyChar value to indicate a logical character. 1136 * 1137 * @param keyChar a char corresponding to to the combination of keystrokes 1138 * that make up this event. 1139 */ 1140 public void setKeyChar(char keyChar) { 1141 this.keyChar = keyChar; 1142 } 1143 1144 /** 1145 * Set the modifiers to indicate additional keys that were held down 1146 * (e.g. shift, ctrl, alt, meta) defined as part of InputEvent. 1147 * <p> 1148 * NOTE: use of this method is not recommended, because many AWT 1149 * implementations do not recognize modifier changes. This is 1150 * especially true for <code>KEY_TYPED</code> events where the shift 1151 * modifier is changed. 1152 * 1153 * @param modifiers an integer combination of the modifier constants. 1154 * @see InputEvent 1155 * @deprecated as of JDK1.1.4 1156 */ 1157 @Deprecated 1158 public void setModifiers(int modifiers) { 1159 this.modifiers = modifiers; 1160 if ((getModifiers() != 0) && (getModifiersEx() == 0)) { 1161 setNewModifiers(); 1162 } else if ((getModifiers() == 0) && (getModifiersEx() != 0)) { 1163 setOldModifiers(); 1164 } 1165 } 1166 1167 /** 1168 * Returns the location of the key that originated this key event. 1169 * 1170 * Some keys occur more than once on a keyboard, e.g. the left and 1171 * right shift keys. Additionally, some keys occur on the numeric 1172 * keypad. This provides a way of distinguishing such keys. 1173 * 1174 * @return the location of the key that was pressed or released. 1175 * Always returns <code>KEY_LOCATION_UNKNOWN</code> for 1176 * <code>KEY_TYPED</code> events. 1177 * @since 1.4 1178 */ 1179 public int getKeyLocation() { 1180 return keyLocation; 1181 } 1182 1183 /** 1184 * Returns a String describing the keyCode, such as "HOME", "F1" or "A". 1185 * These strings can be localized by changing the awt.properties file. 1186 * 1187 * @return a string containing a text description for a physical key, 1188 * identified by its keyCode 1189 */ 1190 public static String getKeyText(int keyCode) { 1191 if (keyCode >= VK_0 && keyCode <= VK_9 || 1192 keyCode >= VK_A && keyCode <= VK_Z) { 1193 return String.valueOf((char)keyCode); 1194 } 1195 1196 switch(keyCode) { 1197 case VK_ENTER: return Toolkit.getProperty("AWT.enter", "Enter"); 1198 case VK_BACK_SPACE: return Toolkit.getProperty("AWT.backSpace", "Backspace"); 1199 case VK_TAB: return Toolkit.getProperty("AWT.tab", "Tab"); 1200 case VK_CANCEL: return Toolkit.getProperty("AWT.cancel", "Cancel"); 1201 case VK_CLEAR: return Toolkit.getProperty("AWT.clear", "Clear"); 1202 case VK_COMPOSE: return Toolkit.getProperty("AWT.compose", "Compose"); 1203 case VK_PAUSE: return Toolkit.getProperty("AWT.pause", "Pause"); 1204 case VK_CAPS_LOCK: return Toolkit.getProperty("AWT.capsLock", "Caps Lock"); 1205 case VK_ESCAPE: return Toolkit.getProperty("AWT.escape", "Escape"); 1206 case VK_SPACE: return Toolkit.getProperty("AWT.space", "Space"); 1207 case VK_PAGE_UP: return Toolkit.getProperty("AWT.pgup", "Page Up"); 1208 case VK_PAGE_DOWN: return Toolkit.getProperty("AWT.pgdn", "Page Down"); 1209 case VK_END: return Toolkit.getProperty("AWT.end", "End"); 1210 case VK_HOME: return Toolkit.getProperty("AWT.home", "Home"); 1211 case VK_LEFT: return Toolkit.getProperty("AWT.left", "Left"); 1212 case VK_UP: return Toolkit.getProperty("AWT.up", "Up"); 1213 case VK_RIGHT: return Toolkit.getProperty("AWT.right", "Right"); 1214 case VK_DOWN: return Toolkit.getProperty("AWT.down", "Down"); 1215 case VK_BEGIN: return Toolkit.getProperty("AWT.begin", "Begin"); 1216 1217 // modifiers 1218 case VK_SHIFT: return Toolkit.getProperty("AWT.shift", "Shift"); 1219 case VK_CONTROL: return Toolkit.getProperty("AWT.control", "Control"); 1220 case VK_ALT: return Toolkit.getProperty("AWT.alt", "Alt"); 1221 case VK_META: return Toolkit.getProperty("AWT.meta", "Meta"); 1222 case VK_ALT_GRAPH: return Toolkit.getProperty("AWT.altGraph", "Alt Graph"); 1223 1224 // punctuation 1225 case VK_COMMA: return Toolkit.getProperty("AWT.comma", "Comma"); 1226 case VK_PERIOD: return Toolkit.getProperty("AWT.period", "Period"); 1227 case VK_SLASH: return Toolkit.getProperty("AWT.slash", "Slash"); 1228 case VK_SEMICOLON: return Toolkit.getProperty("AWT.semicolon", "Semicolon"); 1229 case VK_EQUALS: return Toolkit.getProperty("AWT.equals", "Equals"); 1230 case VK_OPEN_BRACKET: return Toolkit.getProperty("AWT.openBracket", "Open Bracket"); 1231 case VK_BACK_SLASH: return Toolkit.getProperty("AWT.backSlash", "Back Slash"); 1232 case VK_CLOSE_BRACKET: return Toolkit.getProperty("AWT.closeBracket", "Close Bracket"); 1233 1234 // numpad numeric keys handled below 1235 case VK_MULTIPLY: return Toolkit.getProperty("AWT.multiply", "NumPad *"); 1236 case VK_ADD: return Toolkit.getProperty("AWT.add", "NumPad +"); 1237 case VK_SEPARATOR: return Toolkit.getProperty("AWT.separator", "NumPad ,"); 1238 case VK_SUBTRACT: return Toolkit.getProperty("AWT.subtract", "NumPad -"); 1239 case VK_DECIMAL: return Toolkit.getProperty("AWT.decimal", "NumPad ."); 1240 case VK_DIVIDE: return Toolkit.getProperty("AWT.divide", "NumPad /"); 1241 case VK_DELETE: return Toolkit.getProperty("AWT.delete", "Delete"); 1242 case VK_NUM_LOCK: return Toolkit.getProperty("AWT.numLock", "Num Lock"); 1243 case VK_SCROLL_LOCK: return Toolkit.getProperty("AWT.scrollLock", "Scroll Lock"); 1244 1245 case VK_WINDOWS: return Toolkit.getProperty("AWT.windows", "Windows"); 1246 case VK_CONTEXT_MENU: return Toolkit.getProperty("AWT.context", "Context Menu"); 1247 1248 case VK_F1: return Toolkit.getProperty("AWT.f1", "F1"); 1249 case VK_F2: return Toolkit.getProperty("AWT.f2", "F2"); 1250 case VK_F3: return Toolkit.getProperty("AWT.f3", "F3"); 1251 case VK_F4: return Toolkit.getProperty("AWT.f4", "F4"); 1252 case VK_F5: return Toolkit.getProperty("AWT.f5", "F5"); 1253 case VK_F6: return Toolkit.getProperty("AWT.f6", "F6"); 1254 case VK_F7: return Toolkit.getProperty("AWT.f7", "F7"); 1255 case VK_F8: return Toolkit.getProperty("AWT.f8", "F8"); 1256 case VK_F9: return Toolkit.getProperty("AWT.f9", "F9"); 1257 case VK_F10: return Toolkit.getProperty("AWT.f10", "F10"); 1258 case VK_F11: return Toolkit.getProperty("AWT.f11", "F11"); 1259 case VK_F12: return Toolkit.getProperty("AWT.f12", "F12"); 1260 case VK_F13: return Toolkit.getProperty("AWT.f13", "F13"); 1261 case VK_F14: return Toolkit.getProperty("AWT.f14", "F14"); 1262 case VK_F15: return Toolkit.getProperty("AWT.f15", "F15"); 1263 case VK_F16: return Toolkit.getProperty("AWT.f16", "F16"); 1264 case VK_F17: return Toolkit.getProperty("AWT.f17", "F17"); 1265 case VK_F18: return Toolkit.getProperty("AWT.f18", "F18"); 1266 case VK_F19: return Toolkit.getProperty("AWT.f19", "F19"); 1267 case VK_F20: return Toolkit.getProperty("AWT.f20", "F20"); 1268 case VK_F21: return Toolkit.getProperty("AWT.f21", "F21"); 1269 case VK_F22: return Toolkit.getProperty("AWT.f22", "F22"); 1270 case VK_F23: return Toolkit.getProperty("AWT.f23", "F23"); 1271 case VK_F24: return Toolkit.getProperty("AWT.f24", "F24"); 1272 1273 case VK_PRINTSCREEN: return Toolkit.getProperty("AWT.printScreen", "Print Screen"); 1274 case VK_INSERT: return Toolkit.getProperty("AWT.insert", "Insert"); 1275 case VK_HELP: return Toolkit.getProperty("AWT.help", "Help"); 1276 case VK_BACK_QUOTE: return Toolkit.getProperty("AWT.backQuote", "Back Quote"); 1277 case VK_QUOTE: return Toolkit.getProperty("AWT.quote", "Quote"); 1278 1279 case VK_KP_UP: return Toolkit.getProperty("AWT.up", "Up"); 1280 case VK_KP_DOWN: return Toolkit.getProperty("AWT.down", "Down"); 1281 case VK_KP_LEFT: return Toolkit.getProperty("AWT.left", "Left"); 1282 case VK_KP_RIGHT: return Toolkit.getProperty("AWT.right", "Right"); 1283 1284 case VK_DEAD_GRAVE: return Toolkit.getProperty("AWT.deadGrave", "Dead Grave"); 1285 case VK_DEAD_ACUTE: return Toolkit.getProperty("AWT.deadAcute", "Dead Acute"); 1286 case VK_DEAD_CIRCUMFLEX: return Toolkit.getProperty("AWT.deadCircumflex", "Dead Circumflex"); 1287 case VK_DEAD_TILDE: return Toolkit.getProperty("AWT.deadTilde", "Dead Tilde"); 1288 case VK_DEAD_MACRON: return Toolkit.getProperty("AWT.deadMacron", "Dead Macron"); 1289 case VK_DEAD_BREVE: return Toolkit.getProperty("AWT.deadBreve", "Dead Breve"); 1290 case VK_DEAD_ABOVEDOT: return Toolkit.getProperty("AWT.deadAboveDot", "Dead Above Dot"); 1291 case VK_DEAD_DIAERESIS: return Toolkit.getProperty("AWT.deadDiaeresis", "Dead Diaeresis"); 1292 case VK_DEAD_ABOVERING: return Toolkit.getProperty("AWT.deadAboveRing", "Dead Above Ring"); 1293 case VK_DEAD_DOUBLEACUTE: return Toolkit.getProperty("AWT.deadDoubleAcute", "Dead Double Acute"); 1294 case VK_DEAD_CARON: return Toolkit.getProperty("AWT.deadCaron", "Dead Caron"); 1295 case VK_DEAD_CEDILLA: return Toolkit.getProperty("AWT.deadCedilla", "Dead Cedilla"); 1296 case VK_DEAD_OGONEK: return Toolkit.getProperty("AWT.deadOgonek", "Dead Ogonek"); 1297 case VK_DEAD_IOTA: return Toolkit.getProperty("AWT.deadIota", "Dead Iota"); 1298 case VK_DEAD_VOICED_SOUND: return Toolkit.getProperty("AWT.deadVoicedSound", "Dead Voiced Sound"); 1299 case VK_DEAD_SEMIVOICED_SOUND: return Toolkit.getProperty("AWT.deadSemivoicedSound", "Dead Semivoiced Sound"); 1300 1301 case VK_AMPERSAND: return Toolkit.getProperty("AWT.ampersand", "Ampersand"); 1302 case VK_ASTERISK: return Toolkit.getProperty("AWT.asterisk", "Asterisk"); 1303 case VK_QUOTEDBL: return Toolkit.getProperty("AWT.quoteDbl", "Double Quote"); 1304 case VK_LESS: return Toolkit.getProperty("AWT.Less", "Less"); 1305 case VK_GREATER: return Toolkit.getProperty("AWT.greater", "Greater"); 1306 case VK_BRACELEFT: return Toolkit.getProperty("AWT.braceLeft", "Left Brace"); 1307 case VK_BRACERIGHT: return Toolkit.getProperty("AWT.braceRight", "Right Brace"); 1308 case VK_AT: return Toolkit.getProperty("AWT.at", "At"); 1309 case VK_COLON: return Toolkit.getProperty("AWT.colon", "Colon"); 1310 case VK_CIRCUMFLEX: return Toolkit.getProperty("AWT.circumflex", "Circumflex"); 1311 case VK_DOLLAR: return Toolkit.getProperty("AWT.dollar", "Dollar"); 1312 case VK_EURO_SIGN: return Toolkit.getProperty("AWT.euro", "Euro"); 1313 case VK_EXCLAMATION_MARK: return Toolkit.getProperty("AWT.exclamationMark", "Exclamation Mark"); 1314 case VK_INVERTED_EXCLAMATION_MARK: return Toolkit.getProperty("AWT.invertedExclamationMark", "Inverted Exclamation Mark"); 1315 case VK_LEFT_PARENTHESIS: return Toolkit.getProperty("AWT.leftParenthesis", "Left Parenthesis"); 1316 case VK_NUMBER_SIGN: return Toolkit.getProperty("AWT.numberSign", "Number Sign"); 1317 case VK_MINUS: return Toolkit.getProperty("AWT.minus", "Minus"); 1318 case VK_PLUS: return Toolkit.getProperty("AWT.plus", "Plus"); 1319 case VK_RIGHT_PARENTHESIS: return Toolkit.getProperty("AWT.rightParenthesis", "Right Parenthesis"); 1320 case VK_UNDERSCORE: return Toolkit.getProperty("AWT.underscore", "Underscore"); 1321 1322 case VK_FINAL: return Toolkit.getProperty("AWT.final", "Final"); 1323 case VK_CONVERT: return Toolkit.getProperty("AWT.convert", "Convert"); 1324 case VK_NONCONVERT: return Toolkit.getProperty("AWT.noconvert", "No Convert"); 1325 case VK_ACCEPT: return Toolkit.getProperty("AWT.accept", "Accept"); 1326 case VK_MODECHANGE: return Toolkit.getProperty("AWT.modechange", "Mode Change"); 1327 case VK_KANA: return Toolkit.getProperty("AWT.kana", "Kana"); 1328 case VK_KANJI: return Toolkit.getProperty("AWT.kanji", "Kanji"); 1329 case VK_ALPHANUMERIC: return Toolkit.getProperty("AWT.alphanumeric", "Alphanumeric"); 1330 case VK_KATAKANA: return Toolkit.getProperty("AWT.katakana", "Katakana"); 1331 case VK_HIRAGANA: return Toolkit.getProperty("AWT.hiragana", "Hiragana"); 1332 case VK_FULL_WIDTH: return Toolkit.getProperty("AWT.fullWidth", "Full-Width"); 1333 case VK_HALF_WIDTH: return Toolkit.getProperty("AWT.halfWidth", "Half-Width"); 1334 case VK_ROMAN_CHARACTERS: return Toolkit.getProperty("AWT.romanCharacters", "Roman Characters"); 1335 case VK_ALL_CANDIDATES: return Toolkit.getProperty("AWT.allCandidates", "All Candidates"); 1336 case VK_PREVIOUS_CANDIDATE: return Toolkit.getProperty("AWT.previousCandidate", "Previous Candidate"); 1337 case VK_CODE_INPUT: return Toolkit.getProperty("AWT.codeInput", "Code Input"); 1338 case VK_JAPANESE_KATAKANA: return Toolkit.getProperty("AWT.japaneseKatakana", "Japanese Katakana"); 1339 case VK_JAPANESE_HIRAGANA: return Toolkit.getProperty("AWT.japaneseHiragana", "Japanese Hiragana"); 1340 case VK_JAPANESE_ROMAN: return Toolkit.getProperty("AWT.japaneseRoman", "Japanese Roman"); 1341 case VK_KANA_LOCK: return Toolkit.getProperty("AWT.kanaLock", "Kana Lock"); 1342 case VK_INPUT_METHOD_ON_OFF: return Toolkit.getProperty("AWT.inputMethodOnOff", "Input Method On/Off"); 1343 1344 case VK_AGAIN: return Toolkit.getProperty("AWT.again", "Again"); 1345 case VK_UNDO: return Toolkit.getProperty("AWT.undo", "Undo"); 1346 case VK_COPY: return Toolkit.getProperty("AWT.copy", "Copy"); 1347 case VK_PASTE: return Toolkit.getProperty("AWT.paste", "Paste"); 1348 case VK_CUT: return Toolkit.getProperty("AWT.cut", "Cut"); 1349 case VK_FIND: return Toolkit.getProperty("AWT.find", "Find"); 1350 case VK_PROPS: return Toolkit.getProperty("AWT.props", "Props"); 1351 case VK_STOP: return Toolkit.getProperty("AWT.stop", "Stop"); 1352 } 1353 1354 if (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) { 1355 String numpad = Toolkit.getProperty("AWT.numpad", "NumPad"); 1356 char c = (char)(keyCode - VK_NUMPAD0 + '0'); 1357 return numpad + "-" + c; 1358 } 1359 1360 if ((keyCode & 0x01000000) != 0) { 1361 return String.valueOf((char)(keyCode ^ 0x01000000 )); 1362 } 1363 String unknown = Toolkit.getProperty("AWT.unknown", "Unknown"); 1364 return unknown + " keyCode: 0x" + Integer.toString(keyCode, 16); 1365 } 1366 1367 /** 1368 * Returns a <code>String</code> describing the modifier key(s), 1369 * such as "Shift", or "Ctrl+Shift". These strings can be 1370 * localized by changing the <code>awt.properties</code> file. 1371 * <p> 1372 * Note that <code>InputEvent.ALT_MASK</code> and 1373 * <code>InputEvent.BUTTON2_MASK</code> have the same value, 1374 * so the string "Alt" is returned for both modifiers. Likewise, 1375 * <code>InputEvent.META_MASK</code> and 1376 * <code>InputEvent.BUTTON3_MASK</code> have the same value, 1377 * so the string "Meta" is returned for both modifiers. 1378 * 1379 * @return string a text description of the combination of modifier 1380 * keys that were held down during the event 1381 * @see InputEvent#getModifiersExText(int) 1382 */ 1383 public static String getKeyModifiersText(int modifiers) { 1384 StringBuilder buf = new StringBuilder(); 1385 if ((modifiers & InputEvent.META_MASK) != 0) { 1386 buf.append(Toolkit.getProperty("AWT.meta", "Meta")); 1387 buf.append("+"); 1388 } 1389 if ((modifiers & InputEvent.CTRL_MASK) != 0) { 1390 buf.append(Toolkit.getProperty("AWT.control", "Ctrl")); 1391 buf.append("+"); 1392 } 1393 if ((modifiers & InputEvent.ALT_MASK) != 0) { 1394 buf.append(Toolkit.getProperty("AWT.alt", "Alt")); 1395 buf.append("+"); 1396 } 1397 if ((modifiers & InputEvent.SHIFT_MASK) != 0) { 1398 buf.append(Toolkit.getProperty("AWT.shift", "Shift")); 1399 buf.append("+"); 1400 } 1401 if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) { 1402 buf.append(Toolkit.getProperty("AWT.altGraph", "Alt Graph")); 1403 buf.append("+"); 1404 } 1405 if ((modifiers & InputEvent.BUTTON1_MASK) != 0) { 1406 buf.append(Toolkit.getProperty("AWT.button1", "Button1")); 1407 buf.append("+"); 1408 } 1409 if (buf.length() > 0) { 1410 buf.setLength(buf.length()-1); // remove trailing '+' 1411 } 1412 return buf.toString(); 1413 } 1414 1415 1416 /** 1417 * Returns whether the key in this event is an "action" key. 1418 * Typically an action key does not fire a unicode character and is 1419 * not a modifier key. 1420 * 1421 * @return <code>true</code> if the key is an "action" key, 1422 * <code>false</code> otherwise 1423 */ 1424 public boolean isActionKey() { 1425 switch (keyCode) { 1426 case VK_HOME: 1427 case VK_END: 1428 case VK_PAGE_UP: 1429 case VK_PAGE_DOWN: 1430 case VK_UP: 1431 case VK_DOWN: 1432 case VK_LEFT: 1433 case VK_RIGHT: 1434 case VK_BEGIN: 1435 1436 case VK_KP_LEFT: 1437 case VK_KP_UP: 1438 case VK_KP_RIGHT: 1439 case VK_KP_DOWN: 1440 1441 case VK_F1: 1442 case VK_F2: 1443 case VK_F3: 1444 case VK_F4: 1445 case VK_F5: 1446 case VK_F6: 1447 case VK_F7: 1448 case VK_F8: 1449 case VK_F9: 1450 case VK_F10: 1451 case VK_F11: 1452 case VK_F12: 1453 case VK_F13: 1454 case VK_F14: 1455 case VK_F15: 1456 case VK_F16: 1457 case VK_F17: 1458 case VK_F18: 1459 case VK_F19: 1460 case VK_F20: 1461 case VK_F21: 1462 case VK_F22: 1463 case VK_F23: 1464 case VK_F24: 1465 case VK_PRINTSCREEN: 1466 case VK_SCROLL_LOCK: 1467 case VK_CAPS_LOCK: 1468 case VK_NUM_LOCK: 1469 case VK_PAUSE: 1470 case VK_INSERT: 1471 1472 case VK_FINAL: 1473 case VK_CONVERT: 1474 case VK_NONCONVERT: 1475 case VK_ACCEPT: 1476 case VK_MODECHANGE: 1477 case VK_KANA: 1478 case VK_KANJI: 1479 case VK_ALPHANUMERIC: 1480 case VK_KATAKANA: 1481 case VK_HIRAGANA: 1482 case VK_FULL_WIDTH: 1483 case VK_HALF_WIDTH: 1484 case VK_ROMAN_CHARACTERS: 1485 case VK_ALL_CANDIDATES: 1486 case VK_PREVIOUS_CANDIDATE: 1487 case VK_CODE_INPUT: 1488 case VK_JAPANESE_KATAKANA: 1489 case VK_JAPANESE_HIRAGANA: 1490 case VK_JAPANESE_ROMAN: 1491 case VK_KANA_LOCK: 1492 case VK_INPUT_METHOD_ON_OFF: 1493 1494 case VK_AGAIN: 1495 case VK_UNDO: 1496 case VK_COPY: 1497 case VK_PASTE: 1498 case VK_CUT: 1499 case VK_FIND: 1500 case VK_PROPS: 1501 case VK_STOP: 1502 1503 case VK_HELP: 1504 case VK_WINDOWS: 1505 case VK_CONTEXT_MENU: 1506 return true; 1507 } 1508 return false; 1509 } 1510 1511 /** 1512 * Returns a parameter string identifying this event. 1513 * This method is useful for event logging and for debugging. 1514 * 1515 * @return a string identifying the event and its attributes 1516 */ 1517 public String paramString() { 1518 StringBuilder str = new StringBuilder(100); 1519 1520 switch (id) { 1521 case KEY_PRESSED: 1522 str.append("KEY_PRESSED"); 1523 break; 1524 case KEY_RELEASED: 1525 str.append("KEY_RELEASED"); 1526 break; 1527 case KEY_TYPED: 1528 str.append("KEY_TYPED"); 1529 break; 1530 default: 1531 str.append("unknown type"); 1532 break; 1533 } 1534 1535 str.append(",keyCode=").append(keyCode); 1536 str.append(",keyText=").append(getKeyText(keyCode)); 1537 1538 /* Some keychars don't print well, e.g. escape, backspace, 1539 * tab, return, delete, cancel. Get keyText for the keyCode 1540 * instead of the keyChar. 1541 */ 1542 str.append(",keyChar="); 1543 switch (keyChar) { 1544 case '\b': 1545 str.append(getKeyText(VK_BACK_SPACE)); 1546 break; 1547 case '\t': 1548 str.append(getKeyText(VK_TAB)); 1549 break; 1550 case '\n': 1551 str.append(getKeyText(VK_ENTER)); 1552 break; 1553 case '\u0018': 1554 str.append(getKeyText(VK_CANCEL)); 1555 break; 1556 case '\u001b': 1557 str.append(getKeyText(VK_ESCAPE)); 1558 break; 1559 case '\u007f': 1560 str.append(getKeyText(VK_DELETE)); 1561 break; 1562 case CHAR_UNDEFINED: 1563 str.append(Toolkit.getProperty("AWT.undefined", "Undefined")); 1564 str.append(" keyChar"); 1565 break; 1566 default: 1567 str.append("'").append(keyChar).append("'"); 1568 break; 1569 } 1570 1571 if (getModifiers() != 0) { 1572 str.append(",modifiers=").append(getKeyModifiersText(modifiers)); 1573 } 1574 if (getModifiersEx() != 0) { 1575 str.append(",extModifiers=").append(getModifiersExText(modifiers)); 1576 } 1577 1578 str.append(",keyLocation="); 1579 switch (keyLocation) { 1580 case KEY_LOCATION_UNKNOWN: 1581 str.append("KEY_LOCATION_UNKNOWN"); 1582 break; 1583 case KEY_LOCATION_STANDARD: 1584 str.append("KEY_LOCATION_STANDARD"); 1585 break; 1586 case KEY_LOCATION_LEFT: 1587 str.append("KEY_LOCATION_LEFT"); 1588 break; 1589 case KEY_LOCATION_RIGHT: 1590 str.append("KEY_LOCATION_RIGHT"); 1591 break; 1592 case KEY_LOCATION_NUMPAD: 1593 str.append("KEY_LOCATION_NUMPAD"); 1594 break; 1595 default: 1596 str.append("KEY_LOCATION_UNKNOWN"); 1597 break; 1598 } 1599 str.append(",rawCode=").append(rawCode); 1600 str.append(",primaryLevelUnicode=").append(primaryLevelUnicode); 1601 str.append(",scancode=").append(scancode); 1602 str.append(",extendedKeyCode=0x").append(Long.toHexString(extendedKeyCode)); 1603 1604 return str.toString(); 1605 } 1606 /** 1607 * Returns an extended key code for the event. 1608 * The extended key code is a unique id assigned to a key on the keyboard 1609 * just like {@code keyCode}. However, unlike {@code keyCode}, this value depends on the 1610 * current keyboard layout. For instance, pressing the left topmost letter key 1611 * in a common English layout produces the same value as {@code keyCode}, {@code VK_Q}. 1612 * Pressing the same key in a regular Russian layout gives another code, unique for the 1613 * letter "Cyrillic I short". 1614 * 1615 * @since 1.7 1616 * 1617 */ 1618 public int getExtendedKeyCode() { 1619 return (int)extendedKeyCode; 1620 } 1621 /** 1622 * Returns an extended key code for a unicode character. 1623 * 1624 * @return for a unicode character with a corresponding {@code VK_} constant -- this 1625 * {@code VK_} constant; for a character appearing on the primary 1626 * level of a known keyboard layout -- a unique integer. 1627 * If a character does not appear on the primary level of a known keyboard, 1628 * {@code VK_UNDEFINED} is returned. 1629 * 1630 * @since 1.7 1631 * 1632 */ 1633 public static int getExtendedKeyCodeForChar(int c) { 1634 // Return a keycode (if any) associated with a character. 1635 return sun.awt.ExtendedKeyCodes.getExtendedKeyCodeForChar(c); 1636 } 1637 1638 /** 1639 * Sets new modifiers by the old ones. The key modifiers 1640 * override overlaping mouse modifiers. 1641 */ 1642 private void setNewModifiers() { 1643 if ((modifiers & SHIFT_MASK) != 0) { 1644 modifiers |= SHIFT_DOWN_MASK; 1645 } 1646 if ((modifiers & ALT_MASK) != 0) { 1647 modifiers |= ALT_DOWN_MASK; 1648 } 1649 if ((modifiers & CTRL_MASK) != 0) { 1650 modifiers |= CTRL_DOWN_MASK; 1651 } 1652 if ((modifiers & META_MASK) != 0) { 1653 modifiers |= META_DOWN_MASK; 1654 } 1655 if ((modifiers & ALT_GRAPH_MASK) != 0) { 1656 modifiers |= ALT_GRAPH_DOWN_MASK; 1657 } 1658 if ((modifiers & BUTTON1_MASK) != 0) { 1659 modifiers |= BUTTON1_DOWN_MASK; 1660 } 1661 } 1662 1663 /** 1664 * Sets old modifiers by the new ones. 1665 */ 1666 private void setOldModifiers() { 1667 if ((modifiers & SHIFT_DOWN_MASK) != 0) { 1668 modifiers |= SHIFT_MASK; 1669 } 1670 if ((modifiers & ALT_DOWN_MASK) != 0) { 1671 modifiers |= ALT_MASK; 1672 } 1673 if ((modifiers & CTRL_DOWN_MASK) != 0) { 1674 modifiers |= CTRL_MASK; 1675 } 1676 if ((modifiers & META_DOWN_MASK) != 0) { 1677 modifiers |= META_MASK; 1678 } 1679 if ((modifiers & ALT_GRAPH_DOWN_MASK) != 0) { 1680 modifiers |= ALT_GRAPH_MASK; 1681 } 1682 if ((modifiers & BUTTON1_DOWN_MASK) != 0) { 1683 modifiers |= BUTTON1_MASK; 1684 } 1685 } 1686 1687 /** 1688 * Sets new modifiers by the old ones. The key modifiers 1689 * override overlaping mouse modifiers. 1690 * @serial 1691 */ 1692 private void readObject(ObjectInputStream s) 1693 throws IOException, ClassNotFoundException { 1694 s.defaultReadObject(); 1695 if (getModifiers() != 0 && getModifiersEx() == 0) { 1696 setNewModifiers(); 1697 } 1698 } 1699 }