1 /*

     2  * Copyright 1995-2005 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 #ifdef HEADLESS

    27     #error This file should not be included in headless library

    28 #endif

    29 

    30 #include "awt_p.h"

    31 #include <sys/time.h> /* timeval */

    32 

    33 #define XK_KATAKANA

    34 #include <X11/keysym.h>     /* standard X keysyms */

    35 #include <X11/DECkeysym.h>  /* DEC vendor-specific */

    36 #include <X11/Sunkeysym.h>  /* Sun vendor-specific */

    37 #include <X11/ap_keysym.h>  /* Apollo (HP) vendor-specific */

    38 /*

    39  * #include <X11/HPkeysym.h>    HP vendor-specific

    40  * I checked HPkeysym.h into the workspace because it ships

    41  * with X11R6.4.2 (and later) but not with X11R6.4.1.

    42  * So, it ought to ship with Solaris 9, but not Solaris 8.

    43  * Same deal for Linux - newer versions of XFree have it.

    44  *

    45  * Note: this is mainly done for the hp keysyms; it does NOT

    46  * give us the osf keysyms that are also defined in HPkeysym.h.

    47  * This is because we are already getting /Xm/VirtKeys.h

    48  * from awt_p.h <- /Xm/Xm.h <- /Xm/VirtKeys.h, and VirtKeys.h

    49  * #defines _OSF_Keysyms before we get here.  We are

    50  * missing a couple of osf keysyms because of this,

    51  * so I have #defined them below.

    52  */

    53 #include "HPkeysym.h"   /* HP vendor-specific */

    54 

    55 #include <Xm/Display.h>

    56 #include <ctype.h>

    57 #include "java_awt_Frame.h"

    58 #include "java_awt_Component.h"

    59 #include "java_awt_AWTEvent.h"

    60 #include "java_awt_event_KeyEvent.h"

    61 #include "java_awt_event_FocusEvent.h"

    62 #include "java_awt_event_MouseEvent.h"

    63 #include "java_awt_event_MouseWheelEvent.h"

    64 #include "java_awt_event_InputEvent.h"

    65 #include "java_awt_event_WindowEvent.h"

    66 #include "sun_awt_motif_MComponentPeer.h"

    67 #include "color.h"

    68 #include "canvas.h"

    69 #include "awt_Cursor.h"

    70 #include "VDrawingArea.h"

    71 #include "XDrawingArea.h"

    72 #include "awt_Component.h"

    73 #include "awt_AWTEvent.h"

    74 #include "awt_Event.h"

    75 #include "awt_KeyboardFocusManager.h"

    76 #include "awt_MToolkit.h"

    77 #include "awt_TopLevel.h"

    78 #include "awt_util.h"

    79 

    80 #include <jni.h>

    81 #include <jni_util.h>

    82 #include <jvm.h>

    83 #include <jawt.h>

    84 

    85 #ifdef NDEBUG   /* NDEBUG overrides DEBUG */

    86 #undef DEBUG

    87 #endif

    88 

    89 /*

    90  * Two osf keys are not defined in standard keysym.h,

    91  * /Xm/VirtKeys.h, or HPkeysym.h, so I added them below.

    92  * I found them in /usr/openwin/lib/X11/XKeysymDB

    93  */

    94 #ifndef osfXK_Prior

    95 #define osfXK_Prior 0x1004FF55

    96 #endif

    97 #ifndef osfXK_Next

    98 #define osfXK_Next 0x1004FF56

    99 #endif

   100 /*

   101  * osfXK_Escape is defined in HPkeysym.h, but not in

   102  * /Xm/VirtKeys.h, so I added it below.  It is also in

   103  * /usr/openwin/lib/X11/XKeysymDB

   104  * Note: it is in /Xm/VirtKeys.h in the AWT motif workspace,

   105  * but not in /usr/local/Motif/include/Xm/VirtKeys.h

   106  * on the Solaris 7, 8, or 9 machines I tried.

   107  */

   108 #ifndef osfXK_Escape

   109 #define osfXK_Escape 0x1004FF1B

   110 #endif

   111 

   112 extern struct MComponentPeerIDs mComponentPeerIDs;

   113 extern struct AWTEventIDs awtEventIDs;

   114 extern struct KeyEventIDs keyEventIDs;

   115 extern struct InputEventIDs inputEventIDs;

   116 extern struct ComponentIDs componentIDs;

   117 extern struct KeyboardFocusManagerIDs keyboardFocusManagerIDs;

   118 

   119 #ifdef DEBUG

   120 static Boolean debugKeys = False;

   121 #endif

   122 

   123 jint awt_multiclick_smudge = 4;

   124 

   125 extern Widget drag_source;

   126 

   127 Widget prevWidget = NULL; /* for bug fix 4017222 */

   128 

   129 FocusListElt *focusList = NULL, *focusListEnd = NULL;

   130 

   131 jweak forGained = NULL;

   132 

   133 extern Boolean scrollBugWorkAround;

   134 extern jobject currentX11InputMethodInstance;

   135 extern Window  currentFocusWindow;

   136 extern Boolean awt_x11inputmethod_lookupString(XKeyPressedEvent *, KeySym *);

   137 Boolean awt_UseType4Patch = True;

   138 Boolean awt_ServerDetected = False;

   139 Boolean awt_IsXsun = False;

   140 Boolean awt_UseXKB = False;

   141 

   142 void awt_post_java_key_event(XtPointer client_data, jint id,

   143                              XEvent *xevent, Time when, jint keycode,

   144                              jchar keychar, jint modifiers,

   145                              jint keyLocation, XEvent *anEvent);

   146 void awt_post_java_focus_event(XtPointer client_data, jint id, jobject cause,

   147                                XEvent *event);

   148 void awt_post_java_mouse_event(XtPointer client_data, jint id,

   149                                XEvent *event, Time when, jint modifiers,

   150                                jint x, jint y,

   151                                jint xAbs, jint yAbs,

   152                                jint clickcount, Boolean popuptrigger,

   153                                jint wheelAmt, jint button);

   154 

   155 typedef struct KEYMAP_ENTRY {

   156     jint awtKey;

   157     KeySym x11Key;

   158     Boolean mapsToUnicodeChar;

   159     jint keyLocation;

   160 } KeymapEntry;

   161 

   162 /* NB: XK_R? keysyms are for Type 4 keyboards.

   163  * The corresponding XK_F? keysyms are for Type 5

   164  *

   165  * Note: this table must be kept in sorted order, since it is traversed

   166  * according to both Java keycode and X keysym.  There are a number of

   167  * keycodes that map to more than one corresponding keysym, and we need

   168  * to choose the right one.  Unfortunately, there are some keysyms that

   169  * can map to more than one keycode, depending on what kind of keyboard

   170  * is in use (e.g. F11 and F12).

   171  */

   172 

   173 KeymapEntry keymapTable[] =

   174 {

   175     {java_awt_event_KeyEvent_VK_A, XK_a, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   176     {java_awt_event_KeyEvent_VK_B, XK_b, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   177     {java_awt_event_KeyEvent_VK_C, XK_c, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   178     {java_awt_event_KeyEvent_VK_D, XK_d, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   179     {java_awt_event_KeyEvent_VK_E, XK_e, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   180     {java_awt_event_KeyEvent_VK_F, XK_f, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   181     {java_awt_event_KeyEvent_VK_G, XK_g, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   182     {java_awt_event_KeyEvent_VK_H, XK_h, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   183     {java_awt_event_KeyEvent_VK_I, XK_i, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   184     {java_awt_event_KeyEvent_VK_J, XK_j, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   185     {java_awt_event_KeyEvent_VK_K, XK_k, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   186     {java_awt_event_KeyEvent_VK_L, XK_l, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   187     {java_awt_event_KeyEvent_VK_M, XK_m, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   188     {java_awt_event_KeyEvent_VK_N, XK_n, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   189     {java_awt_event_KeyEvent_VK_O, XK_o, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   190     {java_awt_event_KeyEvent_VK_P, XK_p, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   191     {java_awt_event_KeyEvent_VK_Q, XK_q, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   192     {java_awt_event_KeyEvent_VK_R, XK_r, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   193     {java_awt_event_KeyEvent_VK_S, XK_s, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   194     {java_awt_event_KeyEvent_VK_T, XK_t, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   195     {java_awt_event_KeyEvent_VK_U, XK_u, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   196     {java_awt_event_KeyEvent_VK_V, XK_v, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   197     {java_awt_event_KeyEvent_VK_W, XK_w, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   198     {java_awt_event_KeyEvent_VK_X, XK_x, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   199     {java_awt_event_KeyEvent_VK_Y, XK_y, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   200     {java_awt_event_KeyEvent_VK_Z, XK_z, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   201 

   202     /* TTY Function keys */

   203     {java_awt_event_KeyEvent_VK_BACK_SPACE, XK_BackSpace, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   204     {java_awt_event_KeyEvent_VK_TAB, XK_Tab, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   205     {java_awt_event_KeyEvent_VK_CLEAR, XK_Clear, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   206     {java_awt_event_KeyEvent_VK_ENTER, XK_Return, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   207     {java_awt_event_KeyEvent_VK_ENTER, XK_Linefeed, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   208     {java_awt_event_KeyEvent_VK_PAUSE, XK_Pause, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   209     {java_awt_event_KeyEvent_VK_PAUSE, XK_F21, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   210     {java_awt_event_KeyEvent_VK_PAUSE, XK_R1, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   211     {java_awt_event_KeyEvent_VK_SCROLL_LOCK, XK_Scroll_Lock, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   212     {java_awt_event_KeyEvent_VK_SCROLL_LOCK, XK_F23, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   213     {java_awt_event_KeyEvent_VK_SCROLL_LOCK, XK_R3, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   214     {java_awt_event_KeyEvent_VK_ESCAPE, XK_Escape, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   215 

   216     /* Other vendor-specific versions of TTY Function keys */

   217     {java_awt_event_KeyEvent_VK_BACK_SPACE, osfXK_BackSpace, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   218     {java_awt_event_KeyEvent_VK_CLEAR, osfXK_Clear, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   219     {java_awt_event_KeyEvent_VK_ESCAPE, osfXK_Escape, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   220 

   221     /* Modifier keys */

   222     {java_awt_event_KeyEvent_VK_SHIFT, XK_Shift_L, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_LEFT},

   223     {java_awt_event_KeyEvent_VK_SHIFT, XK_Shift_R, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_RIGHT},

   224     {java_awt_event_KeyEvent_VK_CONTROL, XK_Control_L, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_LEFT},

   225     {java_awt_event_KeyEvent_VK_CONTROL, XK_Control_R, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_RIGHT},

   226     {java_awt_event_KeyEvent_VK_ALT, XK_Alt_L, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_LEFT},

   227     {java_awt_event_KeyEvent_VK_ALT, XK_Alt_R, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_RIGHT},

   228     {java_awt_event_KeyEvent_VK_META, XK_Meta_L, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_LEFT},

   229     {java_awt_event_KeyEvent_VK_META, XK_Meta_R, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_RIGHT},

   230     {java_awt_event_KeyEvent_VK_CAPS_LOCK, XK_Caps_Lock, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   231 

   232     /* Misc Functions */

   233     {java_awt_event_KeyEvent_VK_PRINTSCREEN, XK_Print, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   234     {java_awt_event_KeyEvent_VK_PRINTSCREEN, XK_F22, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   235     {java_awt_event_KeyEvent_VK_PRINTSCREEN, XK_R2, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   236     {java_awt_event_KeyEvent_VK_CANCEL, XK_Cancel, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   237     {java_awt_event_KeyEvent_VK_HELP, XK_Help, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   238     {java_awt_event_KeyEvent_VK_NUM_LOCK, XK_Num_Lock, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   239 

   240     /* Other vendor-specific versions of Misc Functions */

   241     {java_awt_event_KeyEvent_VK_CANCEL, osfXK_Cancel, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   242     {java_awt_event_KeyEvent_VK_HELP, osfXK_Help, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   243 

   244     /* Rectangular Navigation Block */

   245     {java_awt_event_KeyEvent_VK_HOME, XK_Home, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   246     {java_awt_event_KeyEvent_VK_HOME, XK_R7, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   247     {java_awt_event_KeyEvent_VK_PAGE_UP, XK_Page_Up, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   248     {java_awt_event_KeyEvent_VK_PAGE_UP, XK_Prior, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   249     {java_awt_event_KeyEvent_VK_PAGE_UP, XK_R9, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   250     {java_awt_event_KeyEvent_VK_PAGE_DOWN, XK_Page_Down, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   251     {java_awt_event_KeyEvent_VK_PAGE_DOWN, XK_Next, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   252     {java_awt_event_KeyEvent_VK_PAGE_DOWN, XK_R15, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   253     {java_awt_event_KeyEvent_VK_END, XK_End, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   254     {java_awt_event_KeyEvent_VK_END, XK_R13, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   255     {java_awt_event_KeyEvent_VK_INSERT, XK_Insert, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   256     {java_awt_event_KeyEvent_VK_DELETE, XK_Delete, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   257 

   258     /* Keypad equivalents of Rectangular Navigation Block */

   259     {java_awt_event_KeyEvent_VK_HOME, XK_KP_Home, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   260     {java_awt_event_KeyEvent_VK_PAGE_UP, XK_KP_Page_Up, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   261     {java_awt_event_KeyEvent_VK_PAGE_UP, XK_KP_Prior, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   262     {java_awt_event_KeyEvent_VK_PAGE_DOWN, XK_KP_Page_Down, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   263     {java_awt_event_KeyEvent_VK_PAGE_DOWN, XK_KP_Next, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   264     {java_awt_event_KeyEvent_VK_END, XK_KP_End, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   265     {java_awt_event_KeyEvent_VK_INSERT, XK_KP_Insert, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   266     {java_awt_event_KeyEvent_VK_DELETE, XK_KP_Delete, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   267 

   268     /* Other vendor-specific Rectangular Navigation Block */

   269     {java_awt_event_KeyEvent_VK_PAGE_UP, osfXK_PageUp, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   270     {java_awt_event_KeyEvent_VK_PAGE_UP, osfXK_Prior, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   271     {java_awt_event_KeyEvent_VK_PAGE_DOWN, osfXK_PageDown, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   272     {java_awt_event_KeyEvent_VK_PAGE_DOWN, osfXK_Next, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   273     {java_awt_event_KeyEvent_VK_END, osfXK_EndLine, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   274     {java_awt_event_KeyEvent_VK_INSERT, osfXK_Insert, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   275     {java_awt_event_KeyEvent_VK_DELETE, osfXK_Delete, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   276 

   277     /* Triangular Navigation Block */

   278     {java_awt_event_KeyEvent_VK_LEFT, XK_Left, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   279     {java_awt_event_KeyEvent_VK_UP, XK_Up, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   280     {java_awt_event_KeyEvent_VK_RIGHT, XK_Right, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   281     {java_awt_event_KeyEvent_VK_DOWN, XK_Down, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   282 

   283     /* Keypad equivalents of Triangular Navigation Block */

   284     {java_awt_event_KeyEvent_VK_KP_LEFT, XK_KP_Left, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   285     {java_awt_event_KeyEvent_VK_KP_UP, XK_KP_Up, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   286     {java_awt_event_KeyEvent_VK_KP_RIGHT, XK_KP_Right, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   287     {java_awt_event_KeyEvent_VK_KP_DOWN, XK_KP_Down, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   288 

   289     /* Other vendor-specific Triangular Navigation Block */

   290     {java_awt_event_KeyEvent_VK_LEFT, osfXK_Left, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   291     {java_awt_event_KeyEvent_VK_UP, osfXK_Up, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   292     {java_awt_event_KeyEvent_VK_RIGHT, osfXK_Right, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   293     {java_awt_event_KeyEvent_VK_DOWN, osfXK_Down, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   294 

   295     /* Remaining Cursor control & motion */

   296     {java_awt_event_KeyEvent_VK_BEGIN, XK_Begin, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   297     {java_awt_event_KeyEvent_VK_BEGIN, XK_KP_Begin, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   298 

   299     {java_awt_event_KeyEvent_VK_0, XK_0, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   300     {java_awt_event_KeyEvent_VK_1, XK_1, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   301     {java_awt_event_KeyEvent_VK_2, XK_2, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   302     {java_awt_event_KeyEvent_VK_3, XK_3, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   303     {java_awt_event_KeyEvent_VK_4, XK_4, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   304     {java_awt_event_KeyEvent_VK_5, XK_5, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   305     {java_awt_event_KeyEvent_VK_6, XK_6, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   306     {java_awt_event_KeyEvent_VK_7, XK_7, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   307     {java_awt_event_KeyEvent_VK_8, XK_8, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   308     {java_awt_event_KeyEvent_VK_9, XK_9, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   309 

   310     {java_awt_event_KeyEvent_VK_SPACE, XK_space, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   311     {java_awt_event_KeyEvent_VK_EXCLAMATION_MARK, XK_exclam, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   312     {java_awt_event_KeyEvent_VK_QUOTEDBL, XK_quotedbl, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   313     {java_awt_event_KeyEvent_VK_NUMBER_SIGN, XK_numbersign, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   314     {java_awt_event_KeyEvent_VK_DOLLAR, XK_dollar, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   315     {java_awt_event_KeyEvent_VK_AMPERSAND, XK_ampersand, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   316     {java_awt_event_KeyEvent_VK_QUOTE, XK_apostrophe, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   317     {java_awt_event_KeyEvent_VK_LEFT_PARENTHESIS, XK_parenleft, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   318     {java_awt_event_KeyEvent_VK_RIGHT_PARENTHESIS, XK_parenright, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   319     {java_awt_event_KeyEvent_VK_ASTERISK, XK_asterisk, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   320     {java_awt_event_KeyEvent_VK_PLUS, XK_plus, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   321     {java_awt_event_KeyEvent_VK_COMMA, XK_comma, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   322     {java_awt_event_KeyEvent_VK_MINUS, XK_minus, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   323     {java_awt_event_KeyEvent_VK_PERIOD, XK_period, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   324     {java_awt_event_KeyEvent_VK_SLASH, XK_slash, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   325 

   326     {java_awt_event_KeyEvent_VK_COLON, XK_colon, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   327     {java_awt_event_KeyEvent_VK_SEMICOLON, XK_semicolon, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   328     {java_awt_event_KeyEvent_VK_LESS, XK_less, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   329     {java_awt_event_KeyEvent_VK_EQUALS, XK_equal, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   330     {java_awt_event_KeyEvent_VK_GREATER, XK_greater, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   331 

   332     {java_awt_event_KeyEvent_VK_AT, XK_at, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   333 

   334     {java_awt_event_KeyEvent_VK_OPEN_BRACKET, XK_bracketleft, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   335     {java_awt_event_KeyEvent_VK_BACK_SLASH, XK_backslash, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   336     {java_awt_event_KeyEvent_VK_CLOSE_BRACKET, XK_bracketright, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   337     {java_awt_event_KeyEvent_VK_CIRCUMFLEX, XK_asciicircum, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   338     {java_awt_event_KeyEvent_VK_UNDERSCORE, XK_underscore, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   339     {java_awt_event_KeyEvent_VK_BACK_QUOTE, XK_grave, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   340 

   341     {java_awt_event_KeyEvent_VK_BRACELEFT, XK_braceleft, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   342     {java_awt_event_KeyEvent_VK_BRACERIGHT, XK_braceright, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   343 

   344     {java_awt_event_KeyEvent_VK_INVERTED_EXCLAMATION_MARK, XK_exclamdown, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   345 

   346     /* Remaining Numeric Keypad Keys */

   347     {java_awt_event_KeyEvent_VK_NUMPAD0, XK_KP_0, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   348     {java_awt_event_KeyEvent_VK_NUMPAD1, XK_KP_1, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   349     {java_awt_event_KeyEvent_VK_NUMPAD2, XK_KP_2, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   350     {java_awt_event_KeyEvent_VK_NUMPAD3, XK_KP_3, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   351     {java_awt_event_KeyEvent_VK_NUMPAD4, XK_KP_4, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   352     {java_awt_event_KeyEvent_VK_NUMPAD5, XK_KP_5, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   353     {java_awt_event_KeyEvent_VK_NUMPAD6, XK_KP_6, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   354     {java_awt_event_KeyEvent_VK_NUMPAD7, XK_KP_7, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   355     {java_awt_event_KeyEvent_VK_NUMPAD8, XK_KP_8, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   356     {java_awt_event_KeyEvent_VK_NUMPAD9, XK_KP_9, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   357     {java_awt_event_KeyEvent_VK_SPACE, XK_KP_Space, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   358     {java_awt_event_KeyEvent_VK_TAB, XK_KP_Tab, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   359     {java_awt_event_KeyEvent_VK_ENTER, XK_KP_Enter, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   360     {java_awt_event_KeyEvent_VK_EQUALS, XK_KP_Equal, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   361     {java_awt_event_KeyEvent_VK_EQUALS, XK_R4, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   362     {java_awt_event_KeyEvent_VK_MULTIPLY, XK_KP_Multiply, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   363     {java_awt_event_KeyEvent_VK_MULTIPLY, XK_F26, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   364     {java_awt_event_KeyEvent_VK_MULTIPLY, XK_R6, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   365     {java_awt_event_KeyEvent_VK_ADD, XK_KP_Add, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   366     {java_awt_event_KeyEvent_VK_SEPARATOR, XK_KP_Separator, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   367     {java_awt_event_KeyEvent_VK_SUBTRACT, XK_KP_Subtract, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   368     {java_awt_event_KeyEvent_VK_SUBTRACT, XK_F24, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   369     {java_awt_event_KeyEvent_VK_DECIMAL, XK_KP_Decimal, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   370     {java_awt_event_KeyEvent_VK_DIVIDE, XK_KP_Divide, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   371     {java_awt_event_KeyEvent_VK_DIVIDE, XK_F25, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   372     {java_awt_event_KeyEvent_VK_DIVIDE, XK_R5, TRUE, java_awt_event_KeyEvent_KEY_LOCATION_NUMPAD},

   373 

   374     /* Function Keys */

   375     {java_awt_event_KeyEvent_VK_F1, XK_F1, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   376     {java_awt_event_KeyEvent_VK_F2, XK_F2, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   377     {java_awt_event_KeyEvent_VK_F3, XK_F3, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   378     {java_awt_event_KeyEvent_VK_F4, XK_F4, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   379     {java_awt_event_KeyEvent_VK_F5, XK_F5, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   380     {java_awt_event_KeyEvent_VK_F6, XK_F6, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   381     {java_awt_event_KeyEvent_VK_F7, XK_F7, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   382     {java_awt_event_KeyEvent_VK_F8, XK_F8, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   383     {java_awt_event_KeyEvent_VK_F9, XK_F9, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   384     {java_awt_event_KeyEvent_VK_F10, XK_F10, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   385     {java_awt_event_KeyEvent_VK_F11, XK_F11, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   386     {java_awt_event_KeyEvent_VK_F12, XK_F12, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   387 

   388     /* Sun vendor-specific version of F11 and F12 */

   389     {java_awt_event_KeyEvent_VK_F11, SunXK_F36, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   390     {java_awt_event_KeyEvent_VK_F12, SunXK_F37, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   391 

   392     /* X11 keysym names for input method related keys don't always

   393      * match keytop engravings or Java virtual key names, so here we

   394      * only map constants that we've found on real keyboards.

   395      */

   396     /* Type 5c Japanese keyboard: kakutei */

   397     {java_awt_event_KeyEvent_VK_ACCEPT, XK_Execute, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   398     /* Type 5c Japanese keyboard: henkan */

   399     {java_awt_event_KeyEvent_VK_CONVERT, XK_Kanji, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   400     /* Type 5c Japanese keyboard: nihongo */

   401     {java_awt_event_KeyEvent_VK_INPUT_METHOD_ON_OFF, XK_Henkan_Mode, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   402     /* VK_KANA_LOCK is handled separately because it generates the

   403      * same keysym as ALT_GRAPH in spite of its different behavior.

   404      */

   405 

   406     {java_awt_event_KeyEvent_VK_COMPOSE, XK_Multi_key, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   407     {java_awt_event_KeyEvent_VK_ALT_GRAPH, XK_Mode_switch, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   408 

   409     /* Editing block */

   410     {java_awt_event_KeyEvent_VK_AGAIN, XK_Redo, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   411     {java_awt_event_KeyEvent_VK_AGAIN, XK_L2, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   412     {java_awt_event_KeyEvent_VK_UNDO, XK_Undo, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   413     {java_awt_event_KeyEvent_VK_UNDO, XK_L4, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   414     {java_awt_event_KeyEvent_VK_COPY, XK_L6, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   415     {java_awt_event_KeyEvent_VK_PASTE, XK_L8, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   416     {java_awt_event_KeyEvent_VK_CUT, XK_L10, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   417     {java_awt_event_KeyEvent_VK_FIND, XK_Find, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   418     {java_awt_event_KeyEvent_VK_FIND, XK_L9, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   419     {java_awt_event_KeyEvent_VK_PROPS, XK_L3, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   420     {java_awt_event_KeyEvent_VK_STOP, XK_L1, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   421 

   422     /* Sun vendor-specific versions for editing block */

   423     {java_awt_event_KeyEvent_VK_AGAIN, SunXK_Again, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   424     {java_awt_event_KeyEvent_VK_UNDO, SunXK_Undo, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   425     {java_awt_event_KeyEvent_VK_COPY, SunXK_Copy, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   426     {java_awt_event_KeyEvent_VK_PASTE, SunXK_Paste, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   427     {java_awt_event_KeyEvent_VK_CUT, SunXK_Cut, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   428     {java_awt_event_KeyEvent_VK_FIND, SunXK_Find, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   429     {java_awt_event_KeyEvent_VK_PROPS, SunXK_Props, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   430     {java_awt_event_KeyEvent_VK_STOP, SunXK_Stop, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   431 

   432     /* Apollo (HP) vendor-specific versions for editing block */

   433     {java_awt_event_KeyEvent_VK_COPY, apXK_Copy, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   434     {java_awt_event_KeyEvent_VK_CUT, apXK_Cut, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   435     {java_awt_event_KeyEvent_VK_PASTE, apXK_Paste, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   436 

   437     /* Other vendor-specific versions for editing block */

   438     {java_awt_event_KeyEvent_VK_COPY, osfXK_Copy, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   439     {java_awt_event_KeyEvent_VK_CUT, osfXK_Cut, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   440     {java_awt_event_KeyEvent_VK_PASTE, osfXK_Paste, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   441     {java_awt_event_KeyEvent_VK_UNDO, osfXK_Undo, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   442 

   443     /* Dead key mappings (for European keyboards) */

   444     {java_awt_event_KeyEvent_VK_DEAD_GRAVE, XK_dead_grave, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   445     {java_awt_event_KeyEvent_VK_DEAD_ACUTE, XK_dead_acute, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   446     {java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX, XK_dead_circumflex, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   447     {java_awt_event_KeyEvent_VK_DEAD_TILDE, XK_dead_tilde, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   448     {java_awt_event_KeyEvent_VK_DEAD_MACRON, XK_dead_macron, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   449     {java_awt_event_KeyEvent_VK_DEAD_BREVE, XK_dead_breve, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   450     {java_awt_event_KeyEvent_VK_DEAD_ABOVEDOT, XK_dead_abovedot, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   451     {java_awt_event_KeyEvent_VK_DEAD_DIAERESIS, XK_dead_diaeresis, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   452     {java_awt_event_KeyEvent_VK_DEAD_ABOVERING, XK_dead_abovering, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   453     {java_awt_event_KeyEvent_VK_DEAD_DOUBLEACUTE, XK_dead_doubleacute, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   454     {java_awt_event_KeyEvent_VK_DEAD_CARON, XK_dead_caron, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   455     {java_awt_event_KeyEvent_VK_DEAD_CEDILLA, XK_dead_cedilla, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   456     {java_awt_event_KeyEvent_VK_DEAD_OGONEK, XK_dead_ogonek, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   457     {java_awt_event_KeyEvent_VK_DEAD_IOTA, XK_dead_iota, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   458     {java_awt_event_KeyEvent_VK_DEAD_VOICED_SOUND, XK_dead_voiced_sound, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   459     {java_awt_event_KeyEvent_VK_DEAD_SEMIVOICED_SOUND, XK_dead_semivoiced_sound, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   460 

   461     /* Sun vendor-specific dead key mappings (for European keyboards) */

   462     {java_awt_event_KeyEvent_VK_DEAD_GRAVE, SunXK_FA_Grave, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   463     {java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX, SunXK_FA_Circum, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   464     {java_awt_event_KeyEvent_VK_DEAD_TILDE, SunXK_FA_Tilde, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   465     {java_awt_event_KeyEvent_VK_DEAD_ACUTE, SunXK_FA_Acute, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   466     {java_awt_event_KeyEvent_VK_DEAD_DIAERESIS, SunXK_FA_Diaeresis, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   467     {java_awt_event_KeyEvent_VK_DEAD_CEDILLA, SunXK_FA_Cedilla, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   468 

   469     /* DEC vendor-specific dead key mappings (for European keyboards) */

   470     {java_awt_event_KeyEvent_VK_DEAD_ABOVERING, DXK_ring_accent, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   471     {java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX, DXK_circumflex_accent, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   472     {java_awt_event_KeyEvent_VK_DEAD_CEDILLA, DXK_cedilla_accent, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   473     {java_awt_event_KeyEvent_VK_DEAD_ACUTE, DXK_acute_accent, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   474     {java_awt_event_KeyEvent_VK_DEAD_GRAVE, DXK_grave_accent, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   475     {java_awt_event_KeyEvent_VK_DEAD_TILDE, DXK_tilde, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   476     {java_awt_event_KeyEvent_VK_DEAD_DIAERESIS, DXK_diaeresis, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   477 

   478     /* Other vendor-specific dead key mappings (for European keyboards) */

   479     {java_awt_event_KeyEvent_VK_DEAD_ACUTE, hpXK_mute_acute, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   480     {java_awt_event_KeyEvent_VK_DEAD_GRAVE, hpXK_mute_grave, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   481     {java_awt_event_KeyEvent_VK_DEAD_CIRCUMFLEX, hpXK_mute_asciicircum, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   482     {java_awt_event_KeyEvent_VK_DEAD_DIAERESIS, hpXK_mute_diaeresis, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   483     {java_awt_event_KeyEvent_VK_DEAD_TILDE, hpXK_mute_asciitilde, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_STANDARD},

   484 

   485     {java_awt_event_KeyEvent_VK_UNDEFINED, NoSymbol, FALSE, java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN}

   486 };

   487 

   488 static Boolean

   489 keyboardHasKanaLockKey()

   490 {

   491     static Boolean haveResult = FALSE;

   492     static Boolean result = FALSE;

   493 

   494     int32_t minKeyCode, maxKeyCode, keySymsPerKeyCode;

   495     KeySym *keySyms, *keySymsStart, keySym;

   496     int32_t i;

   497     int32_t kanaCount = 0;

   498 

   499     // Solaris doesn't let you swap keyboards without rebooting,

   500     // so there's no need to check for the kana lock key more than once.

   501     if (haveResult) {

   502        return result;

   503     }

   504 

   505     // There's no direct way to determine whether the keyboard has

   506     // a kana lock key. From available keyboard mapping tables, it looks

   507     // like only keyboards with the kana lock key can produce keysyms

   508     // for kana characters. So, as an indirect test, we check for those.

   509 

   510     XDisplayKeycodes(awt_display, &minKeyCode, &maxKeyCode);

   511     keySyms = XGetKeyboardMapping(awt_display, minKeyCode, maxKeyCode - minKeyCode + 1, &keySymsPerKeyCode);

   512     keySymsStart = keySyms;

   513     for (i = 0; i < (maxKeyCode - minKeyCode + 1) * keySymsPerKeyCode; i++) {

   514         keySym = *keySyms++;

   515         if ((keySym & 0xff00) == 0x0400) {

   516             kanaCount++;

   517         }

   518     }

   519     XFree(keySymsStart);

   520 

   521     // use a (somewhat arbitrary) minimum so we don't get confused by a stray function key

   522     result = kanaCount > 10;

   523     haveResult = TRUE;

   524     return result;

   525 }

   526 

   527 void

   528 keysymToAWTKeyCode(KeySym x11Key, jint *keycode, Boolean *mapsToUnicodeChar,

   529   jint *keyLocation)

   530 {

   531     int32_t i;

   532 

   533     // Solaris uses XK_Mode_switch for both the non-locking AltGraph

   534     // and the locking Kana key, but we want to keep them separate for

   535     // KeyEvent.

   536     if (x11Key == XK_Mode_switch && keyboardHasKanaLockKey()) {

   537         *keycode = java_awt_event_KeyEvent_VK_KANA_LOCK;

   538         *mapsToUnicodeChar = FALSE;

   539         *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;

   540         return;

   541     }

   542 

   543     for (i = 0;

   544          keymapTable[i].awtKey != java_awt_event_KeyEvent_VK_UNDEFINED;

   545          i++) {

   546         if (keymapTable[i].x11Key == x11Key) {

   547             *keycode = keymapTable[i].awtKey;

   548             *mapsToUnicodeChar = keymapTable[i].mapsToUnicodeChar;

   549             *keyLocation = keymapTable[i].keyLocation;

   550             return;

   551         }

   552     }

   553 

   554     *keycode = java_awt_event_KeyEvent_VK_UNDEFINED;

   555     *mapsToUnicodeChar = FALSE;

   556     *keyLocation = java_awt_event_KeyEvent_KEY_LOCATION_UNKNOWN;

   557 

   558     DTRACE_PRINTLN1("keysymToAWTKeyCode: no key mapping found: keysym = %x", x11Key);

   559 }

   560 

   561 KeySym

   562 awt_getX11KeySym(jint awtKey)

   563 {

   564     int32_t i;

   565 

   566     if (awtKey == java_awt_event_KeyEvent_VK_KANA_LOCK && keyboardHasKanaLockKey()) {

   567         return XK_Mode_switch;

   568     }

   569 

   570     for (i = 0; keymapTable[i].awtKey != 0; i++) {

   571         if (keymapTable[i].awtKey == awtKey) {

   572             return keymapTable[i].x11Key;

   573         }

   574     }

   575 

   576     DTRACE_PRINTLN1("awt_getX11KeySym: no key mapping found: awtKey = %x", awtKey);

   577     return NoSymbol;

   578 }

   579 

   580 

   581 typedef struct COLLAPSE_INFO {

   582     Window win;

   583     DamageRect *r;

   584 } CollapseInfo;

   585 

   586 static void

   587 expandDamageRect(DamageRect * drect, XEvent * xev, Boolean debug, char *str)

   588 {

   589     int32_t x1 = xev->xexpose.x;

   590     int32_t y1 = xev->xexpose.y;

   591     int32_t x2 = x1 + xev->xexpose.width;

   592     int32_t y2 = y1 + xev->xexpose.height;

   593 

   594     /*

   595       if (debug) {

   596       printf("   %s: collapsing (%d,%d %dx%d) into (%d,%d %dx%d) ->>",

   597       str, x1, y1, xev->xexpose.width, xev->xexpose.height,

   598       drect->x1, drect->y1, drect->x2 - drect->x1, drect->y2 - drect->y1);

   599       }

   600     */

   601 

   602     drect->x1 = MIN(x1, drect->x1);

   603     drect->y1 = MIN(y1, drect->y1);

   604     drect->x2 = MAX(x2, drect->x2);

   605     drect->y2 = MAX(y2, drect->y2);

   606 

   607     /*

   608       if (debug) {

   609       printf("(%d,%d %dx%d) %s\n",

   610       drect->x1, drect->y1, drect->x2 - drect->x1, drect->y2 - drect->y1);

   611       }

   612     */

   613 

   614 }

   615 

   616 static Bool

   617 checkForExpose(Display * dpy, XEvent * evt, XPointer client_data)

   618 {

   619     CollapseInfo *cinfo = (CollapseInfo *) client_data;

   620 

   621     if ((evt->type == Expose && evt->xexpose.window == cinfo->win &&

   622          INTERSECTS(cinfo->r->x1, cinfo->r->x2, cinfo->r->y1, cinfo->r->y2,

   623                     evt->xexpose.x,

   624                     evt->xexpose.x + evt->xexpose.width,

   625                     evt->xexpose.y,

   626                     evt->xexpose.y + evt->xexpose.height)) ||

   627         (evt->type == GraphicsExpose && evt->xgraphicsexpose.drawable == cinfo->win &&

   628          INTERSECTS(cinfo->r->x1, cinfo->r->x2, cinfo->r->y1, cinfo->r->y2,

   629                     evt->xgraphicsexpose.x,

   630                     evt->xgraphicsexpose.x + evt->xgraphicsexpose.width,

   631                     evt->xgraphicsexpose.y,

   632                     evt->xgraphicsexpose.y + evt->xgraphicsexpose.height))) {

   633 

   634         return True;

   635     }

   636     return False;

   637 }

   638 

   639 /*

   640  * javaObject is an MComponentPeer instance

   641  */

   642 static void

   643 HandleExposeEvent(Widget w, jobject javaObject, XEvent * event)

   644 {

   645     jobject target;

   646     jint wdth, hght;

   647 

   648     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   649 

   650     switch (event->type) {

   651         case Expose:

   652         case GraphicsExpose:

   653         {

   654             struct ComponentData *cdata;

   655             Boolean debug = FALSE;

   656             jint drawState;

   657 

   658             /* Set the draw state */

   659             drawState = (*env)->GetIntField(env, javaObject,

   660                 mComponentPeerIDs.drawState);

   661             (*env)->SetIntField(env, javaObject, mComponentPeerIDs.drawState,

   662                 drawState | JAWT_LOCK_CLIP_CHANGED);

   663             cdata = (struct ComponentData *)

   664               JNU_GetLongFieldAsPtr(env, javaObject, mComponentPeerIDs.pData);

   665             if (JNU_IsNull(env, javaObject) || (cdata == NULL)) {

   666                 return;

   667             }

   668             if (event->xexpose.send_event) {

   669                 if (cdata->repaintPending & RepaintPending_REPAINT) {

   670                     cdata->repaintPending &= ~RepaintPending_REPAINT;

   671 

   672                     JNU_CallMethodByName(env,

   673                                          NULL,

   674                                          javaObject,

   675                                          "handleRepaint",

   676                                          "(IIII)V",

   677                                          (jint) cdata->repaintRect.x1,

   678                                          (jint) cdata->repaintRect.y1,

   679                                          (jint) cdata->repaintRect.x2

   680                                          - cdata->repaintRect.x1,

   681                                          (jint) cdata->repaintRect.y2

   682                                          - cdata->repaintRect.y1);

   683                     if ((*env)->ExceptionOccurred(env)) {

   684                         (*env)->ExceptionDescribe(env);

   685                         (*env)->ExceptionClear(env);

   686                     }

   687                 }

   688                 return;

   689             }

   690             if ((cdata->repaintPending & RepaintPending_EXPOSE) == 0) {

   691                 cdata->exposeRect.x1 = event->xexpose.x;

   692                 cdata->exposeRect.y1 = event->xexpose.y;

   693                 cdata->exposeRect.x2 = cdata->exposeRect.x1 + event->xexpose.width;

   694                 cdata->exposeRect.y2 = cdata->exposeRect.y1 + event->xexpose.height;

   695                 cdata->repaintPending |= RepaintPending_EXPOSE;

   696             } else {

   697                 expandDamageRect(&(cdata->exposeRect), event, debug, "1");

   698             }

   699 

   700             /* Only post Expose/Repaint if we know others arn't following

   701              * directly in the queue.

   702              */

   703             if (event->xexpose.count == 0) {

   704                 int32_t count = 0;

   705                 CollapseInfo cinfo;

   706 

   707                 cinfo.win = XtWindow(w);

   708                 cinfo.r = &(cdata->exposeRect);

   709 

   710                 /* Do a little more inspecting and collapse further if there

   711                  * are additional expose events pending on this window where

   712                  * the damage rects intersect with the current exposeRect.

   713                  */

   714                 while (TRUE) {

   715                     XEvent xev;

   716 

   717                     if (XCheckIfEvent(XtDisplay(w), &xev

   718                                       ,checkForExpose, (XtPointer) & cinfo)) {

   719                         count = xev.xexpose.count;

   720                         expandDamageRect(&(cdata->exposeRect), &xev, debug, "2");

   721 

   722                     } else {

   723                         /* XCheckIfEvent Failed. */

   724                         break;

   725                     }

   726                 }

   727 

   728                 cdata->repaintPending &= ~RepaintPending_EXPOSE;

   729 

   730                 /* Fix for bugtraq id 4262108. Paint events should not be

   731                  * delivered to components that have one of their

   732                  * dimensions equal to zero.

   733                  */

   734 

   735                 if ((*env)->EnsureLocalCapacity(env, 1) < 0) {

   736                     return;

   737                 }

   738 

   739                 target = (*env)->GetObjectField(env, javaObject,

   740                                                     mComponentPeerIDs.target);

   741                 wdth = (*env)->GetIntField(env, target, componentIDs.width);

   742                 hght = (*env)->GetIntField(env, target, componentIDs.height);

   743                 (*env)->DeleteLocalRef(env, target);

   744 

   745                 if ( wdth != 0 && hght != 0) {

   746                     JNU_CallMethodByName(env,

   747                                         NULL,

   748                                         javaObject,

   749                                         "handleExpose",

   750                                         "(IIII)V",

   751                                         (jint) cdata->exposeRect.x1,

   752                                         (jint) cdata->exposeRect.y1,

   753                                         (jint) cdata->exposeRect.x2

   754                                         - cdata->exposeRect.x1,

   755                                         (jint) cdata->exposeRect.y2

   756                                         - cdata->exposeRect.y1);

   757                     if ((*env)->ExceptionOccurred(env)) {

   758                         (*env)->ExceptionDescribe(env);

   759                         (*env)->ExceptionClear(env);

   760                     }

   761                 }

   762             }

   763         }

   764         break;

   765 

   766         default:

   767             jio_fprintf(stderr, "Got event %d in HandleExposeEvent!\n", event->type);

   768     }

   769 }

   770 

   771 /* We always store and return JNI GlobalRefs. */

   772 static jweak focusOwnerPeer = NULL;

   773 static jweak focusedWindowPeer = NULL;

   774 

   775 /*

   776  * This function should only be called under the

   777  * protection of AWT_LOCK(). Otherwise, multithreaded access

   778  * can corrupt the value of focusOwnerPeer variable.

   779  * This function returns LocalRef, result should be deleted

   780  * explicitly if called on a thread that never returns to

   781  * Java.

   782  */

   783 jobject

   784 awt_canvas_getFocusOwnerPeer() {

   785     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   786     jobject res;

   787     AWT_LOCK();

   788     res = (*env)->NewLocalRef(env, focusOwnerPeer);

   789     AWT_UNLOCK();

   790     return res;

   791 }

   792 

   793 /*

   794  * This function should only be called under the

   795  * protection of AWT_LOCK(). Otherwise, multithreaded access

   796  * can corrupt the value of focusedWindowPeer variable.

   797  * This function returns LocalRef, result should be deleted

   798  * explicitly if called on a thread that never returns to

   799  * Java.

   800  */

   801 jobject

   802 awt_canvas_getFocusedWindowPeer() {

   803     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   804     jobject res;

   805     AWT_LOCK();

   806     res = (*env)->NewLocalRef(env, focusedWindowPeer);

   807     AWT_UNLOCK();

   808     return res;

   809 }

   810 

   811 /*

   812  * Only call this function under AWT_LOCK(). Otherwise, multithreaded

   813  * access can corrupt the value of focusOwnerPeer variable.

   814  */

   815 void

   816 awt_canvas_setFocusOwnerPeer(jobject peer) {

   817     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   818     AWT_LOCK();

   819     if (focusOwnerPeer != NULL) {

   820         (*env)->DeleteWeakGlobalRef(env, focusOwnerPeer);

   821     }

   822     focusOwnerPeer = (peer != NULL)

   823         ? (*env)->NewWeakGlobalRef(env, peer) : NULL;

   824     AWT_UNLOCK();

   825 }

   826 

   827 /*

   828  * Only call this function under AWT_LOCK(). Otherwise, multithreaded

   829  * access can corrupt the value of focusedWindowPeer variable.

   830  */

   831 void

   832 awt_canvas_setFocusedWindowPeer(jobject peer) {

   833     JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);

   834     AWT_LOCK();

   835     if (focusedWindowPeer != NULL) {

   836         (*env)->DeleteWeakGlobalRef(env, focusedWindowPeer);

   837     }

   838     focusedWindowPeer = (peer != NULL)

   839         ? (*env)->NewWeakGlobalRef(env, peer) : NULL;

   840     AWT_UNLOCK();

   841 }

   842 

   843 void callFocusCallback(jobject focusPeer, int focus_type, jobject cause) {

   844     awt_post_java_focus_event(focusPeer,

   845                               focus_type,

   846                               cause,

   847                               NULL);

   848     awt_canvas_setFocusOwnerPeer(focusPeer);

   849 }

   850 

   851 

   852 void

   853 handleFocusEvent(Widget w,

   854                  XFocusChangeEvent * fevent,

   855                  XtPointer client_data,

   856                  Boolean * cont,

   857                  Boolean passEvent,

   858                  jobject cause)

   859 {

   860     if (fevent->type == FocusIn) {

   861         if (fevent->mode == NotifyNormal &&

   862             fevent->detail != NotifyPointer && fevent->detail != NotifyVirtual)

   863         {

   864 #ifdef DEBUG_FOCUS

   865             printf("window = %d, mode = %d, detail = %d\n", fevent->window, fevent->mode, fevent->detail);

   866             printf("----posting java FOCUS GAINED on window %d, pass = %d\n", XtWindow(w), passEvent);

   867 #endif

   868             awt_post_java_focus_event(client_data,

   869                                       java_awt_event_FocusEvent_FOCUS_GAINED,

   870                                       cause,

   871                                       NULL);

   872             awt_canvas_setFocusOwnerPeer(client_data);

   873         }

   874     } else {

   875         /* FocusOut */

   876         if (fevent->mode == NotifyNormal &&

   877             fevent->detail != NotifyPointer && fevent->detail != NotifyVirtual)

   878         {

   879 #ifdef DEBUG_FOCUS

   880           printf("window = %d, mode = %d, detail = %d\n", fevent->window, fevent->mode, fevent->detail);

   881           printf("----posting java FOCUS LOST on window %d, pass = %d, temp = %d\n", XtWindow(w), passEvent, temp);

   882 #endif

   883             awt_post_java_focus_event(client_data,

   884                                       java_awt_event_FocusEvent_FOCUS_LOST,

   885                                       cause,

   886                                       NULL);

   887             awt_canvas_setFocusOwnerPeer(NULL);

   888         }

   889     }

   890     *cont = TRUE;

   891 }

   892 

   893 void callFocusHandler(Widget w, int eventType, jobject cause) {

   894     jobject peer = NULL;

   895     XFocusChangeEvent event;

   896     Boolean cont;

   897     JNIEnv *env = (JNIEnv *) JNU_GetEnv(jvm, JNI_VERSION_1_2);

   898 

   899     if (w == NULL) {

   900         return;

   901     }

   902 

   903     peer = findPeer(&w);

   904     if (peer == NULL) {

   905         w = findTopLevelByShell(w);

   906         if (w != NULL) {

   907             peer = findPeer(&w);

   908         }

   909     }

   910     if (peer == NULL) {

   911         return;

   912     }

   913     memset(&event, 0, sizeof(event));

   914     event.type = eventType;

   915     event.mode = NotifyNormal;

   916     event.detail = NotifyAncestor;

   917     event.window = XtWindow(w);

   918     cont = FALSE;

   919     handleFocusEvent(w, &event, (XtPointer)peer, &cont, TRUE, cause);

   920 }

   921 

   922 /**

   923  * Copy XEvent to jbyteArray and save it in AWTEvent

   924  */

   925 void

   926 awt_copyXEventToAWTEvent(JNIEnv *env, XEvent * xev, jobject jevent)

   927 {

   928     jbyteArray bdata;

   929     if (xev != NULL) {

   930         if ((*env)->EnsureLocalCapacity(env, 1) < 0) {

   931             return;

   932         }

   933         bdata = (*env)->NewByteArray(env, sizeof(XEvent));

   934         if (bdata != NULL) {

   935             (*env)->SetByteArrayRegion(env, bdata, 0, sizeof(XEvent),

   936                                        (jbyte *)xev);

   937             (*env)->SetObjectField(env, jevent, awtEventIDs.bdata, bdata);

   938             (*env)->DeleteLocalRef(env, bdata);

   939         }

   940     }

   941 }

   942 

   943 /* Returns new modifiers set like ???_DOWN_MASK for keyboard and mouse after the event.

   944  * The modifiers on a Java key event reflect the state of the modifier keys

   945  * immediately AFTER the key press or release.  This usually doesn't require

   946  * us to change the modifiers: the exception is when the key pressed or

   947  * released is a modifier key.  Since the state of an XEvent represents

   948  * the modifiers BEFORE the event, we change the modifiers according to

   949  * the button and keycode.

   950  */

   951 jint

   952 getModifiers(uint32_t state, jint button, jint keyCode)

   953 {

   954     jint modifiers = 0;

   955 

   956     if (((state & ShiftMask) != 0) ^ (keyCode == java_awt_event_KeyEvent_VK_SHIFT))

   957     {

   958         modifiers |= java_awt_event_InputEvent_SHIFT_DOWN_MASK;

   959     }

   960     if (((state & ControlMask) != 0) ^ (keyCode == java_awt_event_KeyEvent_VK_CONTROL))

   961     {

   962         modifiers |= java_awt_event_InputEvent_CTRL_DOWN_MASK;

   963     }

   964     if (((state & awt_MetaMask) != 0) ^ (keyCode == java_awt_event_KeyEvent_VK_META))

   965     {

   966         modifiers |= java_awt_event_InputEvent_META_DOWN_MASK;

   967     }

   968     if (((state & awt_AltMask) != 0) ^ (keyCode == java_awt_event_KeyEvent_VK_ALT))

   969     {

   970         modifiers |= java_awt_event_InputEvent_ALT_DOWN_MASK;

   971     }

   972     if (((state & awt_ModeSwitchMask) != 0) ^ (keyCode == java_awt_event_KeyEvent_VK_ALT_GRAPH))

   973     {

   974         modifiers |= java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK;

   975     }

   976     if (((state & Button1Mask) != 0) ^ (button == java_awt_event_MouseEvent_BUTTON1)) {

   977         modifiers |= java_awt_event_InputEvent_BUTTON1_DOWN_MASK;

   978     }

   979     if (((state & Button2Mask) != 0) ^ (button == java_awt_event_MouseEvent_BUTTON2)) {

   980         modifiers |= java_awt_event_InputEvent_BUTTON2_DOWN_MASK;

   981     }

   982     if (((state & Button3Mask) != 0) ^ (button == java_awt_event_MouseEvent_BUTTON3)) {

   983         modifiers |= java_awt_event_InputEvent_BUTTON3_DOWN_MASK;

   984     }

   985     return modifiers;

   986 }

   987 

   988 /* Returns which mouse button has changed state

   989  */

   990 jint

   991 getButton(uint32_t button)

   992 {

   993     switch (button) {

   994     case Button1:

   995         return java_awt_event_MouseEvent_BUTTON1;

   996     case Button2:

   997         return java_awt_event_MouseEvent_BUTTON2;

   998     case Button3:

   999         return java_awt_event_MouseEvent_BUTTON3;

  1000     }

  1001     return java_awt_event_MouseEvent_NOBUTTON;

  1002 }

  1003 

  1004 

  1005 /* This function changes the state of the native XEvent AFTER

  1006  * the corresponding Java event has been processed.  The XEvent

  1007  * needs to be modified before it is dispatched to the native widget.

  1008  */

  1009 void

  1010 awt_modify_KeyEvent(JNIEnv *env, XEvent *xevent, jobject jevent)

  1011 {

  1012     jint keyCode;

  1013     jchar keyChar;

  1014     jint modifiers;

  1015     KeySym keysym = (KeySym) java_awt_event_KeyEvent_CHAR_UNDEFINED;

  1016 

  1017     if (xevent->type != KeyPress && xevent->type != KeyRelease) {

  1018         return;

  1019     }

  1020 

  1021     keyCode = (*env)->GetIntField(env, jevent, keyEventIDs.keyCode);

  1022     keyChar = (*env)->GetCharField(env, jevent, keyEventIDs.keyChar);

  1023     modifiers = (*env)->GetIntField(env, jevent, inputEventIDs.modifiers);

  1024 

  1025     switch (keyCode) {

  1026         case java_awt_event_KeyEvent_VK_MULTIPLY:

  1027         case java_awt_event_KeyEvent_VK_SUBTRACT:

  1028         case java_awt_event_KeyEvent_VK_DIVIDE:

  1029             /* Bugid 4103229:  Change the X event so these three Numpad

  1030              * keys work with the NumLock off.  For some reason, Motif

  1031              * widgets ignore the events produced by these three keys

  1032              * unless the NumLock is on.  It also ignores them if some

  1033              * other modifiers are set.  Turn off ALL modifiers, then

  1034              * turn NumLock mask on in the X event.

  1035              */

  1036             xevent->xkey.state = awt_NumLockMask;

  1037             return;

  1038         case java_awt_event_KeyEvent_VK_ENTER:

  1039         case java_awt_event_KeyEvent_VK_BACK_SPACE:

  1040         case java_awt_event_KeyEvent_VK_TAB:

  1041         case java_awt_event_KeyEvent_VK_ESCAPE:

  1042         case java_awt_event_KeyEvent_VK_ADD:

  1043         case java_awt_event_KeyEvent_VK_DECIMAL:

  1044         case java_awt_event_KeyEvent_VK_NUMPAD0:

  1045         case java_awt_event_KeyEvent_VK_NUMPAD1:

  1046         case java_awt_event_KeyEvent_VK_NUMPAD2:

  1047         case java_awt_event_KeyEvent_VK_NUMPAD3:

  1048         case java_awt_event_KeyEvent_VK_NUMPAD4:

  1049         case java_awt_event_KeyEvent_VK_NUMPAD5:

  1050         case java_awt_event_KeyEvent_VK_NUMPAD6:

  1051         case java_awt_event_KeyEvent_VK_NUMPAD7:

  1052         case java_awt_event_KeyEvent_VK_NUMPAD8:

  1053         case java_awt_event_KeyEvent_VK_NUMPAD9:

  1054             keysym = awt_getX11KeySym(keyCode);

  1055             break;

  1056         case java_awt_event_KeyEvent_VK_DELETE:

  1057             /* For some reason XKeysymToKeycode returns incorrect value for

  1058              * Delete, so we don't want to modify the original event

  1059              */

  1060             break;

  1061         default:

  1062             if (keyChar < (KeySym) 256) {

  1063                 keysym = (KeySym) keyChar;

  1064             } else {

  1065                 keysym = awt_getX11KeySym(keyCode);

  1066             }

  1067             break;

  1068     }

  1069 

  1070     if (keysym < (KeySym) 256) {

  1071         if (modifiers & java_awt_event_InputEvent_CTRL_MASK) {

  1072             switch (keysym + 64) {

  1073                 case '[':

  1074                 case ']':

  1075                 case '\\':

  1076                 case '_':

  1077                     keysym += 64;

  1078                     break;

  1079                 default:

  1080                     if (isalpha((int32_t)(keysym + 'a' - 1))) {

  1081                         keysym += ('a' - 1);

  1082                     }

  1083                     break;

  1084             }

  1085         }

  1086         /*

  1087          * 0xff61 is Unicode value of first XK_kana_fullstop.

  1088          * We need X Keysym to Unicode map in post1.1 release

  1089          * to support more international keyboards.

  1090          */

  1091         if (keysym >= (KeySym) 0xff61 && keysym <= (KeySym) 0xff9f) {

  1092             keysym = keysym - 0xff61 + XK_kana_fullstop;

  1093         }

  1094         xevent->xkey.keycode = XKeysymToKeycode(awt_display, keysym);

  1095     }

  1096 

  1097     if (keysym >= 'A' && keysym <= 'Z') {

  1098         xevent->xkey.state |= ShiftMask;

  1099     }

  1100     if (modifiers & java_awt_event_InputEvent_SHIFT_DOWN_MASK) {

  1101         xevent->xkey.state |= ShiftMask;

  1102     }

  1103     if (modifiers & java_awt_event_InputEvent_CTRL_DOWN_MASK) {

  1104         xevent->xkey.state |= ControlMask;

  1105     }

  1106     if (modifiers & java_awt_event_InputEvent_META_DOWN_MASK) {

  1107         xevent->xkey.state |= awt_MetaMask;

  1108     }

  1109     if (modifiers & java_awt_event_InputEvent_ALT_DOWN_MASK) {

  1110         xevent->xkey.state |= awt_AltMask;

  1111     }

  1112     if (modifiers & java_awt_event_InputEvent_ALT_GRAPH_DOWN_MASK) {

  1113         xevent->xkey.state |= awt_ModeSwitchMask;

  1114     }

  1115     if (modifiers & java_awt_event_InputEvent_BUTTON1_DOWN_MASK) {

  1116         xevent->xkey.state |= Button1Mask;

  1117     }

  1118     if (modifiers & java_awt_event_InputEvent_BUTTON2_DOWN_MASK) {

  1119         xevent->xkey.state |= Button2Mask;

  1120     }

  1121     if (modifiers & java_awt_event_InputEvent_BUTTON3_DOWN_MASK) {

  1122         xevent->xkey.state |= Button3Mask;

  1123     }

  1124 }

  1125 

  1126 

  1127 /* Called from handleKeyEvent.  The purpose of this function is

  1128  * to check for a list of vendor-specific keysyms, most of which

  1129  * have values greater than 0xFFFF.  Most of these keys don't map

  1130  * to unicode characters, but some do.

  1131  *

  1132  * For keys that don't map to unicode characters, the keysym

  1133  * is irrelevant at this point.  We set the keysym to zero

  1134  * to ensure that the switch statement immediately below