[Vm-dev] [commit] r2293 - Provisional check-in of X11 changes for
percolating up meta key events (control,
commits at squeakvm.org
commits at squeakvm.org
Fri Sep 10 21:24:14 UTC 2010
Author: eliot
Date: 2010-09-10 14:24:14 -0700 (Fri, 10 Sep 2010)
New Revision: 2293
Modified:
branches/Cog/platforms/unix/vm-display-X11/sqUnixX11.c
branches/Cog/platforms/unix/vm/sqUnixEvent.c
Log:
Provisional check-in of X11 changes for percolating up meta key events (control,
shift et al)
Modified: branches/Cog/platforms/unix/vm/sqUnixEvent.c
===================================================================
--- branches/Cog/platforms/unix/vm/sqUnixEvent.c 2010-09-09 18:10:20 UTC (rev 2292)
+++ branches/Cog/platforms/unix/vm/sqUnixEvent.c 2010-09-10 21:24:14 UTC (rev 2293)
@@ -34,6 +34,22 @@
* NOTE: this file is included by the window support files that need it.
*/
+#if defined(DEBUG_EVENTS)
+# undef DEBUG_EVENTS
+# define DEBUG_EVENTS 1
+# define DEBUG_KEYBOARD_EVENTS 1
+# define DEBUG_MOUSE_EVENTS 1
+#else
+# if defined(DEBUG_KEYBOARD_EVENTS)
+# undef DEBUG_KEYBOARD_EVENTS
+# define DEBUG_KEYBOARD_EVENTS 1
+# endif
+# if defined(DEBUG_MOUSE_EVENTS)
+# undef DEBUG_MOUSE_EVENTS
+# define DEBUG_MOUSE_EVENTS 1
+# endif
+#endif
+
#define IEB_SIZE 64 /* must be power of 2 */
typedef struct
@@ -55,7 +71,7 @@
int buttonState= 0; /* mouse button state or 0 if not pressed */
int modifierState= 0; /* modifier key state or 0 if none pressed */
-#if defined(DEBUG_EVENTS) || defined(DEBUG_KEYBOARD_EVENTS)
+#if DEBUG_EVENTS || DEBUG_KEYBOARD_EVENTS || DEBUG_MOUSE_EVENTS
#include <ctype.h>
@@ -79,7 +95,7 @@
if (midofiers & OptionKeyBit) printf(" Option");
}
-#endif
+#endif /* DEBUG_KEYBOARD_EVENTS || DEBUG_MOUSE_EVENTS */
static sqInputEvent *allocateInputEvent(int eventType)
@@ -131,7 +147,7 @@
case CommandKeyBit: buttons= blue; modifiers &= ~CommandKeyBit; break;
}
}
-#ifdef DEBUG_EVENTS
+#if DEBUG_MOUSE_EVENTS
printf("BUTTONS");
printModifiers(modifiers);
printButtons(buttons);
@@ -143,7 +159,7 @@
static void signalInputEvent(void)
{
-#ifdef DEBUG_EVENTS
+#if DEBUG_EVENTS
printf("signalInputEvent\n");
#endif
if (inputEventSemaIndex > 0)
@@ -162,7 +178,7 @@
evt->nrClicks=
evt->windowIndex= 0;
signalInputEvent();
-#ifdef DEBUG_EVENTS
+#if DEBUG_MOUSE_EVENTS
printf("EVENT: mouse (%d,%d)", mousePosition.x, mousePosition.y);
printModifiers(state >> 3);
printButtons(state & 7);
@@ -182,7 +198,7 @@
evt->reserved1=
evt->windowIndex= 0;
signalInputEvent();
-#if defined(DEBUG_EVENTS) || defined(DEBUG_KEYBOARD_EVENTS)
+#if DEBUG_KEYBOARD_EVENTS
printf("EVENT: key");
switch (pressCode)
{
@@ -209,7 +225,7 @@
evt->numFiles= numFiles;
evt->windowIndex= 0;
signalInputEvent();
-#ifdef DEBUG_EVENTS
+#if DEBUG_EVENTS
printf("EVENT: drag (%d,%d)", mousePosition.x, mousePosition.y);
printModifiers(state >> 3);
printButtons(state & 7);
@@ -228,7 +244,7 @@
evt->value4= v4;
evt->windowIndex= windowIndex;
signalInputEvent();
-#ifdef DEBUG_EVENTS
+#if DEBUG_EVENTS
printf("EVENT: window (%d %d %d %d %d %d) ", action, v1, v2, v3, v4, 0);
switch (action)
{
@@ -275,7 +291,7 @@
if (inputEventSemaIndex == 0)
{
int keystate= keyCode | (modifierState << 8);
-# ifdef DEBUG_EVENTS
+# if DEBUG_KEYBOARD_EVENTS
printf("RECORD keystroke");
printModifiers(modifierState);
printKey(keyCode);
Modified: branches/Cog/platforms/unix/vm-display-X11/sqUnixX11.c
===================================================================
--- branches/Cog/platforms/unix/vm-display-X11/sqUnixX11.c 2010-09-09 18:10:20 UTC (rev 2292)
+++ branches/Cog/platforms/unix/vm-display-X11/sqUnixX11.c 2010-09-10 21:24:14 UTC (rev 2293)
@@ -27,8 +27,6 @@
/* Author: Ian Piumarta <ian.piumarta at squeakland.org>
*
- * Last edited: 2009-09-02 15:10:16 by piumarta on ubuntu.piumarta.com
- *
* Support for more intelligent CLIPBOARD selection handling contributed by:
* Ned Konz <ned at bike-nomad.com>
*
@@ -74,14 +72,16 @@
#define SQ_FORM_FILENAME "squeak-form.ppm"
#undef FULL_UPDATE_ON_EXPOSE
-#undef DEBUG_FOCUS
-#undef DEBUG_XIM
-#undef DEBUG_CONV
-#undef DEBUG_EVENTS
-#undef DEBUG_SELECTIONS
-#undef DEBUG_BROWSER
-#undef DEBUG_WINDOW
-#undef DEBUG_VISUAL
+#if 0 /* The following is a pain. Leave it to the command line. */
+# undef DEBUG_FOCUS
+# undef DEBUG_XIM
+# undef DEBUG_CONV
+# undef DEBUG_EVENTS
+# undef DEBUG_SELECTIONS
+# undef DEBUG_BROWSER
+# undef DEBUG_WINDOW
+# undef DEBUG_VISUAL
+#endif
#define USE_XICFONT_OPTION
#undef USE_XICFONT_RESOURCE
@@ -322,6 +322,15 @@
#include "sqUnixEvent.c"
+#ifdef DEBUG_CONV
+# define DCONV_PRINTF(...) printf(__VA_ARGS__)
+# define DCONV_FPRINTF(...) fprintf(stderr,__VA_ARGS__)
+#else
+# define DCONV_PRINTF(...) 0
+# define DCONV_FPRINTF(...) 0
+#endif
+
+
#define SqueakWhite 0
#define SqueakBlack 1
@@ -434,7 +443,7 @@
static void getSelection(void);
static char *getSelectionData(Atom selection, Atom target, size_t *bytes);
static char *getSelectionFrom(Atom source);
-static int translateCode(KeySym symbolic);
+static int translateCode(KeySym symbolic, int *modp, XKeyEvent *evt);
#if defined(USE_XSHM)
int XShmGetEventBase(Display *);
@@ -1367,7 +1376,7 @@
(char *)out, sizeof(out),
sqTextEncoding, 0, 1))
charCode= out[0];
-# if defined(DEBUG_EVENTS)
+# if DEBUG_KEYBOARD_EVENTS
fprintf(stderr, " 8-bit: %d=%02x [%c->%c]\n", charCode, charCode,
(char *)uxXWinEncoding, (char *)sqTextEncoding);
# endif
@@ -1777,9 +1786,7 @@
return key;
}
-#if defined(DEBUG_CONV)
- printf("keycode %u\n", xevt->keycode);
-#endif
+ DCONV_PRINTF("keycode %u\n", xevt->keycode);
{
char string[128]; /* way too much */
@@ -1788,34 +1795,22 @@
switch (status)
{
case XLookupNone: /* still composing */
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupNone\n");
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupNone\n");
return -1;
case XLookupChars:
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupChars count %d\n", count);
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupChars count %d\n", count);
case XLookupBoth:
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupBoth count %d\n", count);
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupBoth count %d\n", count);
lastKey= (count ? recode(string[0]) : -1);
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey == %d\n", lastKey);
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey == %d\n", lastKey);
return lastKey;
case XLookupKeySym:
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupKeySym\n");
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupKeySym\n");
{
- int charCode= translateCode(*symbolic);
-# if defined(DEBUG_CONV)
- printf("SYM %d -> %d\n", symbolic, charCode);
-# endif
+ int charCode= translateCode(*symbolic, 0, xevt);
+ DCONV_FPRINTF("SYM %d -> %d\n", symbolic, charCode);
if (charCode < 0)
return -1; /* unknown key */
if ((charCode == 127) && mapDelBs)
@@ -1855,9 +1850,7 @@
return key;
}
-#if defined(DEBUG_CONV)
- fprintf(stderr, "keycode %u\n", xevt->keycode);
-#endif
+ DCONV_FPRINTF(stderr, "keycode %u\n", xevt->keycode);
{
Status status;
@@ -1902,19 +1895,13 @@
switch (status)
{
case XLookupNone: /* still composing */
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupNone\n");
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupNone\n");
return -1;
case XLookupChars:
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupChars count %d\n", inputCount);
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupChars count %d\n", inputCount);
case XLookupBoth:
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupBoth count %d\n", inputCount);
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupBoth count %d\n", inputCount);
if (inputCount == 0)
return lastKey= -1;
else if (inputCount == 1)
@@ -1945,25 +1932,19 @@
}
case XLookupKeySym:
-# if defined(DEBUG_CONV)
- fprintf(stderr, "x2sqKey XLookupKeySym\n");
-# endif
+ DCONV_FPRINTF(stderr, "x2sqKey XLookupKeySym\n");
{
int charCode;
if (*symbolic == XK_Multi_key)
{
multi_key_pressed= 1;
multi_key_buffer= 0;
-# ifdef DEBUG_CONV
- fprintf(stderr, "multi_key was pressed\n");
-# endif
+ DCONV_FPRINTF(stderr, "multi_key was pressed\n");
return -1;
}
- charCode= translateCode(*symbolic);
-# if defined(DEBUG_CONV)
- printf("SYM %x -> %d\n", *symbolic, charCode);
-# endif
+ charCode= translateCode(*symbolic, 0, xevt);
+ DCONV_PRINTF("SYM %x -> %d\n", *symbolic, charCode);
if (charCode < 0)
return -1; /* unknown key */
if ((charCode == 127) && mapDelBs)
@@ -1979,25 +1960,32 @@
}
}
+#if DEBUG_KEYBOARD_EVENTS
+static const char *nameForKeycode(int keycode);
+#endif
+
static int x2sqKeyPlain(XKeyEvent *xevt, KeySym *symbolic)
{
unsigned char buf[32];
int nConv= XLookupString(xevt, (char *)buf, sizeof(buf), symbolic, 0);
int charCode= buf[0];
-#if defined(DEBUG_EVENTS)
- fprintf(stderr, "convert keycode %d=%02x -> %d=%02x (keysym %ld)\n",
- xevt->keycode, xevt->keycode, charCode, charCode, symbolic);
+#if DEBUG_KEYBOARD_EVENTS
+ int i;
+ fprintf(stderr, "convert keycode");
+ for (i = 0; i < nConv; i++) {
+ if (!i) fprintf(stderr, " [");
+ fprintf(stderr, "%d(%02x)%c", buf[i], buf[i], i + 1 < nConv ? ',' : ']');
+ }
+ fprintf(stderr, " %d(%02x) -> %d(%02x) (keysym %p %s)\n",
+ xevt->keycode, xevt->keycode, charCode, charCode, symbolic, nameForKeycode(*symbolic));
#endif
- if (nConv == 0 && (charCode= translateCode(*symbolic)) < 0)
- return -1; /* unknown key */
+ if (!nConv && (charCode= translateCode(*symbolic, &modifierState, xevt)) < 0)
+ return -1; /* unknown key */
if ((charCode == 127) && mapDelBs)
charCode= 8;
- if (charCode > 256) /* ALT+?? */
- {
- modifierState= charCode >> 8;
- charCode &= 0xff;
- }
- return recode(charCode);
+ return nConv == 0 && (modifierState & (CommandKeyBit+CtrlKeyBit+OptionKeyBit))
+ ? charCode
+ : recode(charCode);
}
@@ -2330,7 +2318,7 @@
| (ctrl ? CtrlKeyBit : 0)
| (cmd ? CommandKeyBit : 0)
| (opt ? OptionKeyBit : 0);
-# if defined(DEBUG_EVENTS)
+# if DEBUG_KEYBOARD_EVENTS || DEBUG_MOUSE_EVENTS
fprintf(stderr, "X mod %x -> Sq mod %x (extended opt=%d cmd=%d)\n", state, mods,
optMapIndex, cmdMapIndex);
# endif
@@ -2355,7 +2343,8 @@
# else
mods= midofiers[state & 0x0f];
# endif
-# if defined(DEBUG_EVENTS)
+# if DEBUG_KEYBOARD_EVENTS || DEBUG_MOUSE_EVENTS
+ if (mods)
fprintf(stderr, "X mod %x -> Sq mod %x (default)\n", state & 0xf, mods);
# endif
}
@@ -2434,9 +2423,1018 @@
}
+#if DEBUG_KEYBOARD_EVENTS
+/*
+grep '^#[ ]*define[ ][ ]*XK_.*0x[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][^0-9a-fA-F]' /usr/include/X11/*.h | sed 's/^.*\(XK_[^ ]*\)[ ]*\(0x[0-9a-fA-F]*\).*$/{ "\1", \2 }, /'
+*/
+typedef struct { char *name; int code; } KeyNameEntry;
+static KeyNameEntry codes[] = {
+{ "XK_BackSpace", 0xff08 },
+{ "XK_Linefeed", 0xff0a },
+{ "XK_Return", 0xff0d },
+{ "XK_Pause", 0xff13 },
+{ "XK_Delete", 0xffff },
+{ "XK_Multi_key", 0xff20 },
+{ "XK_Kanji", 0xff21 },
+{ "XK_Muhenkan", 0xff22 },
+{ "XK_Henkan_Mode", 0xff23 },
+{ "XK_Henkan", 0xff23 },
+{ "XK_Romaji", 0xff24 },
+{ "XK_Hiragana", 0xff25 },
+{ "XK_Katakana", 0xff26 },
+{ "XK_Hiragana_Katakana", 0xff27 },
+{ "XK_Zenkaku", 0xff28 },
+{ "XK_Hankaku", 0xff29 },
+{ "XK_Zenkaku_Hankaku", 0xff2a },
+{ "XK_Touroku", 0xff2b },
+{ "XK_Massyo", 0xff2c },
+{ "XK_Kana_Lock", 0xff2d },
+{ "XK_Kana_Shift", 0xff2e },
+{ "XK_Eisu_Shift", 0xff2f },
+{ "XK_Eisu_toggle", 0xff30 },
+{ "XK_Kanji_Bangou", 0xff37 },
+{ "XK_Zen_Koho", 0xff3d },
+{ "XK_Mae_Koho", 0xff3e },
+{ "XK_Left", 0xff51 },
+{ "XK_Up", 0xff52 },
+{ "XK_Right", 0xff53 },
+{ "XK_Down", 0xff54 },
+{ "XK_Prior", 0xff55 },
+{ "XK_Next", 0xff56 },
+{ "XK_End", 0xff57 },
+{ "XK_Begin", 0xff58 },
+{ "XK_Select", 0xff60 },
+{ "XK_Execute", 0xff62 },
+{ "XK_Insert", 0xff63 },
+{ "XK_Redo", 0xff66 },
+{ "XK_Find", 0xff68 },
+{ "XK_Cancel", 0xff69 },
+{ "XK_Help", 0xff6a },
+{ "XK_Mode_switch", 0xff7e },
+{ "XK_script_switch", 0xff7e },
+{ "XK_KP_Space", 0xff80 },
+{ "XK_KP_Enter", 0xff8d },
+{ "XK_KP_F1", 0xff91 },
+{ "XK_KP_Equal", 0xffbd },
+{ "XK_KP_Separator", 0xffac },
+{ "XK_Shift_L", 0xffe1 },
+{ "XK_Shift_R", 0xffe2 },
+{ "XK_Control_L", 0xffe3 },
+{ "XK_Control_R", 0xffe4 },
+{ "XK_Caps_Lock", 0xffe5 },
+{ "XK_Shift_Lock", 0xffe6 },
+{ "XK_Meta_L", 0xffe7 },
+{ "XK_Meta_R", 0xffe8 },
+{ "XK_Alt_L", 0xffe9 },
+{ "XK_Alt_R", 0xffea },
+{ "XK_Super_L", 0xffeb },
+{ "XK_Super_R", 0xffec },
+{ "XK_Hyper_L", 0xffed },
+{ "XK_Hyper_R", 0xffee },
+{ "XK_ISO_Group_Shift", 0xff7e },
+{ "XK_space", 0x0020 },
+{ "XK_exclam", 0x0021 },
+{ "XK_quotedbl", 0x0022 },
+{ "XK_numbersign", 0x0023 },
+{ "XK_dollar", 0x0024 },
+{ "XK_percent", 0x0025 },
+{ "XK_ampersand", 0x0026 },
+{ "XK_apostrophe", 0x0027 },
+{ "XK_quoteright", 0x0027 },
+{ "XK_parenleft", 0x0028 },
+{ "XK_parenright", 0x0029 },
+{ "XK_asterisk", 0x002a },
+{ "XK_plus", 0x002b },
+{ "XK_comma", 0x002c },
+{ "XK_minus", 0x002d },
+{ "XK_period", 0x002e },
+{ "XK_slash", 0x002f },
+{ "XK_0", 0x0030 },
+{ "XK_1", 0x0031 },
+{ "XK_2", 0x0032 },
+{ "XK_3", 0x0033 },
+{ "XK_4", 0x0034 },
+{ "XK_5", 0x0035 },
+{ "XK_6", 0x0036 },
+{ "XK_7", 0x0037 },
+{ "XK_8", 0x0038 },
+{ "XK_9", 0x0039 },
+{ "XK_colon", 0x003a },
+{ "XK_semicolon", 0x003b },
+{ "XK_less", 0x003c },
+{ "XK_equal", 0x003d },
+{ "XK_greater", 0x003e },
+{ "XK_question", 0x003f },
+{ "XK_at", 0x0040 },
+{ "XK_A", 0x0041 },
+{ "XK_B", 0x0042 },
+{ "XK_C", 0x0043 },
+{ "XK_D", 0x0044 },
+{ "XK_E", 0x0045 },
+{ "XK_F", 0x0046 },
+{ "XK_G", 0x0047 },
+{ "XK_H", 0x0048 },
+{ "XK_I", 0x0049 },
+{ "XK_J", 0x004a },
+{ "XK_K", 0x004b },
+{ "XK_L", 0x004c },
+{ "XK_M", 0x004d },
+{ "XK_N", 0x004e },
+{ "XK_O", 0x004f },
+{ "XK_P", 0x0050 },
+{ "XK_Q", 0x0051 },
+{ "XK_R", 0x0052 },
+{ "XK_S", 0x0053 },
+{ "XK_T", 0x0054 },
+{ "XK_U", 0x0055 },
+{ "XK_V", 0x0056 },
+{ "XK_W", 0x0057 },
+{ "XK_X", 0x0058 },
+{ "XK_Y", 0x0059 },
+{ "XK_Z", 0x005a },
+{ "XK_bracketleft", 0x005b },
+{ "XK_backslash", 0x005c },
+{ "XK_bracketright", 0x005d },
+{ "XK_asciicircum", 0x005e },
+{ "XK_underscore", 0x005f },
+{ "XK_grave", 0x0060 },
+{ "XK_quoteleft", 0x0060 },
+{ "XK_a", 0x0061 },
+{ "XK_b", 0x0062 },
+{ "XK_c", 0x0063 },
+{ "XK_d", 0x0064 },
+{ "XK_e", 0x0065 },
+{ "XK_f", 0x0066 },
+{ "XK_g", 0x0067 },
+{ "XK_h", 0x0068 },
+{ "XK_i", 0x0069 },
+{ "XK_j", 0x006a },
+{ "XK_k", 0x006b },
+{ "XK_l", 0x006c },
+{ "XK_m", 0x006d },
+{ "XK_n", 0x006e },
+{ "XK_o", 0x006f },
+{ "XK_p", 0x0070 },
+{ "XK_q", 0x0071 },
+{ "XK_r", 0x0072 },
+{ "XK_s", 0x0073 },
+{ "XK_t", 0x0074 },
+{ "XK_u", 0x0075 },
+{ "XK_v", 0x0076 },
+{ "XK_w", 0x0077 },
+{ "XK_x", 0x0078 },
+{ "XK_y", 0x0079 },
+{ "XK_z", 0x007a },
+{ "XK_braceleft", 0x007b },
+{ "XK_bar", 0x007c },
+{ "XK_braceright", 0x007d },
+{ "XK_asciitilde", 0x007e },
+{ "XK_nobreakspace", 0x00a0 },
+{ "XK_exclamdown", 0x00a1 },
+{ "XK_cent", 0x00a2 },
+{ "XK_sterling", 0x00a3 },
+{ "XK_currency", 0x00a4 },
+{ "XK_yen", 0x00a5 },
+{ "XK_brokenbar", 0x00a6 },
+{ "XK_section", 0x00a7 },
+{ "XK_diaeresis", 0x00a8 },
+{ "XK_copyright", 0x00a9 },
+{ "XK_ordfeminine", 0x00aa },
+{ "XK_guillemotleft", 0x00ab },
+{ "XK_notsign", 0x00ac },
+{ "XK_hyphen", 0x00ad },
+{ "XK_registered", 0x00ae },
+{ "XK_macron", 0x00af },
+{ "XK_degree", 0x00b0 },
+{ "XK_plusminus", 0x00b1 },
+{ "XK_twosuperior", 0x00b2 },
+{ "XK_threesuperior", 0x00b3 },
+{ "XK_acute", 0x00b4 },
+{ "XK_mu", 0x00b5 },
+{ "XK_paragraph", 0x00b6 },
+{ "XK_periodcentered", 0x00b7 },
+{ "XK_cedilla", 0x00b8 },
+{ "XK_onesuperior", 0x00b9 },
+{ "XK_masculine", 0x00ba },
+{ "XK_guillemotright", 0x00bb },
+{ "XK_onequarter", 0x00bc },
+{ "XK_onehalf", 0x00bd },
+{ "XK_threequarters", 0x00be },
+{ "XK_questiondown", 0x00bf },
+{ "XK_Agrave", 0x00c0 },
+{ "XK_Aacute", 0x00c1 },
+{ "XK_Acircumflex", 0x00c2 },
+{ "XK_Atilde", 0x00c3 },
+{ "XK_Adiaeresis", 0x00c4 },
+{ "XK_Aring", 0x00c5 },
+{ "XK_AE", 0x00c6 },
+{ "XK_Ccedilla", 0x00c7 },
+{ "XK_Egrave", 0x00c8 },
+{ "XK_Eacute", 0x00c9 },
+{ "XK_Ecircumflex", 0x00ca },
+{ "XK_Ediaeresis", 0x00cb },
+{ "XK_Igrave", 0x00cc },
+{ "XK_Iacute", 0x00cd },
+{ "XK_Icircumflex", 0x00ce },
+{ "XK_Idiaeresis", 0x00cf },
+{ "XK_ETH", 0x00d0 },
+{ "XK_Eth", 0x00d0 },
+{ "XK_Ntilde", 0x00d1 },
+{ "XK_Ograve", 0x00d2 },
+{ "XK_Oacute", 0x00d3 },
+{ "XK_Ocircumflex", 0x00d4 },
+{ "XK_Otilde", 0x00d5 },
+{ "XK_Odiaeresis", 0x00d6 },
+{ "XK_multiply", 0x00d7 },
+{ "XK_Oslash", 0x00d8 },
+{ "XK_Ooblique", 0x00d8 },
+{ "XK_Ugrave", 0x00d9 },
+{ "XK_Uacute", 0x00da },
+{ "XK_Ucircumflex", 0x00db },
+{ "XK_Udiaeresis", 0x00dc },
+{ "XK_Yacute", 0x00dd },
+{ "XK_THORN", 0x00de },
+{ "XK_Thorn", 0x00de },
+{ "XK_ssharp", 0x00df },
+{ "XK_agrave", 0x00e0 },
+{ "XK_aacute", 0x00e1 },
+{ "XK_acircumflex", 0x00e2 },
+{ "XK_atilde", 0x00e3 },
+{ "XK_adiaeresis", 0x00e4 },
+{ "XK_aring", 0x00e5 },
+{ "XK_ae", 0x00e6 },
+{ "XK_ccedilla", 0x00e7 },
+{ "XK_egrave", 0x00e8 },
+{ "XK_eacute", 0x00e9 },
+{ "XK_ecircumflex", 0x00ea },
+{ "XK_ediaeresis", 0x00eb },
+{ "XK_igrave", 0x00ec },
+{ "XK_iacute", 0x00ed },
+{ "XK_icircumflex", 0x00ee },
+{ "XK_idiaeresis", 0x00ef },
+{ "XK_eth", 0x00f0 },
+{ "XK_ntilde", 0x00f1 },
+{ "XK_ograve", 0x00f2 },
+{ "XK_oacute", 0x00f3 },
+{ "XK_ocircumflex", 0x00f4 },
+{ "XK_otilde", 0x00f5 },
+{ "XK_odiaeresis", 0x00f6 },
+{ "XK_division", 0x00f7 },
+{ "XK_oslash", 0x00f8 },
+{ "XK_ooblique", 0x00f8 },
+{ "XK_ugrave", 0x00f9 },
+{ "XK_uacute", 0x00fa },
+{ "XK_ucircumflex", 0x00fb },
+{ "XK_udiaeresis", 0x00fc },
+{ "XK_yacute", 0x00fd },
+{ "XK_thorn", 0x00fe },
+{ "XK_ydiaeresis", 0x00ff },
+{ "XK_Aogonek", 0x01a1 },
+{ "XK_breve", 0x01a2 },
+{ "XK_Lstroke", 0x01a3 },
+{ "XK_Lcaron", 0x01a5 },
+{ "XK_Sacute", 0x01a6 },
+{ "XK_Scaron", 0x01a9 },
+{ "XK_Scedilla", 0x01aa },
+{ "XK_Tcaron", 0x01ab },
+{ "XK_Zacute", 0x01ac },
+{ "XK_Zcaron", 0x01ae },
+{ "XK_Zabovedot", 0x01af },
+{ "XK_aogonek", 0x01b1 },
+{ "XK_ogonek", 0x01b2 },
+{ "XK_lstroke", 0x01b3 },
+{ "XK_lcaron", 0x01b5 },
+{ "XK_sacute", 0x01b6 },
+{ "XK_caron", 0x01b7 },
+{ "XK_scaron", 0x01b9 },
+{ "XK_scedilla", 0x01ba },
+{ "XK_tcaron", 0x01bb },
+{ "XK_zacute", 0x01bc },
+{ "XK_doubleacute", 0x01bd },
+{ "XK_zcaron", 0x01be },
+{ "XK_zabovedot", 0x01bf },
+{ "XK_Racute", 0x01c0 },
+{ "XK_Abreve", 0x01c3 },
+{ "XK_Lacute", 0x01c5 },
+{ "XK_Cacute", 0x01c6 },
+{ "XK_Ccaron", 0x01c8 },
+{ "XK_Eogonek", 0x01ca },
+{ "XK_Ecaron", 0x01cc },
+{ "XK_Dcaron", 0x01cf },
+{ "XK_Dstroke", 0x01d0 },
+{ "XK_Nacute", 0x01d1 },
+{ "XK_Ncaron", 0x01d2 },
+{ "XK_Odoubleacute", 0x01d5 },
+{ "XK_Rcaron", 0x01d8 },
+{ "XK_Uring", 0x01d9 },
+{ "XK_Udoubleacute", 0x01db },
+{ "XK_Tcedilla", 0x01de },
+{ "XK_racute", 0x01e0 },
+{ "XK_abreve", 0x01e3 },
+{ "XK_lacute", 0x01e5 },
+{ "XK_cacute", 0x01e6 },
+{ "XK_ccaron", 0x01e8 },
+{ "XK_eogonek", 0x01ea },
+{ "XK_ecaron", 0x01ec },
+{ "XK_dcaron", 0x01ef },
+{ "XK_dstroke", 0x01f0 },
+{ "XK_nacute", 0x01f1 },
+{ "XK_ncaron", 0x01f2 },
+{ "XK_odoubleacute", 0x01f5 },
+{ "XK_udoubleacute", 0x01fb },
+{ "XK_rcaron", 0x01f8 },
+{ "XK_uring", 0x01f9 },
+{ "XK_tcedilla", 0x01fe },
+{ "XK_abovedot", 0x01ff },
+{ "XK_Hstroke", 0x02a1 },
+{ "XK_Hcircumflex", 0x02a6 },
+{ "XK_Iabovedot", 0x02a9 },
+{ "XK_Gbreve", 0x02ab },
+{ "XK_Jcircumflex", 0x02ac },
+{ "XK_hstroke", 0x02b1 },
+{ "XK_hcircumflex", 0x02b6 },
+{ "XK_idotless", 0x02b9 },
+{ "XK_gbreve", 0x02bb },
+{ "XK_jcircumflex", 0x02bc },
+{ "XK_Cabovedot", 0x02c5 },
+{ "XK_Ccircumflex", 0x02c6 },
+{ "XK_Gabovedot", 0x02d5 },
+{ "XK_Gcircumflex", 0x02d8 },
+{ "XK_Ubreve", 0x02dd },
+{ "XK_Scircumflex", 0x02de },
+{ "XK_cabovedot", 0x02e5 },
+{ "XK_ccircumflex", 0x02e6 },
+{ "XK_gabovedot", 0x02f5 },
+{ "XK_gcircumflex", 0x02f8 },
+{ "XK_ubreve", 0x02fd },
+{ "XK_scircumflex", 0x02fe },
+{ "XK_kra", 0x03a2 },
+{ "XK_kappa", 0x03a2 },
+{ "XK_Rcedilla", 0x03a3 },
+{ "XK_Itilde", 0x03a5 },
+{ "XK_Lcedilla", 0x03a6 },
+{ "XK_Emacron", 0x03aa },
+{ "XK_Gcedilla", 0x03ab },
+{ "XK_Tslash", 0x03ac },
+{ "XK_rcedilla", 0x03b3 },
+{ "XK_itilde", 0x03b5 },
+{ "XK_lcedilla", 0x03b6 },
+{ "XK_emacron", 0x03ba },
+{ "XK_gcedilla", 0x03bb },
+{ "XK_tslash", 0x03bc },
+{ "XK_ENG", 0x03bd },
+{ "XK_eng", 0x03bf },
+{ "XK_Amacron", 0x03c0 },
+{ "XK_Iogonek", 0x03c7 },
+{ "XK_Eabovedot", 0x03cc },
+{ "XK_Imacron", 0x03cf },
+{ "XK_Ncedilla", 0x03d1 },
+{ "XK_Omacron", 0x03d2 },
+{ "XK_Kcedilla", 0x03d3 },
+{ "XK_Uogonek", 0x03d9 },
+{ "XK_Utilde", 0x03dd },
+{ "XK_Umacron", 0x03de },
+{ "XK_amacron", 0x03e0 },
+{ "XK_iogonek", 0x03e7 },
+{ "XK_eabovedot", 0x03ec },
+{ "XK_imacron", 0x03ef },
+{ "XK_ncedilla", 0x03f1 },
+{ "XK_omacron", 0x03f2 },
+{ "XK_kcedilla", 0x03f3 },
+{ "XK_uogonek", 0x03f9 },
+{ "XK_utilde", 0x03fd },
+{ "XK_umacron", 0x03fe },
+{ "XK_OE", 0x13bc },
+{ "XK_oe", 0x13bd },
+{ "XK_Ydiaeresis", 0x13be },
+{ "XK_overline", 0x047e },
+{ "XK_kana_fullstop", 0x04a1 },
+{ "XK_kana_openingbracket", 0x04a2 },
+{ "XK_kana_closingbracket", 0x04a3 },
+{ "XK_kana_comma", 0x04a4 },
+{ "XK_kana_conjunctive", 0x04a5 },
+{ "XK_kana_middledot", 0x04a5 },
+{ "XK_kana_WO", 0x04a6 },
+{ "XK_kana_a", 0x04a7 },
+{ "XK_kana_i", 0x04a8 },
+{ "XK_kana_u", 0x04a9 },
+{ "XK_kana_e", 0x04aa },
+{ "XK_kana_o", 0x04ab },
+{ "XK_kana_ya", 0x04ac },
+{ "XK_kana_yu", 0x04ad },
+{ "XK_kana_yo", 0x04ae },
+{ "XK_kana_tsu", 0x04af },
+{ "XK_kana_tu", 0x04af },
+{ "XK_prolongedsound", 0x04b0 },
+{ "XK_kana_A", 0x04b1 },
+{ "XK_kana_I", 0x04b2 },
+{ "XK_kana_U", 0x04b3 },
+{ "XK_kana_E", 0x04b4 },
+{ "XK_kana_O", 0x04b5 },
+{ "XK_kana_KA", 0x04b6 },
+{ "XK_kana_KI", 0x04b7 },
+{ "XK_kana_KU", 0x04b8 },
+{ "XK_kana_KE", 0x04b9 },
+{ "XK_kana_KO", 0x04ba },
+{ "XK_kana_SA", 0x04bb },
+{ "XK_kana_SHI", 0x04bc },
+{ "XK_kana_SU", 0x04bd },
+{ "XK_kana_SE", 0x04be },
+{ "XK_kana_SO", 0x04bf },
+{ "XK_kana_TA", 0x04c0 },
+{ "XK_kana_CHI", 0x04c1 },
+{ "XK_kana_TI", 0x04c1 },
+{ "XK_kana_TSU", 0x04c2 },
+{ "XK_kana_TU", 0x04c2 },
+{ "XK_kana_TE", 0x04c3 },
+{ "XK_kana_TO", 0x04c4 },
+{ "XK_kana_NA", 0x04c5 },
+{ "XK_kana_NI", 0x04c6 },
+{ "XK_kana_NU", 0x04c7 },
+{ "XK_kana_NE", 0x04c8 },
+{ "XK_kana_NO", 0x04c9 },
+{ "XK_kana_HA", 0x04ca },
+{ "XK_kana_HI", 0x04cb },
+{ "XK_kana_FU", 0x04cc },
+{ "XK_kana_HU", 0x04cc },
+{ "XK_kana_HE", 0x04cd },
+{ "XK_kana_HO", 0x04ce },
+{ "XK_kana_MA", 0x04cf },
+{ "XK_kana_MI", 0x04d0 },
+{ "XK_kana_MU", 0x04d1 },
+{ "XK_kana_ME", 0x04d2 },
+{ "XK_kana_MO", 0x04d3 },
+{ "XK_kana_YA", 0x04d4 },
+{ "XK_kana_YU", 0x04d5 },
+{ "XK_kana_YO", 0x04d6 },
+{ "XK_kana_RA", 0x04d7 },
+{ "XK_kana_RI", 0x04d8 },
+{ "XK_kana_RU", 0x04d9 },
+{ "XK_kana_RE", 0x04da },
+{ "XK_kana_RO", 0x04db },
+{ "XK_kana_WA", 0x04dc },
+{ "XK_kana_N", 0x04dd },
+{ "XK_voicedsound", 0x04de },
+{ "XK_semivoicedsound", 0x04df },
+{ "XK_kana_switch", 0xff7e },
+{ "XK_Arabic_comma", 0x05ac },
+{ "XK_Arabic_semicolon", 0x05bb },
+{ "XK_Arabic_question_mark", 0x05bf },
+{ "XK_Arabic_hamza", 0x05c1 },
+{ "XK_Arabic_maddaonalef", 0x05c2 },
+{ "XK_Arabic_hamzaonalef", 0x05c3 },
+{ "XK_Arabic_hamzaonwaw", 0x05c4 },
+{ "XK_Arabic_hamzaunderalef", 0x05c5 },
+{ "XK_Arabic_hamzaonyeh", 0x05c6 },
+{ "XK_Arabic_alef", 0x05c7 },
+{ "XK_Arabic_beh", 0x05c8 },
+{ "XK_Arabic_tehmarbuta", 0x05c9 },
+{ "XK_Arabic_teh", 0x05ca },
+{ "XK_Arabic_theh", 0x05cb },
+{ "XK_Arabic_jeem", 0x05cc },
+{ "XK_Arabic_hah", 0x05cd },
+{ "XK_Arabic_khah", 0x05ce },
+{ "XK_Arabic_dal", 0x05cf },
+{ "XK_Arabic_thal", 0x05d0 },
+{ "XK_Arabic_ra", 0x05d1 },
+{ "XK_Arabic_zain", 0x05d2 },
+{ "XK_Arabic_seen", 0x05d3 },
+{ "XK_Arabic_sheen", 0x05d4 },
+{ "XK_Arabic_sad", 0x05d5 },
+{ "XK_Arabic_dad", 0x05d6 },
+{ "XK_Arabic_tah", 0x05d7 },
+{ "XK_Arabic_zah", 0x05d8 },
+{ "XK_Arabic_ain", 0x05d9 },
+{ "XK_Arabic_ghain", 0x05da },
+{ "XK_Arabic_tatweel", 0x05e0 },
+{ "XK_Arabic_feh", 0x05e1 },
+{ "XK_Arabic_qaf", 0x05e2 },
+{ "XK_Arabic_kaf", 0x05e3 },
+{ "XK_Arabic_lam", 0x05e4 },
+{ "XK_Arabic_meem", 0x05e5 },
+{ "XK_Arabic_noon", 0x05e6 },
+{ "XK_Arabic_ha", 0x05e7 },
+{ "XK_Arabic_heh", 0x05e7 },
+{ "XK_Arabic_waw", 0x05e8 },
+{ "XK_Arabic_alefmaksura", 0x05e9 },
+{ "XK_Arabic_yeh", 0x05ea },
+{ "XK_Arabic_fathatan", 0x05eb },
+{ "XK_Arabic_dammatan", 0x05ec },
+{ "XK_Arabic_kasratan", 0x05ed },
+{ "XK_Arabic_fatha", 0x05ee },
+{ "XK_Arabic_damma", 0x05ef },
+{ "XK_Arabic_kasra", 0x05f0 },
+{ "XK_Arabic_shadda", 0x05f1 },
+{ "XK_Arabic_sukun", 0x05f2 },
+{ "XK_Arabic_switch", 0xff7e },
+{ "XK_Serbian_dje", 0x06a1 },
+{ "XK_Macedonia_gje", 0x06a2 },
+{ "XK_Cyrillic_io", 0x06a3 },
+{ "XK_Ukrainian_ie", 0x06a4 },
+{ "XK_Ukranian_je", 0x06a4 },
+{ "XK_Macedonia_dse", 0x06a5 },
+{ "XK_Ukrainian_i", 0x06a6 },
+{ "XK_Ukranian_i", 0x06a6 },
+{ "XK_Ukrainian_yi", 0x06a7 },
+{ "XK_Ukranian_yi", 0x06a7 },
+{ "XK_Cyrillic_je", 0x06a8 },
+{ "XK_Serbian_je", 0x06a8 },
+{ "XK_Cyrillic_lje", 0x06a9 },
+{ "XK_Serbian_lje", 0x06a9 },
+{ "XK_Cyrillic_nje", 0x06aa },
+{ "XK_Serbian_nje", 0x06aa },
+{ "XK_Serbian_tshe", 0x06ab },
+{ "XK_Macedonia_kje", 0x06ac },
+{ "XK_Ukrainian_ghe_with_upturn", 0x06ad },
+{ "XK_Byelorussian_shortu", 0x06ae },
+{ "XK_Cyrillic_dzhe", 0x06af },
+{ "XK_Serbian_dze", 0x06af },
+{ "XK_numerosign", 0x06b0 },
+{ "XK_Serbian_DJE", 0x06b1 },
+{ "XK_Macedonia_GJE", 0x06b2 },
+{ "XK_Cyrillic_IO", 0x06b3 },
+{ "XK_Ukrainian_IE", 0x06b4 },
+{ "XK_Ukranian_JE", 0x06b4 },
+{ "XK_Macedonia_DSE", 0x06b5 },
+{ "XK_Ukrainian_I", 0x06b6 },
+{ "XK_Ukranian_I", 0x06b6 },
+{ "XK_Ukrainian_YI", 0x06b7 },
+{ "XK_Ukranian_YI", 0x06b7 },
+{ "XK_Cyrillic_JE", 0x06b8 },
+{ "XK_Serbian_JE", 0x06b8 },
+{ "XK_Cyrillic_LJE", 0x06b9 },
+{ "XK_Serbian_LJE", 0x06b9 },
+{ "XK_Cyrillic_NJE", 0x06ba },
+{ "XK_Serbian_NJE", 0x06ba },
+{ "XK_Serbian_TSHE", 0x06bb },
+{ "XK_Macedonia_KJE", 0x06bc },
+{ "XK_Ukrainian_GHE_WITH_UPTURN", 0x06bd },
+{ "XK_Byelorussian_SHORTU", 0x06be },
+{ "XK_Cyrillic_DZHE", 0x06bf },
+{ "XK_Serbian_DZE", 0x06bf },
+{ "XK_Cyrillic_yu", 0x06c0 },
+{ "XK_Cyrillic_a", 0x06c1 },
+{ "XK_Cyrillic_be", 0x06c2 },
+{ "XK_Cyrillic_tse", 0x06c3 },
+{ "XK_Cyrillic_de", 0x06c4 },
+{ "XK_Cyrillic_ie", 0x06c5 },
+{ "XK_Cyrillic_ef", 0x06c6 },
+{ "XK_Cyrillic_ghe", 0x06c7 },
+{ "XK_Cyrillic_ha", 0x06c8 },
+{ "XK_Cyrillic_i", 0x06c9 },
+{ "XK_Cyrillic_shorti", 0x06ca },
+{ "XK_Cyrillic_ka", 0x06cb },
+{ "XK_Cyrillic_el", 0x06cc },
+{ "XK_Cyrillic_em", 0x06cd },
+{ "XK_Cyrillic_en", 0x06ce },
+{ "XK_Cyrillic_o", 0x06cf },
+{ "XK_Cyrillic_pe", 0x06d0 },
+{ "XK_Cyrillic_ya", 0x06d1 },
+{ "XK_Cyrillic_er", 0x06d2 },
+{ "XK_Cyrillic_es", 0x06d3 },
+{ "XK_Cyrillic_te", 0x06d4 },
+{ "XK_Cyrillic_u", 0x06d5 },
+{ "XK_Cyrillic_zhe", 0x06d6 },
+{ "XK_Cyrillic_ve", 0x06d7 },
+{ "XK_Cyrillic_softsign", 0x06d8 },
+{ "XK_Cyrillic_yeru", 0x06d9 },
+{ "XK_Cyrillic_ze", 0x06da },
+{ "XK_Cyrillic_sha", 0x06db },
+{ "XK_Cyrillic_e", 0x06dc },
+{ "XK_Cyrillic_shcha", 0x06dd },
+{ "XK_Cyrillic_che", 0x06de },
+{ "XK_Cyrillic_hardsign", 0x06df },
+{ "XK_Cyrillic_YU", 0x06e0 },
+{ "XK_Cyrillic_A", 0x06e1 },
+{ "XK_Cyrillic_BE", 0x06e2 },
+{ "XK_Cyrillic_TSE", 0x06e3 },
+{ "XK_Cyrillic_DE", 0x06e4 },
+{ "XK_Cyrillic_IE", 0x06e5 },
+{ "XK_Cyrillic_EF", 0x06e6 },
+{ "XK_Cyrillic_GHE", 0x06e7 },
+{ "XK_Cyrillic_HA", 0x06e8 },
+{ "XK_Cyrillic_I", 0x06e9 },
+{ "XK_Cyrillic_SHORTI", 0x06ea },
+{ "XK_Cyrillic_KA", 0x06eb },
+{ "XK_Cyrillic_EL", 0x06ec },
+{ "XK_Cyrillic_EM", 0x06ed },
+{ "XK_Cyrillic_EN", 0x06ee },
+{ "XK_Cyrillic_O", 0x06ef },
+{ "XK_Cyrillic_PE", 0x06f0 },
+{ "XK_Cyrillic_YA", 0x06f1 },
+{ "XK_Cyrillic_ER", 0x06f2 },
+{ "XK_Cyrillic_ES", 0x06f3 },
+{ "XK_Cyrillic_TE", 0x06f4 },
+{ "XK_Cyrillic_U", 0x06f5 },
+{ "XK_Cyrillic_ZHE", 0x06f6 },
+{ "XK_Cyrillic_VE", 0x06f7 },
+{ "XK_Cyrillic_SOFTSIGN", 0x06f8 },
+{ "XK_Cyrillic_YERU", 0x06f9 },
+{ "XK_Cyrillic_ZE", 0x06fa },
+{ "XK_Cyrillic_SHA", 0x06fb },
+{ "XK_Cyrillic_E", 0x06fc },
+{ "XK_Cyrillic_SHCHA", 0x06fd },
+{ "XK_Cyrillic_CHE", 0x06fe },
+{ "XK_Cyrillic_HARDSIGN", 0x06ff },
+{ "XK_Greek_ALPHAaccent", 0x07a1 },
+{ "XK_Greek_EPSILONaccent", 0x07a2 },
+{ "XK_Greek_ETAaccent", 0x07a3 },
+{ "XK_Greek_IOTAaccent", 0x07a4 },
+{ "XK_Greek_IOTAdieresis", 0x07a5 },
+{ "XK_Greek_IOTAdiaeresis", 0x07a5 },
+{ "XK_Greek_OMICRONaccent", 0x07a7 },
+{ "XK_Greek_UPSILONaccent", 0x07a8 },
+{ "XK_Greek_UPSILONdieresis", 0x07a9 },
+{ "XK_Greek_OMEGAaccent", 0x07ab },
+{ "XK_Greek_accentdieresis", 0x07ae },
+{ "XK_Greek_horizbar", 0x07af },
+{ "XK_Greek_alphaaccent", 0x07b1 },
+{ "XK_Greek_epsilonaccent", 0x07b2 },
+{ "XK_Greek_etaaccent", 0x07b3 },
+{ "XK_Greek_iotaaccent", 0x07b4 },
+{ "XK_Greek_iotadieresis", 0x07b5 },
+{ "XK_Greek_iotaaccentdieresis", 0x07b6 },
+{ "XK_Greek_omicronaccent", 0x07b7 },
+{ "XK_Greek_upsilonaccent", 0x07b8 },
+{ "XK_Greek_upsilondieresis", 0x07b9 },
+{ "XK_Greek_upsilonaccentdieresis", 0x07ba },
+{ "XK_Greek_omegaaccent", 0x07bb },
+{ "XK_Greek_ALPHA", 0x07c1 },
+{ "XK_Greek_BETA", 0x07c2 },
+{ "XK_Greek_GAMMA", 0x07c3 },
+{ "XK_Greek_DELTA", 0x07c4 },
+{ "XK_Greek_EPSILON", 0x07c5 },
+{ "XK_Greek_ZETA", 0x07c6 },
+{ "XK_Greek_ETA", 0x07c7 },
+{ "XK_Greek_THETA", 0x07c8 },
+{ "XK_Greek_IOTA", 0x07c9 },
+{ "XK_Greek_KAPPA", 0x07ca },
+{ "XK_Greek_LAMDA", 0x07cb },
+{ "XK_Greek_LAMBDA", 0x07cb },
+{ "XK_Greek_MU", 0x07cc },
+{ "XK_Greek_NU", 0x07cd },
+{ "XK_Greek_XI", 0x07ce },
+{ "XK_Greek_OMICRON", 0x07cf },
+{ "XK_Greek_PI", 0x07d0 },
+{ "XK_Greek_RHO", 0x07d1 },
+{ "XK_Greek_SIGMA", 0x07d2 },
+{ "XK_Greek_TAU", 0x07d4 },
+{ "XK_Greek_UPSILON", 0x07d5 },
+{ "XK_Greek_PHI", 0x07d6 },
+{ "XK_Greek_CHI", 0x07d7 },
+{ "XK_Greek_PSI", 0x07d8 },
+{ "XK_Greek_OMEGA", 0x07d9 },
+{ "XK_Greek_alpha", 0x07e1 },
+{ "XK_Greek_beta", 0x07e2 },
+{ "XK_Greek_gamma", 0x07e3 },
+{ "XK_Greek_delta", 0x07e4 },
+{ "XK_Greek_epsilon", 0x07e5 },
+{ "XK_Greek_zeta", 0x07e6 },
+{ "XK_Greek_eta", 0x07e7 },
+{ "XK_Greek_theta", 0x07e8 },
+{ "XK_Greek_iota", 0x07e9 },
+{ "XK_Greek_kappa", 0x07ea },
+{ "XK_Greek_lamda", 0x07eb },
+{ "XK_Greek_lambda", 0x07eb },
+{ "XK_Greek_mu", 0x07ec },
+{ "XK_Greek_nu", 0x07ed },
+{ "XK_Greek_xi", 0x07ee },
+{ "XK_Greek_omicron", 0x07ef },
+{ "XK_Greek_pi", 0x07f0 },
+{ "XK_Greek_rho", 0x07f1 },
+{ "XK_Greek_sigma", 0x07f2 },
+{ "XK_Greek_finalsmallsigma", 0x07f3 },
+{ "XK_Greek_tau", 0x07f4 },
+{ "XK_Greek_upsilon", 0x07f5 },
+{ "XK_Greek_phi", 0x07f6 },
+{ "XK_Greek_chi", 0x07f7 },
+{ "XK_Greek_psi", 0x07f8 },
+{ "XK_Greek_omega", 0x07f9 },
+{ "XK_Greek_switch", 0xff7e },
+{ "XK_leftradical", 0x08a1 },
+{ "XK_topleftradical", 0x08a2 },
+{ "XK_horizconnector", 0x08a3 },
+{ "XK_topintegral", 0x08a4 },
+{ "XK_botintegral", 0x08a5 },
+{ "XK_vertconnector", 0x08a6 },
+{ "XK_topleftsqbracket", 0x08a7 },
+{ "XK_botleftsqbracket", 0x08a8 },
+{ "XK_toprightsqbracket", 0x08a9 },
+{ "XK_botrightsqbracket", 0x08aa },
+{ "XK_topleftparens", 0x08ab },
+{ "XK_botleftparens", 0x08ac },
+{ "XK_toprightparens", 0x08ad },
+{ "XK_botrightparens", 0x08ae },
+{ "XK_leftmiddlecurlybrace", 0x08af },
+{ "XK_rightmiddlecurlybrace", 0x08b0 },
+{ "XK_lessthanequal", 0x08bc },
+{ "XK_notequal", 0x08bd },
+{ "XK_greaterthanequal", 0x08be },
+{ "XK_integral", 0x08bf },
+{ "XK_therefore", 0x08c0 },
+{ "XK_variation", 0x08c1 },
+{ "XK_infinity", 0x08c2 },
+{ "XK_nabla", 0x08c5 },
+{ "XK_approximate", 0x08c8 },
+{ "XK_similarequal", 0x08c9 },
+{ "XK_ifonlyif", 0x08cd },
+{ "XK_implies", 0x08ce },
+{ "XK_identical", 0x08cf },
+{ "XK_radical", 0x08d6 },
+{ "XK_includedin", 0x08da },
+{ "XK_includes", 0x08db },
+{ "XK_intersection", 0x08dc },
+{ "XK_union", 0x08dd },
+{ "XK_logicaland", 0x08de },
+{ "XK_logicalor", 0x08df },
+{ "XK_partialderivative", 0x08ef },
+{ "XK_function", 0x08f6 },
+{ "XK_leftarrow", 0x08fb },
+{ "XK_uparrow", 0x08fc },
+{ "XK_rightarrow", 0x08fd },
+{ "XK_downarrow", 0x08fe },
+{ "XK_soliddiamond", 0x09e0 },
+{ "XK_checkerboard", 0x09e1 },
+{ "XK_ht", 0x09e2 },
+{ "XK_ff", 0x09e3 },
+{ "XK_cr", 0x09e4 },
+{ "XK_lf", 0x09e5 },
+{ "XK_nl", 0x09e8 },
+{ "XK_vt", 0x09e9 },
+{ "XK_lowrightcorner", 0x09ea },
+{ "XK_uprightcorner", 0x09eb },
+{ "XK_upleftcorner", 0x09ec },
+{ "XK_lowleftcorner", 0x09ed },
+{ "XK_crossinglines", 0x09ee },
+{ "XK_horizlinescan1", 0x09ef },
+{ "XK_horizlinescan3", 0x09f0 },
+{ "XK_horizlinescan5", 0x09f1 },
+{ "XK_horizlinescan7", 0x09f2 },
+{ "XK_horizlinescan9", 0x09f3 },
+{ "XK_leftt", 0x09f4 },
+{ "XK_rightt", 0x09f5 },
+{ "XK_bott", 0x09f6 },
+{ "XK_topt", 0x09f7 },
+{ "XK_vertbar", 0x09f8 },
+{ "XK_emspace", 0x0aa1 },
+{ "XK_enspace", 0x0aa2 },
+{ "XK_em3space", 0x0aa3 },
+{ "XK_em4space", 0x0aa4 },
+{ "XK_digitspace", 0x0aa5 },
+{ "XK_punctspace", 0x0aa6 },
+{ "XK_thinspace", 0x0aa7 },
+{ "XK_hairspace", 0x0aa8 },
+{ "XK_emdash", 0x0aa9 },
+{ "XK_endash", 0x0aaa },
+{ "XK_signifblank", 0x0aac },
+{ "XK_ellipsis", 0x0aae },
+{ "XK_doubbaselinedot", 0x0aaf },
+{ "XK_onethird", 0x0ab0 },
+{ "XK_twothirds", 0x0ab1 },
+{ "XK_onefifth", 0x0ab2 },
+{ "XK_twofifths", 0x0ab3 },
+{ "XK_threefifths", 0x0ab4 },
+{ "XK_fourfifths", 0x0ab5 },
+{ "XK_onesixth", 0x0ab6 },
+{ "XK_fivesixths", 0x0ab7 },
+{ "XK_careof", 0x0ab8 },
+{ "XK_figdash", 0x0abb },
+{ "XK_leftanglebracket", 0x0abc },
+{ "XK_decimalpoint", 0x0abd },
+{ "XK_rightanglebracket", 0x0abe },
+{ "XK_oneeighth", 0x0ac3 },
+{ "XK_threeeighths", 0x0ac4 },
+{ "XK_fiveeighths", 0x0ac5 },
+{ "XK_seveneighths", 0x0ac6 },
+{ "XK_trademark", 0x0ac9 },
+{ "XK_signaturemark", 0x0aca },
+{ "XK_leftopentriangle", 0x0acc },
+{ "XK_rightopentriangle", 0x0acd },
+{ "XK_emopencircle", 0x0ace },
+{ "XK_emopenrectangle", 0x0acf },
+{ "XK_leftsinglequotemark", 0x0ad0 },
+{ "XK_rightsinglequotemark", 0x0ad1 },
+{ "XK_leftdoublequotemark", 0x0ad2 },
+{ "XK_rightdoublequotemark", 0x0ad3 },
+{ "XK_prescription", 0x0ad4 },
+{ "XK_minutes", 0x0ad6 },
+{ "XK_seconds", 0x0ad7 },
+{ "XK_latincross", 0x0ad9 },
+{ "XK_filledrectbullet", 0x0adb },
+{ "XK_filledlefttribullet", 0x0adc },
+{ "XK_filledrighttribullet", 0x0add },
+{ "XK_emfilledcircle", 0x0ade },
+{ "XK_emfilledrect", 0x0adf },
+{ "XK_enopencircbullet", 0x0ae0 },
+{ "XK_enopensquarebullet", 0x0ae1 },
+{ "XK_openrectbullet", 0x0ae2 },
+{ "XK_opentribulletup", 0x0ae3 },
+{ "XK_opentribulletdown", 0x0ae4 },
+{ "XK_openstar", 0x0ae5 },
+{ "XK_enfilledcircbullet", 0x0ae6 },
+{ "XK_enfilledsqbullet", 0x0ae7 },
+{ "XK_filledtribulletup", 0x0ae8 },
+{ "XK_filledtribulletdown", 0x0ae9 },
+{ "XK_leftpointer", 0x0aea },
+{ "XK_rightpointer", 0x0aeb },
+{ "XK_club", 0x0aec },
+{ "XK_diamond", 0x0aed },
+{ "XK_heart", 0x0aee },
+{ "XK_maltesecross", 0x0af0 },
+{ "XK_dagger", 0x0af1 },
+{ "XK_doubledagger", 0x0af2 },
+{ "XK_checkmark", 0x0af3 },
+{ "XK_ballotcross", 0x0af4 },
+{ "XK_musicalsharp", 0x0af5 },
+{ "XK_musicalflat", 0x0af6 },
+{ "XK_malesymbol", 0x0af7 },
+{ "XK_femalesymbol", 0x0af8 },
+{ "XK_telephone", 0x0af9 },
+{ "XK_telephonerecorder", 0x0afa },
+{ "XK_phonographcopyright", 0x0afb },
+{ "XK_caret", 0x0afc },
+{ "XK_singlelowquotemark", 0x0afd },
+{ "XK_doublelowquotemark", 0x0afe },
+{ "XK_leftcaret", 0x0ba3 },
+{ "XK_rightcaret", 0x0ba6 },
+{ "XK_downcaret", 0x0ba8 },
+{ "XK_upcaret", 0x0ba9 },
+{ "XK_overbar", 0x0bc0 },
+{ "XK_downtack", 0x0bc2 },
+{ "XK_upshoe", 0x0bc3 },
+{ "XK_downstile", 0x0bc4 },
+{ "XK_underbar", 0x0bc6 },
+{ "XK_jot", 0x0bca },
+{ "XK_quad", 0x0bcc },
+{ "XK_uptack", 0x0bce },
+{ "XK_circle", 0x0bcf },
+{ "XK_upstile", 0x0bd3 },
+{ "XK_downshoe", 0x0bd6 },
+{ "XK_rightshoe", 0x0bd8 },
+{ "XK_leftshoe", 0x0bda },
+{ "XK_lefttack", 0x0bdc },
+{ "XK_righttack", 0x0bfc },
+{ "XK_hebrew_doublelowline", 0x0cdf },
+{ "XK_hebrew_aleph", 0x0ce0 },
+{ "XK_hebrew_bet", 0x0ce1 },
+{ "XK_hebrew_beth", 0x0ce1 },
+{ "XK_hebrew_gimel", 0x0ce2 },
+{ "XK_hebrew_gimmel", 0x0ce2 },
+{ "XK_hebrew_dalet", 0x0ce3 },
+{ "XK_hebrew_daleth", 0x0ce3 },
+{ "XK_hebrew_he", 0x0ce4 },
+{ "XK_hebrew_waw", 0x0ce5 },
+{ "XK_hebrew_zain", 0x0ce6 },
+{ "XK_hebrew_zayin", 0x0ce6 },
+{ "XK_hebrew_chet", 0x0ce7 },
+{ "XK_hebrew_het", 0x0ce7 },
+{ "XK_hebrew_tet", 0x0ce8 },
+{ "XK_hebrew_teth", 0x0ce8 },
+{ "XK_hebrew_yod", 0x0ce9 },
+{ "XK_hebrew_finalkaph", 0x0cea },
+{ "XK_hebrew_kaph", 0x0ceb },
+{ "XK_hebrew_lamed", 0x0cec },
+{ "XK_hebrew_finalmem", 0x0ced },
+{ "XK_hebrew_mem", 0x0cee },
+{ "XK_hebrew_finalnun", 0x0cef },
+{ "XK_hebrew_nun", 0x0cf0 },
+{ "XK_hebrew_samech", 0x0cf1 },
+{ "XK_hebrew_samekh", 0x0cf1 },
+{ "XK_hebrew_ayin", 0x0cf2 },
+{ "XK_hebrew_finalpe", 0x0cf3 },
+{ "XK_hebrew_pe", 0x0cf4 },
+{ "XK_hebrew_finalzade", 0x0cf5 },
+{ "XK_hebrew_finalzadi", 0x0cf5 },
+{ "XK_hebrew_zade", 0x0cf6 },
+{ "XK_hebrew_zadi", 0x0cf6 },
+{ "XK_hebrew_qoph", 0x0cf7 },
+{ "XK_hebrew_kuf", 0x0cf7 },
+{ "XK_hebrew_resh", 0x0cf8 },
+{ "XK_hebrew_shin", 0x0cf9 },
+{ "XK_hebrew_taw", 0x0cfa },
+{ "XK_hebrew_taf", 0x0cfa },
+{ "XK_Hebrew_switch", 0xff7e },
+{ "XK_Thai_kokai", 0x0da1 },
+{ "XK_Thai_khokhai", 0x0da2 },
+{ "XK_Thai_khokhuat", 0x0da3 },
+{ "XK_Thai_khokhwai", 0x0da4 },
+{ "XK_Thai_khokhon", 0x0da5 },
+{ "XK_Thai_khorakhang", 0x0da6 },
+{ "XK_Thai_ngongu", 0x0da7 },
+{ "XK_Thai_chochan", 0x0da8 },
+{ "XK_Thai_choching", 0x0da9 },
+{ "XK_Thai_chochang", 0x0daa },
+{ "XK_Thai_soso", 0x0dab },
+{ "XK_Thai_chochoe", 0x0dac },
+{ "XK_Thai_yoying", 0x0dad },
+{ "XK_Thai_dochada", 0x0dae },
+{ "XK_Thai_topatak", 0x0daf },
+{ "XK_Thai_thothan", 0x0db0 },
+{ "XK_Thai_thonangmontho", 0x0db1 },
+{ "XK_Thai_thophuthao", 0x0db2 },
+{ "XK_Thai_nonen", 0x0db3 },
+{ "XK_Thai_dodek", 0x0db4 },
+{ "XK_Thai_totao", 0x0db5 },
+{ "XK_Thai_thothung", 0x0db6 },
+{ "XK_Thai_thothahan", 0x0db7 },
+{ "XK_Thai_thothong", 0x0db8 },
+{ "XK_Thai_nonu", 0x0db9 },
+{ "XK_Thai_bobaimai", 0x0dba },
+{ "XK_Thai_popla", 0x0dbb },
+{ "XK_Thai_phophung", 0x0dbc },
+{ "XK_Thai_fofa", 0x0dbd },
+{ "XK_Thai_phophan", 0x0dbe },
+{ "XK_Thai_fofan", 0x0dbf },
+{ "XK_Thai_phosamphao", 0x0dc0 },
+{ "XK_Thai_moma", 0x0dc1 },
+{ "XK_Thai_yoyak", 0x0dc2 },
+{ "XK_Thai_rorua", 0x0dc3 },
+{ "XK_Thai_ru", 0x0dc4 },
+{ "XK_Thai_loling", 0x0dc5 },
+{ "XK_Thai_lu", 0x0dc6 },
+{ "XK_Thai_wowaen", 0x0dc7 },
+{ "XK_Thai_sosala", 0x0dc8 },
+{ "XK_Thai_sorusi", 0x0dc9 },
+{ "XK_Thai_sosua", 0x0dca },
+{ "XK_Thai_hohip", 0x0dcb },
+{ "XK_Thai_lochula", 0x0dcc },
+{ "XK_Thai_oang", 0x0dcd },
+{ "XK_Thai_honokhuk", 0x0dce },
+{ "XK_Thai_paiyannoi", 0x0dcf },
+{ "XK_Thai_saraa", 0x0dd0 },
+{ "XK_Thai_maihanakat", 0x0dd1 },
+{ "XK_Thai_saraaa", 0x0dd2 },
+{ "XK_Thai_saraam", 0x0dd3 },
+{ "XK_Thai_sarai", 0x0dd4 },
+{ "XK_Thai_saraii", 0x0dd5 },
+{ "XK_Thai_saraue", 0x0dd6 },
+{ "XK_Thai_sarauee", 0x0dd7 },
+{ "XK_Thai_sarau", 0x0dd8 },
+{ "XK_Thai_sarauu", 0x0dd9 },
+{ "XK_Thai_phinthu", 0x0dda },
+{ "XK_Thai_baht", 0x0ddf },
+{ "XK_Thai_sarae", 0x0de0 },
+{ "XK_Thai_saraae", 0x0de1 },
+{ "XK_Thai_sarao", 0x0de2 },
+{ "XK_Thai_saraaimaimuan", 0x0de3 },
+{ "XK_Thai_saraaimaimalai", 0x0de4 },
+{ "XK_Thai_lakkhangyao", 0x0de5 },
+{ "XK_Thai_maiyamok", 0x0de6 },
+{ "XK_Thai_maitaikhu", 0x0de7 },
+{ "XK_Thai_maiek", 0x0de8 },
+{ "XK_Thai_maitho", 0x0de9 },
+{ "XK_Thai_maitri", 0x0dea },
+{ "XK_Thai_maichattawa", 0x0deb },
+{ "XK_Thai_thanthakhat", 0x0dec },
+{ "XK_Thai_nikhahit", 0x0ded },
+{ "XK_Thai_leksun", 0x0df0 },
+{ "XK_Thai_leknung", 0x0df1 },
+{ "XK_Thai_leksong", 0x0df2 },
+{ "XK_Thai_leksam", 0x0df3 },
+{ "XK_Thai_leksi", 0x0df4 },
+{ "XK_Thai_lekha", 0x0df5 },
+{ "XK_Thai_lekhok", 0x0df6 },
+{ "XK_Thai_lekchet", 0x0df7 },
+{ "XK_Thai_lekpaet", 0x0df8 },
+{ "XK_Thai_lekkao", 0x0df9 },
+{ "XK_Hangul", 0xff31 },
+{ "XK_Hangul_Start", 0xff32 },
+{ "XK_Hangul_End", 0xff33 },
+{ "XK_Hangul_Hanja", 0xff34 },
+{ "XK_Hangul_Jamo", 0xff35 },
+{ "XK_Hangul_Romaja", 0xff36 },
+{ "XK_Hangul_Codeinput", 0xff37 },
+{ "XK_Hangul_Jeonja", 0xff38 },
+{ "XK_Hangul_Banja", 0xff39 },
+{ "XK_Hangul_PreHanja", 0xff3a },
+{ "XK_Hangul_PostHanja", 0xff3b },
+{ "XK_Hangul_SingleCandidate", 0xff3c },
+{ "XK_Hangul_MultipleCandidate", 0xff3d },
+{ "XK_Hangul_PreviousCandidate", 0xff3e },
+{ "XK_Hangul_Special", 0xff3f },
+{ "XK_Hangul_switch", 0xff7e },
+{ "XK_Korean_Won", 0x0eff },
+{ "XK_EuroSign", 0x20ac },
+{ 0, 0 }};
+
+static const char *
+nameForKeycode(int keycode)
+{ KeyNameEntry *kne;
+
+ for (kne = codes; kne->name; kne++)
+ if (kne->code == keycode)
+ return kne->name;
+
+ return "UNKNOWN CODE";
+}
+
+static const char *
+nameForKeyboardEvent(XEvent *evt) { return nameForKeycode(evt->xkey.keycode); }
+#endif /* DEBUG_EVENTS */
+
static void handleEvent(XEvent *evt)
{
-#if defined(DEBUG_EVENTS)
+#if DEBUG_EVENTS
switch (evt->type)
{
case ButtonPress:
@@ -2448,15 +3446,15 @@
evt->xbutton.state, evt->xbutton.button);
break;
case KeyPress:
- fprintf(stderr, "\nX KeyPress state 0x%x keycode %d\n",
+ fprintf(stderr, "\nX KeyPress state 0x%x raw keycode %d\n",
evt->xkey.state, evt->xkey.keycode);
break;
case KeyRelease:
- fprintf(stderr, "\nX KeyRelease state 0x%x keycode %d\n",
+ fprintf(stderr, "\nX KeyRelease state 0x%x raw keycode %d\n",
evt->xkey.state, evt->xkey.keycode);
break;
}
-#endif
+#endif /* DEBUG_EVENTS */
# define noteEventPosition(evt) \
{ \
@@ -2601,10 +3599,8 @@
KeySym symbolic;
int keyCode= x2sqKey(&evt->xkey, &symbolic);
int ucs4= xkeysym2ucs4(symbolic);
-# ifdef DEBUG_CONV
- fprintf(stderr, "symbolic, keyCode, ucs4: %x, %d, %d\n", symbolic, keyCode, ucs4);
- fprintf(stderr, "pressed, buffer: %d, %x\n", multi_key_pressed, multi_key_buffer);
-# endif
+ DCONV_FPRINTF(stderr, "symbolic, keyCode, ucs4: %x, %d, %d\n", symbolic, keyCode, ucs4);
+ DCONV_FPRINTF(stderr, "pressed, buffer: %d, %x\n", multi_key_pressed, multi_key_buffer);
if (multi_key_pressed && multi_key_buffer == 0)
{
switch (ucs4)
@@ -2666,14 +3662,10 @@
if (symbolic != XK_Multi_key)
{
multi_key_pressed= 0;
-# ifdef DEBUG_CONV
- fprintf(stderr, "multi_key reset\n");
-# endif
+ DCONV_FPRINTF(stderr, "multi_key reset\n");
}
}
-# ifdef DEBUG_CONV
- fprintf(stderr, "keyCode, ucs4, multi_key_buffer: %d, %d, %x\n", keyCode, ucs4, multi_key_buffer);
-# endif
+ DCONV_FPRINTF(stderr, "keyCode, ucs4, multi_key_buffer: %d, %d, %x\n", keyCode, ucs4, multi_key_buffer);
if (keyCode >= 0)
{
recordKeystroke(keyCode); /* DEPRECATED */
@@ -2683,7 +3675,8 @@
if ((keyCode >= 0) || (ucs4 > 0))
{
recordKeyboardEvent(keyCode, EventKeyDown, modifierState, ucs4);
- recordKeyboardEvent(keyCode, EventKeyChar, modifierState, ucs4);
+ if (ucs4) /* only generate a key char event if there's a code. */
+ recordKeyboardEvent(keyCode, EventKeyChar, modifierState, ucs4);
if (multi_key_buffer != 0)
{
recordKeyboardEvent(multi_key_buffer, EventKeyDown, modifierState, multi_key_buffer);
@@ -3492,10 +4485,24 @@
/*** Event Recording Functions ***/
+/* Support for translateCode. For KeyPress set meta. For KeyRelease clear
+ * notmeta. Of course this is simplistic and wrong because it doesn't deal
+ * with left and right versions of the key. e.g. the key sequence
+ * press left press right lift left lift right will release before lift right.
+ */
+static inline int
+withMetaSet(int code, int meta, int notmeta, int *modStatp, XKeyEvent *evt)
+{
+ if (modStatp)
+ *modStatp = evt->type == KeyPress
+ ? x2sqModifier(evt->state) | meta
+ : x2sqModifier(evt->state) & ~notmeta;
+ return code;
+}
-static int translateCode(KeySym symbolic)
+static int
+translateCode(KeySym symbolic, int *modp, XKeyEvent *evt)
{
-# define ALT (8<<8)
switch (symbolic)
{
case XK_Left: return 28;
@@ -3523,27 +4530,63 @@
case XK_R15: return 12; /* page down */
case XK_R7: return 1; /* home */
case XK_R13: return 4; /* end */
- case XK_L1: return ALT+'.'; /* stop */
- case XK_L2: return ALT+'j'; /* again */
- case XK_L4: return ALT+'z'; /* undo */
- case XK_L6: return ALT+'c'; /* copy */
- case XK_L8: return ALT+'v'; /* paste */
- case XK_L9: return ALT+'f'; /* find */
- case XK_L10: return ALT+'x'; /* cut */
+ /* if this is a key down event return the char with ALT/CommandKey set */
+ case XK_L1: /* stop */
+ return withMetaSet('.',CommandKeyBit,CommandKeyBit,modp,evt);
+ case XK_L2: /* again */
+ return withMetaSet('j',CommandKeyBit,CommandKeyBit,modp,evt);
+ case XK_L4: /* undo */
+ return withMetaSet('z',CommandKeyBit,CommandKeyBit,modp,evt);
+ case XK_L6: /* copy */
+ return withMetaSet('c',CommandKeyBit,CommandKeyBit,modp,evt);
+ case XK_L8: /* paste */
+ return withMetaSet('v',CommandKeyBit,CommandKeyBit,modp,evt);
+ case XK_L9: /* find */
+ return withMetaSet('f',CommandKeyBit,CommandKeyBit,modp,evt);
+ case XK_L10:/* cut */
+ return withMetaSet('x',CommandKeyBit,CommandKeyBit,modp,evt);
+
/* XKB extensions */
# if defined(XK_ISO_Left_Tab)
case XK_ISO_Left_Tab: return 9; /* shift-tab */
# endif
# if defined(XF86XK_Start)
- case XF86XK_Start: return ALT+','; /* OLPC view source */
+ case XF86XK_Start: /* OLPC view source */
+ return withMetaSet(',',CommandKeyBit,CommandKeyBit,modp,evt);
# endif
- default: return -1;
+# if defined(XK_Control_L)
+ /* For XK_Shift_L, XK_Shift_R, XK_Caps_Lock & XK_Shift_Lock we can't just
+ * use the SHIFT metastate since it would generate key codes. We use
+ * META + SHIFT as these are all meta keys (meta == OptionKeyBit).
+ */
+ case XK_Shift_L:
+ return withMetaSet(255,OptionKeyBit+ShiftKeyBit,ShiftKeyBit,modp,evt);
+ case XK_Shift_R:
+ return withMetaSet(254,OptionKeyBit+ShiftKeyBit,ShiftKeyBit,modp,evt);
+ case XK_Caps_Lock:
+ return withMetaSet(253,OptionKeyBit+ShiftKeyBit,ShiftKeyBit,modp,evt);
+ case XK_Shift_Lock:
+ return withMetaSet(252,OptionKeyBit+ShiftKeyBit,ShiftKeyBit,modp,evt);
+ case XK_Control_L:
+ return withMetaSet(251,OptionKeyBit+CtrlKeyBit,CtrlKeyBit,modp,evt);
+ case XK_Control_R:
+ return withMetaSet(250,OptionKeyBit+CtrlKeyBit,CtrlKeyBit,modp,evt);
+ case XK_Meta_L:
+ return withMetaSet(249,OptionKeyBit,0,modp,evt);
+ case XK_Meta_R:
+ return withMetaSet(248,OptionKeyBit,0,modp,evt);
+ case XK_Alt_L:
+ return withMetaSet(247,OptionKeyBit+CommandKeyBit,OptionKeyBit,modp,evt);
+ case XK_Alt_R:
+ return withMetaSet(246,OptionKeyBit+CommandKeyBit,OptionKeyBit,modp,evt);
+# endif
+
+ default:;
}
- /*NOTREACHED*/
-# undef ALT
+ return -1;
}
More information about the Vm-dev
mailing list