libjava/java/awt/event/KeyEvent.java

   1 /* KeyEvent.java -- event for key presses
   2    Copyright (C) 1999, 2002, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt.event;
  40
  41 import gnu.java.awt.EventModifier;
  42
  43 import java.awt.Component;
  44 import java.io.IOException;
  45 import java.io.ObjectInputStream;
  46
  47 /**
  48  * This event is generated when a key is pressed or released. There are two
  49  * categories of key events:
  50  *
  51  * <p><em>"Key typed" events</em> are higher-level, and have already
  52  * compensated for modifiers and keyboard layout to generate a single Unicode
  53  * character. It may take several key press events to generate one key typed.
  54  * The <code>getKeyCode</code> method will return <code>VK_UNDEFINED</code>,
  55  * and <code>getKeyChar</code> will return a valid Unicode character or
  56  * <code>CHAR_UNDEFINED</code>.
  57  *
  58  * <p><em>"Key pressed" and "key released" events</em> are lower-level, and
  59  * are platform and keyboard dependent. They correspond to the actaul motion
  60  * on a keyboard, and return a virtual key code which labels the key that was
  61  * pressed. The <code>getKeyCode</code> method will return one of the
  62  * <code>VK_*</code> constants (except VK_UNDEFINED), and the
  63  * <code>getKeyChar</code> method is undefined.
  64  *
  65  * <p>Some keys do not generate key typed events, such as the F1 or HELP keys.
  66  * Not all keyboards can generate all virtual keys, and no attempt is made to
  67  * simulate the ones that can't be typed. Virtual keys correspond to the
  68  * keyboard layout, so for example, VK_Q in English is VK_A in French. Also,
  69  * there are some additional virtual keys to ease handling of actions, such
  70  * as VK_ALL_CANDIDATES in place of ALT+VK_CONVERT. Do not rely on the value
  71  * of the VK_* constants, except for VK_ENTER, VK_BACK_SPACE, and VK_TAB.
  72  *
  73  * @author Aaron M. Renn (arenn@urbanophile.com)
  74  * @author Eric Blake (ebb9@email.byu.edu)
  75  * @see KeyAdapter
  76  * @see KeyListener
  77  * @since 1.1
  78  * @status updated to 1.4
  79  */
  80 public class KeyEvent extends InputEvent
  81 {
  82   /**
  83    * Compatible with JDK 1.1+.
  84    */
  85   private static final long serialVersionUID = -2352130953028126954L;
  86
  87   /** This is the first id in the range of event ids used by this class. */
  88   public static final int KEY_FIRST = 400;
  89
  90   /** This is the last id in the range of event ids used by this class. */
  91   public static final int KEY_LAST = 402;
  92
  93   /**
  94    * This event id indicates a key was typed, which is a key press followed
  95    * by a key release to generate an actual Unicode character. It may take
  96    * several key presses to generate one key typed event, and some action
  97    * keys have no corresponding key typed.
  98    */
  99   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 virtual key VK_UNDEFINED. This is used for key typed events, which
 997    * do not have a virtual key.
 998    */
 999   public static final int VK_UNDEFINED = 0;
1000
1001   /**
1002    * The only char with no valid Unicode interpretation. This is used for
1003    * key pressed and key released events which do not have a valid keyChar.
1004    */
1005   public static final char CHAR_UNDEFINED = '\uffff';
1006
1007   /**
1008    * Indicates unknown or irrelavent key location. This is also used for
1009    * key typed events, which do not need a location.
1010    *
1011    * @since 1.4
1012    */
1013   public static final int KEY_LOCATION_UNKNOWN = 0;
1014
1015   /**
1016    * Indicates a standard key location, with no left/right variants and not
1017    * on the numeric pad.
1018    *
1019    * @since 1.4
1020    */
1021   public static final int KEY_LOCATION_STANDARD = 1;
1022
1023   /**
1024    * Indicates the key is on the left side of the keyboard, such as the left
1025    * shift.
1026    *
1027    * @since 1.4
1028    */
1029   public static final int KEY_LOCATION_LEFT = 2;
1030
1031   /**
1032    * Indicates the key is on the right side of the keyboard, such as the right
1033    * shift.
1034    *
1035    * @since 1.4
1036    */
1037   public static final int KEY_LOCATION_RIGHT = 3;
1038
1039   /**
1040    * Indicates the key is on the numeric pad, such as the numpad 0.
1041    *
1042    * @since 1.4
1043    */
1044   public static final int KEY_LOCATION_NUMPAD = 4;
1045
1046   /**
1047    * The code assigned to the physical keyboard location (as adjusted by the
1048    * keyboard layout). Use the symbolic VK_* names instead of numbers.
1049    *
1050    * @see #getKeyCode()
1051    * @serial the VK_ code for this key
1052   */
1053   private int keyCode;
1054
1055   /**
1056    * The Unicode character produced by the key type event. This has no meaning
1057    * for key pressed and key released events.
1058    *
1059    * @see #getKeyChar()
1060    * @serial the Unicode value for this key
1061    */
1062   private char keyChar;
1063
1064   /**
1065    * The keyboard location of the key. One of {@link #KEY_LOCATION_UNKNOWN},
1066    * {@link #KEY_LOCATION_STANDARD}, {@link #KEY_LOCATION_LEFT},
1067    * {@link #KEY_LOCATION_RIGHT}, or {@link #KEY_LOCATION_NUMPAD}.
1068    *
1069    * @see #getKeyLocation()
1070    * @serial the key location
1071    * @since 1.4
1072    */
1073   private final int keyLocation;
1074
1075   /**
1076    * Stores the state of the native event dispatching system, to correctly
1077    * dispatch in Component#dispatchEventImpl when a proxy is active.
1078    *
1079    * XXX Does this matter in Classpath?
1080    *
1081    * @serial whether the proxy is active
1082    */
1083   private boolean isProxyActive;
1084
1085 \f
1086   /**
1087    * Initializes a new instance of <code>KeyEvent</code> with the specified
1088    * information. Note that an invalid id leads to unspecified results.
1089    *
1090    * @param source the component that generated this event
1091    * @param id the event id
1092    * @param when the timestamp when the even occurred
1093    * @param modifiers the modifier keys during the event, in old or new style
1094    * @param keyCode the integer constant for the virtual key type
1095    * @param keyChar the Unicode value of the key
1096    * @param keyLocation the location of the key
1097    * @throws IllegalArgumentException if source is null, if keyLocation is
1098    *         invalid, or if (id == KEY_TYPED && (keyCode != VK_UNDEFINED
1099    *         || keyChar == CHAR_UNDEFINED))
1100    */
1101   public KeyEvent(Component source, int id, long when, int modifiers,
1102                   int keyCode, char keyChar, int keyLocation)
1103   {
1104     super(source, id, when, modifiers);
1105     this.keyCode = keyCode;
1106     this.keyChar = keyChar;
1107     this.keyLocation = keyLocation;
1108     if ((id == KEY_TYPED && (keyCode != VK_UNDEFINED
1109                              || keyChar == CHAR_UNDEFINED))
1110         || keyLocation < KEY_LOCATION_UNKNOWN
1111         || keyLocation > KEY_LOCATION_NUMPAD)
1112       throw new IllegalArgumentException();
1113   }
1114
1115   /**
1116    * Initializes a new instance of <code>KeyEvent</code> with the specified
1117    * information. Note that an invalid id leads to unspecified results.
1118    *
1119    * @param source the component that generated this event
1120    * @param id the event id
1121    * @param when the timestamp when the even occurred
1122    * @param modifiers the modifier keys during the event, in old or new style
1123    * @param keyCode the integer constant for the virtual key type
1124    * @param keyChar the Unicode value of the key
1125    * @throws IllegalArgumentException if source is null, or if
1126    *         (id == KEY_TYPED && (keyCode != VK_UNDEFINED
1127    *         || keyChar == CHAR_UNDEFINED))
1128    */
1129   public KeyEvent(Component source, int id, long when, int modifiers,
1130                   int keyCode, char keyChar)
1131   {
1132     this(source, id, when, modifiers, keyCode, keyChar, KEY_LOCATION_UNKNOWN);
1133   }
1134
1135   /**
1136    * Initializes a new instance of <code>KeyEvent</code> with the specified
1137    * information. Note that an invalid id leads to unspecified results.
1138    *
1139    * @param source the component that generated this event
1140    * @param id the event id
1141    * @param when the timestamp when the even occurred
1142    * @param modifiers the modifier keys during the event, in old or new style
1143    * @param keyCode the integer constant for the virtual key type
1144    * @throws IllegalArgumentException if source is null, or if
1145    *         id == KEY_TYPED but keyCode != VK_UNDEFINED
1146    *
1147    * @deprecated
1148    */
1149   public KeyEvent(Component source, int id, long when, int modifiers,
1150                   int keyCode)
1151   {
1152     this(source, id, when, modifiers, keyCode, '\0', KEY_LOCATION_UNKNOWN);
1153   }
1154
1155   /**
1156    * Returns the key code for the event key.  This will be one of the
1157    * <code>VK_*</code> constants defined in this class. If the event type is
1158    * KEY_TYPED, the result will be VK_UNDEFINED.
1159    *
1160    * @return the key code for this event
1161    */
1162   public int getKeyCode()
1163   {
1164     return keyCode;
1165   }
1166
1167   /**
1168    * Sets the key code for this event.  This must be one of the
1169    * <code>VK_*</code> constants defined in this class.
1170    *
1171    * @param keyCode the new key code for this event
1172    */
1173   public void setKeyCode(int keyCode)
1174   {
1175     this.keyCode = keyCode;
1176   }
1177
1178   /**
1179    * Returns the Unicode value for the event key.  This will be
1180    * <code>CHAR_UNDEFINED</code> if there is no Unicode equivalent for
1181    * this key, usually when this is a KEY_PRESSED or KEY_RELEASED event.
1182    *
1183    * @return the Unicode character for this event
1184    */
1185   public char getKeyChar()
1186   {
1187     return keyChar;
1188   }
1189
1190   /**
1191    * Sets the Unicode character for this event to the specified value.
1192    *
1193    * @param keyChar the new Unicode character for this event
1194    */
1195   public void setKeyChar(char keyChar)
1196   {
1197     this.keyChar = keyChar;
1198   }
1199
1200   /**
1201    * Sets the modifier keys to the specified value. This should be a union
1202    * of the bit mask constants from <code>InputEvent</code>. The use of this
1203    * method is not recommended, particularly for KEY_TYPED events, which do
1204    * not check if the modifiers were changed.
1205    *
1206    * @param modifiers the new modifier value, in either old or new style
1207    * @see InputEvent
1208    *
1209    * @deprecated
1210    */
1211   public void setModifiers(int modifiers)
1212   {
1213     this.modifiers = EventModifier.extend(modifiers);
1214   }
1215
1216   /**
1217    * Returns the keyboard location of the key that generated this event. This
1218    * provides a way to distinguish between keys like left and right shift
1219    * which share a common key code. The result will be one of
1220    * {@link #KEY_LOCATION_UNKNOWN}, {@link #KEY_LOCATION_STANDARD},
1221    * {@link #KEY_LOCATION_LEFT}, {@link #KEY_LOCATION_RIGHT}, or
1222    * {@link #KEY_LOCATION_NUMPAD}.
1223    *
1224    * @return the key location
1225    * @since 1.4
1226    */
1227   public int getKeyLocation()
1228   {
1229     return keyLocation;
1230   }
1231
1232   /**
1233    * Returns the text name of key code, such as "HOME", "F1", or "A".
1234    *
1235    * XXX Sun claims this can be localized via the awt.properties file - how
1236    * do we implement that?
1237    *
1238    * @return the text name of the key code
1239    */
1240   public static String getKeyText(int keyCode)
1241   {
1242     switch (keyCode)
1243       {
1244       case VK_CANCEL:
1245         return "Cancel";
1246       case VK_BACK_SPACE:
1247         return "Backspace";
1248       case VK_TAB:
1249         return "Tab";
1250       case VK_ENTER:
1251         return "Enter";
1252       case VK_CLEAR:
1253         return "Clear";
1254       case VK_SHIFT:
1255         return "Shift";
1256       case VK_CONTROL:
1257         return "Ctrl";
1258       case VK_ALT:
1259         return "Alt";
1260       case VK_PAUSE:
1261         return "Pause";
1262       case VK_CAPS_LOCK:
1263         return "Caps Lock";
1264       case VK_KANA:
1265         return "Kana";
1266       case VK_FINAL:
1267         return "Final";
1268       case VK_KANJI:
1269         return "Kanji";
1270       case VK_ESCAPE:
1271         return "Escape";
1272       case VK_CONVERT:
1273         return "Convert";
1274       case VK_NONCONVERT:
1275         return "No Convert";
1276       case VK_ACCEPT:
1277         return "Accept";
1278       case VK_MODECHANGE:
1279         return "Mode Change";
1280       case VK_SPACE:
1281         return "Space";
1282       case VK_PAGE_UP:
1283         return "Page Up";
1284       case VK_PAGE_DOWN:
1285         return "Page Down";
1286       case VK_END:
1287         return "End";
1288       case VK_HOME:
1289         return "Home";
1290       case VK_LEFT:
1291       case VK_KP_LEFT:
1292         return "Left";
1293       case VK_UP:
1294       case VK_KP_UP:
1295         return "Up";
1296       case VK_RIGHT:
1297       case VK_KP_RIGHT:
1298         return "Right";
1299       case VK_DOWN:
1300       case VK_KP_DOWN:
1301         return "Down";
1302       case VK_MINUS:
1303         return "Minus";
1304       case VK_MULTIPLY:
1305         return "NumPad *";
1306       case VK_ADD:
1307         return "NumPad +";
1308       case VK_SEPARATOR:
1309         return "NumPad ,";
1310       case VK_SUBTRACT:
1311         return "NumPad -";
1312       case VK_DECIMAL:
1313         return "NumPad .";
1314       case VK_DIVIDE:
1315         return "NumPad /";
1316       case VK_DELETE:
1317         return "Delete";
1318       case VK_DEAD_GRAVE:
1319         return "Dead Grave";
1320       case VK_DEAD_ACUTE:
1321         return "Dead Acute";
1322       case VK_DEAD_CIRCUMFLEX:
1323         return "Dead Circumflex";
1324       case VK_DEAD_TILDE:
1325         return "Dead Tilde";
1326       case VK_DEAD_MACRON:
1327         return "Dead Macron";
1328       case VK_DEAD_BREVE:
1329         return "Dead Breve";
1330       case VK_DEAD_ABOVEDOT:
1331         return "Dead Above Dot";
1332       case VK_DEAD_DIAERESIS:
1333         return "Dead Diaeresis";
1334       case VK_DEAD_ABOVERING:
1335         return "Dead Above Ring";
1336       case VK_DEAD_DOUBLEACUTE:
1337         return "Dead Double Acute";
1338       case VK_DEAD_CARON:
1339         return "Dead Caron";
1340       case VK_DEAD_CEDILLA:
1341         return "Dead Cedilla";
1342       case VK_DEAD_OGONEK:
1343         return "Dead Ogonek";
1344       case VK_DEAD_IOTA:
1345         return "Dead Iota";
1346       case VK_DEAD_VOICED_SOUND:
1347         return "Dead Voiced Sound";
1348       case VK_DEAD_SEMIVOICED_SOUND:
1349         return "Dead Semivoiced Sound";
1350       case VK_NUM_LOCK:
1351         return "Num Lock";
1352       case VK_SCROLL_LOCK:
1353         return "Scroll Lock";
1354       case VK_AMPERSAND:
1355         return "Ampersand";
1356       case VK_ASTERISK:
1357         return "Asterisk";
1358       case VK_QUOTEDBL:
1359         return "Double Quote";
1360       case VK_LESS:
1361         return "Less";
1362       case VK_PRINTSCREEN:
1363         return "Print Screen";
1364       case VK_INSERT:
1365         return "Insert";
1366       case VK_HELP:
1367         return "Help";
1368       case VK_META:
1369         return "Meta";
1370       case VK_GREATER:
1371         return "Greater";
1372       case VK_BRACELEFT:
1373         return "Left Brace";
1374       case VK_BRACERIGHT:
1375         return "Right Brace";
1376       case VK_BACK_QUOTE:
1377         return "Back Quote";
1378       case VK_QUOTE:
1379         return "Quote";
1380       case VK_ALPHANUMERIC:
1381         return "Alphanumeric";
1382       case VK_KATAKANA:
1383         return "Katakana";
1384       case VK_HIRAGANA:
1385         return "Hiragana";
1386       case VK_FULL_WIDTH:
1387         return "Full-Width";
1388       case VK_HALF_WIDTH:
1389         return "Half-Width";
1390       case VK_ROMAN_CHARACTERS:
1391         return "Roman Characters";
1392       case VK_ALL_CANDIDATES:
1393         return "All Candidates";
1394       case VK_PREVIOUS_CANDIDATE:
1395         return "Previous Candidate";
1396       case VK_CODE_INPUT:
1397         return "Code Input";
1398       case VK_JAPANESE_KATAKANA:
1399         return "Japanese Katakana";
1400       case VK_JAPANESE_HIRAGANA:
1401         return "Japanese Hiragana";
1402       case VK_JAPANESE_ROMAN:
1403         return "Japanese Roman";
1404       case VK_KANA_LOCK:
1405         return "Kana Lock";
1406       case VK_INPUT_METHOD_ON_OFF:
1407         return "Input Method On/Off";
1408       case VK_AT:
1409         return "At";
1410       case VK_COLON:
1411         return "Colon";
1412       case VK_CIRCUMFLEX:
1413         return "Circumflex";
1414       case VK_DOLLAR:
1415         return "Dollar";
1416       case VK_EURO_SIGN:
1417         return "Euro";
1418       case VK_EXCLAMATION_MARK:
1419         return "Exclamation Mark";
1420       case VK_INVERTED_EXCLAMATION_MARK:
1421         return "Inverted Exclamation Mark";
1422       case VK_LEFT_PARENTHESIS:
1423         return "Left Parenthesis";
1424       case VK_NUMBER_SIGN:
1425         return "Number Sign";
1426       case VK_PLUS:
1427         return "Plus";
1428       case VK_RIGHT_PARENTHESIS:
1429         return "Right Parenthesis";
1430       case VK_UNDERSCORE:
1431         return "Underscore";
1432       case VK_COMPOSE:
1433         return "Compose";
1434       case VK_ALT_GRAPH:
1435         return "Alt Graph";
1436       case VK_STOP:
1437         return "Stop";
1438       case VK_AGAIN:
1439         return "Again";
1440       case VK_PROPS:
1441         return "Props";
1442       case VK_UNDO:
1443         return "Undo";
1444       case VK_COPY:
1445         return "Copy";
1446       case VK_PASTE:
1447         return "Paste";
1448       case VK_FIND:
1449         return "Find";
1450       case VK_CUT:
1451         return "Cut";
1452       case VK_COMMA:
1453       case VK_PERIOD:
1454       case VK_SLASH:
1455       case VK_0:
1456       case VK_1:
1457       case VK_2:
1458       case VK_3:
1459       case VK_4:
1460       case VK_5:
1461       case VK_6:
1462       case VK_7:
1463       case VK_8:
1464       case VK_9:
1465       case VK_SEMICOLON:
1466       case VK_EQUALS:
1467       case VK_A:
1468       case VK_B:
1469       case VK_C:
1470       case VK_D:
1471       case VK_E:
1472       case VK_F:
1473       case VK_G:
1474       case VK_H:
1475       case VK_I:
1476       case VK_J:
1477       case VK_K:
1478       case VK_L:
1479       case VK_M:
1480       case VK_N:
1481       case VK_O:
1482       case VK_P:
1483       case VK_Q:
1484       case VK_R:
1485       case VK_S:
1486       case VK_T:
1487       case VK_U:
1488       case VK_V:
1489       case VK_W:
1490       case VK_X:
1491       case VK_Y:
1492       case VK_Z:
1493       case VK_OPEN_BRACKET:
1494       case VK_BACK_SLASH:
1495       case VK_CLOSE_BRACKET:
1496         return "" + (char) keyCode;
1497       case VK_NUMPAD0:
1498       case VK_NUMPAD1:
1499       case VK_NUMPAD2:
1500       case VK_NUMPAD3:
1501       case VK_NUMPAD4:
1502       case VK_NUMPAD5:
1503       case VK_NUMPAD6:
1504       case VK_NUMPAD7:
1505       case VK_NUMPAD8:
1506       case VK_NUMPAD9:
1507         return "NumPad-" + (keyCode - VK_NUMPAD0);
1508       case VK_F1:
1509       case VK_F2:
1510       case VK_F3:
1511       case VK_F4:
1512       case VK_F5:
1513       case VK_F6:
1514       case VK_F7:
1515       case VK_F8:
1516       case VK_F9:
1517       case VK_F10:
1518       case VK_F11:
1519       case VK_F12:
1520         return "F" + (keyCode - (VK_F1 - 1));
1521       case VK_F13:
1522       case VK_F14:
1523       case VK_F15:
1524       case VK_F16:
1525       case VK_F17:
1526       case VK_F18:
1527       case VK_F19:
1528       case VK_F20:
1529       case VK_F21:
1530       case VK_F22:
1531       case VK_F23:
1532       case VK_F24:
1533         return "F" + (keyCode - (VK_F13 - 13));
1534       default:
1535         // This is funky on negative numbers, but that's Sun's fault.
1536         return "Unknown keyCode: 0x" + (keyCode < 0 ? "-" : "")
1537           + Integer.toHexString(Math.abs(keyCode));
1538       }
1539   }
1540
1541   /**
1542    * Returns a string describing the modifiers, such as "Shift" or
1543    * "Ctrl+Button1".
1544    *
1545    * XXX Sun claims this can be localized via the awt.properties file - how
1546    * do we implement that?
1547    *
1548    * @param modifiers the old-style modifiers to convert to text
1549    * @return a string representation of the modifiers in this bitmask
1550    */
1551   public static String getKeyModifiersText(int modifiers)
1552   {
1553     return getModifiersExText(EventModifier.extend(modifiers
1554                                                    & EventModifier.OLD_MASK));
1555   }
1556
1557   /**
1558    * Tests whether or not this key is an action key. An action key typically
1559    * does not fire a KEY_TYPED event, and is not a modifier.
1560    *
1561    * @return true if this is an action key
1562    */
1563   public boolean isActionKey()
1564   {
1565     switch (keyCode)
1566       {
1567       case VK_PAUSE:
1568       case VK_CAPS_LOCK:
1569       case VK_KANA:
1570       case VK_FINAL:
1571       case VK_KANJI:
1572       case VK_CONVERT:
1573       case VK_NONCONVERT:
1574       case VK_ACCEPT:
1575       case VK_MODECHANGE:
1576       case VK_PAGE_UP:
1577       case VK_PAGE_DOWN:
1578       case VK_END:
1579       case VK_HOME:
1580       case VK_LEFT:
1581       case VK_UP:
1582       case VK_RIGHT:
1583       case VK_DOWN:
1584       case VK_F1:
1585       case VK_F2:
1586       case VK_F3:
1587       case VK_F4:
1588       case VK_F5:
1589       case VK_F6:
1590       case VK_F7:
1591       case VK_F8:
1592       case VK_F9:
1593       case VK_F10:
1594       case VK_F11:
1595       case VK_F12:
1596       case VK_NUM_LOCK:
1597       case VK_SCROLL_LOCK:
1598       case VK_PRINTSCREEN:
1599       case VK_INSERT:
1600       case VK_HELP:
1601       case VK_KP_UP:
1602       case VK_KP_DOWN:
1603       case VK_KP_LEFT:
1604       case VK_KP_RIGHT:
1605       case VK_ALPHANUMERIC:
1606       case VK_KATAKANA:
1607       case VK_HIRAGANA:
1608       case VK_FULL_WIDTH:
1609       case VK_HALF_WIDTH:
1610       case VK_ROMAN_CHARACTERS:
1611       case VK_ALL_CANDIDATES:
1612       case VK_PREVIOUS_CANDIDATE:
1613       case VK_CODE_INPUT:
1614       case VK_JAPANESE_KATAKANA:
1615       case VK_JAPANESE_HIRAGANA:
1616       case VK_JAPANESE_ROMAN:
1617       case VK_KANA_LOCK:
1618       case VK_INPUT_METHOD_ON_OFF:
1619       case VK_F13:
1620       case VK_F14:
1621       case VK_F15:
1622       case VK_F16:
1623       case VK_F17:
1624       case VK_F18:
1625       case VK_F19:
1626       case VK_F20:
1627       case VK_F21:
1628       case VK_F22:
1629       case VK_F23:
1630       case VK_F24:
1631       case VK_STOP:
1632       case VK_AGAIN:
1633       case VK_PROPS:
1634       case VK_UNDO:
1635       case VK_COPY:
1636       case VK_PASTE:
1637       case VK_FIND:
1638       case VK_CUT:
1639         return true;
1640       default:
1641         return false;
1642       }
1643   }
1644
1645   /**
1646    * Returns a string identifying the event.  This is formatted as the
1647    * field name of the id type, followed by the keyCode, then the
1648    * keyChar, modifiers (if any), extModifiers (if any), and
1649    * keyLocation.
1650    *
1651    * @return a string identifying the event
1652    */
1653   public String paramString()
1654   {
1655     StringBuffer s = new StringBuffer();
1656
1657     switch (id)
1658       {
1659       case KEY_PRESSED:
1660         s.append("KEY_PRESSED");
1661         break;
1662       case KEY_RELEASED:
1663         s.append("KEY_RELEASED");
1664         break;
1665       case KEY_TYPED:
1666         s.append("KEY_TYPED");
1667         break;
1668       default:
1669         s.append("unknown type");
1670       }
1671
1672     s.append(",keyCode=").append(keyCode);
1673
1674     s.append(",keyText=").append(getKeyText(keyCode));
1675
1676     s.append(",keyChar=");
1677     if (isActionKey()
1678         || keyCode == VK_SHIFT
1679         || keyCode == VK_CONTROL
1680         || keyCode == VK_ALT)
1681       s.append("Undefined keyChar");
1682     else
1683       {
1684         /* This output string must be selected by examining keyChar
1685          * rather than keyCode, because key code information is not
1686          * included in KEY_TYPED events.
1687          */
1688         if (keyChar == VK_BACK_SPACE
1689             || keyChar == VK_TAB
1690             || keyChar == VK_ENTER
1691             || keyChar == VK_ESCAPE
1692             || keyChar == VK_DELETE)
1693           s.append(getKeyText(keyChar));
1694         else
1695           s.append("'").append(keyChar).append("'");
1696       }
1697
1698     if ((modifiers & CONVERT_MASK) != 0)
1699       s.append(",modifiers=").append(getModifiersExText(modifiers
1700                                                         & CONVERT_MASK));
1701     if (modifiers != 0)
1702       s.append(",extModifiers=").append(getModifiersExText(modifiers));
1703
1704     s.append(",keyLocation=KEY_LOCATION_");
1705     switch (keyLocation)
1706       {
1707       case KEY_LOCATION_UNKNOWN:
1708         s.append("UNKNOWN");
1709         break;
1710       case KEY_LOCATION_STANDARD:
1711         s.append("STANDARD");
1712         break;
1713       case KEY_LOCATION_LEFT:
1714         s.append("LEFT");
1715         break;
1716       case KEY_LOCATION_RIGHT:
1717         s.append("RIGHT");
1718         break;
1719       case KEY_LOCATION_NUMPAD:
1720         s.append("NUMPAD");
1721       }
1722
1723     return s.toString();
1724   }
1725
1726   /**
1727    * Reads in the object from a serial stream.
1728    *
1729    * @param s the stream to read from
1730    * @throws IOException if deserialization fails
1731    * @throws ClassNotFoundException if deserialization fails
1732    * @serialData default, except that the modifiers are converted to new style
1733    */
1734   private void readObject(ObjectInputStream s)
1735     throws IOException, ClassNotFoundException
1736   {
1737     s.defaultReadObject();
1738     modifiers = EventModifier.extend(modifiers);
1739   }
1740 } // class KeyEvent