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