001 /* KeyEvent.java -- event for key presses 002 Copyright (C) 1999, 2002, 2004, 2005 Free Software Foundation, Inc. 003 004 This file is part of GNU Classpath. 005 006 GNU Classpath is free software; you can redistribute it and/or modify 007 it under the terms of the GNU General Public License as published by 008 the Free Software Foundation; either version 2, or (at your option) 009 any later version. 010 011 GNU Classpath is distributed in the hope that it will be useful, but 012 WITHOUT ANY WARRANTY; without even the implied warranty of 013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 General Public License for more details. 015 016 You should have received a copy of the GNU General Public License 017 along with GNU Classpath; see the file COPYING. If not, write to the 018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 019 02110-1301 USA. 020 021 Linking this library statically or dynamically with other modules is 022 making a combined work based on this library. Thus, the terms and 023 conditions of the GNU General Public License cover the whole 024 combination. 025 026 As a special exception, the copyright holders of this library give you 027 permission to link this library with independent modules to produce an 028 executable, regardless of the license terms of these independent 029 modules, and to copy and distribute the resulting executable under 030 terms of your choice, provided that you also meet, for each linked 031 independent module, the terms and conditions of the license of that 032 module. An independent module is a module which is not derived from 033 or based on this library. If you modify this library, you may extend 034 this exception to your version of the library, but you are not 035 obligated to do so. If you do not wish to do so, delete this 036 exception statement from your version. */ 037 038 039 package java.awt.event; 040 041 import gnu.java.awt.EventModifier; 042 043 import java.awt.Component; 044 import java.io.IOException; 045 import java.io.ObjectInputStream; 046 047 /** 048 * This event is generated when a key is pressed or released. There are two 049 * categories of key events: 050 * 051 * <p><em>"Key typed" events</em> are higher-level, and have already 052 * compensated for modifiers and keyboard layout to generate a single Unicode 053 * character. It may take several key press events to generate one key typed. 054 * The <code>getKeyCode</code> method will return <code>VK_UNDEFINED</code>, 055 * and <code>getKeyChar</code> will return a valid Unicode character or 056 * <code>CHAR_UNDEFINED</code>. 057 * 058 * <p><em>"Key pressed" and "key released" events</em> are lower-level, and 059 * are platform and keyboard dependent. They correspond to the actaul motion 060 * on a keyboard, and return a virtual key code which labels the key that was 061 * pressed. The <code>getKeyCode</code> method will return one of the 062 * <code>VK_*</code> constants (except VK_UNDEFINED), and the 063 * <code>getKeyChar</code> method is undefined. 064 * 065 * <p>Some keys do not generate key typed events, such as the F1 or HELP keys. 066 * Not all keyboards can generate all virtual keys, and no attempt is made to 067 * simulate the ones that can't be typed. Virtual keys correspond to the 068 * keyboard layout, so for example, VK_Q in English is VK_A in French. Also, 069 * there are some additional virtual keys to ease handling of actions, such 070 * as VK_ALL_CANDIDATES in place of ALT+VK_CONVERT. Do not rely on the value 071 * of the VK_* constants, except for VK_ENTER, VK_BACK_SPACE, and VK_TAB. 072 * 073 * @author Aaron M. Renn (arenn@urbanophile.com) 074 * @author Eric Blake (ebb9@email.byu.edu) 075 * @see KeyAdapter 076 * @see KeyListener 077 * @since 1.1 078 * @status updated to 1.4 079 */ 080 public class KeyEvent extends InputEvent 081 { 082 /** 083 * Compatible with JDK 1.1+. 084 */ 085 private static final long serialVersionUID = -2352130953028126954L; 086 087 /** This is the first id in the range of event ids used by this class. */ 088 public static final int KEY_FIRST = 400; 089 090 /** This is the last id in the range of event ids used by this class. */ 091 public static final int KEY_LAST = 402; 092 093 /** 094 * This event id indicates a key was typed, which is a key press followed 095 * by a key release to generate an actual Unicode character. It may take 096 * several key presses to generate one key typed event, and some action 097 * keys have no corresponding key typed. 098 */ 099 public static final int KEY_TYPED = 400; 100 101 /** This event id indicates a key was pressed. */ 102 public static final int KEY_PRESSED = 401; 103 104 /** This event it indicates a key was released. */ 105 public static final int KEY_RELEASED = 402; 106 107 /** The virtual key Enter, which will always map to '\n'. */ 108 public static final int VK_ENTER = '\n'; 109 110 /** The virtual key Backspace, which will always map to '\b'. */ 111 public static final int VK_BACK_SPACE = '\b'; 112 113 /** The virtual key Tab, which will always map to '\t'. */ 114 public static final int VK_TAB = '\t'; 115 116 /** The virtual key Cancel. */ 117 public static final int VK_CANCEL = 3; 118 119 /** The virtual key VK_CLEAR. */ 120 public static final int VK_CLEAR = 12; 121 122 /** The virtual key VK_SHIFT. */ 123 public static final int VK_SHIFT = 16; 124 125 /** The virtual key VK_CONTROL. */ 126 public static final int VK_CONTROL = 17; 127 128 /** The virtual key VK_ALT. */ 129 public static final int VK_ALT = 18; 130 131 /** The virtual key VK_PAUSE. */ 132 public static final int VK_PAUSE = 19; 133 134 /** The virtual key VK_CAPS_LOCK. */ 135 public static final int VK_CAPS_LOCK = 20; 136 137 /** The virtual key VK_ESCAPE. */ 138 public static final int VK_ESCAPE = 27; 139 140 /** The virtual key VK_SPACE. */ 141 public static final int VK_SPACE = ' '; 142 143 /** The virtual key VK_PAGE_UP. */ 144 public static final int VK_PAGE_UP = 33; 145 146 /** The virtual key VK_PAGE_DOWN. */ 147 public static final int VK_PAGE_DOWN = 34; 148 149 /** The virtual key VK_END. */ 150 public static final int VK_END = 35; 151 152 /** The virtual key VK_HOME. */ 153 public static final int VK_HOME = 36; 154 155 /** 156 * The virtual key for the non-numpad VK_LEFT. 157 * 158 * @see #VK_KP_LEFT 159 */ 160 public static final int VK_LEFT = 37; 161 162 /** 163 * The virtual key for the non-numpad VK_UP. 164 * 165 * @see #VK_KP_UP 166 */ 167 public static final int VK_UP = 38; 168 169 /** 170 * The virtual key for the non-numpad VK_RIGHT. 171 * 172 * @see #VK_KP_RIGHT 173 */ 174 public static final int VK_RIGHT = 39; 175 176 /** 177 * The virtual key for the non-numpad VK_DOWN. 178 * 179 * @see #VK_KP_DOWN 180 */ 181 public static final int VK_DOWN = 40; 182 183 /** The virtual key VK_COMMA. */ 184 public static final int VK_COMMA = ','; 185 186 /** 187 * The virtual key VK_MINUS. 188 * 189 * @since 1.2 190 */ 191 public static final int VK_MINUS = '-'; 192 193 /** The virtual key VK_PERIOD. */ 194 public static final int VK_PERIOD = '.'; 195 196 /** The virtual key VK_SLASH. */ 197 public static final int VK_SLASH = '/'; 198 199 /** The virtual key VK_0. */ 200 public static final int VK_0 = '0'; 201 202 /** The virtual key VK_1. */ 203 public static final int VK_1 = '1'; 204 205 /** The virtual key VK_2. */ 206 public static final int VK_2 = '2'; 207 208 /** The virtual key VK_3. */ 209 public static final int VK_3 = '3'; 210 211 /** The virtual key VK_4. */ 212 public static final int VK_4 = '4'; 213 214 /** The virtual key VK_5. */ 215 public static final int VK_5 = '5'; 216 217 /** The virtual key VK_6. */ 218 public static final int VK_6 = '6'; 219 220 /** The virtual key VK_7. */ 221 public static final int VK_7 = '7'; 222 223 /** The virtual key VK_8. */ 224 public static final int VK_8 = '8'; 225 226 /** The virtual key VK_9. */ 227 public static final int VK_9 = '9'; 228 229 /** The virtual key VK_SEMICOLON. */ 230 public static final int VK_SEMICOLON = ';'; 231 232 /** The virtual key VK_EQUALS. */ 233 public static final int VK_EQUALS = '='; 234 235 /** The virtual key VK_A. */ 236 public static final int VK_A = 'A'; 237 238 /** The virtual key VK_B. */ 239 public static final int VK_B = 'B'; 240 241 /** The virtual key VK_C. */ 242 public static final int VK_C = 'C'; 243 244 /** The virtual key VK_D. */ 245 public static final int VK_D = 'D'; 246 247 /** The virtual key VK_E. */ 248 public static final int VK_E = 'E'; 249 250 /** The virtual key VK_F. */ 251 public static final int VK_F = 'F'; 252 253 /** The virtual key VK_G. */ 254 public static final int VK_G = 'G'; 255 256 /** The virtual key VK_H. */ 257 public static final int VK_H = 'H'; 258 259 /** The virtual key VK_I. */ 260 public static final int VK_I = 'I'; 261 262 /** The virtual key VK_J. */ 263 public static final int VK_J = 'J'; 264 265 /** The virtual key VK_K. */ 266 public static final int VK_K = 'K'; 267 268 /** The virtual key VK_L. */ 269 public static final int VK_L = 'L'; 270 271 /** The virtual key VK_M. */ 272 public static final int VK_M = 'M'; 273 274 /** The virtual key VK_N. */ 275 public static final int VK_N = 'N'; 276 277 /** The virtual key VK_O. */ 278 public static final int VK_O = 'O'; 279 280 /** The virtual key VK_P. */ 281 public static final int VK_P = 'P'; 282 283 /** The virtual key VK_Q. */ 284 public static final int VK_Q = 'Q'; 285 286 /** The virtual key VK_R. */ 287 public static final int VK_R = 'R'; 288 289 /** The virtual key VK_S. */ 290 public static final int VK_S = 'S'; 291 292 /** The virtual key VK_T. */ 293 public static final int VK_T = 'T'; 294 295 /** The virtual key VK_U. */ 296 public static final int VK_U = 'U'; 297 298 /** The virtual key VK_V. */ 299 public static final int VK_V = 'V'; 300 301 /** The virtual key VK_W. */ 302 public static final int VK_W = 'W'; 303 304 /** The virtual key VK_X. */ 305 public static final int VK_X = 'X'; 306 307 /** The virtual key VK_Y. */ 308 public static final int VK_Y = 'Y'; 309 310 /** The virtual key VK_Z. */ 311 public static final int VK_Z = 'Z'; 312 313 /** The virtual key VK_OPEN_BRACKET. */ 314 public static final int VK_OPEN_BRACKET = '['; 315 316 /** The virtual key VK_BACK_SLASH. */ 317 public static final int VK_BACK_SLASH = '\\'; 318 319 /** The virtual key VK_CLOSE_BRACKET. */ 320 public static final int VK_CLOSE_BRACKET = ']'; 321 322 /** The virtual key VK_NUMPAD0. */ 323 public static final int VK_NUMPAD0 = 96; 324 325 /** The virtual key VK_NUMPAD1. */ 326 public static final int VK_NUMPAD1 = 97; 327 328 /** The virtual key VK_NUMPAD2. */ 329 public static final int VK_NUMPAD2 = 98; 330 331 /** The virtual key VK_NUMPAD3. */ 332 public static final int VK_NUMPAD3 = 99; 333 334 /** The virtual key VK_NUMPAD4. */ 335 public static final int VK_NUMPAD4 = 100; 336 337 /** The virtual key VK_NUMPAD5. */ 338 public static final int VK_NUMPAD5 = 101; 339 340 /** The virtual key VK_NUMPAD6. */ 341 public static final int VK_NUMPAD6 = 102; 342 343 /** The virtual key VK_NUMPAD7. */ 344 public static final int VK_NUMPAD7 = 103; 345 346 /** The virtual key VK_NUMPAD8. */ 347 public static final int VK_NUMPAD8 = 104; 348 349 /** The virtual key VK_NUMPAD9. */ 350 public static final int VK_NUMPAD9 = 105; 351 352 /** The virtual key VK_MULTIPLY. */ 353 public static final int VK_MULTIPLY = 106; 354 355 /** The virtual key VK_ADD. */ 356 public static final int VK_ADD = 107; 357 358 /** 359 * The virtual key VK_SEPARATOR, handily mispelled for those who can't 360 * figure it out. 361 * 362 * @deprecated use {@link #VK_SEPARATOR} 363 */ 364 public static final int VK_SEPARATER = 108; 365 366 /** 367 * The virtual key VK_SEPARATOR. 368 * 369 * @since 1.4 370 */ 371 public static final int VK_SEPARATOR = 108; 372 373 /** The virtual key VK_SUBTRACT. */ 374 public static final int VK_SUBTRACT = 109; 375 376 /** The virtual key VK_DECIMAL. */ 377 public static final int VK_DECIMAL = 110; 378 379 /** The virtual key VK_DIVIDE. */ 380 public static final int VK_DIVIDE = 111; 381 382 /** The virtual key VK_DELETE. */ 383 public static final int VK_DELETE = 127; 384 385 /** The virtual key VK_NUM_LOCK. */ 386 public static final int VK_NUM_LOCK = 144; 387 388 /** The virtual key VK_SCROLL_LOCK. */ 389 public static final int VK_SCROLL_LOCK = 145; 390 391 /** The virtual key VK_F1. */ 392 public static final int VK_F1 = 112; 393 394 /** The virtual key VK_F2. */ 395 public static final int VK_F2 = 113; 396 397 /** The virtual key VK_F3. */ 398 public static final int VK_F3 = 114; 399 400 /** The virtual key VK_F4. */ 401 public static final int VK_F4 = 115; 402 403 /** The virtual key VK_F5. */ 404 public static final int VK_F5 = 116; 405 406 /** The virtual key VK_F6. */ 407 public static final int VK_F6 = 117; 408 409 /** The virtual key VK_F7. */ 410 public static final int VK_F7 = 118; 411 412 /** The virtual key VK_F8. */ 413 public static final int VK_F8 = 119; 414 415 /** The virtual key VK_F9. */ 416 public static final int VK_F9 = 120; 417 418 /** The virtual key VK_F10. */ 419 public static final int VK_F10 = 121; 420 421 /** The virtual key VK_F11. */ 422 public static final int VK_F11 = 122; 423 424 /** The virtual key VK_F12. */ 425 public static final int VK_F12 = 123; 426 427 /** 428 * The virtual key VK_F13. 429 * 430 * @since 1.2 431 */ 432 public static final int VK_F13 = 61440; 433 434 /** 435 * The virtual key VK_F14. 436 * 437 * @since 1.2 438 */ 439 public static final int VK_F14 = 61441; 440 441 /** 442 * The virtual key VK_F15. 443 * 444 * @since 1.2 445 */ 446 public static final int VK_F15 = 61442; 447 448 /** 449 * The virtual key VK_F16. 450 * 451 * @since 1.2 452 */ 453 public static final int VK_F16 = 61443; 454 455 /** 456 * The virtual key VK_F17. 457 * 458 * @since 1.2 459 */ 460 public static final int VK_F17 = 61444; 461 462 /** 463 * The virtual key VK_F18. 464 * 465 * @since 1.2 466 */ 467 public static final int VK_F18 = 61445; 468 469 /** 470 * The virtual key VK_F19. 471 * 472 * @since 1.2 473 */ 474 public static final int VK_F19 = 61446; 475 476 /** 477 * The virtual key VK_F20. 478 * 479 * @since 1.2 480 */ 481 public static final int VK_F20 = 61447; 482 483 /** 484 * The virtual key VK_F21. 485 * 486 * @since 1.2 487 */ 488 public static final int VK_F21 = 61448; 489 490 /** 491 * The virtual key VK_F22. 492 * 493 * @since 1.2 494 */ 495 public static final int VK_F22 = 61449; 496 497 /** 498 * The virtual key VK_F23. 499 * 500 * @since 1.2 501 */ 502 public static final int VK_F23 = 61450; 503 504 /** 505 * The virtual key VK_F24. 506 * 507 * @since 1.2 508 */ 509 public static final int VK_F24 = 61451; 510 511 /** The virtual key VK_PRINTSCREEN. */ 512 public static final int VK_PRINTSCREEN = 154; 513 514 /** The virtual key VK_INSERT. */ 515 public static final int VK_INSERT = 155; 516 517 /** The virtual key VK_HELP. */ 518 public static final int VK_HELP = 156; 519 520 /** The virtual key VK_META. */ 521 public static final int VK_META = 157; 522 523 /** The virtual key VK_BACK_QUOTE. */ 524 public static final int VK_BACK_QUOTE = 192; 525 526 /** The virtual key VK_QUOTE. */ 527 public static final int VK_QUOTE = 222; 528 529 /** 530 * The virtual key for the numpad VK_KP_UP. 531 * 532 * @see #VK_UP 533 * @since 1.2 534 */ 535 public static final int VK_KP_UP = 224; 536 537 /** 538 * The virtual key for the numpad VK_KP_DOWN. 539 * 540 * @see #VK_DOWN 541 * @since 1.2 542 */ 543 public static final int VK_KP_DOWN = 225; 544 545 /** 546 * The virtual key for the numpad VK_KP_LEFT. 547 * 548 * @see #VK_LEFT 549 * @since 1.2 550 */ 551 public static final int VK_KP_LEFT = 226; 552 553 /** 554 * The virtual key for the numpad VK_KP_RIGHT. 555 * 556 * @see #VK_RIGHT 557 * @since 1.2 558 */ 559 public static final int VK_KP_RIGHT = 227; 560 561 /** 562 * The virtual key VK_DEAD_GRAVE. 563 * 564 * @since 1.2 565 */ 566 public static final int VK_DEAD_GRAVE = 128; 567 568 /** 569 * The virtual key VK_DEAD_ACUTE. 570 * 571 * @since 1.2 572 */ 573 public static final int VK_DEAD_ACUTE = 129; 574 575 /** 576 * The virtual key VK_DEAD_CIRCUMFLEX. 577 * 578 * @since 1.2 579 */ 580 public static final int VK_DEAD_CIRCUMFLEX = 130; 581 582 /** 583 * The virtual key VK_DEAD_TILDE. 584 * 585 * @since 1.2 586 */ 587 public static final int VK_DEAD_TILDE = 131; 588 589 /** 590 * The virtual key VK_DEAD_MACRON. 591 * 592 * @since 1.2 593 */ 594 public static final int VK_DEAD_MACRON = 132; 595 596 /** 597 * The virtual key VK_DEAD_BREVE. 598 * 599 * @since 1.2 600 */ 601 public static final int VK_DEAD_BREVE = 133; 602 603 /** 604 * The virtual key VK_DEAD_ABOVEDOT. 605 * 606 * @since 1.2 607 */ 608 public static final int VK_DEAD_ABOVEDOT = 134; 609 610 /** 611 * The virtual key VK_DEAD_DIAERESIS. 612 * 613 * @since 1.2 614 */ 615 public static final int VK_DEAD_DIAERESIS = 135; 616 617 /** 618 * The virtual key VK_DEAD_ABOVERING. 619 * 620 * @since 1.2 621 */ 622 public static final int VK_DEAD_ABOVERING = 136; 623 624 /** 625 * The virtual key VK_DEAD_DOUBLEACUTE. 626 * 627 * @since 1.2 628 */ 629 public static final int VK_DEAD_DOUBLEACUTE = 137; 630 631 /** 632 * The virtual key VK_DEAD_CARON. 633 * 634 * @since 1.2 635 */ 636 public static final int VK_DEAD_CARON = 138; 637 638 /** 639 * The virtual key VK_DEAD_CEDILLA. 640 * 641 * @since 1.2 642 */ 643 public static final int VK_DEAD_CEDILLA = 139; 644 645 /** 646 * The virtual key VK_DEAD_OGONEK. 647 * 648 * @since 1.2 649 */ 650 public static final int VK_DEAD_OGONEK = 140; 651 652 /** 653 * The virtual key VK_DEAD_IOTA. 654 * 655 * @since 1.2 656 */ 657 public static final int VK_DEAD_IOTA = 141; 658 659 /** 660 * The virtual key VK_DEAD_VOICED_SOUND. 661 * 662 * @since 1.2 663 */ 664 public static final int VK_DEAD_VOICED_SOUND = 142; 665 666 /** 667 * The virtual key VK_DEAD_SEMIVOICED_SOUND. 668 * 669 * @since 1.2 670 */ 671 public static final int VK_DEAD_SEMIVOICED_SOUND = 143; 672 673 /** 674 * The virtual key VK_AMPERSAND. 675 * 676 * @since 1.2 677 */ 678 public static final int VK_AMPERSAND = 150; 679 680 /** 681 * The virtual key VK_ASTERISK. 682 * 683 * @since 1.2 684 */ 685 public static final int VK_ASTERISK = 151; 686 687 /** 688 * The virtual key VK_QUOTEDBL. 689 * 690 * @since 1.2 691 */ 692 public static final int VK_QUOTEDBL = 152; 693 694 /** 695 * The virtual key VK_LESS. 696 * 697 * @since 1.2 698 */ 699 public static final int VK_LESS = 153; 700 701 /** 702 * The virtual key VK_GREATER. 703 * 704 * @since 1.2 705 */ 706 public static final int VK_GREATER = 160; 707 708 /** 709 * The virtual key VK_BRACELEFT. 710 * 711 * @since 1.2 712 */ 713 public static final int VK_BRACELEFT = 161; 714 715 /** 716 * The virtual key VK_BRACERIGHT. 717 * 718 * @since 1.2 719 */ 720 public static final int VK_BRACERIGHT = 162; 721 722 /** 723 * The virtual key VK_AT. 724 * 725 * @since 1.2 726 */ 727 public static final int VK_AT = 512; 728 729 /** 730 * The virtual key VK_COLON. 731 * 732 * @since 1.2 733 */ 734 public static final int VK_COLON = 513; 735 736 /** 737 * The virtual key VK_CIRCUMFLEX. 738 * 739 * @since 1.2 740 */ 741 public static final int VK_CIRCUMFLEX = 514; 742 743 /** 744 * The virtual key VK_DOLLAR. 745 * 746 * @since 1.2 747 */ 748 public static final int VK_DOLLAR = 515; 749 750 /** 751 * The virtual key VK_EURO_SIGN. 752 * 753 * @since 1.2 754 */ 755 public static final int VK_EURO_SIGN = 516; 756 757 /** 758 * The virtual key VK_EXCLAMATION_MARK. 759 * 760 * @since 1.2 761 */ 762 public static final int VK_EXCLAMATION_MARK = 517; 763 764 /** 765 * The virtual key VK_INVERTED_EXCLAMATION_MARK. 766 * 767 * @since 1.2 768 */ 769 public static final int VK_INVERTED_EXCLAMATION_MARK = 518; 770 771 /** 772 * The virtual key VK_LEFT_PARENTHESIS. 773 * 774 * @since 1.2 775 */ 776 public static final int VK_LEFT_PARENTHESIS = 519; 777 778 /** 779 * The virtual key VK_NUMBER_SIGN. 780 * 781 * @since 1.2 782 */ 783 public static final int VK_NUMBER_SIGN = 520; 784 785 /** 786 * The virtual key VK_PLUS. 787 * 788 * @since 1.2 789 */ 790 public static final int VK_PLUS = 521; 791 792 /** 793 * The virtual key VK_RIGHT_PARENTHESIS. 794 * 795 * @since 1.2 796 */ 797 public static final int VK_RIGHT_PARENTHESIS = 522; 798 799 /** 800 * The virtual key VK_UNDERSCORE. 801 * 802 * @since 1.2 803 */ 804 public static final int VK_UNDERSCORE = 523; 805 806 /** The virtual key VK_FINAL. */ 807 public static final int VK_FINAL = 24; 808 809 /** The virtual key VK_CONVERT. */ 810 public static final int VK_CONVERT = 28; 811 812 /** The virtual key VK_NONCONVERT. */ 813 public static final int VK_NONCONVERT = 29; 814 815 /** The virtual key VK_ACCEPT. */ 816 public static final int VK_ACCEPT = 30; 817 818 /** The virtual key VK_MODECHANGE. */ 819 public static final int VK_MODECHANGE = 31; 820 821 /** The virtual key VK_KANA. */ 822 public static final int VK_KANA = 21; 823 824 /** The virtual key VK_KANJI. */ 825 public static final int VK_KANJI = 25; 826 827 /** 828 * The virtual key VK_ALPHANUMERIC. 829 * 830 * @since 1.2 831 */ 832 public static final int VK_ALPHANUMERIC = 240; 833 834 /** 835 * The virtual key VK_KATAKANA. 836 * 837 * @since 1.2 838 */ 839 public static final int VK_KATAKANA = 241; 840 841 /** 842 * The virtual key VK_HIRAGANA. 843 * 844 * @since 1.2 845 */ 846 public static final int VK_HIRAGANA = 242; 847 848 /** 849 * The virtual key VK_FULL_WIDTH. 850 * 851 * @since 1.2 852 */ 853 public static final int VK_FULL_WIDTH = 243; 854 855 /** 856 * The virtual key VK_HALF_WIDTH. 857 * 858 * @since 1.2 859 */ 860 public static final int VK_HALF_WIDTH = 244; 861 862 /** 863 * The virtual key VK_ROMAN_CHARACTERS. 864 * 865 * @since 1.2 866 */ 867 public static final int VK_ROMAN_CHARACTERS = 245; 868 869 /** 870 * The virtual key VK_ALL_CANDIDATES. 871 * 872 * @since 1.2 873 */ 874 public static final int VK_ALL_CANDIDATES = 256; 875 876 /** 877 * The virtual key VK_PREVIOUS_CANDIDATE. 878 * 879 * @since 1.2 880 */ 881 public static final int VK_PREVIOUS_CANDIDATE = 257; 882 883 /** 884 * The virtual key VK_CODE_INPUT. 885 * 886 * @since 1.2 887 */ 888 public static final int VK_CODE_INPUT = 258; 889 890 /** 891 * The virtual key VK_JAPANESE_KATAKANA. 892 * 893 * @since 1.2 894 */ 895 public static final int VK_JAPANESE_KATAKANA = 259; 896 897 /** 898 * The virtual key VK_JAPANESE_HIRAGANA. 899 * 900 * @since 1.2 901 */ 902 public static final int VK_JAPANESE_HIRAGANA = 260; 903 904 /** 905 * The virtual key VK_JAPANESE_ROMAN. 906 * 907 * @since 1.2 908 */ 909 public static final int VK_JAPANESE_ROMAN = 261; 910 911 /** 912 * The virtual key VK_KANA_LOCK. 913 * 914 * @since 1.3 915 */ 916 public static final int VK_KANA_LOCK = 262; 917 918 /** 919 * The virtual key VK_INPUT_METHOD_ON_OFF. 920 * 921 * @since 1.3 922 */ 923 public static final int VK_INPUT_METHOD_ON_OFF = 263; 924 925 /** 926 * The virtual key VK_CUT. 927 * 928 * @since 1.2 929 */ 930 public static final int VK_CUT = 65489; 931 932 /** 933 * The virtual key VK_COPY. 934 * 935 * @since 1.2 936 */ 937 public static final int VK_COPY = 65485; 938 939 /** 940 * The virtual key VK_PASTE. 941 * 942 * @since 1.2 943 */ 944 public static final int VK_PASTE = 65487; 945 946 /** 947 * The virtual key VK_UNDO. 948 * 949 * @since 1.2 950 */ 951 public static final int VK_UNDO = 65483; 952 953 /** 954 * The virtual key VK_AGAIN. 955 * 956 * @since 1.2 957 */ 958 public static final int VK_AGAIN = 65481; 959 960 /** 961 * The virtual key VK_FIND. 962 * 963 * @since 1.2 964 */ 965 public static final int VK_FIND = 65488; 966 967 /** 968 * The virtual key VK_PROPS. 969 * 970 * @since 1.2 971 */ 972 public static final int VK_PROPS = 65482; 973 974 /** 975 * The virtual key VK_STOP. 976 * 977 * @since 1.2 978 */ 979 public static final int VK_STOP = 65480; 980 981 /** 982 * The virtual key VK_COMPOSE. 983 * 984 * @since 1.2 985 */ 986 public static final int VK_COMPOSE = 65312; 987 988 /** 989 * The virtual key VK_ALT_GRAPH. 990 * 991 * @since 1.2 992 */ 993 public static final int VK_ALT_GRAPH = 65406; 994 995 /** 996 * The 'begin' key VK_BEGIN 997 * 998 * @since 1.5 999 */ 1000 public static final int VK_BEGIN = 65368; 1001 1002 /** 1003 * The context-menu key VK_CONTEXT_MENU 1004 * 1005 * @since 1.5 1006 */ 1007 public static final int VK_CONTEXT_MENU = 525; 1008 1009 /** 1010 * The 'Windows' key VK_WINDOWS 1011 * 1012 * @since 1.5 1013 */ 1014 public static final int VK_WINDOWS = 524; 1015 1016 /** 1017 * The virtual key VK_UNDEFINED. This is used for key typed events, which 1018 * do not have a virtual key. 1019 */ 1020 public static final int VK_UNDEFINED = 0; 1021 1022 /** 1023 * The only char with no valid Unicode interpretation. This is used for 1024 * key pressed and key released events which do not have a valid keyChar. 1025 */ 1026 public static final char CHAR_UNDEFINED = '\uffff'; 1027 1028 /** 1029 * Indicates unknown or irrelavent key location. This is also used for 1030 * key typed events, which do not need a location. 1031 * 1032 * @since 1.4 1033 */ 1034 public static final int KEY_LOCATION_UNKNOWN = 0; 1035 1036 /** 1037 * Indicates a standard key location, with no left/right variants and not 1038 * on the numeric pad. 1039 * 1040 * @since 1.4 1041 */ 1042 public static final int KEY_LOCATION_STANDARD = 1; 1043 1044 /** 1045 * Indicates the key is on the left side of the keyboard, such as the left 1046 * shift. 1047 * 1048 * @since 1.4 1049 */ 1050 public static final int KEY_LOCATION_LEFT = 2; 1051 1052 /** 1053 * Indicates the key is on the right side of the keyboard, such as the right 1054 * shift. 1055 * 1056 * @since 1.4 1057 */ 1058 public static final int KEY_LOCATION_RIGHT = 3; 1059 1060 /** 1061 * Indicates the key is on the numeric pad, such as the numpad 0. 1062 * 1063 * @since 1.4 1064 */ 1065 public static final int KEY_LOCATION_NUMPAD = 4; 1066 1067 /** 1068 * The code assigned to the physical keyboard location (as adjusted by the 1069 * keyboard layout). Use the symbolic VK_* names instead of numbers. 1070 * 1071 * @see #getKeyCode() 1072 * @serial the VK_ code for this key 1073 */ 1074 private int keyCode; 1075 1076 /** 1077 * The Unicode character produced by the key type event. This has no meaning 1078 * for key pressed and key released events. 1079 * 1080 * @see #getKeyChar() 1081 * @serial the Unicode value for this key 1082 */ 1083 private char keyChar; 1084 1085 /** 1086 * The keyboard location of the key. One of {@link #KEY_LOCATION_UNKNOWN}, 1087 * {@link #KEY_LOCATION_STANDARD}, {@link #KEY_LOCATION_LEFT}, 1088 * {@link #KEY_LOCATION_RIGHT}, or {@link #KEY_LOCATION_NUMPAD}. 1089 * 1090 * @see #getKeyLocation() 1091 * @serial the key location 1092 * @since 1.4 1093 */ 1094 private final int keyLocation; 1095 1096 /** 1097 * Stores the state of the native event dispatching system, to correctly 1098 * dispatch in Component#dispatchEventImpl when a proxy is active. 1099 * 1100 * XXX Does this matter in Classpath? 1101 * 1102 * @serial whether the proxy is active 1103 */ 1104 private boolean isProxyActive; 1105 1106 1107 /** 1108 * Initializes a new instance of <code>KeyEvent</code> with the specified 1109 * information. Note that an invalid id leads to unspecified results. 1110 * 1111 * @param source the component that generated this event 1112 * @param id the event id 1113 * @param when the timestamp when the even occurred 1114 * @param modifiers the modifier keys during the event, in old or new style 1115 * @param keyCode the integer constant for the virtual key type 1116 * @param keyChar the Unicode value of the key 1117 * @param keyLocation the location of the key 1118 * @throws IllegalArgumentException if source is null, if keyLocation is 1119 * invalid, or if (id == KEY_TYPED && (keyCode != VK_UNDEFINED 1120 * || keyChar == CHAR_UNDEFINED)) 1121 */ 1122 public KeyEvent(Component source, int id, long when, int modifiers, 1123 int keyCode, char keyChar, int keyLocation) 1124 { 1125 super(source, id, when, modifiers); 1126 this.keyCode = keyCode; 1127 this.keyChar = keyChar; 1128 this.keyLocation = keyLocation; 1129 if ((id == KEY_TYPED && (keyCode != VK_UNDEFINED 1130 || keyChar == CHAR_UNDEFINED)) 1131 || keyLocation < KEY_LOCATION_UNKNOWN 1132 || keyLocation > KEY_LOCATION_NUMPAD) 1133 throw new IllegalArgumentException(); 1134 } 1135 1136 /** 1137 * Initializes a new instance of <code>KeyEvent</code> with the specified 1138 * information. Note that an invalid id leads to unspecified results. 1139 * 1140 * @param source the component that generated this event 1141 * @param id the event id 1142 * @param when the timestamp when the even occurred 1143 * @param modifiers the modifier keys during the event, in old or new style 1144 * @param keyCode the integer constant for the virtual key type 1145 * @param keyChar the Unicode value of the key 1146 * @throws IllegalArgumentException if source is null, or if 1147 * (id == KEY_TYPED && (keyCode != VK_UNDEFINED 1148 * || keyChar == CHAR_UNDEFINED)) 1149 */ 1150 public KeyEvent(Component source, int id, long when, int modifiers, 1151 int keyCode, char keyChar) 1152 { 1153 this(source, id, when, modifiers, keyCode, keyChar, KEY_LOCATION_UNKNOWN); 1154 } 1155 1156 /** 1157 * Initializes a new instance of <code>KeyEvent</code> with the specified 1158 * information. Note that an invalid id leads to unspecified results. 1159 * 1160 * @param source the component that generated this event 1161 * @param id the event id 1162 * @param when the timestamp when the even occurred 1163 * @param modifiers the modifier keys during the event, in old or new style 1164 * @param keyCode the integer constant for the virtual key type 1165 * @throws IllegalArgumentException if source is null, or if 1166 * id == KEY_TYPED but keyCode != VK_UNDEFINED 1167 * 1168 * @deprecated 1169 */ 1170 public KeyEvent(Component source, int id, long when, int modifiers, 1171 int keyCode) 1172 { 1173 this(source, id, when, modifiers, keyCode, '\0', KEY_LOCATION_UNKNOWN); 1174 } 1175 1176 /** 1177 * Returns the key code for the event key. This will be one of the 1178 * <code>VK_*</code> constants defined in this class. If the event type is 1179 * KEY_TYPED, the result will be VK_UNDEFINED. 1180 * 1181 * @return the key code for this event 1182 */ 1183 public int getKeyCode() 1184 { 1185 return keyCode; 1186 } 1187 1188 /** 1189 * Sets the key code for this event. This must be one of the 1190 * <code>VK_*</code> constants defined in this class. 1191 * 1192 * @param keyCode the new key code for this event 1193 */ 1194 public void setKeyCode(int keyCode) 1195 { 1196 this.keyCode = keyCode; 1197 } 1198 1199 /** 1200 * Returns the Unicode value for the event key. This will be 1201 * <code>CHAR_UNDEFINED</code> if there is no Unicode equivalent for 1202 * this key, usually when this is a KEY_PRESSED or KEY_RELEASED event. 1203 * 1204 * @return the Unicode character for this event 1205 */ 1206 public char getKeyChar() 1207 { 1208 return keyChar; 1209 } 1210 1211 /** 1212 * Sets the Unicode character for this event to the specified value. 1213 * 1214 * @param keyChar the new Unicode character for this event 1215 */ 1216 public void setKeyChar(char keyChar) 1217 { 1218 this.keyChar = keyChar; 1219 } 1220 1221 /** 1222 * Sets the modifier keys to the specified value. This should be a union 1223 * of the bit mask constants from <code>InputEvent</code>. The use of this 1224 * method is not recommended, particularly for KEY_TYPED events, which do 1225 * not check if the modifiers were changed. 1226 * 1227 * @param modifiers the new modifier value, in either old or new style 1228 * @see InputEvent 1229 * 1230 * @deprecated 1231 */ 1232 public void setModifiers(int modifiers) 1233 { 1234 this.modifiers = EventModifier.extend(modifiers); 1235 } 1236 1237 /** 1238 * Returns the keyboard location of the key that generated this event. This 1239 * provides a way to distinguish between keys like left and right shift 1240 * which share a common key code. The result will be one of 1241 * {@link #KEY_LOCATION_UNKNOWN}, {@link #KEY_LOCATION_STANDARD}, 1242 * {@link #KEY_LOCATION_LEFT}, {@link #KEY_LOCATION_RIGHT}, or 1243 * {@link #KEY_LOCATION_NUMPAD}. 1244 * 1245 * @return the key location 1246 * @since 1.4 1247 */ 1248 public int getKeyLocation() 1249 { 1250 return keyLocation; 1251 } 1252 1253 /** 1254 * Returns the text name of key code, such as "HOME", "F1", or "A". 1255 * 1256 * XXX Sun claims this can be localized via the awt.properties file - how 1257 * do we implement that? 1258 * 1259 * @return the text name of the key code 1260 */ 1261 public static String getKeyText(int keyCode) 1262 { 1263 switch (keyCode) 1264 { 1265 case VK_CANCEL: 1266 return "Cancel"; 1267 case VK_BACK_SPACE: 1268 return "Backspace"; 1269 case VK_TAB: 1270 return "Tab"; 1271 case VK_ENTER: 1272 return "Enter"; 1273 case VK_CLEAR: 1274 return "Clear"; 1275 case VK_SHIFT: 1276 return "Shift"; 1277 case VK_CONTROL: 1278 return "Ctrl"; 1279 case VK_ALT: 1280 return "Alt"; 1281 case VK_PAUSE: 1282 return "Pause"; 1283 case VK_CAPS_LOCK: 1284 return "Caps Lock"; 1285 case VK_KANA: 1286 return "Kana"; 1287 case VK_FINAL: 1288 return "Final"; 1289 case VK_KANJI: 1290 return "Kanji"; 1291 case VK_ESCAPE: 1292 return "Escape"; 1293 case VK_CONVERT: 1294 return "Convert"; 1295 case VK_NONCONVERT: 1296 return "No Convert"; 1297 case VK_ACCEPT: 1298 return "Accept"; 1299 case VK_MODECHANGE: 1300 return "Mode Change"; 1301 case VK_SPACE: 1302 return "Space"; 1303 case VK_PAGE_UP: 1304 return "Page Up"; 1305 case VK_PAGE_DOWN: 1306 return "Page Down"; 1307 case VK_END: 1308 return "End"; 1309 case VK_HOME: 1310 return "Home"; 1311 case VK_LEFT: 1312 case VK_KP_LEFT: 1313 return "Left"; 1314 case VK_UP: 1315 case VK_KP_UP: 1316 return "Up"; 1317 case VK_RIGHT: 1318 case VK_KP_RIGHT: 1319 return "Right"; 1320 case VK_DOWN: 1321 case VK_KP_DOWN: 1322 return "Down"; 1323 case VK_MINUS: 1324 return "Minus"; 1325 case VK_MULTIPLY: 1326 return "NumPad *"; 1327 case VK_ADD: 1328 return "NumPad +"; 1329 case VK_SEPARATOR: 1330 return "NumPad ,"; 1331 case VK_SUBTRACT: 1332 return "NumPad -"; 1333 case VK_DECIMAL: 1334 return "NumPad ."; 1335 case VK_DIVIDE: 1336 return "NumPad /"; 1337 case VK_DELETE: 1338 return "Delete"; 1339 case VK_DEAD_GRAVE: 1340 return "Dead Grave"; 1341 case VK_DEAD_ACUTE: 1342 return "Dead Acute"; 1343 case VK_DEAD_CIRCUMFLEX: 1344 return "Dead Circumflex"; 1345 case VK_DEAD_TILDE: 1346 return "Dead Tilde"; 1347 case VK_DEAD_MACRON: 1348 return "Dead Macron"; 1349 case VK_DEAD_BREVE: 1350 return "Dead Breve"; 1351 case VK_DEAD_ABOVEDOT: 1352 return "Dead Above Dot"; 1353 case VK_DEAD_DIAERESIS: 1354 return "Dead Diaeresis"; 1355 case VK_DEAD_ABOVERING: 1356 return "Dead Above Ring"; 1357 case VK_DEAD_DOUBLEACUTE: 1358 return "Dead Double Acute"; 1359 case VK_DEAD_CARON: 1360 return "Dead Caron"; 1361 case VK_DEAD_CEDILLA: 1362 return "Dead Cedilla"; 1363 case VK_DEAD_OGONEK: 1364 return "Dead Ogonek"; 1365 case VK_DEAD_IOTA: 1366 return "Dead Iota"; 1367 case VK_DEAD_VOICED_SOUND: 1368 return "Dead Voiced Sound"; 1369 case VK_DEAD_SEMIVOICED_SOUND: 1370 return "Dead Semivoiced Sound"; 1371 case VK_NUM_LOCK: 1372 return "Num Lock"; 1373 case VK_SCROLL_LOCK: 1374 return "Scroll Lock"; 1375 case VK_AMPERSAND: 1376 return "Ampersand"; 1377 case VK_ASTERISK: 1378 return "Asterisk"; 1379 case VK_QUOTEDBL: 1380 return "Double Quote"; 1381 case VK_LESS: 1382 return "Less"; 1383 case VK_PRINTSCREEN: 1384 return "Print Screen"; 1385 case VK_INSERT: 1386 return "Insert"; 1387 case VK_HELP: 1388 return "Help"; 1389 case VK_META: 1390 return "Meta"; 1391 case VK_GREATER: 1392 return "Greater"; 1393 case VK_BRACELEFT: 1394 return "Left Brace"; 1395 case VK_BRACERIGHT: 1396 return "Right Brace"; 1397 case VK_BACK_QUOTE: 1398 return "Back Quote"; 1399 case VK_QUOTE: 1400 return "Quote"; 1401 case VK_ALPHANUMERIC: 1402 return "Alphanumeric"; 1403 case VK_KATAKANA: 1404 return "Katakana"; 1405 case VK_HIRAGANA: 1406 return "Hiragana"; 1407 case VK_FULL_WIDTH: 1408 return "Full-Width"; 1409 case VK_HALF_WIDTH: 1410 return "Half-Width"; 1411 case VK_ROMAN_CHARACTERS: 1412 return "Roman Characters"; 1413 case VK_ALL_CANDIDATES: 1414 return "All Candidates"; 1415 case VK_PREVIOUS_CANDIDATE: 1416 return "Previous Candidate"; 1417 case VK_CODE_INPUT: 1418 return "Code Input"; 1419 case VK_JAPANESE_KATAKANA: 1420 return "Japanese Katakana"; 1421 case VK_JAPANESE_HIRAGANA: 1422 return "Japanese Hiragana"; 1423 case VK_JAPANESE_ROMAN: 1424 return "Japanese Roman"; 1425 case VK_KANA_LOCK: 1426 return "Kana Lock"; 1427 case VK_INPUT_METHOD_ON_OFF: 1428 return "Input Method On/Off"; 1429 case VK_AT: 1430 return "At"; 1431 case VK_COLON: 1432 return "Colon"; 1433 case VK_CIRCUMFLEX: 1434 return "Circumflex"; 1435 case VK_DOLLAR: 1436 return "Dollar"; 1437 case VK_EURO_SIGN: 1438 return "Euro"; 1439 case VK_EXCLAMATION_MARK: 1440 return "Exclamation Mark"; 1441 case VK_INVERTED_EXCLAMATION_MARK: 1442 return "Inverted Exclamation Mark"; 1443 case VK_LEFT_PARENTHESIS: 1444 return "Left Parenthesis"; 1445 case VK_NUMBER_SIGN: 1446 return "Number Sign"; 1447 case VK_PLUS: 1448 return "Plus"; 1449 case VK_RIGHT_PARENTHESIS: 1450 return "Right Parenthesis"; 1451 case VK_UNDERSCORE: 1452 return "Underscore"; 1453 case VK_COMPOSE: 1454 return "Compose"; 1455 case VK_ALT_GRAPH: 1456 return "Alt Graph"; 1457 case VK_STOP: 1458 return "Stop"; 1459 case VK_AGAIN: 1460 return "Again"; 1461 case VK_PROPS: 1462 return "Props"; 1463 case VK_UNDO: 1464 return "Undo"; 1465 case VK_COPY: 1466 return "Copy"; 1467 case VK_PASTE: 1468 return "Paste"; 1469 case VK_FIND: 1470 return "Find"; 1471 case VK_CUT: 1472 return "Cut"; 1473 case VK_COMMA: 1474 case VK_PERIOD: 1475 case VK_SLASH: 1476 case VK_0: 1477 case VK_1: 1478 case VK_2: 1479 case VK_3: 1480 case VK_4: 1481 case VK_5: 1482 case VK_6: 1483 case VK_7: 1484 case VK_8: 1485 case VK_9: 1486 case VK_SEMICOLON: 1487 case VK_EQUALS: 1488 case VK_A: 1489 case VK_B: 1490 case VK_C: 1491 case VK_D: 1492 case VK_E: 1493 case VK_F: 1494 case VK_G: 1495 case VK_H: 1496 case VK_I: 1497 case VK_J: 1498 case VK_K: 1499 case VK_L: 1500 case VK_M: 1501 case VK_N: 1502 case VK_O: 1503 case VK_P: 1504 case VK_Q: 1505 case VK_R: 1506 case VK_S: 1507 case VK_T: 1508 case VK_U: 1509 case VK_V: 1510 case VK_W: 1511 case VK_X: 1512 case VK_Y: 1513 case VK_Z: 1514 case VK_OPEN_BRACKET: 1515 case VK_BACK_SLASH: 1516 case VK_CLOSE_BRACKET: 1517 return "" + (char) keyCode; 1518 case VK_NUMPAD0: 1519 case VK_NUMPAD1: 1520 case VK_NUMPAD2: 1521 case VK_NUMPAD3: 1522 case VK_NUMPAD4: 1523 case VK_NUMPAD5: 1524 case VK_NUMPAD6: 1525 case VK_NUMPAD7: 1526 case VK_NUMPAD8: 1527 case VK_NUMPAD9: 1528 return "NumPad-" + (keyCode - VK_NUMPAD0); 1529 case VK_F1: 1530 case VK_F2: 1531 case VK_F3: 1532 case VK_F4: 1533 case VK_F5: 1534 case VK_F6: 1535 case VK_F7: 1536 case VK_F8: 1537 case VK_F9: 1538 case VK_F10: 1539 case VK_F11: 1540 case VK_F12: 1541 return "F" + (keyCode - (VK_F1 - 1)); 1542 case VK_F13: 1543 case VK_F14: 1544 case VK_F15: 1545 case VK_F16: 1546 case VK_F17: 1547 case VK_F18: 1548 case VK_F19: 1549 case VK_F20: 1550 case VK_F21: 1551 case VK_F22: 1552 case VK_F23: 1553 case VK_F24: 1554 return "F" + (keyCode - (VK_F13 - 13)); 1555 default: 1556 // This is funky on negative numbers, but that's Sun's fault. 1557 return "Unknown keyCode: 0x" + (keyCode < 0 ? "-" : "") 1558 + Integer.toHexString(Math.abs(keyCode)); 1559 } 1560 } 1561 1562 /** 1563 * Returns a string describing the modifiers, such as "Shift" or 1564 * "Ctrl+Button1". 1565 * 1566 * XXX Sun claims this can be localized via the awt.properties file - how 1567 * do we implement that? 1568 * 1569 * @param modifiers the old-style modifiers to convert to text 1570 * @return a string representation of the modifiers in this bitmask 1571 */ 1572 public static String getKeyModifiersText(int modifiers) 1573 { 1574 return getModifiersExText(EventModifier.extend(modifiers 1575 & EventModifier.OLD_MASK)); 1576 } 1577 1578 /** 1579 * Tests whether or not this key is an action key. An action key typically 1580 * does not fire a KEY_TYPED event, and is not a modifier. 1581 * 1582 * @return true if this is an action key 1583 */ 1584 public boolean isActionKey() 1585 { 1586 switch (keyCode) 1587 { 1588 case VK_PAUSE: 1589 case VK_CAPS_LOCK: 1590 case VK_KANA: 1591 case VK_FINAL: 1592 case VK_KANJI: 1593 case VK_CONVERT: 1594 case VK_NONCONVERT: 1595 case VK_ACCEPT: 1596 case VK_MODECHANGE: 1597 case VK_PAGE_UP: 1598 case VK_PAGE_DOWN: 1599 case VK_END: 1600 case VK_HOME: 1601 case VK_LEFT: 1602 case VK_UP: 1603 case VK_RIGHT: 1604 case VK_DOWN: 1605 case VK_F1: 1606 case VK_F2: 1607 case VK_F3: 1608 case VK_F4: 1609 case VK_F5: 1610 case VK_F6: 1611 case VK_F7: 1612 case VK_F8: 1613 case VK_F9: 1614 case VK_F10: 1615 case VK_F11: 1616 case VK_F12: 1617 case VK_NUM_LOCK: 1618 case VK_SCROLL_LOCK: 1619 case VK_PRINTSCREEN: 1620 case VK_INSERT: 1621 case VK_HELP: 1622 case VK_KP_UP: 1623 case VK_KP_DOWN: 1624 case VK_KP_LEFT: 1625 case VK_KP_RIGHT: 1626 case VK_ALPHANUMERIC: 1627 case VK_KATAKANA: 1628 case VK_HIRAGANA: 1629 case VK_FULL_WIDTH: 1630 case VK_HALF_WIDTH: 1631 case VK_ROMAN_CHARACTERS: 1632 case VK_ALL_CANDIDATES: 1633 case VK_PREVIOUS_CANDIDATE: 1634 case VK_CODE_INPUT: 1635 case VK_JAPANESE_KATAKANA: 1636 case VK_JAPANESE_HIRAGANA: 1637 case VK_JAPANESE_ROMAN: 1638 case VK_KANA_LOCK: 1639 case VK_INPUT_METHOD_ON_OFF: 1640 case VK_F13: 1641 case VK_F14: 1642 case VK_F15: 1643 case VK_F16: 1644 case VK_F17: 1645 case VK_F18: 1646 case VK_F19: 1647 case VK_F20: 1648 case VK_F21: 1649 case VK_F22: 1650 case VK_F23: 1651 case VK_F24: 1652 case VK_STOP: 1653 case VK_AGAIN: 1654 case VK_PROPS: 1655 case VK_UNDO: 1656 case VK_COPY: 1657 case VK_PASTE: 1658 case VK_FIND: 1659 case VK_CUT: 1660 return true; 1661 default: 1662 return false; 1663 } 1664 } 1665 1666 /** 1667 * Returns a string identifying the event. This is formatted as the 1668 * field name of the id type, followed by the keyCode, then the 1669 * keyChar, modifiers (if any), extModifiers (if any), and 1670 * keyLocation. 1671 * 1672 * @return a string identifying the event 1673 */ 1674 public String paramString() 1675 { 1676 StringBuffer s = new StringBuffer(); 1677 1678 switch (id) 1679 { 1680 case KEY_PRESSED: 1681 s.append("KEY_PRESSED"); 1682 break; 1683 case KEY_RELEASED: 1684 s.append("KEY_RELEASED"); 1685 break; 1686 case KEY_TYPED: 1687 s.append("KEY_TYPED"); 1688 break; 1689 default: 1690 s.append("unknown type"); 1691 } 1692 1693 s.append(",keyCode=").append(keyCode); 1694 1695 s.append(",keyText=").append(getKeyText(keyCode)); 1696 1697 s.append(",keyChar="); 1698 if (isActionKey() 1699 || keyCode == VK_SHIFT 1700 || keyCode == VK_CONTROL 1701 || keyCode == VK_ALT) 1702 s.append("Undefined keyChar"); 1703 else 1704 { 1705 /* This output string must be selected by examining keyChar 1706 * rather than keyCode, because key code information is not 1707 * included in KEY_TYPED events. 1708 */ 1709 if (keyChar == VK_BACK_SPACE 1710 || keyChar == VK_TAB 1711 || keyChar == VK_ENTER 1712 || keyChar == VK_ESCAPE 1713 || keyChar == VK_DELETE) 1714 s.append(getKeyText(keyChar)); 1715 else 1716 s.append("'").append(keyChar).append("'"); 1717 } 1718 1719 if ((modifiers & CONVERT_MASK) != 0) 1720 s.append(",modifiers=").append(getModifiersExText(modifiers 1721 & CONVERT_MASK)); 1722 if (modifiers != 0) 1723 s.append(",extModifiers=").append(getModifiersExText(modifiers)); 1724 1725 s.append(",keyLocation=KEY_LOCATION_"); 1726 switch (keyLocation) 1727 { 1728 case KEY_LOCATION_UNKNOWN: 1729 s.append("UNKNOWN"); 1730 break; 1731 case KEY_LOCATION_STANDARD: 1732 s.append("STANDARD"); 1733 break; 1734 case KEY_LOCATION_LEFT: 1735 s.append("LEFT"); 1736 break; 1737 case KEY_LOCATION_RIGHT: 1738 s.append("RIGHT"); 1739 break; 1740 case KEY_LOCATION_NUMPAD: 1741 s.append("NUMPAD"); 1742 } 1743 1744 return s.toString(); 1745 } 1746 1747 /** 1748 * Reads in the object from a serial stream. 1749 * 1750 * @param s the stream to read from 1751 * @throws IOException if deserialization fails 1752 * @throws ClassNotFoundException if deserialization fails 1753 * @serialData default, except that the modifiers are converted to new style 1754 */ 1755 private void readObject(ObjectInputStream s) 1756 throws IOException, ClassNotFoundException 1757 { 1758 s.defaultReadObject(); 1759 modifiersEx = EventModifier.extend(modifiers) & EventModifier.NEW_MASK; 1760 } 1761 } // class KeyEvent