1. /*

  2.  * @(#)KeyEvent.java	1.65 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package java.awt.event;

  9. 

  10. import java.awt.Event;

  11. import java.awt.Component;

  12. import java.awt.GraphicsEnvironment;

  13. import java.awt.Toolkit;

  14. import java.io.IOException;

  15. import java.io.ObjectInputStream;

  16. 

  17. /**

  18.  * An event which indicates that a keystroke occurred in a component.

  19.  * <p>

  20.  * This low-level event is generated by a component object (such as a text 

  21.  * field) when a key is pressed, released, or typed.  

  22.  * The event is passed to every <code>KeyListener</code>

  23.  * or <code>KeyAdapter</code> object which registered to receive such

  24.  * events using the component's <code>addKeyListener</code> method.

  25.  * (<code>KeyAdapter</code> objects implement the 

  26.  * <code>KeyListener</code> interface.)  Each such listener object 

  27.  * gets this <code>KeyEvent</code> when the event occurs.

  28.  *

  29.  * <p>

  30.  * <em>"Key typed" events</em> are higher-level and generally do not depend on 

  31.  * the platform or keyboard layout.  They are generated when a Unicode character 

  32.  * is entered, and are the preferred way to find out about character input.

  33.  * In the simplest case, a key typed event is produced by a single key press 

  34.  * (e.g., 'a').  Often, however, characters are produced by series of key 

  35.  * presses (e.g., 'shift' + 'a'), and the mapping from key pressed events to 

  36.  * key typed events may be many-to-one or many-to-many.  Key releases are not 

  37.  * usually necessary to generate a key typed event, but there are some cases 

  38.  * where the key typed event is not generated until a key is released (e.g., 

  39.  * entering ASCII sequences via the Alt-Numpad method in Windows).  

  40.  * No key typed events are generated for keys that don't generate Unicode 

  41.  * characters (e.g., action keys, modifier keys, etc.).

  42.  * The getKeyChar method always returns a valid Unicode character or 

  43.  * CHAR_UNDEFINED.  

  44.  * For key pressed and key released events, the getKeyCode method returns 

  45.  * the event's keyCode.  For key typed events, the getKeyCode method 

  46.  * always returns VK_UNDEFINED.

  47.  *

  48.  * <p>

  49.  * <em>"Key pressed" and "key released" events</em> are lower-level and depend 

  50.  * on the platform and keyboard layout. They are generated whenever a key is 

  51.  * pressed or released, and are the only way to find out about keys that don't 

  52.  * generate character input (e.g., action keys, modifier keys, etc.). The key 

  53.  * being pressed or released is indicated by the getKeyCode method, which returns 

  54.  * a virtual key code.

  55.  *

  56.  * <p>

  57.  * <em>Virtual key codes</em> are used to report which keyboard key has

  58.  * been pressed, rather than a character generated by the combination

  59.  * of one or more keystrokes (such as "A", which comes from shift and "a").  

  60.  *

  61.  * <p>

  62.  * For example, pressing the Shift key will cause a KEY_PRESSED event 

  63.  * with a VK_SHIFT keyCode, while pressing the 'a' key will result in 

  64.  * a VK_A keyCode.  After the 'a' key is released, a KEY_RELEASED event 

  65.  * will be fired with VK_A. Separately, a KEY_TYPED event with a keyChar 

  66.  * value of 'A' is generated.

  67.  *

  68.  * <p>

  69.  * Notes:

  70.  * <ul>

  71.  * <li>Key combinations which do not result in Unicode characters, such as action 

  72.  * keys like F1 and the HELP key, do not generate KEY_TYPED events.

  73.  * <li>Not all keyboards or systems are capable of generating all

  74.  * virtual key codes.  No attempt is made in Java to generate these keys 

  75.  * artificially. 

  76.  * <li>Virtual key codes do not identify a physical key: they depend on the

  77.  * platform and keyboard layout. For example, the key that generates VK_Q 

  78.  * when using a U.S. keyboard layout will generate VK_A when using a French 

  79.  * keyboard layout.

  80.  * <li>Not all characters have a keycode associated with them.  For example, 

  81.  * there is no keycode for the question mark because there is no keyboard 

  82.  * for which it appears on the primary layer.  

  83.  * <li>In order to support the platform-independent handling of action keys,

  84.  * the Java platform uses a few additional virtual key constants for functions

  85.  * that would otherwise have to be recognized by interpreting virtual key codes

  86.  * and modifiers. For example, for Japanese Windows keyboards, VK_ALL_CANDIDATES

  87.  * is returned instead of VK_CONVERT with the ALT modifier.

  88.  * </ul>

  89.  *

  90.  * <p>

  91.  * WARNING: Aside from those keys that are defined by the Java language

  92.  * (VK_ENTER, VK_BACK_SPACE, and VK_TAB), do not rely on the values of the VK_

  93.  * constants.  Sun reserves the right to change these values as needed

  94.  * to accomodate a wider range of keyboards in the future.  

  95.  *

  96.  * @author Carl Quinn

  97.  * @author Amy Fowler

  98.  * @author Norbert Lindenberg

  99.  * @version 1.65 01/23/03

  100.  *

  101.  * @see KeyAdapter

  102.  * @see KeyListener

  103.  * @see <a href="http://java.sun.com/docs/books/tutorial/post1.0/ui/keylistener.html">Tutorial: Writing a Key Listener</a>

  104.  * @see <a href="http://www.awl.com/cp/javaseries/jcl1_2.html">Reference: The Java Class Libraries (update file)</a>

  105.  *

  106.  * @since 1.1

  107.  */

  108. public class KeyEvent extends InputEvent {

  109. 

  110.     /**

  111.      * Stores the state of native event dispatching system

  112.      * - true, if when the event was created event proxying 

  113.      *         mechanism was active

  114.      * - false, if it was inactive

  115.      * Used in Component.dispatchEventImpl to correctly dispatch

  116.      * events when proxy is active

  117.      */

  118.     private boolean isProxyActive = false;

  119. 

  120.     /**

  121.      * The first number in the range of ids used for key events.

  122.      */

  123.     public static final int KEY_FIRST = 400;

  124. 

  125.     /**

  126.      * The last number in the range of ids used for key events.

  127.      */

  128.     public static final int KEY_LAST  = 402;

  129. 

  130.     /**

  131.      * The "key typed" event.  This event is generated when a character is

  132.      * entered.  In the simplest case, it is produced by a single key press.  

  133.      * Often, however, characters are produced by series of key presses, and 

  134.      * the mapping from key pressed events to key typed events may be 

  135.      * many-to-one or many-to-many.  

  136.      */

  137.     public static final int KEY_TYPED = KEY_FIRST;

  138. 

  139.     /**

  140.      * The "key pressed" event. This event is generated when a key

  141.      * is pushed down.

  142.      */

  143.     public static final int KEY_PRESSED = 1 + KEY_FIRST; //Event.KEY_PRESS

  144. 

  145.     /**

  146.      * The "key released" event. This event is generated when a key

  147.      * is let up.

  148.      */

  149.     public static final int KEY_RELEASED = 2 + KEY_FIRST; //Event.KEY_RELEASE

  150. 

  151.     /* Virtual key codes. */

  152. 

  153.     public static final int VK_ENTER          = '\n';

  154.     public static final int VK_BACK_SPACE     = '\b';

  155.     public static final int VK_TAB            = '\t';

  156.     public static final int VK_CANCEL         = 0x03;

  157.     public static final int VK_CLEAR          = 0x0C;

  158.     public static final int VK_SHIFT          = 0x10;

  159.     public static final int VK_CONTROL        = 0x11;

  160.     public static final int VK_ALT            = 0x12;

  161.     public static final int VK_PAUSE          = 0x13;

  162.     public static final int VK_CAPS_LOCK      = 0x14;

  163.     public static final int VK_ESCAPE         = 0x1B;

  164.     public static final int VK_SPACE          = 0x20;

  165.     public static final int VK_PAGE_UP        = 0x21;

  166.     public static final int VK_PAGE_DOWN      = 0x22;

  167.     public static final int VK_END            = 0x23;

  168.     public static final int VK_HOME           = 0x24;

  169. 

  170.     /**

  171.      * Constant for the non-numpad <b>left</b> arrow key.

  172.      * @see #VK_KP_LEFT

  173.      */

  174.     public static final int VK_LEFT           = 0x25;

  175. 

  176.     /**

  177.      * Constant for the non-numpad <b>up</b> arrow key.

  178.      * @see #VK_KP_UP

  179.      */

  180.     public static final int VK_UP             = 0x26;

  181. 

  182.     /**

  183.      * Constant for the non-numpad <b>right</b> arrow key.

  184.      * @see #VK_KP_RIGHT

  185.      */

  186.     public static final int VK_RIGHT          = 0x27;

  187. 

  188.     /**

  189.      * Constant for the non-numpad <b>down</b> arrow key.

  190.      * @see #VK_KP_DOWN

  191.      */

  192.     public static final int VK_DOWN           = 0x28;

  193. 

  194.     public static final int VK_COMMA          = 0x2C;

  195. 

  196.     /**

  197.      * Constant for the "-" key.

  198.      * @since 1.2

  199.      */

  200.     public static final int VK_MINUS          = 0x2D;

  201. 

  202.     public static final int VK_PERIOD         = 0x2E;

  203.     public static final int VK_SLASH          = 0x2F;

  204. 

  205.     /** VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */

  206.     public static final int VK_0              = 0x30;

  207.     public static final int VK_1              = 0x31;

  208.     public static final int VK_2              = 0x32;

  209.     public static final int VK_3              = 0x33;

  210.     public static final int VK_4              = 0x34;

  211.     public static final int VK_5              = 0x35;

  212.     public static final int VK_6              = 0x36;

  213.     public static final int VK_7              = 0x37;

  214.     public static final int VK_8              = 0x38;

  215.     public static final int VK_9              = 0x39;

  216. 

  217.     public static final int VK_SEMICOLON      = 0x3B;

  218.     public static final int VK_EQUALS         = 0x3D;

  219. 

  220.     /** VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */

  221.     public static final int VK_A              = 0x41;

  222.     public static final int VK_B              = 0x42;

  223.     public static final int VK_C              = 0x43;

  224.     public static final int VK_D              = 0x44;

  225.     public static final int VK_E              = 0x45;

  226.     public static final int VK_F              = 0x46;

  227.     public static final int VK_G              = 0x47;

  228.     public static final int VK_H              = 0x48;

  229.     public static final int VK_I              = 0x49;

  230.     public static final int VK_J              = 0x4A;

  231.     public static final int VK_K              = 0x4B;

  232.     public static final int VK_L              = 0x4C;

  233.     public static final int VK_M              = 0x4D;

  234.     public static final int VK_N              = 0x4E;

  235.     public static final int VK_O              = 0x4F;

  236.     public static final int VK_P              = 0x50;

  237.     public static final int VK_Q              = 0x51;

  238.     public static final int VK_R              = 0x52;

  239.     public static final int VK_S              = 0x53;

  240.     public static final int VK_T              = 0x54;

  241.     public static final int VK_U              = 0x55;

  242.     public static final int VK_V              = 0x56;

  243.     public static final int VK_W              = 0x57;

  244.     public static final int VK_X              = 0x58;

  245.     public static final int VK_Y              = 0x59;

  246.     public static final int VK_Z              = 0x5A;

  247. 

  248.     public static final int VK_OPEN_BRACKET   = 0x5B;

  249.     public static final int VK_BACK_SLASH     = 0x5C;

  250.     public static final int VK_CLOSE_BRACKET  = 0x5D;

  251. 

  252.     public static final int VK_NUMPAD0        = 0x60;

  253.     public static final int VK_NUMPAD1        = 0x61;

  254.     public static final int VK_NUMPAD2        = 0x62;

  255.     public static final int VK_NUMPAD3        = 0x63;

  256.     public static final int VK_NUMPAD4        = 0x64;

  257.     public static final int VK_NUMPAD5        = 0x65;

  258.     public static final int VK_NUMPAD6        = 0x66;

  259.     public static final int VK_NUMPAD7        = 0x67;

  260.     public static final int VK_NUMPAD8        = 0x68;

  261.     public static final int VK_NUMPAD9        = 0x69;

  262.     public static final int VK_MULTIPLY       = 0x6A;

  263.     public static final int VK_ADD            = 0x6B;

  264. 

  265.     /** 

  266.      * This constant is obsolete, and is included only for backwards

  267.      * compatibility.

  268.      * @see #VK_SEPARATOR

  269.      */

  270.     public static final int VK_SEPARATER      = 0x6C;

  271. 

  272.     /** 

  273.      * Constant for the Numpad Separator key. 

  274.      * @since 1.4

  275.      */

  276.     public static final int VK_SEPARATOR      = VK_SEPARATER;

  277. 

  278.     public static final int VK_SUBTRACT       = 0x6D;

  279.     public static final int VK_DECIMAL        = 0x6E;

  280.     public static final int VK_DIVIDE         = 0x6F;

  281.     public static final int VK_DELETE         = 0x7F; /* ASCII DEL */

  282.     public static final int VK_NUM_LOCK       = 0x90;

  283.     public static final int VK_SCROLL_LOCK    = 0x91;

  284. 

  285.     /** Constant for the F1 function key. */

  286.     public static final int VK_F1             = 0x70;

  287. 

  288.     /** Constant for the F2 function key. */

  289.     public static final int VK_F2             = 0x71;

  290. 

  291.     /** Constant for the F3 function key. */

  292.     public static final int VK_F3             = 0x72;

  293. 

  294.     /** Constant for the F4 function key. */

  295.     public static final int VK_F4             = 0x73;

  296. 

  297.     /** Constant for the F5 function key. */

  298.     public static final int VK_F5             = 0x74;

  299. 

  300.     /** Constant for the F6 function key. */

  301.     public static final int VK_F6             = 0x75;

  302. 

  303.     /** Constant for the F7 function key. */

  304.     public static final int VK_F7             = 0x76;

  305. 

  306.     /** Constant for the F8 function key. */

  307.     public static final int VK_F8             = 0x77;

  308. 

  309.     /** Constant for the F9 function key. */

  310.     public static final int VK_F9             = 0x78;

  311. 

  312.     /** Constant for the F10 function key. */

  313.     public static final int VK_F10            = 0x79;

  314. 

  315.     /** Constant for the F11 function key. */

  316.     public static final int VK_F11            = 0x7A;

  317. 

  318.     /** Constant for the F12 function key. */

  319.     public static final int VK_F12            = 0x7B;

  320. 

  321.     /**

  322.      * Constant for the F13 function key.

  323.      * @since 1.2

  324.      */

  325.     /* F13 - F24 are used on IBM 3270 keyboard; use random range for constants. */

  326.     public static final int VK_F13            = 0xF000;

  327.  

  328.     /**

  329.      * Constant for the F14 function key.

  330.      * @since 1.2

  331.      */

  332.     public static final int VK_F14            = 0xF001;

  333.  

  334.     /**

  335.      * Constant for the F15 function key.

  336.      * @since 1.2

  337.      */

  338.     public static final int VK_F15            = 0xF002;

  339.  

  340.     /**

  341.      * Constant for the F16 function key.

  342.      * @since 1.2

  343.      */

  344.     public static final int VK_F16            = 0xF003;

  345.  

  346.     /**

  347.      * Constant for the F17 function key.

  348.      * @since 1.2

  349.      */

  350.     public static final int VK_F17            = 0xF004;

  351.  

  352.     /**

  353.      * Constant for the F18 function key.

  354.      * @since 1.2

  355.      */

  356.     public static final int VK_F18            = 0xF005;

  357.  

  358.     /**

  359.      * Constant for the F19 function key.

  360.      * @since 1.2

  361.      */

  362.     public static final int VK_F19            = 0xF006;

  363.  

  364.     /**

  365.      * Constant for the F20 function key.

  366.      * @since 1.2

  367.      */

  368.     public static final int VK_F20            = 0xF007;

  369.  

  370.     /**

  371.      * Constant for the F21 function key.

  372.      * @since 1.2

  373.      */

  374.     public static final int VK_F21            = 0xF008;

  375.  

  376.     /**

  377.      * Constant for the F22 function key.

  378.      * @since 1.2

  379.      */

  380.     public static final int VK_F22            = 0xF009;

  381.  

  382.     /**

  383.      * Constant for the F23 function key.

  384.      * @since 1.2

  385.      */

  386.     public static final int VK_F23            = 0xF00A;

  387.  

  388.     /**

  389.      * Constant for the F24 function key.

  390.      * @since 1.2

  391.      */

  392.     public static final int VK_F24            = 0xF00B;

  393.  

  394.     public static final int VK_PRINTSCREEN    = 0x9A;

  395.     public static final int VK_INSERT         = 0x9B;

  396.     public static final int VK_HELP           = 0x9C;

  397.     public static final int VK_META           = 0x9D;

  398. 

  399.     public static final int VK_BACK_QUOTE     = 0xC0;

  400.     public static final int VK_QUOTE          = 0xDE;

  401. 

  402.     /**

  403.      * Constant for the numeric keypad <b>up</b> arrow key.

  404.      * @see #VK_UP

  405.      * @since 1.2

  406.      */

  407.     public static final int VK_KP_UP          = 0xE0;

  408. 

  409.     /**

  410.      * Constant for the numeric keypad <b>down</b> arrow key.

  411.      * @see #VK_DOWN

  412.      * @since 1.2

  413.      */

  414.     public static final int VK_KP_DOWN        = 0xE1;

  415. 

  416.     /**

  417.      * Constant for the numeric keypad <b>left</b> arrow key.

  418.      * @see #VK_LEFT

  419.      * @since 1.2

  420.      */

  421.     public static final int VK_KP_LEFT        = 0xE2;

  422. 

  423.     /**

  424.      * Constant for the numeric keypad <b>right</b> arrow key.

  425.      * @see #VK_RIGHT

  426.      * @since 1.2

  427.      */

  428.     public static final int VK_KP_RIGHT       = 0xE3;

  429.     

  430.     /* For European keyboards */

  431.     /** @since 1.2 */

  432.     public static final int VK_DEAD_GRAVE               = 0x80;

  433.     /** @since 1.2 */

  434.     public static final int VK_DEAD_ACUTE               = 0x81;

  435.     /** @since 1.2 */

  436.     public static final int VK_DEAD_CIRCUMFLEX          = 0x82;

  437.     /** @since 1.2 */

  438.     public static final int VK_DEAD_TILDE               = 0x83;

  439.     /** @since 1.2 */

  440.     public static final int VK_DEAD_MACRON              = 0x84;

  441.     /** @since 1.2 */

  442.     public static final int VK_DEAD_BREVE               = 0x85;

  443.     /** @since 1.2 */

  444.     public static final int VK_DEAD_ABOVEDOT            = 0x86;

  445.     /** @since 1.2 */

  446.     public static final int VK_DEAD_DIAERESIS           = 0x87;

  447.     /** @since 1.2 */

  448.     public static final int VK_DEAD_ABOVERING           = 0x88;

  449.     /** @since 1.2 */

  450.     public static final int VK_DEAD_DOUBLEACUTE         = 0x89;

  451.     /** @since 1.2 */

  452.     public static final int VK_DEAD_CARON               = 0x8a;

  453.     /** @since 1.2 */

  454.     public static final int VK_DEAD_CEDILLA             = 0x8b;

  455.     /** @since 1.2 */

  456.     public static final int VK_DEAD_OGONEK              = 0x8c;

  457.     /** @since 1.2 */

  458.     public static final int VK_DEAD_IOTA                = 0x8d;

  459.     /** @since 1.2 */

  460.     public static final int VK_DEAD_VOICED_SOUND        = 0x8e;

  461.     /** @since 1.2 */

  462.     public static final int VK_DEAD_SEMIVOICED_SOUND    = 0x8f;

  463. 

  464.     /** @since 1.2 */

  465.     public static final int VK_AMPERSAND                = 0x96;

  466.     /** @since 1.2 */

  467.     public static final int VK_ASTERISK                 = 0x97;

  468.     /** @since 1.2 */

  469.     public static final int VK_QUOTEDBL                 = 0x98;

  470.     /** @since 1.2 */

  471.     public static final int VK_LESS                     = 0x99;

  472. 

  473.     /** @since 1.2 */

  474.     public static final int VK_GREATER                  = 0xa0;

  475.     /** @since 1.2 */

  476.     public static final int VK_BRACELEFT                = 0xa1;

  477.     /** @since 1.2 */

  478.     public static final int VK_BRACERIGHT               = 0xa2;

  479. 

  480.     /**

  481.      * Constant for the "@" key.

  482.      * @since 1.2

  483.      */

  484.     public static final int VK_AT                       = 0x0200;

  485.  

  486.     /**

  487.      * Constant for the ":" key.

  488.      * @since 1.2

  489.      */

  490.     public static final int VK_COLON                    = 0x0201;

  491.  

  492.     /**

  493.      * Constant for the "^" key.

  494.      * @since 1.2

  495.      */

  496.     public static final int VK_CIRCUMFLEX               = 0x0202;

  497.  

  498.     /**

  499.      * Constant for the "$" key.

  500.      * @since 1.2

  501.      */

  502.     public static final int VK_DOLLAR                   = 0x0203;

  503.  

  504.     /**

  505.      * Constant for the Euro currency sign key.

  506.      * @since 1.2

  507.      */

  508.     public static final int VK_EURO_SIGN                = 0x0204;

  509.  

  510.     /**

  511.      * Constant for the "!" key.

  512.      * @since 1.2

  513.      */

  514.     public static final int VK_EXCLAMATION_MARK         = 0x0205;

  515.  

  516.     /**

  517.      * Constant for the inverted exclamation mark key.

  518.      * @since 1.2

  519.      */

  520.     public static final int VK_INVERTED_EXCLAMATION_MARK = 0x0206;

  521.  

  522.     /**

  523.      * Constant for the "(" key.

  524.      * @since 1.2

  525.      */

  526.     public static final int VK_LEFT_PARENTHESIS         = 0x0207;

  527.  

  528.     /**

  529.      * Constant for the "#" key.

  530.      * @since 1.2

  531.      */

  532.     public static final int VK_NUMBER_SIGN              = 0x0208;

  533.  

  534.     /**

  535.      * Constant for the "+" key.

  536.      * @since 1.2

  537.      */

  538.     public static final int VK_PLUS                     = 0x0209;

  539.  

  540.     /**

  541.      * Constant for the ")" key.

  542.      * @since 1.2

  543.      */

  544.     public static final int VK_RIGHT_PARENTHESIS        = 0x020A;

  545.  

  546.     /**

  547.      * Constant for the "_" key.

  548.      * @since 1.2

  549.      */

  550.     public static final int VK_UNDERSCORE               = 0x020B;

  551.  

  552.     /* for input method support on Asian Keyboards */

  553. 

  554.     /* not clear what this means - listed in Microsoft Windows API */

  555.     public static final int VK_FINAL                    = 0x0018;

  556.     

  557.     /** Constant for the Convert function key. */

  558.     /* Japanese PC 106 keyboard, Japanese Solaris keyboard: henkan */

  559.     public static final int VK_CONVERT                  = 0x001C;

  560. 

  561.     /** Constant for the Don't Convert function key. */

  562.     /* Japanese PC 106 keyboard: muhenkan */

  563.     public static final int VK_NONCONVERT               = 0x001D;

  564.     

  565.     /** Constant for the Accept or Commit function key. */

  566.     /* Japanese Solaris keyboard: kakutei */

  567.     public static final int VK_ACCEPT                   = 0x001E;

  568. 

  569.     /* not clear what this means - listed in Microsoft Windows API */

  570.     public static final int VK_MODECHANGE               = 0x001F;

  571. 

  572.     /* replaced by VK_KANA_LOCK for Microsoft Windows and Solaris; 

  573.        might still be used on other platforms */

  574.     public static final int VK_KANA                     = 0x0015;

  575. 

  576.     /* replaced by VK_INPUT_METHOD_ON_OFF for Microsoft Windows and Solaris; 

  577.        might still be used for other platforms */

  578.     public static final int VK_KANJI                    = 0x0019;

  579. 

  580.     /**

  581.      * Constant for the Alphanumeric function key.

  582.      * @since 1.2

  583.      */

  584.     /* Japanese PC 106 keyboard: eisuu */

  585.     public static final int VK_ALPHANUMERIC             = 0x00F0;

  586.  

  587.     /**

  588.      * Constant for the Katakana function key.

  589.      * @since 1.2

  590.      */

  591.     /* Japanese PC 106 keyboard: katakana */

  592.     public static final int VK_KATAKANA                 = 0x00F1;

  593.  

  594.     /**

  595.      * Constant for the Hiragana function key.

  596.      * @since 1.2

  597.      */

  598.     /* Japanese PC 106 keyboard: hiragana */

  599.     public static final int VK_HIRAGANA                 = 0x00F2;

  600.  

  601.     /**

  602.      * Constant for the Full-Width Characters function key.

  603.      * @since 1.2

  604.      */

  605.     /* Japanese PC 106 keyboard: zenkaku */

  606.     public static final int VK_FULL_WIDTH               = 0x00F3;

  607.  

  608.     /**

  609.      * Constant for the Half-Width Characters function key.

  610.      * @since 1.2

  611.      */

  612.     /* Japanese PC 106 keyboard: hankaku */

  613.     public static final int VK_HALF_WIDTH               = 0x00F4;

  614.  

  615.     /**

  616.      * Constant for the Roman Characters function key.

  617.      * @since 1.2

  618.      */

  619.     /* Japanese PC 106 keyboard: roumaji */

  620.     public static final int VK_ROMAN_CHARACTERS         = 0x00F5;

  621.  

  622.     /**

  623.      * Constant for the All Candidates function key.

  624.      * @since 1.2

  625.      */

  626.     /* Japanese PC 106 keyboard - VK_CONVERT + ALT: zenkouho */

  627.     public static final int VK_ALL_CANDIDATES           = 0x0100;

  628.  

  629.     /**

  630.      * Constant for the Previous Candidate function key.

  631.      * @since 1.2

  632.      */

  633.     /* Japanese PC 106 keyboard - VK_CONVERT + SHIFT: maekouho */

  634.     public static final int VK_PREVIOUS_CANDIDATE       = 0x0101;

  635.  

  636.     /**

  637.      * Constant for the Code Input function key.

  638.      * @since 1.2

  639.      */

  640.     /* Japanese PC 106 keyboard - VK_ALPHANUMERIC + ALT: kanji bangou */

  641.     public static final int VK_CODE_INPUT               = 0x0102;

  642.  

  643.     /**

  644.      * Constant for the Japanese-Katakana function key.

  645.      * This key switches to a Japanese input method and selects its Katakana input mode.

  646.      * @since 1.2

  647.      */

  648.     /* Japanese Macintosh keyboard - VK_JAPANESE_HIRAGANA + SHIFT */

  649.     public static final int VK_JAPANESE_KATAKANA        = 0x0103;

  650.  

  651.     /**

  652.      * Constant for the Japanese-Hiragana function key.

  653.      * This key switches to a Japanese input method and selects its Hiragana input mode.

  654.      * @since 1.2

  655.      */

  656.     /* Japanese Macintosh keyboard */

  657.     public static final int VK_JAPANESE_HIRAGANA        = 0x0104;

  658.  

  659.     /**

  660.      * Constant for the Japanese-Roman function key.

  661.      * This key switches to a Japanese input method and selects its Roman-Direct input mode.

  662.      * @since 1.2

  663.      */

  664.     /* Japanese Macintosh keyboard */

  665.     public static final int VK_JAPANESE_ROMAN           = 0x0105;

  666. 

  667.     /**

  668.      * Constant for the locking Kana function key.

  669.      * This key locks the keyboard into a Kana layout.

  670.      * @since 1.3

  671.      */

  672.     /* Japanese PC 106 keyboard with special Windows driver - eisuu + Control; Japanese Solaris keyboard: kana */

  673.     public static final int VK_KANA_LOCK                = 0x0106;

  674. 

  675.     /**

  676.      * Constant for the input method on/off key.

  677.      * @since 1.3

  678.      */

  679.     /* Japanese PC 106 keyboard: kanji. Japanese Solaris keyboard: nihongo */

  680.     public static final int VK_INPUT_METHOD_ON_OFF      = 0x0107;

  681. 

  682.     /* for Sun keyboards */

  683.     /** @since 1.2 */

  684.     public static final int VK_CUT                      = 0xFFD1;

  685.     /** @since 1.2 */

  686.     public static final int VK_COPY                     = 0xFFCD;

  687.     /** @since 1.2 */

  688.     public static final int VK_PASTE                    = 0xFFCF;

  689.     /** @since 1.2 */

  690.     public static final int VK_UNDO                     = 0xFFCB;

  691.     /** @since 1.2 */

  692.     public static final int VK_AGAIN                    = 0xFFC9;

  693.     /** @since 1.2 */

  694.     public static final int VK_FIND                     = 0xFFD0;

  695.     /** @since 1.2 */

  696.     public static final int VK_PROPS                    = 0xFFCA;

  697.     /** @since 1.2 */

  698.     public static final int VK_STOP                     = 0xFFC8;

  699.     

  700.     /**

  701.      * Constant for the Compose function key.

  702.      * @since 1.2

  703.      */

  704.     public static final int VK_COMPOSE                  = 0xFF20;

  705.  

  706.     /**

  707.      * Constant for the AltGraph function key.

  708.      * @since 1.2

  709.      */

  710.     public static final int VK_ALT_GRAPH                = 0xFF7E;

  711. 

  712.     /**

  713.      * This value is used to indicate that the keyCode is unknown.

  714.      * KEY_TYPED events do not have a keyCode value; this value 

  715.      * is used instead.  

  716.      */

  717.     public static final int VK_UNDEFINED      = 0x0;

  718. 

  719.     /**

  720.      * KEY_PRESSED and KEY_RELEASED events which do not map to a

  721.      * valid Unicode character use this for the keyChar value.

  722.      */

  723.     public static final char CHAR_UNDEFINED   = 0xFFFF;

  724. 

  725.     /**

  726.      * A constant indicating that the keyLocation is indeterminate

  727.      * or not relevant.

  728.      * KEY_TYPED events do not have a keyLocation; this value

  729.      * is used instead.

  730.      * @since 1.4

  731.      */

  732.     public static final int KEY_LOCATION_UNKNOWN  = 0;

  733. 

  734.     /**

  735.      * A constant indicating that the key pressed or released

  736.      * is not distinguished as the left or right version of a key,

  737.      * and did not originate on the numeric keypad (or did not

  738.      * originate with a virtual key corresponding to the numeric

  739.      * keypad).

  740.      * @since 1.4

  741.      */

  742.     public static final int KEY_LOCATION_STANDARD = 1;

  743. 

  744.     /**

  745.      * A constant indicating that the key pressed or released is in

  746.      * the left key location (there is more than one possible location

  747.      * for this key).  Example: the left shift key.

  748.      * @since 1.4

  749.      */

  750.     public static final int KEY_LOCATION_LEFT     = 2;

  751. 

  752.     /**

  753.      * A constant indicating that the key pressed or released is in

  754.      * the right key location (there is more than one possible location

  755.      * for this key).  Example: the right shift key.

  756.      * @since 1.4

  757.      */

  758.     public static final int KEY_LOCATION_RIGHT    = 3;

  759. 

  760.     /**

  761.      * A constant indicating that the key event originated on the

  762.      * numeric keypad or with a virtual key corresponding to the

  763.      * numeric keypad.

  764.      * @since 1.4

  765.      */

  766.     public static final int KEY_LOCATION_NUMPAD   = 4;

  767. 

  768.     /**

  769.      * The unique value assigned to each of the keys on the

  770.      * keyboard.  There is a common set of key codes that

  771.      * can be fired by most keyboards.

  772.      * The symbolic name for a key code should be used rather

  773.      * than the code value itself.

  774.      *

  775.      * @serial

  776.      * @see #getKeyCode()

  777.      * @see #setKeyCode(int)

  778.      */

  779.     int  keyCode;

  780. 

  781.     /**

  782.      * <code>keyChar</code> is a valid unicode character

  783.      * that is fired by a key or a key combination on

  784.      * a keyboard.

  785.      *

  786.      * @serial

  787.      * @see #getKeyChar()

  788.      * @see #setKeyChar(char)

  789.      */

  790.     char keyChar;

  791. 

  792.     /**

  793.      * The location of the key on the keyboard.

  794.      *

  795.      * Some keys occur more than once on a keyboard, e.g. the left and

  796.      * right shift keys.  Additionally, some keys occur on the numeric

  797.      * keypad.  This variable is used to distinguish such keys.

  798.      *

  799.      * The only legal values are <code>KEY_LOCATION_UNKNOWN</code>, 

  800.      * <code>KEY_LOCATION_STANDARD</code>, <code>KEY_LOCATION_LEFT</code>, 

  801.      * <code>KEY_LOCATION_RIGHT</code>, and <code>KEY_LOCATION_NUMPAD</code>.

  802.      *

  803.      * @serial

  804.      * @see #getKeyLocation()

  805.      */

  806.     int keyLocation;

  807. 

  808.     /*

  809.      * JDK 1.1 serialVersionUID 

  810.      */

  811.     private static final long serialVersionUID = -2352130953028126954L;

  812. 

  813.     static {

  814.         /* ensure that the necessary native libraries are loaded */

  815. 	NativeLibLoader.loadLibraries();

  816.         if (!GraphicsEnvironment.isHeadless()) {

  817.             initIDs();

  818.         }

  819.     }

  820. 

  821.     /**

  822.      * Initialize JNI field and method IDs for fields that may be

  823.      * accessed from C.

  824.      */

  825.     private static native void initIDs();

  826. 

  827.     /**

  828.      * Constructs a <code>KeyEvent</code> object.

  829.      * <p>Note that passing in an invalid <code>id</code> results in

  830.      * unspecified behavior.

  831.      *

  832.      * @param source    the <code>Component</code> that originated the event

  833.      * @param id        an integer identifying the type of event

  834.      * @param when      a long integer that specifies the time the event

  835.      *                  occurred

  836.      * @param modifiers the modifier keys down during event (shift, ctrl,

  837.      *                  alt, meta)

  838.      *                  Either extended _DOWN_MASK or old _MASK modifiers

  839.      *                  should be used, but both models should not be mixed

  840.      *                  in one event. Use of the extended modifiers is

  841.      *                  preferred.

  842.      * @param keyCode   the integer code for an actual key, or VK_UNDEFINED

  843.      *                  (for a key-typed event)

  844.      * @param keyChar   the Unicode character generated by this event, or

  845.      *                  CHAR_UNDEFINED (for key-pressed and key-released

  846.      *                  events which do not map to a valid Unicode character)

  847.      * @param keyLocation  identifies the key location.  The only legal

  848.      *        values are <code>KEY_LOCATION_UNKNOWN</code>, 

  849.      *        <code>KEY_LOCATION_STANDARD</code>, <code>KEY_LOCATION_LEFT</code>, 

  850.      *        <code>KEY_LOCATION_RIGHT</code>, and <code>KEY_LOCATION_NUMPAD</code>.

  851.      * @exception IllegalArgumentException  

  852.      *     if <code>id</code> is <code>KEY_TYPED</code> and 

  853.      *       <code>keyChar</code> is <code>CHAR_UNDEFINED</code> 

  854.      *     or if <code>id</code> is <code>KEY_TYPED</code> and 

  855.      *       <code>keyCode</code> is not <code>VK_UNDEFINED</code> 

  856.      *     or if <code>id</code> is <code>KEY_TYPED</code> and

  857.      *       <code>keyLocation</code> is not <code>KEY_LOCATION_UNKNOWN</code>

  858.      *     or if <code>keyLocation</code> is not one of the legal 

  859.      *       values enumerated above.  

  860.      * @since 1.4

  861.      */

  862.     private KeyEvent(Component source, int id, long when, int modifiers,

  863.                     int keyCode, char keyChar, int keyLocation, boolean isProxyActive) {

  864.         this(source, id, when, modifiers, keyCode, keyChar, keyLocation);

  865.         this.isProxyActive = isProxyActive;

  866.     }

  867.     public KeyEvent(Component source, int id, long when, int modifiers,

  868.                     int keyCode, char keyChar, int keyLocation) {

  869.         super(source, id, when, modifiers);

  870.         if (id == KEY_TYPED) {

  871.             if (keyChar == CHAR_UNDEFINED) {

  872.                 throw new IllegalArgumentException("invalid keyChar");

  873.             }

  874.             if (keyCode != VK_UNDEFINED) {

  875.                 throw new IllegalArgumentException("invalid keyCode");

  876.             }

  877.             if (keyLocation != KEY_LOCATION_UNKNOWN) {

  878.                 throw new IllegalArgumentException("invalid keyLocation");

  879.             }

  880.         }

  881. 

  882.         this.keyCode = keyCode;

  883.         this.keyChar = keyChar;

  884. 

  885.         if ((keyLocation < KEY_LOCATION_UNKNOWN) ||

  886.             (keyLocation > KEY_LOCATION_NUMPAD)) {

  887.             throw new IllegalArgumentException("invalid keyLocation");

  888.         }

  889.         this.keyLocation = keyLocation;

  890.         if ((getModifiers() != 0) && (getModifiersEx() == 0)) {

  891. 	    setNewModifiers();    

  892. 	} else if ((getModifiers() == 0) && (getModifiersEx() != 0)) {

  893. 	    setOldModifiers();

  894. 	}

  895.     }

  896. 

  897.     /**

  898.      * Constructs a <code>KeyEvent</code> object.

  899.      * <p>Note that passing in an invalid <code>id</code> results in

  900.      * unspecified behavior.

  901.      *

  902.      * @param source    the <code>Component</code> that originated the event

  903.      * @param id        an integer identifying the type of event

  904.      * @param when      a long integer that specifies the time the event

  905.      *                  occurred

  906.      * @param modifiers the modifier keys down during event (shift, ctrl,

  907.      *                  alt, meta)

  908.      *                  Either extended _DOWN_MASK or old _MASK modifiers

  909.      *                  should be used, but both models should not be mixed

  910.      *                  in one event. Use of the extended modifiers is

  911.      *                  preferred.

  912.      * @param keyCode   the integer code for an actual key, or VK_UNDEFINED 

  913.      *                  (for a key-typed event)

  914.      * @param keyChar   the Unicode character generated by this event, or 

  915.      *                  CHAR_UNDEFINED (for key-pressed and key-released

  916.      *                  events which do not map to a valid Unicode character)

  917.      * @exception IllegalArgumentException  if <code>id</code> is

  918.      *     <code>KEY_TYPED</code> and <code>keyChar</code> is

  919.      *     <code>CHAR_UNDEFINED</code> or if <code>id</code> is

  920.      *     <code>KEY_TYPED</code> and <code>keyCode</code> is not

  921.      *     <code>VK_UNDEFINED</code>

  922.      */

  923.     public KeyEvent(Component source, int id, long when, int modifiers,

  924.                     int keyCode, char keyChar) {

  925.         this(source, id, when, modifiers, keyCode, keyChar,

  926.           KEY_LOCATION_UNKNOWN);

  927.     }

  928. 

  929.     /**

  930.      * @deprecated as of JDK1.1 

  931.      */

  932.     public KeyEvent(Component source, int id, long when, int modifiers,

  933.                     int keyCode) {

  934.         this(source, id, when, modifiers, keyCode, (char)keyCode);

  935.     }

  936. 

  937.     /**

  938.      * Returns the integer keyCode associated with the key in this event.

  939.      * 

  940.      * @return the integer code for an actual key on the keyboard. 

  941.      *         (For <code>KEY_TYPED</code> events, the keyCode is 

  942.      *         <code>VK_UNDEFINED</code>.)

  943.      */

  944.     public int getKeyCode() {

  945.         return keyCode;

  946.     }

  947. 

  948.     /**

  949.      * Set the keyCode value to indicate a physical key.

  950.      *

  951.      * @param keyCode an integer corresponding to an actual key on the keyboard.

  952.      */

  953.     public void setKeyCode(int keyCode) {

  954.         this.keyCode = keyCode;

  955.     }

  956. 

  957.     /**

  958.      * Returns the character associated with the key in this event.

  959.      * For example, the key-typed event for shift + "a" returns the 

  960.      * value for "A".

  961.      *

  962.      * @return the Unicode character defined for this key event.

  963.      *         If no valid Unicode character exists for this key event, 

  964.      *         keyChar is <code>CHAR_UNDEFINED</code>.

  965.      */

  966.     public char getKeyChar() {

  967.         return keyChar;

  968.     }

  969. 

  970.     /**

  971.      * Set the keyChar value to indicate a logical character.

  972.      *

  973.      * @param keyChar a char corresponding to to the combination of keystrokes

  974.      *                that make up this event.

  975.      */

  976.     public void setKeyChar(char keyChar) {

  977.         this.keyChar = keyChar;

  978.     }

  979. 

  980.     /**

  981.      * Set the modifiers to indicate additional keys that were held down

  982.      * (e.g. shift, ctrl, alt, meta) defined as part of InputEvent.

  983.      * <p>

  984.      * NOTE:  use of this method is not recommended, because many AWT

  985.      * implementations do not recognize modifier changes.  This is

  986.      * especially true for <code>KEY_TYPED</code> events where the shift 

  987.      * modifier is changed.

  988.      *

  989.      * @param modifiers an integer combination of the modifier constants.

  990.      * @see InputEvent

  991.      * @deprecated as of JDK1.1.4

  992.      */

  993.     public void setModifiers(int modifiers) {

  994.         this.modifiers = modifiers;

  995.         if ((getModifiers() != 0) && (getModifiersEx() == 0)) {

  996. 	    setNewModifiers();    

  997. 	} else if ((getModifiers() == 0) && (getModifiersEx() != 0)) {

  998. 	    setOldModifiers();

  999. 	}

  1000.     }

  1001. 

  1002.     /**

  1003.      * Returns the location of the key that originated this key event.

  1004.      *

  1005.      * Some keys occur more than once on a keyboard, e.g. the left and

  1006.      * right shift keys.  Additionally, some keys occur on the numeric

  1007.      * keypad.  This provides a way of distinguishing such keys.

  1008.      *

  1009.      * @return the location of the key that was pressed or released.

  1010.      *         Always returns <code>KEY_LOCATION_UNKNOWN</code> for 

  1011.      *         <code>KEY_TYPED</code> events.

  1012.      * @since 1.4

  1013.      */

  1014.     public int getKeyLocation() {

  1015.         return keyLocation;

  1016.     }

  1017. 

  1018.     /**

  1019.      * Returns a String describing the keyCode, such as "HOME", "F1" or "A".

  1020.      * These strings can be localized by changing the awt.properties file.

  1021.      *

  1022.      * @return a string containing a text description for a physical key,

  1023.      *         identified by its keyCode

  1024.      */

  1025.     public static String getKeyText(int keyCode) {

  1026.         if (keyCode >= VK_0 && keyCode <= VK_9 || 

  1027.             keyCode >= VK_A && keyCode <= VK_Z) {

  1028.             return String.valueOf((char)keyCode);

  1029.         }

  1030. 

  1031.         // Check for other ASCII keyCodes.

  1032.         int index = ",./;=[\\]".indexOf(keyCode);

  1033.         if (index >= 0) {

  1034.             return String.valueOf((char)keyCode);

  1035.         }

  1036. 	

  1037.         switch(keyCode) {

  1038.           case VK_ENTER: return Toolkit.getProperty("AWT.enter", "Enter");

  1039.           case VK_BACK_SPACE: return Toolkit.getProperty("AWT.backSpace", "Backspace");

  1040.           case VK_TAB: return Toolkit.getProperty("AWT.tab", "Tab");

  1041.           case VK_CANCEL: return Toolkit.getProperty("AWT.cancel", "Cancel");

  1042.           case VK_CLEAR: return Toolkit.getProperty("AWT.clear", "Clear");

  1043.           case VK_SHIFT: return Toolkit.getProperty("AWT.shift", "Shift");

  1044.           case VK_CONTROL: return Toolkit.getProperty("AWT.control", "Control");

  1045.           case VK_ALT: return Toolkit.getProperty("AWT.alt", "Alt");

  1046.           case VK_PAUSE: return Toolkit.getProperty("AWT.pause", "Pause");

  1047.           case VK_CAPS_LOCK: return Toolkit.getProperty("AWT.capsLock", "Caps Lock");

  1048.           case VK_ESCAPE: return Toolkit.getProperty("AWT.escape", "Escape");

  1049.           case VK_SPACE: return Toolkit.getProperty("AWT.space", "Space");

  1050.           case VK_PAGE_UP: return Toolkit.getProperty("AWT.pgup", "Page Up");

  1051.           case VK_PAGE_DOWN: return Toolkit.getProperty("AWT.pgdn", "Page Down");

  1052.           case VK_END: return Toolkit.getProperty("AWT.end", "End");

  1053.           case VK_HOME: return Toolkit.getProperty("AWT.home", "Home");

  1054.           case VK_LEFT: return Toolkit.getProperty("AWT.left", "Left");

  1055.           case VK_UP: return Toolkit.getProperty("AWT.up", "Up");

  1056.           case VK_RIGHT: return Toolkit.getProperty("AWT.right", "Right");

  1057.           case VK_DOWN: return Toolkit.getProperty("AWT.down", "Down");

  1058.           // handled by ASCII value above:

  1059.           //   comma, period, slash, 0-9, semicolon, equals, A-Z,

  1060.           //   open_bracket, back_slash, close_bracket

  1061. 

  1062.           // numpad numeric keys handled below

  1063.           case VK_MULTIPLY: return Toolkit.getProperty("AWT.multiply", "NumPad *");

  1064.           case VK_ADD: return Toolkit.getProperty("AWT.add", "NumPad +");

  1065.           case VK_SEPARATOR: return Toolkit.getProperty("AWT.separator", "NumPad ,");

  1066.           case VK_SUBTRACT: return Toolkit.getProperty("AWT.subtract", "NumPad -");

  1067.           case VK_DECIMAL: return Toolkit.getProperty("AWT.decimal", "NumPad .");

  1068.           case VK_DIVIDE: return Toolkit.getProperty("AWT.divide", "NumPad /");

  1069.           case VK_DELETE: return Toolkit.getProperty("AWT.delete", "Delete");

  1070.           case VK_NUM_LOCK: return Toolkit.getProperty("AWT.numLock", "Num Lock");

  1071.           case VK_SCROLL_LOCK: return Toolkit.getProperty("AWT.scrollLock", "Scroll Lock");

  1072. 

  1073.           case VK_F1: return Toolkit.getProperty("AWT.f1", "F1");

  1074.           case VK_F2: return Toolkit.getProperty("AWT.f2", "F2");

  1075.           case VK_F3: return Toolkit.getProperty("AWT.f3", "F3");

  1076.           case VK_F4: return Toolkit.getProperty("AWT.f4", "F4");

  1077.           case VK_F5: return Toolkit.getProperty("AWT.f5", "F5");

  1078.           case VK_F6: return Toolkit.getProperty("AWT.f6", "F6");

  1079.           case VK_F7: return Toolkit.getProperty("AWT.f7", "F7");

  1080.           case VK_F8: return Toolkit.getProperty("AWT.f8", "F8");

  1081.           case VK_F9: return Toolkit.getProperty("AWT.f9", "F9");

  1082.           case VK_F10: return Toolkit.getProperty("AWT.f10", "F10");

  1083.           case VK_F11: return Toolkit.getProperty("AWT.f11", "F11");

  1084.           case VK_F12: return Toolkit.getProperty("AWT.f12", "F12");

  1085.           case VK_F13: return Toolkit.getProperty("AWT.f13", "F13");

  1086.           case VK_F14: return Toolkit.getProperty("AWT.f14", "F14");

  1087.           case VK_F15: return Toolkit.getProperty("AWT.f15", "F15");

  1088.           case VK_F16: return Toolkit.getProperty("AWT.f16", "F16");

  1089.           case VK_F17: return Toolkit.getProperty("AWT.f17", "F17");

  1090.           case VK_F18: return Toolkit.getProperty("AWT.f18", "F18");

  1091.           case VK_F19: return Toolkit.getProperty("AWT.f19", "F19");

  1092.           case VK_F20: return Toolkit.getProperty("AWT.f20", "F20");

  1093.           case VK_F21: return Toolkit.getProperty("AWT.f21", "F21");

  1094.           case VK_F22: return Toolkit.getProperty("AWT.f22", "F22");

  1095.           case VK_F23: return Toolkit.getProperty("AWT.f23", "F23");

  1096.           case VK_F24: return Toolkit.getProperty("AWT.f24", "F24");

  1097. 

  1098.           case VK_PRINTSCREEN: return Toolkit.getProperty("AWT.printScreen", "Print Screen");

  1099.           case VK_INSERT: return Toolkit.getProperty("AWT.insert", "Insert");

  1100.           case VK_HELP: return Toolkit.getProperty("AWT.help", "Help");

  1101.           case VK_META: return Toolkit.getProperty("AWT.meta", "Meta");

  1102.           case VK_BACK_QUOTE: return Toolkit.getProperty("AWT.backQuote", "Back Quote");

  1103.           case VK_QUOTE: return Toolkit.getProperty("AWT.quote", "Quote");

  1104. 			 

  1105.           case VK_KP_UP: return Toolkit.getProperty("AWT.up", "Up");

  1106.           case VK_KP_DOWN: return Toolkit.getProperty("AWT.down", "Down");

  1107.           case VK_KP_LEFT: return Toolkit.getProperty("AWT.left", "Left");

  1108.           case VK_KP_RIGHT: return Toolkit.getProperty("AWT.right", "Right");

  1109. 

  1110.           case VK_DEAD_GRAVE: return Toolkit.getProperty("AWT.deadGrave", "Dead Grave");

  1111.           case VK_DEAD_ACUTE: return Toolkit.getProperty("AWT.deadAcute", "Dead Acute");

  1112.           case VK_DEAD_CIRCUMFLEX: return Toolkit.getProperty("AWT.deadCircumflex", "Dead Circumflex");

  1113.           case VK_DEAD_TILDE: return Toolkit.getProperty("AWT.deadTilde", "Dead Tilde");

  1114.           case VK_DEAD_MACRON: return Toolkit.getProperty("AWT.deadMacron", "Dead Macron");

  1115.           case VK_DEAD_BREVE: return Toolkit.getProperty("AWT.deadBreve", "Dead Breve");

  1116.           case VK_DEAD_ABOVEDOT: return Toolkit.getProperty("AWT.deadAboveDot", "Dead Above Dot");

  1117.           case VK_DEAD_DIAERESIS: return Toolkit.getProperty("AWT.deadDiaeresis", "Dead Diaeresis");

  1118.           case VK_DEAD_ABOVERING: return Toolkit.getProperty("AWT.deadAboveRing", "Dead Above Ring");

  1119.           case VK_DEAD_DOUBLEACUTE: return Toolkit.getProperty("AWT.deadDoubleAcute", "Dead Double Acute");

  1120.           case VK_DEAD_CARON: return Toolkit.getProperty("AWT.deadCaron", "Dead Caron");

  1121.           case VK_DEAD_CEDILLA: return Toolkit.getProperty("AWT.deadCedilla", "Dead Cedilla");

  1122.           case VK_DEAD_OGONEK: return Toolkit.getProperty("AWT.deadOgonek", "Dead Ogonek");

  1123.           case VK_DEAD_IOTA: return Toolkit.getProperty("AWT.deadIota", "Dead Iota");

  1124.           case VK_DEAD_VOICED_SOUND: return Toolkit.getProperty("AWT.deadVoicedSound", "Dead Voiced Sound");

  1125.           case VK_DEAD_SEMIVOICED_SOUND: return Toolkit.getProperty("AWT.deadSemivoicedSound", "Dead Semivoiced Sound");

  1126. 

  1127.           case VK_AMPERSAND: return Toolkit.getProperty("AWT.ampersand", "Ampersand");

  1128.           case VK_ASTERISK: return Toolkit.getProperty("AWT.asterisk", "Asterisk");

  1129.           case VK_QUOTEDBL: return Toolkit.getProperty("AWT.quoteDbl", "Double Quote");

  1130.           case VK_LESS: return Toolkit.getProperty("AWT.Less", "Less");

  1131.           case VK_GREATER: return Toolkit.getProperty("AWT.greater", "Greater");

  1132.           case VK_BRACELEFT: return Toolkit.getProperty("AWT.braceLeft", "Left Brace");

  1133.           case VK_BRACERIGHT: return Toolkit.getProperty("AWT.braceRight", "Right Brace");

  1134.           case VK_AT: return Toolkit.getProperty("AWT.at", "At");

  1135.           case VK_COLON: return Toolkit.getProperty("AWT.colon", "Colon");

  1136.           case VK_CIRCUMFLEX: return Toolkit.getProperty("AWT.circumflex", "Circumflex");

  1137.           case VK_DOLLAR: return Toolkit.getProperty("AWT.dollar", "Dollar");

  1138.           case VK_EURO_SIGN: return Toolkit.getProperty("AWT.euro", "Euro");

  1139.           case VK_EXCLAMATION_MARK: return Toolkit.getProperty("AWT.exclamationMark", "Exclamation Mark");

  1140.           case VK_INVERTED_EXCLAMATION_MARK: return Toolkit.getProperty("AWT.invertedExclamationMark", "Inverted Exclamation Mark");

  1141.           case VK_LEFT_PARENTHESIS: return Toolkit.getProperty("AWT.leftParenthesis", "Left Parenthesis");

  1142.           case VK_NUMBER_SIGN: return Toolkit.getProperty("AWT.numberSign", "Number Sign");

  1143.           case VK_MINUS: return Toolkit.getProperty("AWT.minus", "Minus");

  1144.           case VK_PLUS: return Toolkit.getProperty("AWT.plus", "Plus");

  1145.           case VK_RIGHT_PARENTHESIS: return Toolkit.getProperty("AWT.rightParenthesis", "Right Parenthesis");

  1146.           case VK_UNDERSCORE: return Toolkit.getProperty("AWT.underscore", "Underscore");

  1147. 

  1148.           case VK_FINAL: return Toolkit.getProperty("AWT.final", "Final");

  1149.           case VK_CONVERT: return Toolkit.getProperty("AWT.convert", "Convert");

  1150.           case VK_NONCONVERT: return Toolkit.getProperty("AWT.noconvert", "No Convert");

  1151.           case VK_ACCEPT: return Toolkit.getProperty("AWT.accept", "Accept");

  1152.           case VK_MODECHANGE: return Toolkit.getProperty("AWT.modechange", "Mode Change");

  1153. 	  case VK_KANA: return Toolkit.getProperty("AWT.kana", "Kana");

  1154. 	  case VK_KANJI: return Toolkit.getProperty("AWT.kanji", "Kanji");

  1155.           case VK_ALPHANUMERIC: return Toolkit.getProperty("AWT.alphanumeric", "Alphanumeric");

  1156. 	  case VK_KATAKANA: return Toolkit.getProperty("AWT.katakana", "Katakana");

  1157. 	  case VK_HIRAGANA: return Toolkit.getProperty("AWT.hiragana", "Hiragana");

  1158. 	  case VK_FULL_WIDTH: return Toolkit.getProperty("AWT.fullWidth", "Full-Width");

  1159. 	  case VK_HALF_WIDTH: return Toolkit.getProperty("AWT.halfWidth", "Half-Width");

  1160. 	  case VK_ROMAN_CHARACTERS: return Toolkit.getProperty("AWT.romanCharacters", "Roman Characters");

  1161. 	  case VK_ALL_CANDIDATES: return Toolkit.getProperty("AWT.allCandidates", "All Candidates");

  1162. 	  case VK_PREVIOUS_CANDIDATE: return Toolkit.getProperty("AWT.previousCandidate", "Previous Candidate");

  1163. 	  case VK_CODE_INPUT: return Toolkit.getProperty("AWT.codeInput", "Code Input");

  1164. 	  case VK_JAPANESE_KATAKANA: return Toolkit.getProperty("AWT.japaneseKatakana", "Japanese Katakana");

  1165. 	  case VK_JAPANESE_HIRAGANA: return Toolkit.getProperty("AWT.japaneseHiragana", "Japanese Hiragana");

  1166. 	  case VK_JAPANESE_ROMAN: return Toolkit.getProperty("AWT.japaneseRoman", "Japanese Roman");

  1167. 	  case VK_KANA_LOCK: return Toolkit.getProperty("AWT.kanaLock", "Kana Lock");

  1168. 	  case VK_INPUT_METHOD_ON_OFF: return Toolkit.getProperty("AWT.inputMethodOnOff", "Input Method On/Off");

  1169. 

  1170.           case VK_AGAIN: return Toolkit.getProperty("AWT.again", "Again");

  1171.           case VK_UNDO: return Toolkit.getProperty("AWT.undo", "Undo");

  1172.           case VK_COPY: return Toolkit.getProperty("AWT.copy", "Copy");

  1173.           case VK_PASTE: return Toolkit.getProperty("AWT.paste", "Paste");

  1174.           case VK_CUT: return Toolkit.getProperty("AWT.cut", "Cut");

  1175.           case VK_FIND: return Toolkit.getProperty("AWT.find", "Find");

  1176.           case VK_PROPS: return Toolkit.getProperty("AWT.props", "Props");

  1177.           case VK_STOP: return Toolkit.getProperty("AWT.stop", "Stop");

  1178. 

  1179.           case VK_COMPOSE: return Toolkit.getProperty("AWT.compose", "Compose");

  1180.           case VK_ALT_GRAPH: return Toolkit.getProperty("AWT.altGraph", "Alt Graph");

  1181.         }

  1182. 

  1183.         if (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) {

  1184.             String numpad = Toolkit.getProperty("AWT.numpad", "NumPad");

  1185. 	    char c = (char)(keyCode - VK_NUMPAD0 + '0');

  1186.             return numpad + "-" + c;

  1187.         }

  1188. 

  1189.         String unknown = Toolkit.getProperty("AWT.unknown", "Unknown keyCode");

  1190.         return unknown + ": 0x" + Integer.toString(keyCode, 16);

  1191.     }

  1192. 

  1193.     /**

  1194.      * Returns a String describing the modifier key(s), such as "Shift",

  1195.      * or "Ctrl+Shift".  These strings can be localized by changing the 

  1196.      * awt.properties file.

  1197.      *

  1198.      * @return string a text description of the combination of modifier

  1199.      *                keys that were held down during the event

  1200.      */

  1201.     public static String getKeyModifiersText(int modifiers) {

  1202.         StringBuffer buf = new StringBuffer();

  1203.         if ((modifiers & InputEvent.META_MASK) != 0) {

  1204.             buf.append(Toolkit.getProperty("AWT.meta", "Meta"));

  1205.             buf.append("+");

  1206.         }

  1207.         if ((modifiers & InputEvent.CTRL_MASK) != 0) {

  1208.             buf.append(Toolkit.getProperty("AWT.control", "Ctrl"));

  1209.             buf.append("+");

  1210.         }

  1211.         if ((modifiers & InputEvent.ALT_MASK) != 0) {

  1212.             buf.append(Toolkit.getProperty("AWT.alt", "Alt"));

  1213.             buf.append("+");

  1214.         }

  1215.         if ((modifiers & InputEvent.SHIFT_MASK) != 0) {

  1216.             buf.append(Toolkit.getProperty("AWT.shift", "Shift"));

  1217.             buf.append("+");

  1218.         }

  1219.         if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) {

  1220.             buf.append(Toolkit.getProperty("AWT.altGraph", "Alt Graph"));

  1221.             buf.append("+");

  1222.         }

  1223.         if ((modifiers & InputEvent.BUTTON1_MASK) != 0) {

  1224.             buf.append(Toolkit.getProperty("AWT.button1", "Button1"));

  1225.             buf.append("+");

  1226.         }

  1227.         if (buf.length() > 0) {

  1228.             buf.setLength(buf.length()-1); // remove trailing '+'

  1229.         }

  1230.         return buf.toString();

  1231.     }

  1232. 

  1233. 

  1234.     /** 

  1235.      * Returns whether the key in this event is an "action" key.

  1236.      * Typically an action key does not fire a unicode character and is

  1237.      * not a modifier key.

  1238.      *

  1239.      * @return <code>true</code> if the key is an "action" key,

  1240.      *         <code>false</code> otherwise

  1241.      */

  1242.     public boolean isActionKey() {

  1243.         switch (keyCode) {

  1244.           case VK_HOME:

  1245.           case VK_END:

  1246.           case VK_PAGE_UP:

  1247.           case VK_PAGE_DOWN:

  1248.           case VK_UP:

  1249.           case VK_DOWN:

  1250.           case VK_LEFT:

  1251.           case VK_RIGHT:

  1252. 

  1253. 	  case VK_KP_LEFT: 

  1254. 	  case VK_KP_UP: 

  1255. 	  case VK_KP_RIGHT: 

  1256. 	  case VK_KP_DOWN: 

  1257. 

  1258.           case VK_F1:

  1259.           case VK_F2:

  1260.           case VK_F3:

  1261.           case VK_F4:

  1262.           case VK_F5:

  1263.           case VK_F6:

  1264.           case VK_F7:

  1265.           case VK_F8:

  1266.           case VK_F9:

  1267.           case VK_F10:

  1268.           case VK_F11:

  1269.           case VK_F12:

  1270.           case VK_F13:

  1271.           case VK_F14:

  1272.           case VK_F15:

  1273.           case VK_F16:

  1274.           case VK_F17:

  1275.           case VK_F18:

  1276.           case VK_F19:

  1277.           case VK_F20:

  1278.           case VK_F21:

  1279.           case VK_F22:

  1280.           case VK_F23:

  1281.           case VK_F24:

  1282.           case VK_PRINTSCREEN:

  1283.           case VK_SCROLL_LOCK:

  1284.           case VK_CAPS_LOCK:

  1285.           case VK_NUM_LOCK:

  1286.           case VK_PAUSE:

  1287.           case VK_INSERT:

  1288. 

  1289.           case VK_FINAL:

  1290.           case VK_CONVERT:

  1291.           case VK_NONCONVERT:

  1292.           case VK_ACCEPT:

  1293.           case VK_MODECHANGE:

  1294. 	  case VK_KANA:

  1295. 	  case VK_KANJI:

  1296.           case VK_ALPHANUMERIC:

  1297. 	  case VK_KATAKANA:

  1298. 	  case VK_HIRAGANA:

  1299. 	  case VK_FULL_WIDTH:

  1300. 	  case VK_HALF_WIDTH:

  1301. 	  case VK_ROMAN_CHARACTERS:

  1302. 	  case VK_ALL_CANDIDATES:

  1303. 	  case VK_PREVIOUS_CANDIDATE:

  1304. 	  case VK_CODE_INPUT:

  1305. 	  case VK_JAPANESE_KATAKANA:

  1306. 	  case VK_JAPANESE_HIRAGANA:

  1307. 	  case VK_JAPANESE_ROMAN:

  1308. 	  case VK_KANA_LOCK:

  1309. 	  case VK_INPUT_METHOD_ON_OFF:

  1310. 

  1311.           case VK_AGAIN:

  1312.           case VK_UNDO:

  1313.           case VK_COPY:

  1314.           case VK_PASTE:

  1315.           case VK_CUT:

  1316.           case VK_FIND:

  1317.           case VK_PROPS:

  1318.           case VK_STOP:

  1319. 

  1320.           case VK_HELP:

  1321.               return true;

  1322.         }

  1323.         return false;

  1324.     }

  1325. 

  1326.     /**

  1327.      * Returns a parameter string identifying this event.

  1328.      * This method is useful for event logging and for debugging.

  1329.      *

  1330.      * @return a string identifying the event and its attributes

  1331.      */

  1332.     public String paramString() {

  1333.         StringBuffer str = new StringBuffer(100);

  1334. 

  1335.         switch (id) {

  1336.           case KEY_PRESSED:

  1337.             str.append("KEY_PRESSED");

  1338.             break;

  1339.           case KEY_RELEASED:

  1340.             str.append("KEY_RELEASED");

  1341.             break;

  1342.           case KEY_TYPED:

  1343.             str.append("KEY_TYPED");

  1344.             break;

  1345.           default:

  1346.             str.append("unknown type");

  1347.             break;

  1348.         }

  1349. 

  1350.         str.append(",keyCode=").append(keyCode); 

  1351.         str.append(",keyText=").append(getKeyText(keyCode));

  1352. 

  1353.         /* Some keychars don't print well, e.g. escape, backspace,

  1354.          * tab, return, delete, cancel.  Get keyText for the keyCode 

  1355.          * instead of the keyChar.  

  1356.          */

  1357.         str.append(",keyChar=");

  1358.         switch (keyChar) {

  1359.           case '\b':

  1360.             str.append(getKeyText(VK_BACK_SPACE));

  1361.             break;

  1362.           case '\t':

  1363.             str.append(getKeyText(VK_TAB));

  1364.             break;

  1365.           case '\n':

  1366.             str.append(getKeyText(VK_ENTER));

  1367.             break;

  1368.           case '\u0018':

  1369.             str.append(getKeyText(VK_CANCEL));

  1370.             break;

  1371.           case '\u001b':

  1372.             str.append(getKeyText(VK_ESCAPE));

  1373.             break;

  1374.           case '\u007f':

  1375.             str.append(getKeyText(VK_DELETE));

  1376.             break;

  1377.           case CHAR_UNDEFINED:

  1378.             str.append(Toolkit.getProperty("AWT.undefinedKeyChar", "Undefined keyChar"));

  1379.             break;

  1380.           default:

  1381.             str.append("'").append(keyChar).append("'");

  1382.             break;

  1383.         }

  1384. 

  1385.         if (getModifiers() != 0) {

  1386.             str.append(",modifiers=").append(getKeyModifiersText(modifiers));

  1387.         }

  1388.         if (getModifiersEx() != 0) {

  1389.             str.append(",extModifiers=").append(getModifiersExText(modifiers));

  1390.         }

  1391. 

  1392.         str.append(",keyLocation="); 

  1393.         switch (keyLocation) {

  1394.           case KEY_LOCATION_UNKNOWN:

  1395.             str.append("KEY_LOCATION_UNKNOWN");

  1396.             break;

  1397.           case KEY_LOCATION_STANDARD:

  1398.             str.append("KEY_LOCATION_STANDARD");

  1399.             break;

  1400.           case KEY_LOCATION_LEFT:

  1401.             str.append("KEY_LOCATION_LEFT");

  1402.             break;

  1403.           case KEY_LOCATION_RIGHT:

  1404.             str.append("KEY_LOCATION_RIGHT");

  1405.             break;

  1406.           case KEY_LOCATION_NUMPAD:

  1407.             str.append("KEY_LOCATION_NUMPAD");

  1408.             break;

  1409.           default:

  1410.             str.append("KEY_LOCATION_UNKNOWN");

  1411.             break;

  1412.         }

  1413. 

  1414.         return str.toString();

  1415.     }

  1416. 

  1417.     /**

  1418.      * Sets new modifiers by the old ones. The key modifiers 

  1419.      * override overlaping mouse modifiers.

  1420.      */

  1421.     private void setNewModifiers() {

  1422. 	if ((modifiers & SHIFT_MASK) != 0) {

  1423. 	    modifiers |= SHIFT_DOWN_MASK;

  1424. 	}

  1425. 	if ((modifiers & ALT_MASK) != 0) {

  1426. 	    modifiers |= ALT_DOWN_MASK;

  1427. 	}

  1428. 	if ((modifiers & CTRL_MASK) != 0) {

  1429. 	    modifiers |= CTRL_DOWN_MASK;

  1430. 	}

  1431. 	if ((modifiers & META_MASK) != 0) {

  1432. 	    modifiers |= META_DOWN_MASK;

  1433. 	}

  1434. 	if ((modifiers & ALT_GRAPH_MASK) != 0) {

  1435. 	    modifiers |= ALT_GRAPH_DOWN_MASK;

  1436. 	}

  1437. 	if ((modifiers & BUTTON1_MASK) != 0) {

  1438. 	    modifiers |= BUTTON1_DOWN_MASK;

  1439. 	}

  1440.     }

  1441. 

  1442.     /**

  1443.      * Sets old modifiers by the new ones. 

  1444.      */

  1445.     private void setOldModifiers() {

  1446. 	if ((modifiers & SHIFT_DOWN_MASK) != 0) {

  1447. 	    modifiers |= SHIFT_MASK;

  1448. 	}

  1449. 	if ((modifiers & ALT_DOWN_MASK) != 0) {

  1450. 	    modifiers |= ALT_MASK;

  1451. 	}

  1452. 	if ((modifiers & CTRL_DOWN_MASK) != 0) {

  1453. 	    modifiers |= CTRL_MASK;

  1454. 	}

  1455. 	if ((modifiers & META_DOWN_MASK) != 0) {

  1456. 	    modifiers |= META_MASK;

  1457. 	}

  1458. 	if ((modifiers & ALT_GRAPH_DOWN_MASK) != 0) {

  1459. 	    modifiers |= ALT_GRAPH_MASK;

  1460. 	}

  1461. 	if ((modifiers & BUTTON1_DOWN_MASK) != 0) {

  1462. 	    modifiers |= BUTTON1_MASK;

  1463. 	}

  1464.     }

  1465. 

  1466.     /**

  1467.      * Sets new modifiers by the old ones. The key modifiers 

  1468.      * override overlaping mouse modifiers.

  1469.      * @serial

  1470.      */

  1471.     private void readObject(ObjectInputStream s)

  1472.       throws IOException, ClassNotFoundException {

  1473. 	s.defaultReadObject();

  1474.         if (getModifiers() != 0 && getModifiersEx() == 0) {

  1475. 	    setNewModifiers();    

  1476. 	}

  1477.     }

  1478. }

  1479.