1. /*

  2.  * @(#)KeyEvent.java	1.44 00/04/06

  3.  *

  4.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

  11. package java.awt.event;

  12. 

  13. import java.awt.Event;

  14. import java.awt.Component;

  15. import java.awt.Toolkit;

  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 character is 

  32.  * 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 characters

  41.  * (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 (like "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 characters, such as action keys 

  72.  * 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 artificially

  75.  * generate these keys.

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

  77.  * platform and keyboard layout. For

  78.  * example, the key that on a Windows U.S. keyboard layout generates VK_Q,

  79.  * generates VK_A on a Windows French keyboard layout.

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

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

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

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

  84.  * is returned instead of VK_CONVERT with the ALT modifer.

  85.  * </ul>

  86.  *

  87.  * <P>

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

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

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

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

  92.  *

  93.  * @author Carl Quinn

  94.  * @author Amy Fowler

  95.  * @author Norbert Lindenberg

  96.  * @version 1.44 04/06/00

  97.  *

  98.  * @see KeyAdapter

  99.  * @see KeyListener

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

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

  102.  *

  103.  * @since 1.1

  104.  */

  105. public class KeyEvent extends InputEvent {

  106. 

  107.     /**

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

  109.      */

  110.     public static final int KEY_FIRST = 400;

  111. 

  112.     /**

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

  114.      */

  115.     public static final int KEY_LAST  = 402;

  116. 

  117.     /**

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

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

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

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

  122.      * many-to-one or many-to-many.  

  123.      */

  124.     public static final int KEY_TYPED = KEY_FIRST;

  125. 

  126.     /**

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

  128.      * is pushed down.

  129.      */

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

  131. 

  132.     /**

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

  134.      * is let up.

  135.      */

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

  137. 

  138.     /* Virtual key codes. */

  139. 

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

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

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

  143.     public static final int VK_CANCEL         = 0x03;

  144.     public static final int VK_CLEAR          = 0x0C;

  145.     public static final int VK_SHIFT          = 0x10;

  146.     public static final int VK_CONTROL        = 0x11;

  147.     public static final int VK_ALT            = 0x12;

  148.     public static final int VK_PAUSE          = 0x13;

  149.     public static final int VK_CAPS_LOCK      = 0x14;

  150.     public static final int VK_ESCAPE         = 0x1B;

  151.     public static final int VK_SPACE          = 0x20;

  152.     public static final int VK_PAGE_UP        = 0x21;

  153.     public static final int VK_PAGE_DOWN      = 0x22;

  154.     public static final int VK_END            = 0x23;

  155.     public static final int VK_HOME           = 0x24;

  156.     public static final int VK_LEFT           = 0x25;

  157.     public static final int VK_UP             = 0x26;

  158.     public static final int VK_RIGHT          = 0x27;

  159.     public static final int VK_DOWN           = 0x28;

  160.     public static final int VK_COMMA          = 0x2C;

  161. 

  162.     /**

  163.      * Constant for the "-" key.

  164.      * @since 1.2

  165.      */

  166.     public static final int VK_MINUS          = 0x2D;

  167. 

  168.     public static final int VK_PERIOD         = 0x2E;

  169.     public static final int VK_SLASH          = 0x2F;

  170. 

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

  172.     public static final int VK_0              = 0x30;

  173.     public static final int VK_1              = 0x31;

  174.     public static final int VK_2              = 0x32;

  175.     public static final int VK_3              = 0x33;

  176.     public static final int VK_4              = 0x34;

  177.     public static final int VK_5              = 0x35;

  178.     public static final int VK_6              = 0x36;

  179.     public static final int VK_7              = 0x37;

  180.     public static final int VK_8              = 0x38;

  181.     public static final int VK_9              = 0x39;

  182. 

  183.     public static final int VK_SEMICOLON      = 0x3B;

  184.     public static final int VK_EQUALS         = 0x3D;

  185. 

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

  187.     public static final int VK_A              = 0x41;

  188.     public static final int VK_B              = 0x42;

  189.     public static final int VK_C              = 0x43;

  190.     public static final int VK_D              = 0x44;

  191.     public static final int VK_E              = 0x45;

  192.     public static final int VK_F              = 0x46;

  193.     public static final int VK_G              = 0x47;

  194.     public static final int VK_H              = 0x48;

  195.     public static final int VK_I              = 0x49;

  196.     public static final int VK_J              = 0x4A;

  197.     public static final int VK_K              = 0x4B;

  198.     public static final int VK_L              = 0x4C;

  199.     public static final int VK_M              = 0x4D;

  200.     public static final int VK_N              = 0x4E;

  201.     public static final int VK_O              = 0x4F;

  202.     public static final int VK_P              = 0x50;

  203.     public static final int VK_Q              = 0x51;

  204.     public static final int VK_R              = 0x52;

  205.     public static final int VK_S              = 0x53;

  206.     public static final int VK_T              = 0x54;

  207.     public static final int VK_U              = 0x55;

  208.     public static final int VK_V              = 0x56;

  209.     public static final int VK_W              = 0x57;

  210.     public static final int VK_X              = 0x58;

  211.     public static final int VK_Y              = 0x59;

  212.     public static final int VK_Z              = 0x5A;

  213. 

  214.     public static final int VK_OPEN_BRACKET   = 0x5B;

  215.     public static final int VK_BACK_SLASH     = 0x5C;

  216.     public static final int VK_CLOSE_BRACKET  = 0x5D;

  217. 

  218.     public static final int VK_NUMPAD0        = 0x60;

  219.     public static final int VK_NUMPAD1        = 0x61;

  220.     public static final int VK_NUMPAD2        = 0x62;

  221.     public static final int VK_NUMPAD3        = 0x63;

  222.     public static final int VK_NUMPAD4        = 0x64;

  223.     public static final int VK_NUMPAD5        = 0x65;

  224.     public static final int VK_NUMPAD6        = 0x66;

  225.     public static final int VK_NUMPAD7        = 0x67;

  226.     public static final int VK_NUMPAD8        = 0x68;

  227.     public static final int VK_NUMPAD9        = 0x69;

  228.     public static final int VK_MULTIPLY       = 0x6A;

  229.     public static final int VK_ADD            = 0x6B;

  230.     public static final int VK_SEPARATER      = 0x6C;

  231.     public static final int VK_SUBTRACT       = 0x6D;

  232.     public static final int VK_DECIMAL        = 0x6E;

  233.     public static final int VK_DIVIDE         = 0x6F;

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

  235.     public static final int VK_NUM_LOCK       = 0x90;

  236.     public static final int VK_SCROLL_LOCK    = 0x91;

  237. 

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

  239.     public static final int VK_F1             = 0x70;

  240. 

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

  242.     public static final int VK_F2             = 0x71;

  243. 

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

  245.     public static final int VK_F3             = 0x72;

  246. 

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

  248.     public static final int VK_F4             = 0x73;

  249. 

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

  251.     public static final int VK_F5             = 0x74;

  252. 

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

  254.     public static final int VK_F6             = 0x75;

  255. 

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

  257.     public static final int VK_F7             = 0x76;

  258. 

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

  260.     public static final int VK_F8             = 0x77;

  261. 

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

  263.     public static final int VK_F9             = 0x78;

  264. 

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

  266.     public static final int VK_F10            = 0x79;

  267. 

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

  269.     public static final int VK_F11            = 0x7A;

  270. 

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

  272.     public static final int VK_F12            = 0x7B;

  273. 

  274.     /**

  275.      * Constant for the F13 function key.

  276.      * @since 1.2

  277.      */

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

  279.     public static final int VK_F13            = 0xF000;

  280.  

  281.     /**

  282.      * Constant for the F14 function key.

  283.      * @since 1.2

  284.      */

  285.     public static final int VK_F14            = 0xF001;

  286.  

  287.     /**

  288.      * Constant for the F15 function key.

  289.      * @since 1.2

  290.      */

  291.     public static final int VK_F15            = 0xF002;

  292.  

  293.     /**

  294.      * Constant for the F16 function key.

  295.      * @since 1.2

  296.      */

  297.     public static final int VK_F16            = 0xF003;

  298.  

  299.     /**

  300.      * Constant for the F17 function key.

  301.      * @since 1.2

  302.      */

  303.     public static final int VK_F17            = 0xF004;

  304.  

  305.     /**

  306.      * Constant for the F18 function key.

  307.      * @since 1.2

  308.      */

  309.     public static final int VK_F18            = 0xF005;

  310.  

  311.     /**

  312.      * Constant for the F19 function key.

  313.      * @since 1.2

  314.      */

  315.     public static final int VK_F19            = 0xF006;

  316.  

  317.     /**

  318.      * Constant for the F20 function key.

  319.      * @since 1.2

  320.      */

  321.     public static final int VK_F20            = 0xF007;

  322.  

  323.     /**

  324.      * Constant for the F21 function key.

  325.      * @since 1.2

  326.      */

  327.     public static final int VK_F21            = 0xF008;

  328.  

  329.     /**

  330.      * Constant for the F22 function key.

  331.      * @since 1.2

  332.      */

  333.     public static final int VK_F22            = 0xF009;

  334.  

  335.     /**

  336.      * Constant for the F23 function key.

  337.      * @since 1.2

  338.      */

  339.     public static final int VK_F23            = 0xF00A;

  340.  

  341.     /**

  342.      * Constant for the F24 function key.

  343.      * @since 1.2

  344.      */

  345.     public static final int VK_F24            = 0xF00B;

  346.  

  347.     public static final int VK_PRINTSCREEN    = 0x9A;

  348.     public static final int VK_INSERT         = 0x9B;

  349.     public static final int VK_HELP           = 0x9C;

  350.     public static final int VK_META           = 0x9D;

  351. 

  352.     public static final int VK_BACK_QUOTE     = 0xC0;

  353.     public static final int VK_QUOTE          = 0xDE;

  354. 

  355.     /**

  356.      * Constant for the key pad arrow up function key.

  357.      * @since 1.2

  358.      */

  359.     public static final int VK_KP_UP          = 0xE0;

  360. 

  361.     /**

  362.      * Constant for the key pad arrow down function key.

  363.      * @since 1.2

  364.      */

  365.     public static final int VK_KP_DOWN        = 0xE1;

  366. 

  367.     /**

  368.      * Constant for the key pad arrow left function key.

  369.      * @since 1.2

  370.      */

  371.     public static final int VK_KP_LEFT        = 0xE2;

  372. 

  373.     /**

  374.      * Constant for the key pad arrow right function key.

  375.      * @since 1.2

  376.      */

  377.     public static final int VK_KP_RIGHT       = 0xE3;

  378.     

  379.     /* For European keyboards */

  380.     /** @since 1.2 */

  381.     public static final int VK_DEAD_GRAVE               = 0x80;

  382.     /** @since 1.2 */

  383.     public static final int VK_DEAD_ACUTE               = 0x81;

  384.     /** @since 1.2 */

  385.     public static final int VK_DEAD_CIRCUMFLEX          = 0x82;

  386.     /** @since 1.2 */

  387.     public static final int VK_DEAD_TILDE               = 0x83;

  388.     /** @since 1.2 */

  389.     public static final int VK_DEAD_MACRON              = 0x84;

  390.     /** @since 1.2 */

  391.     public static final int VK_DEAD_BREVE               = 0x85;

  392.     /** @since 1.2 */

  393.     public static final int VK_DEAD_ABOVEDOT            = 0x86;

  394.     /** @since 1.2 */

  395.     public static final int VK_DEAD_DIAERESIS           = 0x87;

  396.     /** @since 1.2 */

  397.     public static final int VK_DEAD_ABOVERING           = 0x88;

  398.     /** @since 1.2 */

  399.     public static final int VK_DEAD_DOUBLEACUTE         = 0x89;

  400.     /** @since 1.2 */

  401.     public static final int VK_DEAD_CARON               = 0x8a;

  402.     /** @since 1.2 */

  403.     public static final int VK_DEAD_CEDILLA             = 0x8b;

  404.     /** @since 1.2 */

  405.     public static final int VK_DEAD_OGONEK              = 0x8c;

  406.     /** @since 1.2 */

  407.     public static final int VK_DEAD_IOTA                = 0x8d;

  408.     /** @since 1.2 */

  409.     public static final int VK_DEAD_VOICED_SOUND        = 0x8e;

  410.     /** @since 1.2 */

  411.     public static final int VK_DEAD_SEMIVOICED_SOUND    = 0x8f;

  412. 

  413.     /** @since 1.2 */

  414.     public static final int VK_AMPERSAND                = 0x96;

  415.     /** @since 1.2 */

  416.     public static final int VK_ASTERISK                 = 0x97;

  417.     /** @since 1.2 */

  418.     public static final int VK_QUOTEDBL                 = 0x98;

  419.     /** @since 1.2 */

  420.     public static final int VK_LESS                     = 0x99;

  421. 

  422.     /** @since 1.2 */

  423.     public static final int VK_GREATER                  = 0xa0;

  424.     /** @since 1.2 */

  425.     public static final int VK_BRACELEFT                = 0xa1;

  426.     /** @since 1.2 */

  427.     public static final int VK_BRACERIGHT               = 0xa2;

  428. 

  429.     /**

  430.      * Constant for the "@" key.

  431.      * @since 1.2

  432.      */

  433.     public static final int VK_AT                       = 0x0200;

  434.  

  435.     /**

  436.      * Constant for the ":" key.

  437.      * @since 1.2

  438.      */

  439.     public static final int VK_COLON                    = 0x0201;

  440.  

  441.     /**

  442.      * Constant for the "^" key.

  443.      * @since 1.2

  444.      */

  445.     public static final int VK_CIRCUMFLEX               = 0x0202;

  446.  

  447.     /**

  448.      * Constant for the "$" key.

  449.      * @since 1.2

  450.      */

  451.     public static final int VK_DOLLAR                   = 0x0203;

  452.  

  453.     /**

  454.      * Constant for the Euro currency sign key.

  455.      * @since 1.2

  456.      */

  457.     public static final int VK_EURO_SIGN                = 0x0204;

  458.  

  459.     /**

  460.      * Constant for the "!" key.

  461.      * @since 1.2

  462.      */

  463.     public static final int VK_EXCLAMATION_MARK         = 0x0205;

  464.  

  465.     /**

  466.      * Constant for the inverted exclamation mark key.

  467.      * @since 1.2

  468.      */

  469.     public static final int VK_INVERTED_EXCLAMATION_MARK = 0x0206;

  470.  

  471.     /**

  472.      * Constant for the "(" key.

  473.      * @since 1.2

  474.      */

  475.     public static final int VK_LEFT_PARENTHESIS         = 0x0207;

  476.  

  477.     /**

  478.      * Constant for the "#" key.

  479.      * @since 1.2

  480.      */

  481.     public static final int VK_NUMBER_SIGN              = 0x0208;

  482.  

  483.     /**

  484.      * Constant for the "+" key.

  485.      * @since 1.2

  486.      */

  487.     public static final int VK_PLUS                     = 0x0209;

  488.  

  489.     /**

  490.      * Constant for the ")" key.

  491.      * @since 1.2

  492.      */

  493.     public static final int VK_RIGHT_PARENTHESIS        = 0x020A;

  494.  

  495.     /**

  496.      * Constant for the "_" key.

  497.      * @since 1.2

  498.      */

  499.     public static final int VK_UNDERSCORE               = 0x020B;

  500.  

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

  502. 

  503.     /* not clear what this means - listed in Win32 API */

  504.     public static final int VK_FINAL                    = 0x0018;

  505.     

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

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

  508.     public static final int VK_CONVERT                  = 0x001C;

  509. 

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

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

  512.     public static final int VK_NONCONVERT               = 0x001D;

  513.     

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

  515.     /* Japanese Solaris keyboard: kakutei */

  516.     public static final int VK_ACCEPT                   = 0x001E;

  517. 

  518.     /* not clear what this means - listed in Win32 API */

  519.     public static final int VK_MODECHANGE               = 0x001F;

  520. 

  521.     /* replaced by VK_KANA_LOCK for Win32 and Solaris; might still be used on other platforms */

  522.     public static final int VK_KANA                     = 0x0015;

  523. 

  524.     /* replaced by VK_INPUT_METHOD_ON_OFF for Win32 and Solaris; might still be used for other platforms */

  525.     public static final int VK_KANJI                    = 0x0019;

  526. 

  527.     /**

  528.      * Constant for the Alphanumeric function key.

  529.      * @since 1.2

  530.      */

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

  532.     public static final int VK_ALPHANUMERIC             = 0x00F0;

  533.  

  534.     /**

  535.      * Constant for the Katakana function key.

  536.      * @since 1.2

  537.      */

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

  539.     public static final int VK_KATAKANA                 = 0x00F1;

  540.  

  541.     /**

  542.      * Constant for the Hiragana function key.

  543.      * @since 1.2

  544.      */

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

  546.     public static final int VK_HIRAGANA                 = 0x00F2;

  547.  

  548.     /**

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

  550.      * @since 1.2

  551.      */

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

  553.     public static final int VK_FULL_WIDTH               = 0x00F3;

  554.  

  555.     /**

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

  557.      * @since 1.2

  558.      */

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

  560.     public static final int VK_HALF_WIDTH               = 0x00F4;

  561.  

  562.     /**

  563.      * Constant for the Roman Characters function key.

  564.      * @since 1.2

  565.      */

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

  567.     public static final int VK_ROMAN_CHARACTERS         = 0x00F5;

  568.  

  569.     /**

  570.      * Constant for the All Candidates function key.

  571.      * @since 1.2

  572.      */

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

  574.     public static final int VK_ALL_CANDIDATES           = 0x0100;

  575.  

  576.     /**

  577.      * Constant for the Previous Candidate function key.

  578.      * @since 1.2

  579.      */

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

  581.     public static final int VK_PREVIOUS_CANDIDATE       = 0x0101;

  582.  

  583.     /**

  584.      * Constant for the Code Input function key.

  585.      * @since 1.2

  586.      */

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

  588.     public static final int VK_CODE_INPUT               = 0x0102;

  589.  

  590.     /**

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

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

  593.      * @since 1.2

  594.      */

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

  596.     public static final int VK_JAPANESE_KATAKANA        = 0x0103;

  597.  

  598.     /**

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

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

  601.      * @since 1.2

  602.      */

  603.     /* Japanese Macintosh keyboard */

  604.     public static final int VK_JAPANESE_HIRAGANA        = 0x0104;

  605.  

  606.     /**

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

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

  609.      * @since 1.2

  610.      */

  611.     /* Japanese Macintosh keyboard */

  612.     public static final int VK_JAPANESE_ROMAN           = 0x0105;

  613. 

  614.     /**

  615.      * Constant for the locking Kana function key.

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

  617.      * @since 1.3

  618.      */

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

  620.     public static final int VK_KANA_LOCK                = 0x0106;

  621. 

  622.     /**

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

  624.      * @since 1.3

  625.      */

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

  627.     public static final int VK_INPUT_METHOD_ON_OFF      = 0x0107;

  628. 

  629.     /* for Sun keyboards */

  630.     /** @since 1.2 */

  631.     public static final int VK_CUT                      = 0xFFD1;

  632.     /** @since 1.2 */

  633.     public static final int VK_COPY                     = 0xFFCD;

  634.     /** @since 1.2 */

  635.     public static final int VK_PASTE                    = 0xFFCF;

  636.     /** @since 1.2 */

  637.     public static final int VK_UNDO                     = 0xFFCB;

  638.     /** @since 1.2 */

  639.     public static final int VK_AGAIN                    = 0xFFC9;

  640.     /** @since 1.2 */

  641.     public static final int VK_FIND                     = 0xFFD0;

  642.     /** @since 1.2 */

  643.     public static final int VK_PROPS                    = 0xFFCA;

  644.     /** @since 1.2 */

  645.     public static final int VK_STOP                     = 0xFFC8;

  646.     

  647.     /**

  648.      * Constant for the Compose function key.

  649.      * @since 1.2

  650.      */

  651.     public static final int VK_COMPOSE                  = 0xFF20;

  652.  

  653.     /**

  654.      * Constant for the AltGraph function key.

  655.      * @since 1.2

  656.      */

  657.     public static final int VK_ALT_GRAPH                = 0xFF7E;

  658. 

  659.     /**

  660.      * KEY_TYPED events do not have a keyCode value.

  661.      * This value is used, instead.  

  662.      */

  663.     public static final int VK_UNDEFINED      = 0x0;

  664. 

  665.     /**

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

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

  668.      */

  669.     public static final char CHAR_UNDEFINED   = 0x0ffff;

  670. 

  671.     /**

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

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

  674.      * can be fired by most keyboards.

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

  676.      * than the code value itself.

  677.      *

  678.      * @serial

  679.      * @see getKeyCode()

  680.      * @see setKeyCode()

  681.      */

  682. 

  683.     int  keyCode;

  684.     /**

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

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

  687.      * a keyboard.

  688.      *

  689.      * @serial

  690.      * @see getKeyChar()

  691.      * @see setKeyChar()

  692.      */

  693.     char keyChar;

  694. 

  695.     /*

  696.      * JDK 1.1 serialVersionUID 

  697.      */

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

  699. 

  700.     static {

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

  702. 	NativeLibLoader.loadLibraries();

  703. 	initIDs();

  704.     }

  705. 

  706.     /**

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

  708.        accessed from C.

  709.      */

  710.     private static native void initIDs();

  711. 

  712.     /**

  713.      * Constructs a KeyEvent object.

  714.      *

  715.      * @param source    the Component that originated the event

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

  717.      * @param when      a long integer that specifys the time the event occurred

  718.      * @param modifiers the modifier keys down during event 

  719.      *                  (shift, ctrl, alt, meta)

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

  721.      *                  (for a key-typed event)

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

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

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

  725.      */

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

  727.                     int keyCode, char keyChar) {

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

  729. 

  730.         if (id == KEY_TYPED && keyChar == CHAR_UNDEFINED) {

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

  732.         }

  733.         if (id == KEY_TYPED && keyCode != VK_UNDEFINED) {

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

  735.         }

  736. 

  737.         this.keyCode = keyCode;

  738.         this.keyChar = keyChar;

  739.     }

  740. 

  741.     /*

  742.      * @deprecated, as of JDK1.1 - Do NOT USE; will be removed in 1.1.1.

  743.      */

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

  745.                     int keyCode) {

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

  747.     }

  748. 

  749.     /**

  750.      * Set the source of this KeyEvent. Dispatching this event subsequent

  751.      * to this operation will send this event to the new Object.

  752.      *

  753.      * @param newSource the KeyEvent's new source.

  754.      */

  755.     public void setSource(Object newSource) {

  756.         source = newSource;

  757.     }

  758. 

  759.     /**

  760.      * Returns the integer key-code associated with the key in this event.

  761.      * 

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

  763.      *         (For KEY_TYPED events, keyCode is VK_UNDEFINED.)

  764.      */

  765.     public int getKeyCode() {

  766.         return keyCode;

  767.     }

  768. 

  769.     /**

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

  771.      *

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

  773.      */

  774.     public void setKeyCode(int keyCode) {

  775.         this.keyCode = keyCode;

  776.     }

  777. 

  778.     /**

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

  780.      *

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

  782.      *                that make up this event.

  783.      */

  784.     public void setKeyChar(char keyChar) {

  785.         this.keyChar = keyChar;

  786.     }

  787. 

  788.     /**

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

  790.      * (shift, ctrl, alt, meta) defined as part of InputEvent.

  791.      * <p>

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

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

  794.      * especially true for KEY_TYPED events where the shift modifier

  795.      * is changed.

  796.      *

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

  798.      *

  799.      * @see InputEvent

  800.      *

  801.      * @deprecated, as of JDK1.1.4

  802.      */

  803.     public void setModifiers(int modifiers) {

  804.         this.modifiers = modifiers;

  805.     }

  806. 

  807.     /**

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

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

  810.      * value for "A".

  811.      *

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

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

  814.      *         keyChar is CHAR_UNDEFINED.

  815.      */

  816.     public char getKeyChar() {

  817.         return keyChar;

  818.     }

  819. 

  820.     /**

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

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

  823.      *

  824.      * @return string a text description for a physical key, identified by

  825.      *                its keyCode

  826.      */

  827.     public static String getKeyText(int keyCode) {

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

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

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

  831.         }

  832. 

  833.         // Check for other ASCII keyCodes.

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

  835.         if (index >= 0) {

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

  837.         }

  838. 	

  839.         switch(keyCode) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  860.           // handled by ASCII value above:

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

  862.           //   open_bracket, back_slash, close_bracket

  863. 

  864.           // numpad numeric keys handled below

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

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

  867.           case VK_SEPARATER: return Toolkit.getProperty("AWT.separater", "NumPad ,");

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

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

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

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

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

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

  874. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  899. 

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

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

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

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

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

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

  906. 			 

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

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

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

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

  911. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  928. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  949. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  971. 

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

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

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

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

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

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

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

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

  980. 

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

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

  983.         }

  984. 

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

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

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

  988.             return numpad + "-" + c;

  989.         }

  990. 

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

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

  993.     }

  994. 

  995.     /**

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

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

  998.      * awt.properties file.

  999.      *

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

  1001.      *                keys that were held down during the event

  1002.      */

  1003.     public static String getKeyModifiersText(int modifiers) {

  1004.         StringBuffer buf = new StringBuffer();

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

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

  1007.             buf.append("+");

  1008.         }

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

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

  1011.             buf.append("+");

  1012.         }

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

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

  1015.             buf.append("+");

  1016.         }

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

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

  1019.             buf.append("+");

  1020.         }

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

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

  1023.             buf.append("+");

  1024.         }

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

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

  1027.         }

  1028.         return buf.toString();

  1029.     }

  1030. 

  1031.     /** Returns whether or not the key in this event is an "action" key,

  1032.      *  as defined in Event.java.

  1033.      *

  1034.      * @return boolean value, true if the key is an "action" key

  1035.      *

  1036.      * @see Event

  1037.      */

  1038.     public boolean isActionKey() {

  1039.         switch (keyCode) {

  1040.           case VK_HOME:

  1041.           case VK_END:

  1042.           case VK_PAGE_UP:

  1043.           case VK_PAGE_DOWN:

  1044.           case VK_UP:

  1045.           case VK_DOWN:

  1046.           case VK_LEFT:

  1047.           case VK_RIGHT:

  1048. 

  1049. 	  case VK_KP_LEFT: 

  1050. 	  case VK_KP_UP: 

  1051. 	  case VK_KP_RIGHT: 

  1052. 	  case VK_KP_DOWN: 

  1053. 

  1054.           case VK_F1:

  1055.           case VK_F2:

  1056.           case VK_F3:

  1057.           case VK_F4:

  1058.           case VK_F5:

  1059.           case VK_F6:

  1060.           case VK_F7:

  1061.           case VK_F8:

  1062.           case VK_F9:

  1063.           case VK_F10:

  1064.           case VK_F11:

  1065.           case VK_F12:

  1066.           case VK_F13:

  1067.           case VK_F14:

  1068.           case VK_F15:

  1069.           case VK_F16:

  1070.           case VK_F17:

  1071.           case VK_F18:

  1072.           case VK_F19:

  1073.           case VK_F20:

  1074.           case VK_F21:

  1075.           case VK_F22:

  1076.           case VK_F23:

  1077.           case VK_F24:

  1078.           case VK_PRINTSCREEN:

  1079.           case VK_SCROLL_LOCK:

  1080.           case VK_CAPS_LOCK:

  1081.           case VK_NUM_LOCK:

  1082.           case VK_PAUSE:

  1083.           case VK_INSERT:

  1084. 

  1085.           case VK_FINAL:

  1086.           case VK_CONVERT:

  1087.           case VK_NONCONVERT:

  1088.           case VK_ACCEPT:

  1089.           case VK_MODECHANGE:

  1090. 	  case VK_KANA:

  1091. 	  case VK_KANJI:

  1092.           case VK_ALPHANUMERIC:

  1093. 	  case VK_KATAKANA:

  1094. 	  case VK_HIRAGANA:

  1095. 	  case VK_FULL_WIDTH:

  1096. 	  case VK_HALF_WIDTH:

  1097. 	  case VK_ROMAN_CHARACTERS:

  1098. 	  case VK_ALL_CANDIDATES:

  1099. 	  case VK_PREVIOUS_CANDIDATE:

  1100. 	  case VK_CODE_INPUT:

  1101. 	  case VK_JAPANESE_KATAKANA:

  1102. 	  case VK_JAPANESE_HIRAGANA:

  1103. 	  case VK_JAPANESE_ROMAN:

  1104. 	  case VK_KANA_LOCK:

  1105. 	  case VK_INPUT_METHOD_ON_OFF:

  1106. 

  1107.           case VK_AGAIN:

  1108.           case VK_UNDO:

  1109.           case VK_COPY:

  1110.           case VK_PASTE:

  1111.           case VK_CUT:

  1112.           case VK_FIND:

  1113.           case VK_PROPS:

  1114.           case VK_STOP:

  1115. 

  1116.           case VK_HELP:

  1117.               return true;

  1118.         }

  1119.         return false;

  1120.     }

  1121. 

  1122.     /**

  1123.      * Returns a parameter string identifying this event.

  1124.      * This method is useful for event-logging and for debugging.

  1125.      *

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

  1127.      */

  1128.     public String paramString() {

  1129.         String typeStr;

  1130.         switch(id) {

  1131.           case KEY_PRESSED:

  1132.               typeStr = "KEY_PRESSED";

  1133.               break;

  1134.           case KEY_RELEASED:

  1135.               typeStr = "KEY_RELEASED";

  1136.               break;

  1137.           case KEY_TYPED:

  1138.               typeStr = "KEY_TYPED";

  1139.               break;

  1140.           default:

  1141.               typeStr = "unknown type";

  1142.         }

  1143. 

  1144.         String str = typeStr + ",keyCode=" + keyCode;

  1145.         if (isActionKey() || keyCode == VK_ENTER || keyCode == VK_BACK_SPACE || 

  1146. 	    keyCode == VK_TAB || keyCode == VK_ESCAPE || keyCode == VK_DELETE ||

  1147. 	    (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) ||

  1148. 	    keyCode == VK_COMPOSE || keyCode == VK_ALT_GRAPH) {

  1149.             str += "," + getKeyText(keyCode);

  1150. 	} else if (keyChar == '\n' || keyChar == '\b' ||

  1151. 	    keyChar == '\t' || keyChar == VK_ESCAPE || keyChar == VK_DELETE) {

  1152.             str += "," + getKeyText(keyChar);

  1153.         } else {

  1154.             str += ",keyChar='" + keyChar + "'";

  1155.         }

  1156.         if (modifiers > 0) {

  1157.             str += ",modifiers=" + getKeyModifiersText(modifiers);

  1158.         }

  1159.         return str;

  1160.     }

  1161. 

  1162. }