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