diff options
| author | Raymaekers Luca <luca@spacehb.net> | 2025-07-24 11:05:50 +0200 |
|---|---|---|
| committer | Raymaekers Luca <luca@spacehb.net> | 2025-07-24 11:11:23 +0200 |
| commit | e7dc403c36d5958238691578610d442a27ecc943 (patch) | |
| tree | 95ad6a7f74acf736c5d423c8742496761dd436e7 | |
| parent | 4ab197add10847d4ba3036ed525f96db00a9849f (diff) | |
checkpoint
| -rwxr-xr-x | build/handmade.so | bin | 222136 -> 228352 bytes | |||
| -rwxr-xr-x | build/linux_handmade | bin | 91512 -> 196880 bytes | |||
| -rwxr-xr-x | code/build.sh | 2 | ||||
| -rw-r--r-- | code/handmade.cpp | 134 | ||||
| -rw-r--r-- | code/handmade.h | 5 | ||||
| -rw-r--r-- | code/handmade_platform.h | 20 | ||||
| -rw-r--r-- | code/linux_handmade.cpp | 200 | ||||
| -rw-r--r-- | code/x11_key_to_keysym.c | 51 | ||||
| -rw-r--r-- | code/x11_keysym_convert.c | 2048 |
9 files changed, 2426 insertions, 34 deletions
diff --git a/build/handmade.so b/build/handmade.so Binary files differindex 3cb284d..aa20335 100755 --- a/build/handmade.so +++ b/build/handmade.so diff --git a/build/linux_handmade b/build/linux_handmade Binary files differindex a304d6e..27c66c6 100755 --- a/build/linux_handmade +++ b/build/linux_handmade diff --git a/code/build.sh b/code/build.sh index 3380b73..6cc9240 100755 --- a/code/build.sh +++ b/code/build.sh @@ -5,7 +5,7 @@ cd "$ThisDir" mkdir ../build > /dev/null 2>&1 -CompilerFlags="-ggdb -DHANDMADE_SLOW" +CompilerFlags="-ggdb -DHANDMADE_SLOW -DHANDMADE_INTERNAL" WarningFlags="-Wall -Wextra -Wno-unused-but-set-variable -Wno-unused-variable -Wno-write-strings -Wno-unused-parameter -Wno-unused-function" printf 'handmade.cpp\n' diff --git a/code/handmade.cpp b/code/handmade.cpp index b5fa5c5..c3c8cf4 100644 --- a/code/handmade.cpp +++ b/code/handmade.cpp @@ -355,13 +355,19 @@ DrawCharacter(game_offscreen_buffer *Buffer, u8 *FontBitmap, X < MaxX; X++) { - u8 Brightness = FontBitmap[Y*FontWidth+X]; - u32 Value = ((0xFF << 24) | - ((u32)(Color.R*Brightness) << 16) | - ((u32)(Color.G*Brightness) << 8) | - ((u32)(Color.B*Brightness) << 0)); - *Pixel++ = Value; + if(Brightness > 0) + { + u32 Value = ((0xFF << 24) | + ((u32)(Color.R*Brightness) << 16) | + ((u32)(Color.G*Brightness) << 8) | + ((u32)(Color.B*Brightness) << 0)); + *Pixel++ = Value; + } + else + { + Pixel++; + } } Row += Buffer->Pitch; } @@ -370,17 +376,17 @@ DrawCharacter(game_offscreen_buffer *Buffer, u8 *FontBitmap, internal void DrawText(game_state *GameState, game_offscreen_buffer *Buffer, r32 FontScale, - char *Text, u32 TextLen, v2 Offset, color_rgb Color) + rune *Text, u32 TextLen, v2 Offset, color_rgb Color) { for(u32 TextIndex = 0; TextIndex < TextLen; TextIndex++) { - int CharAt = Text[TextIndex]; + rune CharAt = Text[TextIndex]; - int FontWidth, FontHeight; - int AdvanceWidth, LeftSideBearing; - int X0, Y0, X1, Y1; + s32 FontWidth, FontHeight; + s32 AdvanceWidth, LeftSideBearing; + s32 X0, Y0, X1, Y1; u8 *FontBitmap = 0; // TODO(luca): Get rid of malloc. FontBitmap = stbtt_GetCodepointBitmap(&GameState->FontInfo, @@ -440,8 +446,16 @@ GetTodaysWordle(thread_context *Thread, game_memory *Memory, char *Word) sprintf(URLBuffer, "%s/%d-%02d-%d.json", URL, LocalTimeNow->tm_year + 1900, LocalTimeNow->tm_mon + 1, LocalTimeNow->tm_mday); char OutputBuffer[4096] = {0}; - char *Command[] = {"/usr/bin/curl", "-sL", URLBuffer, 0}; - + char *Command[] = + { + "/usr/bin/curl", + "--silent", + "--location", + "--max-time", "10", + URLBuffer, 0 + }; + + // TODO(luca): This should be asynchronous at least because in the case of no internet the application would not even start. int BytesOutputted = Memory->PlatformRunCommandAndGetOutput(Thread, OutputBuffer, Command); int Matches; int MatchedAt = 0; @@ -484,6 +498,15 @@ GetTodaysWordle(thread_context *Thread, game_memory *Memory, char *Word) } } +internal void +AppendCharToInputText(game_state *GameState, rune Codepoint) +{ + if(GameState->TextInputCount < ArrayCount(GameState->TextInputText)) + { + GameState->TextInputText[GameState->TextInputCount++] = Codepoint; + } +} + extern "C" GAME_UPDATE_AND_RENDER(GameUpdateAndRender) { Assert((&Input->Controllers[0].Terminator - &Input->Controllers[0].Buttons[0]) == @@ -514,7 +537,19 @@ extern "C" GAME_UPDATE_AND_RENDER(GameUpdateAndRender) GameState->SelectedColor = SquareColor_Yellow; GameState->ExportedPatternIndex = 0; + +#if 0 GetTodaysWordle(Thread, Memory, GameState->WordleWord); +#else + char *Word = "sword"; + for(u32 Count = 0; Count < 5; Count++) + { + GameState->WordleWord[Count] = Word[Count]; + } +#endif + + GameState->TextInputCount = 0; + GameState->TextInputMode = true; Memory->IsInitialized = true; } @@ -532,14 +567,34 @@ extern "C" GAME_UPDATE_AND_RENDER(GameUpdateAndRender) } else { - if(WasPressed(Input->MouseButtons[PlatformMouseButton_Right])) + Assert(Controller->Keyboard.TextInputCount < ArrayCount(Controller->Keyboard.TextInputBuffer)); + for(u32 InputIndex = 0; + InputIndex < Controller->Keyboard.TextInputCount; + InputIndex++) + { + rune Codepoint = Controller->Keyboard.TextInputBuffer[InputIndex].Codepoint; + AppendCharToInputText(GameState, Codepoint); + } + + if(WasPressed(Controller->ActionUp)) { GameState->SelectedColor = (GameState->SelectedColor < SquareColor_Count- 1) ? - GameState->SelectedColor + 1: 0; + GameState->SelectedColor + 1 : 0; + } + if(WasPressed(Controller->ActionDown)) + { + GameState->SelectedColor = (GameState->SelectedColor > 0) ? + GameState->SelectedColor - 1 : SquareColor_Count - 1; } + if(WasPressed(Controller->ActionLeft)) + { + GameState->TextInputMode = !GameState->TextInputMode; + } + } } } + Assert(GameState->SelectedColor < SquareColor_Count); r32 Width = 48.0f; @@ -641,13 +696,16 @@ extern "C" GAME_UPDATE_AND_RENDER(GameUpdateAndRender) GameState->FontDescent + GameState->FontLineGap); Baseline = (GameState->FontAscent*FontScale); + TextOffset = v2{16.0f, 16.0f + Baseline}; +#if 0 { char Text[WORDLE_LENGTH + 2 + 1] = {}; - int TextLen = sprintf(Text, "\"%s\"", GameState->WordleWord); + s32 TextLen = sprintf(Text, "\"%s\"", GameState->WordleWord); DrawText(GameState, Buffer, FontScale, Text, TextLen, TextOffset + -v2{8.0f, 0.0f}, ColorYellow); } +#endif TextOffset.Y += YAdvance*2.0f; @@ -743,9 +801,12 @@ extern "C" GAME_UPDATE_AND_RENDER(GameUpdateAndRender) if(PatternMatches) { +#if 0 DrawText(GameState, Buffer, FontScale, Guess, WORDLE_LENGTH, TextOffset, color_rgb{1.0f, 1.0f, 1.0f}); +#endif + TextOffset.Y += YAdvance; WordsIndex = 0; @@ -756,6 +817,47 @@ extern "C" GAME_UPDATE_AND_RENDER(GameUpdateAndRender) Memory->DEBUGPlatformFreeFileMemory(Thread, File.Contents, File.ContentsSize); + // NOTE(luca): Debug code for drawing inputted text. +#if 1 + { + r32 FontScale = stbtt_ScaleForPixelHeight(&GameState->FontInfo, 20.0f); + color_rgb Color = {1.0f, 0.0f, 0.5f}; + v2 Offset = {100.0f, 30.0f}; + + r32 TextHeight = FontScale*(GameState->FontAscent - + GameState->FontDescent + + GameState->FontLineGap); + r32 TextWidth = 0; + for(u32 InputIndex = 0; + InputIndex < GameState->TextInputCount; + InputIndex++) + { + int AdvanceWidth, LeftSideBearing; + rune Codepoint = GameState->TextInputText[InputIndex]; + stbtt_GetCodepointHMetrics(&GameState->FontInfo, Codepoint, + &AdvanceWidth, &LeftSideBearing); + TextWidth += (AdvanceWidth)*FontScale; + } + + r32 Baseline = (GameState->FontAscent*FontScale); + + v2 Min = {Offset.X, Offset.Y - Baseline}; + v2 Max = {Offset.X + TextWidth, Min.Y + TextHeight}; + color_rgb ColorWhite = {1.0f, 1.0f, 1.0f}; + color_rgb ColorBlue = {0.2f, 0.0f, 1.0f}; + + DrawRectangle(Buffer, Min + -1, Max + 1, ColorBlue); + DrawRectangle(Buffer, Min, Max, ColorWhite); + + DrawText(GameState, Buffer, FontScale, + GameState->TextInputText, GameState->TextInputCount, + Offset, Color); + + Assert(GameState->TextInputCount < ArrayCount(GameState->TextInputText)); + } + +#endif + } extern "C" GAME_GET_SOUND_SAMPLES(GameGetSoundSamples) diff --git a/code/handmade.h b/code/handmade.h index 42910fc..699167f 100644 --- a/code/handmade.h +++ b/code/handmade.h @@ -85,6 +85,11 @@ struct game_state s32 FontDescent; s32 FontLineGap; v2 FontBoundingBox[2]; + + b32 TextInputMode; + rune TextInputText[256]; + u32 TextInputCount; + }; #define HANDMADE_H diff --git a/code/handmade_platform.h b/code/handmade_platform.h index 2eef88b..e241b28 100644 --- a/code/handmade_platform.h +++ b/code/handmade_platform.h @@ -81,6 +81,7 @@ extern "C" { typedef uint64_t u64; typedef size_t memory_index; + typedef s32 rune; typedef float r32; typedef double r64; @@ -141,6 +142,14 @@ extern "C" { s16 *Samples; } game_sound_output_buffer; + typedef struct game_text_button + { + rune Codepoint; + b32 Control; + b32 Shift; + b32 Alt; + } game_text_button; + typedef struct game_button_state { int HalfTransitionCount; @@ -150,6 +159,15 @@ extern "C" { typedef struct game_controller_input { b32 IsConnected; + + struct + { + u32 TextInputCount; + game_text_button TextInputBuffer[64]; + + // TODO(luca): Generate code for keys that are not characters like Return, Backspace, etc. + } Keyboard; + b32 IsAnalog; r32 StickAverageX; r32 StickAverageY; @@ -192,7 +210,7 @@ extern "C" { typedef struct game_input { - game_button_state MouseButtons[5]; + game_button_state MouseButtons[PlatformMouseButton_Count]; s32 MouseX, MouseY, MouseZ; r32 dtForFrame; diff --git a/code/linux_handmade.cpp b/code/linux_handmade.cpp index ba75aed..0ed3b1d 100644 --- a/code/linux_handmade.cpp +++ b/code/linux_handmade.cpp @@ -21,9 +21,12 @@ #include "handmade_platform.h" #include "linux_handmade.h" +#include "x11_keysym_convert.c" + #define true 1 #define false 0 +#define ALSA_RECOVER_SILENT true #define MAX_PLAYER_COUNT 4 #ifdef Assert @@ -45,7 +48,6 @@ global_variable b32 GlobalPaused; void MemCpy(char *Dest, char *Source, size_t Count) { while(Count--) *Dest++ = *Source++; - } void MemSet(char *Dest, char Value, size_t Count) @@ -81,6 +83,47 @@ void CatStrings(size_t SourceACount, char *SourceA, } } +internal rune +ConvertUTF8StringToRune(u8 UTF8String[4]) +{ + rune Codepoint = 0; + + if((UTF8String[0] & 0x80) == 0x00) + { + Codepoint = UTF8String[0]; + } + else if((UTF8String[0] & 0xE0) == 0xC0) + { + Codepoint = ( + ((UTF8String[0] & 0x1F) << 6*1) | + ((UTF8String[1] & 0x3F) << 6*0) + ); + } + else if((UTF8String[0] & 0xF0) == 0xE0) + { + Codepoint = ( + ((UTF8String[0] & 0x0F) << 6*2) | + ((UTF8String[1] & 0x3F) << 6*1) | + ((UTF8String[2] & 0x3F) << 6*0) + ); + } + else if((UTF8String[0] & 0xF8) == 0xF8) + { + Codepoint = ( + ((UTF8String[0] & 0x0E) << 6*3) | + ((UTF8String[1] & 0x3F) << 6*2) | + ((UTF8String[2] & 0x3F) << 6*1) | + ((UTF8String[3] & 0x3F) << 6*0) + ); + } + else + { + Assert(0); + } + + return Codepoint; +} + struct linux_init_alsa_result { snd_pcm_t *PCMHandle; @@ -414,7 +457,6 @@ internal void LinuxEndInputPlayBack(linux_state *State) } State->InputPlayingIndex = 0; - } internal void LinuxRecordInput(linux_state *State, game_input *Input) @@ -466,20 +508,124 @@ internal void LinuxShowCursor(Display *DisplayHandle, Window WindowHandle) } internal void LinuxProcessPendingMessages(Display *DisplayHandle, Window WindowHandle, - Atom WM_DELETE_WINDOW, linux_state *State, game_controller_input *KeyboardController) + XIC InputContext, Atom WM_DELETE_WINDOW, linux_state *State, game_controller_input *KeyboardController) { XEvent WindowEvent = {}; while(XPending(DisplayHandle) > 0) { XNextEvent(DisplayHandle, &WindowEvent); - switch (WindowEvent.type) + b32 FilteredEvent = XFilterEvent(&WindowEvent, WindowHandle); + if(FilteredEvent) + { + Assert(WindowEvent.type == KeyPress || WindowEvent.type == KeyRelease); + } + + switch(WindowEvent.type) { case KeyPress: case KeyRelease: { + //- How text input works + // The needs: + // 1. Preserve game buttons, so that we can switch between a "game mode" or + // "text input mode". + // 2. Text input using the input method of the user which should allow for utf8 characters. + // 3. Hotkey support. Eg. quickly navigating text. + // 3 will be supported by 2 for code reuse. + // + // We are going to send a buffer text button presses to the game layer, this solves these + // issues: + // - Pressing the same key multiple times in one frame. + // - Having modifiers be specific to each key press. + // - Not having to create a button record for each possible character in the structure. + // - Key events come in one at a time in the event loop, thus we need to have a buffer for + // multiple keys pressed on a single frame. + // + // We store a count along the buffer and in the buffer we store the utf8 codepoint and its + // modifiers. + // The app code is responsible for traversing this buffer and applying the logic. + + // The problem of input methods and hotkeys: + // Basically the problem is that if we allow the input method and combo's that could be + // filtered by the input method it won't seem consistent to the user. + // So we don't allow key bound to the input method to have an effect and we only pass key + // inputs that have not been filtered. + // + // In the platform layer we handle the special case were the input methods creates non- + // printable characters and we decompose those key inputs since non-printable characters + // have no use anymore. + + // Extra: + // - I refuse to check which keys bind to what modifiers. It's not important. + + // - Handy resources: + // - https://www.coderstool.com/unicode-text-converter + // - man Compose(5). + // - https://en.wikipedia.org/wiki/Control_key#History + KeySym Symbol = XLookupKeysym(&WindowEvent.xkey, 0); b32 IsDown = (WindowEvent.type == KeyPress); + // TODO(luca): Refresh mappings. + // NOTE(luca): Only KeyPress events see man page of Xutf8LookupString(). And skip filtered events for text input, but keep them for controller. + if(IsDown && !FilteredEvent) + { + rune Codepoint = 'e'; + u8 LookupBuffer[4] = {}; + Status LookupStatus = {}; + + s32 BytesLookepdUp = Xutf8LookupString(InputContext, &WindowEvent.xkey, + (char *)&LookupBuffer, ArrayCount(LookupBuffer), + 0, &LookupStatus); + Assert(LookupStatus != XBufferOverflow); + Assert(BytesLookepdUp <= 4); + + if(LookupStatus!= XLookupNone && + LookupStatus!= XLookupKeySym) + { + if(BytesLookepdUp) + { + Assert(KeyboardController->Keyboard.TextInputCount < ArrayCount(KeyboardController->Keyboard.TextInputBuffer)); + + Codepoint = ConvertUTF8StringToRune(LookupBuffer); + + // NOTE(luca): Input methods might produce non printable characters (< ' '). If this + // happens we try to "decompose" the key input. + if(Codepoint < ' ' && Codepoint >= 0) + { + if(Symbol >= XK_space) + { + Codepoint = (char)(' ' + (Symbol - XK_space)); + } + } + + + if(Codepoint >= ' ' || Codepoint < 0) + { + game_text_button *TextButton = &KeyboardController->Keyboard.TextInputBuffer[KeyboardController->Keyboard.TextInputCount++]; + TextButton->Codepoint = Codepoint; + TextButton->Shift = (WindowEvent.xkey.state & ShiftMask); + TextButton->Control = (WindowEvent.xkey.state & ControlMask); + TextButton->Alt = (WindowEvent.xkey.state & Mod1Mask); +#if 0 + printf("%d bytes '%c' %d (%c|%c|%c)\n", + BytesLookepdUp, + ((Codepoint >= ' ') ? (char)Codepoint : '\0'), + Codepoint, + ((WindowEvent.xkey.state & ShiftMask) ? 'S' : ' '), + ((WindowEvent.xkey.state & ControlMask) ? 'C' : ' '), + ((WindowEvent.xkey.state & Mod1Mask) ? 'A' : ' ')); +#endif + } + else + { + // TODO(luca): Logging + } + + } + } + } + if(0) {} else if(Symbol == XK_w) { @@ -517,14 +663,16 @@ internal void LinuxProcessPendingMessages(Display *DisplayHandle, Window WindowH { LinuxProcessKeyPress(&KeyboardController->Start, IsDown); } - else if(Symbol == XK_p) + else if((WindowEvent.xkey.state & Mod1Mask) && + (Symbol == XK_p)) { if(IsDown) { GlobalPaused = !GlobalPaused; } } - else if(Symbol == XK_l) + else if((WindowEvent.xkey.state & Mod1Mask) && + (Symbol == XK_l)) { if(IsDown) { @@ -542,7 +690,8 @@ internal void LinuxProcessPendingMessages(Display *DisplayHandle, Window WindowH } else { - // TODO(luca): Reset buttons so they aren't held? + // NOTE(luca) Reset buttons so they aren't held. + // TODO(luca): Check if still needed since we clear halftransition counts. for(u32 ButtonIndex = 0; ButtonIndex < ArrayCount(KeyboardController->Buttons); ButtonIndex++) @@ -553,8 +702,8 @@ internal void LinuxProcessPendingMessages(Display *DisplayHandle, Window WindowH } } } - else if(Symbol == XK_Escape || - Symbol == XK_q) + else if((WindowEvent.xkey.state & Mod1Mask) && + (Symbol == XK_F4)) { GlobalRunning = false; } @@ -588,11 +737,8 @@ internal void LinuxProcessPendingMessages(Display *DisplayHandle, Window WindowH { //LinuxShowCursor(DisplayHandle, WindowHandle); } break; - } - } - } internal void LinuxSetSizeHint(Display *DisplayHandle, Window WindowHandle, @@ -841,6 +987,20 @@ int main(int ArgC, char *Args[]) ClassHint.res_class = "Handmade Window"; XSetClassHint(DisplayHandle, WindowHandle, &ClassHint); + XSetLocaleModifiers(""); + + XIM InputMethod = XOpenIM(DisplayHandle, 0, 0, 0); + if(!InputMethod){ + XSetLocaleModifiers("@im=none"); + InputMethod = XOpenIM(DisplayHandle, 0, 0, 0); + } + XIC InputContext = XCreateIC(InputMethod, + XNInputStyle, XIMPreeditNothing | XIMStatusNothing, + XNClientWindow, WindowHandle, + XNFocusWindow, WindowHandle, + NULL); + XSetICFocus(InputContext); + int BitsPerPixel = 32; int BytesPerPixel = BitsPerPixel/8; int WindowBufferSize = Width*Height*BytesPerPixel; @@ -990,7 +1150,7 @@ int main(int ArgC, char *Args[]) { NewInput->dtForFrame = TargetSecondsPerFrame; -#if HANDMADE_INTERNAL +#if HANDMADE_SLOW // NOTE(luca): Because gcc will first create an empty file and then write into it we skip trying to reload when the file is empty. struct stat FileStats = {}; stat(LibraryFullPath, &FileStats); @@ -1010,7 +1170,16 @@ int main(int ArgC, char *Args[]) game_controller_input *NewKeyboardController = GetController(NewInput, 0); NewKeyboardController->IsConnected = true; - LinuxProcessPendingMessages(DisplayHandle, WindowHandle, WM_DELETE_WINDOW, &LinuxState, NewKeyboardController); + NewKeyboardController->Keyboard.TextInputCount = 0; + for(u32 ButtonIndex = 0; + ButtonIndex < ArrayCount(NewKeyboardController->Buttons); + ButtonIndex++) + { + NewKeyboardController->Buttons[ButtonIndex].HalfTransitionCount = 0; + } + + LinuxProcessPendingMessages(DisplayHandle, WindowHandle, InputContext, WM_DELETE_WINDOW, + &LinuxState, NewKeyboardController); // TODO(luca): Use buttonpress/release events instead so we query this less frequently. s32 MouseX = 0, MouseY = 0, MouseZ = 0; // TODO(luca): Support mousewheel? @@ -1127,7 +1296,6 @@ int main(int ArgC, char *Args[]) #endif } } - } } } @@ -1229,7 +1397,7 @@ TODO { // TODO(luca): Logging // NOTE(luca): We might want to silence in case of overruns ahead of time. We also probably want to handle latency differently here. - snd_pcm_recover(PCMHandle, LastFramesWritten, 0); + snd_pcm_recover(PCMHandle, LastFramesWritten, ALSA_RECOVER_SILENT); // underrun if(LastFramesWritten == -EPIPE) diff --git a/code/x11_key_to_keysym.c b/code/x11_key_to_keysym.c new file mode 100644 index 0000000..57c8841 --- /dev/null +++ b/code/x11_key_to_keysym.c @@ -0,0 +1,51 @@ +@table(Name, KeySym) KeyboardButtons +{ + { Return XK_Return } + { Delete XK_Delete } + { BackSpace XK_BackSpace } + { Home XK_KP_Home } + { End XK_KP_End } + { PageUp XK_KP_Prior } + { PageDown XK_KP_Next } + { Control XK_Control_L } + { Shift XK_Shift_L } + { Alt XK_Alt_L } + { Insert XK_Insert } + { Escape XK_Escape } + { Up XK_Up } + { Down XK_Down } + { Left XK_Left } + { Right XK_Right } + { F1 XK_F1 } + { F2 XK_F2 } + { F3 XK_F3 } + { F4 XK_F4 } + { F5 XK_F5 } + { F6 XK_F6 } + { F7 XK_F7 } + { F8 XK_F8 } + { F9 XK_F9 } + { F10 XK_F10 } + { F11 XK_F11 } + { F12 XK_F12 } +} + + +if(0) {} +@expand(KeyboardButtons k) +`if\(Symbol == $(k.KeySym)\) +{ + LinuxProcessKeyPress\(&KeyboardController->Keyboard.$(k.Name), IsDown\); +}` + +@expand(KeyboardButtons k) +`game_button_state $(k.Name)` + +typedef enum +{ +@expand(KeyboardButtons k) ` PlatformKeyboardButton_$(k.Name),` + PlatformKeyboardButton_Count +} platform_keyboard_buttons; + +@count(KeyboardButtons) + diff --git a/code/x11_keysym_convert.c b/code/x11_keysym_convert.c new file mode 100644 index 0000000..f05289d --- /dev/null +++ b/code/x11_keysym_convert.c @@ -0,0 +1,2048 @@ +#define XK_MISCELLANY +#define XK_XKB_KEYS +#define XK_3270 +#define XK_LATIN1 +#define XK_LATIN2 +#define XK_LATIN3 +#define XK_LATIN4 +#define XK_LATIN8 +#define XK_LATIN9 +#define XK_KATAKANA +#define XK_ARABIC +#define XK_CYRILLIC +#define XK_GREEK +#define XK_TECHNICAL +#define XK_SPECIAL +#define XK_PUBLISHING +#define XK_APL +#define XK_HEBREW +#define XK_THAI +#define XK_KOREAN +#define XK_ARMENIAN +#define XK_GEORGIAN +#define XK_CAUCASUS +#define XK_VIETNAMESE +#define XK_CURRENCY +#define XK_MATHEMATICAL +#define XK_BRAILLE +#define XK_SINHALA + +#include <X11/keysymdef.h> + +internal char * +LinuxReturnStringForSymbol(KeySym Symbol) +{ + switch(Symbol) + { + case XK_VoidSymbol: return "VoidSymbol"; break; + case XK_BackSpace: return "BackSpace"; break; + case XK_Tab: return "Tab"; break; + case XK_Linefeed: return "Linefeed"; break; + case XK_Clear: return "Clear"; break; + case XK_Return: return "Return"; break; + case XK_Pause: return "Pause"; break; + case XK_Scroll_Lock: return "Scroll_Lock"; break; + case XK_Sys_Req: return "Sys_Req"; break; + case XK_Escape: return "Escape"; break; + case XK_Delete: return "Delete"; break; + case XK_Multi_key: return "Multi_key"; break; + case XK_Codeinput: return "Codeinput"; break; + case XK_SingleCandidate: return "SingleCandidate"; break; + case XK_MultipleCandidate: return "MultipleCandidate"; break; + case XK_PreviousCandidate: return "PreviousCandidate"; break; + case XK_Kanji: return "Kanji"; break; + case XK_Muhenkan: return "Muhenkan"; break; + case XK_Henkan_Mode: return "Henkan_Mode"; break; + case XK_Romaji: return "Romaji"; break; + case XK_Hiragana: return "Hiragana"; break; + case XK_Katakana: return "Katakana"; break; + case XK_Hiragana_Katakana: return "Hiragana_Katakana"; break; + case XK_Zenkaku: return "Zenkaku"; break; + case XK_Hankaku: return "Hankaku"; break; + case XK_Zenkaku_Hankaku: return "Zenkaku_Hankaku"; break; + case XK_Touroku: return "Touroku"; break; + case XK_Massyo: return "Massyo"; break; + case XK_Kana_Lock: return "Kana_Lock"; break; + case XK_Kana_Shift: return "Kana_Shift"; break; + case XK_Eisu_Shift: return "Eisu_Shift"; break; + case XK_Eisu_toggle: return "Eisu_toggle"; break; + case XK_Home: return "Home"; break; + case XK_Left: return "Left"; break; + case XK_Up: return "Up"; break; + case XK_Right: return "Right"; break; + case XK_Down: return "Down"; break; + case XK_Prior: return "Prior"; break; + case XK_Next: return "Next"; break; + case XK_End: return "End"; break; + case XK_Begin: return "Begin"; break; + case XK_Select: return "Select"; break; + case XK_Print: return "Print"; break; + case XK_Execute: return "Execute"; break; + case XK_Insert: return "Insert"; break; + case XK_Undo: return "Undo"; break; + case XK_Redo: return "Redo"; break; + case XK_Menu: return "Menu"; break; + case XK_Find: return "Find"; break; + case XK_Cancel: return "Cancel"; break; + case XK_Help: return "Help"; break; + case XK_Break: return "Break"; break; + case XK_Mode_switch: return "Mode_switch"; break; + case XK_Num_Lock: return "Num_Lock"; break; + case XK_KP_Space: return "KP_Space"; break; + case XK_KP_Tab: return "KP_Tab"; break; + case XK_KP_Enter: return "KP_Enter"; break; + case XK_KP_F1: return "KP_F1"; break; + case XK_KP_F2: return "KP_F2"; break; + case XK_KP_F3: return "KP_F3"; break; + case XK_KP_F4: return "KP_F4"; break; + case XK_KP_Home: return "KP_Home"; break; + case XK_KP_Left: return "KP_Left"; break; + case XK_KP_Up: return "KP_Up"; break; + case XK_KP_Right: return "KP_Right"; break; + case XK_KP_Down: return "KP_Down"; break; + case XK_KP_Prior: return "KP_Prior"; break; + case XK_KP_Next: return "KP_Next"; break; + case XK_KP_End: return "KP_End"; break; + case XK_KP_Begin: return "KP_Begin"; break; + case XK_KP_Insert: return "KP_Insert"; break; + case XK_KP_Delete: return "KP_Delete"; break; + case XK_KP_Equal: return "KP_Equal"; break; + case XK_KP_Multiply: return "KP_Multiply"; break; + case XK_KP_Add: return "KP_Add"; break; + case XK_KP_Separator: return "KP_Separator"; break; + case XK_KP_Subtract: return "KP_Subtract"; break; + case XK_KP_Decimal: return "KP_Decimal"; break; + case XK_KP_Divide: return "KP_Divide"; break; + case XK_KP_0: return "KP_0"; break; + case XK_KP_1: return "KP_1"; break; + case XK_KP_2: return "KP_2"; break; + case XK_KP_3: return "KP_3"; break; + case XK_KP_4: return "KP_4"; break; + case XK_KP_5: return "KP_5"; break; + case XK_KP_6: return "KP_6"; break; + case XK_KP_7: return "KP_7"; break; + case XK_KP_8: return "KP_8"; break; + case XK_KP_9: return "KP_9"; break; + case XK_F1: return "F1"; break; + case XK_F2: return "F2"; break; + case XK_F3: return "F3"; break; + case XK_F4: return "F4"; break; + case XK_F5: return "F5"; break; + case XK_F6: return "F6"; break; + case XK_F7: return "F7"; break; + case XK_F8: return "F8"; break; + case XK_F9: return "F9"; break; + case XK_F10: return "F10"; break; + case XK_F11: return "F11"; break; + case XK_F12: return "F12"; break; + case XK_F13: return "F13"; break; + case XK_F14: return "F14"; break; + case XK_F15: return "F15"; break; + case XK_F16: return "F16"; break; + case XK_F17: return "F17"; break; + case XK_F18: return "F18"; break; + case XK_F19: return "F19"; break; + case XK_F20: return "F20"; break; + case XK_F21: return "F21"; break; + case XK_F22: return "F22"; break; + case XK_F23: return "F23"; break; + case XK_F24: return "F24"; break; + case XK_F25: return "F25"; break; + case XK_F26: return "F26"; break; + case XK_F27: return "F27"; break; + case XK_F28: return "F28"; break; + case XK_F29: return "F29"; break; + case XK_F30: return "F30"; break; + case XK_F31: return "F31"; break; + case XK_F32: return "F32"; break; + case XK_F33: return "F33"; break; + case XK_F34: return "F34"; break; + case XK_F35: return "F35"; break; + case XK_Shift_L: return "Shift_L"; break; + case XK_Shift_R: return "Shift_R"; break; + case XK_Control_L: return "Control_L"; break; + case XK_Control_R: return "Control_R"; break; + case XK_Caps_Lock: return "Caps_Lock"; break; + case XK_Shift_Lock: return "Shift_Lock"; break; + case XK_Meta_L: return "Meta_L"; break; + case XK_Meta_R: return "Meta_R"; break; + case XK_Alt_L: return "Alt_L"; break; + case XK_Alt_R: return "Alt_R"; break; + case XK_Super_L: return "Super_L"; break; + case XK_Super_R: return "Super_R"; break; + case XK_Hyper_L: return "Hyper_L"; break; + case XK_Hyper_R: return "Hyper_R"; break; + case XK_ISO_Lock: return "ISO_Lock"; break; + case XK_ISO_Level2_Latch: return "ISO_Level2_Latch"; break; + case XK_ISO_Level3_Shift: return "ISO_Level3_Shift"; break; + case XK_ISO_Level3_Latch: return "ISO_Level3_Latch"; break; + case XK_ISO_Level3_Lock: return "ISO_Level3_Lock"; break; + case XK_ISO_Level5_Shift: return "ISO_Level5_Shift"; break; + case XK_ISO_Level5_Latch: return "ISO_Level5_Latch"; break; + case XK_ISO_Level5_Lock: return "ISO_Level5_Lock"; break; + case XK_ISO_Group_Latch: return "ISO_Group_Latch"; break; + case XK_ISO_Group_Lock: return "ISO_Group_Lock"; break; + case XK_ISO_Next_Group: return "ISO_Next_Group"; break; + case XK_ISO_Next_Group_Lock: return "ISO_Next_Group_Lock"; break; + case XK_ISO_Prev_Group: return "ISO_Prev_Group"; break; + case XK_ISO_Prev_Group_Lock: return "ISO_Prev_Group_Lock"; break; + case XK_ISO_First_Group: return "ISO_First_Group"; break; + case XK_ISO_First_Group_Lock: return "ISO_First_Group_Lock"; break; + case XK_ISO_Last_Group: return "ISO_Last_Group"; break; + case XK_ISO_Last_Group_Lock: return "ISO_Last_Group_Lock"; break; + case XK_ISO_Left_Tab: return "ISO_Left_Tab"; break; + case XK_ISO_Move_Line_Up: return "ISO_Move_Line_Up"; break; + case XK_ISO_Move_Line_Down: return "ISO_Move_Line_Down"; break; + case XK_ISO_Partial_Line_Up: return "ISO_Partial_Line_Up"; break; + case XK_ISO_Partial_Line_Down: return "ISO_Partial_Line_Down"; break; + case XK_ISO_Partial_Space_Left: return "ISO_Partial_Space_Left"; break; + case XK_ISO_Partial_Space_Right: return "ISO_Partial_Space_Right"; break; + case XK_ISO_Set_Margin_Left: return "ISO_Set_Margin_Left"; break; + case XK_ISO_Set_Margin_Right: return "ISO_Set_Margin_Right"; break; + case XK_ISO_Release_Margin_Left: return "ISO_Release_Margin_Left"; break; + case XK_ISO_Release_Margin_Right: return "ISO_Release_Margin_Right"; break; + case XK_ISO_Release_Both_Margins: return "ISO_Release_Both_Margins"; break; + case XK_ISO_Fast_Cursor_Left: return "ISO_Fast_Cursor_Left"; break; + case XK_ISO_Fast_Cursor_Right: return "ISO_Fast_Cursor_Right"; break; + case XK_ISO_Fast_Cursor_Up: return "ISO_Fast_Cursor_Up"; break; + case XK_ISO_Fast_Cursor_Down: return "ISO_Fast_Cursor_Down"; break; + case XK_ISO_Continuous_Underline: return "ISO_Continuous_Underline"; break; + case XK_ISO_Discontinuous_Underline: return "ISO_Discontinuous_Underline"; break; + case XK_ISO_Emphasize: return "ISO_Emphasize"; break; + case XK_ISO_Center_Object: return "ISO_Center_Object"; break; + case XK_ISO_Enter: return "ISO_Enter"; break; + case XK_dead_grave: return "dead_grave"; break; + case XK_dead_acute: return "dead_acute"; break; + case XK_dead_circumflex: return "dead_circumflex"; break; + case XK_dead_tilde: return "dead_tilde"; break; + case XK_dead_macron: return "dead_macron"; break; + case XK_dead_breve: return "dead_breve"; break; + case XK_dead_abovedot: return "dead_abovedot"; break; + case XK_dead_diaeresis: return "dead_diaeresis"; break; + case XK_dead_abovering: return "dead_abovering"; break; + case XK_dead_doubleacute: return "dead_doubleacute"; break; + case XK_dead_caron: return "dead_caron"; break; + case XK_dead_cedilla: return "dead_cedilla"; break; + case XK_dead_ogonek: return "dead_ogonek"; break; + case XK_dead_iota: return "dead_iota"; break; + case XK_dead_voiced_sound: return "dead_voiced_sound"; break; + case XK_dead_semivoiced_sound: return "dead_semivoiced_sound"; break; + case XK_dead_belowdot: return "dead_belowdot"; break; + case XK_dead_hook: return "dead_hook"; break; + case XK_dead_horn: return "dead_horn"; break; + case XK_dead_stroke: return "dead_stroke"; break; + case XK_dead_abovecomma: return "dead_abovecomma"; break; + case XK_dead_abovereversedcomma: return "dead_abovereversedcomma"; break; + case XK_dead_doublegrave: return "dead_doublegrave"; break; + case XK_dead_belowring: return "dead_belowring"; break; + case XK_dead_belowmacron: return "dead_belowmacron"; break; + case XK_dead_belowcircumflex: return "dead_belowcircumflex"; break; + case XK_dead_belowtilde: return "dead_belowtilde"; break; + case XK_dead_belowbreve: return "dead_belowbreve"; break; + case XK_dead_belowdiaeresis: return "dead_belowdiaeresis"; break; + case XK_dead_invertedbreve: return "dead_invertedbreve"; break; + case XK_dead_belowcomma: return "dead_belowcomma"; break; + case XK_dead_currency: return "dead_currency"; break; + case XK_dead_lowline: return "dead_lowline"; break; + case XK_dead_aboveverticalline: return "dead_aboveverticalline"; break; + case XK_dead_belowverticalline: return "dead_belowverticalline"; break; + case XK_dead_longsolidusoverlay: return "dead_longsolidusoverlay"; break; + case XK_dead_a: return "dead_a"; break; + case XK_dead_A: return "dead_A"; break; + case XK_dead_e: return "dead_e"; break; + case XK_dead_E: return "dead_E"; break; + case XK_dead_i: return "dead_i"; break; + case XK_dead_I: return "dead_I"; break; + case XK_dead_o: return "dead_o"; break; + case XK_dead_O: return "dead_O"; break; + case XK_dead_u: return "dead_u"; break; + case XK_dead_U: return "dead_U"; break; + case XK_dead_small_schwa: return "dead_small_schwa"; break; + case XK_dead_capital_schwa: return "dead_capital_schwa"; break; + case XK_dead_greek: return "dead_greek"; break; + case XK_dead_hamza: return "dead_hamza"; break; + case XK_First_Virtual_Screen: return "First_Virtual_Screen"; break; + case XK_Prev_Virtual_Screen: return "Prev_Virtual_Screen"; break; + case XK_Next_Virtual_Screen: return "Next_Virtual_Screen"; break; + case XK_Last_Virtual_Screen: return "Last_Virtual_Screen"; break; + case XK_Terminate_Server: return "Terminate_Server"; break; + case XK_AccessX_Enable: return "AccessX_Enable"; break; + case XK_AccessX_Feedback_Enable: return "AccessX_Feedback_Enable"; break; + case XK_RepeatKeys_Enable: return "RepeatKeys_Enable"; break; + case XK_SlowKeys_Enable: return "SlowKeys_Enable"; break; + case XK_BounceKeys_Enable: return "BounceKeys_Enable"; break; + case XK_StickyKeys_Enable: return "StickyKeys_Enable"; break; + case XK_MouseKeys_Enable: return "MouseKeys_Enable"; break; + case XK_MouseKeys_Accel_Enable: return "MouseKeys_Accel_Enable"; break; + case XK_Overlay1_Enable: return "Overlay1_Enable"; break; + case XK_Overlay2_Enable: return "Overlay2_Enable"; break; + case XK_AudibleBell_Enable: return "AudibleBell_Enable"; break; + case XK_Pointer_Left: return "Pointer_Left"; break; + case XK_Pointer_Right: return "Pointer_Right"; break; + case XK_Pointer_Up: return "Pointer_Up"; break; + case XK_Pointer_Down: return "Pointer_Down"; break; + case XK_Pointer_UpLeft: return "Pointer_UpLeft"; break; + case XK_Pointer_UpRight: return "Pointer_UpRight"; break; + case XK_Pointer_DownLeft: return "Pointer_DownLeft"; break; + case XK_Pointer_DownRight: return "Pointer_DownRight"; break; + case XK_Pointer_Button_Dflt: return "Pointer_Button_Dflt"; break; + case XK_Pointer_Button1: return "Pointer_Button1"; break; + case XK_Pointer_Button2: return "Pointer_Button2"; break; + case XK_Pointer_Button3: return "Pointer_Button3"; break; + case XK_Pointer_Button4: return "Pointer_Button4"; break; + case XK_Pointer_Button5: return "Pointer_Button5"; break; + case XK_Pointer_DblClick_Dflt: return "Pointer_DblClick_Dflt"; break; + case XK_Pointer_DblClick1: return "Pointer_DblClick1"; break; + case XK_Pointer_DblClick2: return "Pointer_DblClick2"; break; + case XK_Pointer_DblClick3: return "Pointer_DblClick3"; break; + case XK_Pointer_DblClick4: return "Pointer_DblClick4"; break; + case XK_Pointer_DblClick5: return "Pointer_DblClick5"; break; + case XK_Pointer_Drag_Dflt: return "Pointer_Drag_Dflt"; break; + case XK_Pointer_Drag1: return "Pointer_Drag1"; break; + case XK_Pointer_Drag2: return "Pointer_Drag2"; break; + case XK_Pointer_Drag3: return "Pointer_Drag3"; break; + case XK_Pointer_Drag4: return "Pointer_Drag4"; break; + case XK_Pointer_Drag5: return "Pointer_Drag5"; break; + case XK_Pointer_EnableKeys: return "Pointer_EnableKeys"; break; + case XK_Pointer_Accelerate: return "Pointer_Accelerate"; break; + case XK_Pointer_DfltBtnNext: return "Pointer_DfltBtnNext"; break; + case XK_Pointer_DfltBtnPrev: return "Pointer_DfltBtnPrev"; break; + case XK_ch: return "ch"; break; + case XK_Ch: return "Ch"; break; + case XK_CH: return "CH"; break; + case XK_c_h: return "c_h"; break; + case XK_C_h: return "C_h"; break; + case XK_C_H: return "C_H"; break; + case XK_3270_Duplicate: return "3270_Duplicate"; break; + case XK_3270_FieldMark: return "3270_FieldMark"; break; + case XK_3270_Right2: return "3270_Right2"; break; + case XK_3270_Left2: return "3270_Left2"; break; + case XK_3270_BackTab: return "3270_BackTab"; break; + case XK_3270_EraseEOF: return "3270_EraseEOF"; break; + case XK_3270_EraseInput: return "3270_EraseInput"; break; + case XK_3270_Reset: return "3270_Reset"; break; + case XK_3270_Quit: return "3270_Quit"; break; + case XK_3270_PA1: return "3270_PA1"; break; + case XK_3270_PA2: return "3270_PA2"; break; + case XK_3270_PA3: return "3270_PA3"; break; + case XK_3270_Test: return "3270_Test"; break; + case XK_3270_Attn: return "3270_Attn"; break; + case XK_3270_CursorBlink: return "3270_CursorBlink"; break; + case XK_3270_AltCursor: return "3270_AltCursor"; break; + case XK_3270_KeyClick: return "3270_KeyClick"; break; + case XK_3270_Jump: return "3270_Jump"; break; + case XK_3270_Ident: return "3270_Ident"; break; + case XK_3270_Rule: return "3270_Rule"; break; + case XK_3270_Copy: return "3270_Copy"; break; + case XK_3270_Play: return "3270_Play"; break; + case XK_3270_Setup: return "3270_Setup"; break; + case XK_3270_Record: return "3270_Record"; break; + case XK_3270_ChangeScreen: return "3270_ChangeScreen"; break; + case XK_3270_DeleteWord: return "3270_DeleteWord"; break; + case XK_3270_ExSelect: return "3270_ExSelect"; break; + case XK_3270_CursorSelect: return "3270_CursorSelect"; break; + case XK_3270_PrintScreen: return "3270_PrintScreen"; break; + case XK_3270_Enter: return "3270_Enter"; break; + case XK_space: return "space"; break; + case XK_exclam: return "exclam"; break; + case XK_quotedbl: return "quotedbl"; break; + case XK_numbersign: return "numbersign"; break; + case XK_dollar: return "dollar"; break; + case XK_percent: return "percent"; break; + case XK_ampersand: return "ampersand"; break; + case XK_apostrophe: return "apostrophe"; break; + case XK_parenleft: return "parenleft"; break; + case XK_parenright: return "parenright"; break; + case XK_asterisk: return "asterisk"; break; + case XK_plus: return "plus"; break; + case XK_comma: return "comma"; break; + case XK_minus: return "minus"; break; + case XK_period: return "period"; break; + case XK_slash: return "slash"; break; + case XK_0: return "0"; break; + case XK_1: return "1"; break; + case XK_2: return "2"; break; + case XK_3: return "3"; break; + case XK_4: return "4"; break; + case XK_5: return "5"; break; + case XK_6: return "6"; break; + case XK_7: return "7"; break; + case XK_8: return "8"; break; + case XK_9: return "9"; break; + case XK_colon: return "colon"; break; + case XK_semicolon: return "semicolon"; break; + case XK_less: return "less"; break; + case XK_equal: return "equal"; break; + case XK_greater: return "greater"; break; + case XK_question: return "question"; break; + case XK_at: return "at"; break; + case XK_A: return "A"; break; + case XK_B: return "B"; break; + case XK_C: return "C"; break; + case XK_D: return "D"; break; + case XK_E: return "E"; break; + case XK_F: return "F"; break; + case XK_G: return "G"; break; + case XK_H: return "H"; break; + case XK_I: return "I"; break; + case XK_J: return "J"; break; + case XK_K: return "K"; break; + case XK_L: return "L"; break; + case XK_M: return "M"; break; + case XK_N: return "N"; break; + case XK_O: return "O"; break; + case XK_P: return "P"; break; + case XK_Q: return "Q"; break; + case XK_R: return "R"; break; + case XK_S: return "S"; break; + case XK_T: return "T"; break; + case XK_U: return "U"; break; + case XK_V: return "V"; break; + case XK_W: return "W"; break; + case XK_X: return "X"; break; + case XK_Y: return "Y"; break; + case XK_Z: return "Z"; break; + case XK_bracketleft: return "bracketleft"; break; + case XK_backslash: return "backslash"; break; + case XK_bracketright: return "bracketright"; break; + case XK_asciicircum: return "asciicircum"; break; + case XK_underscore: return "underscore"; break; + case XK_grave: return "grave"; break; + case XK_a: return "a"; break; + case XK_b: return "b"; break; + case XK_c: return "c"; break; + case XK_d: return "d"; break; + case XK_e: return "e"; break; + case XK_f: return "f"; break; + case XK_g: return "g"; break; + case XK_h: return "h"; break; + case XK_i: return "i"; break; + case XK_j: return "j"; break; + case XK_k: return "k"; break; + case XK_l: return "l"; break; + case XK_m: return "m"; break; + case XK_n: return "n"; break; + case XK_o: return "o"; break; + case XK_p: return "p"; break; + case XK_q: return "q"; break; + case XK_r: return "r"; break; + case XK_s: return "s"; break; + case XK_t: return "t"; break; + case XK_u: return "u"; break; + case XK_v: return "v"; break; + case XK_w: return "w"; break; + case XK_x: return "x"; break; + case XK_y: return "y"; break; + case XK_z: return "z"; break; + case XK_braceleft: return "braceleft"; break; + case XK_bar: return "bar"; break; + case XK_braceright: return "braceright"; break; + case XK_asciitilde: return "asciitilde"; break; + case XK_nobreakspace: return "nobreakspace"; break; + case XK_exclamdown: return "exclamdown"; break; + case XK_cent: return "cent"; break; + case XK_sterling: return "sterling"; break; + case XK_currency: return "currency"; break; + case XK_yen: return "yen"; break; + case XK_brokenbar: return "brokenbar"; break; + case XK_section: return "section"; break; + case XK_diaeresis: return "diaeresis"; break; + case XK_copyright: return "copyright"; break; + case XK_ordfeminine: return "ordfeminine"; break; + case XK_guillemotleft: return "guillemotleft"; break; + case XK_notsign: return "notsign"; break; + case XK_hyphen: return "hyphen"; break; + case XK_registered: return "registered"; break; + case XK_macron: return "macron"; break; + case XK_degree: return "degree"; break; + case XK_plusminus: return "plusminus"; break; + case XK_twosuperior: return "twosuperior"; break; + case XK_threesuperior: return "threesuperior"; break; + case XK_acute: return "acute"; break; + case XK_mu: return "mu"; break; + case XK_paragraph: return "paragraph"; break; + case XK_periodcentered: return "periodcentered"; break; + case XK_cedilla: return "cedilla"; break; + case XK_onesuperior: return "onesuperior"; break; + case XK_masculine: return "masculine"; break; + case XK_guillemotright: return "guillemotright"; break; + case XK_onequarter: return "onequarter"; break; + case XK_onehalf: return "onehalf"; break; + case XK_threequarters: return "threequarters"; break; + case XK_questiondown: return "questiondown"; break; + case XK_Agrave: return "Agrave"; break; + case XK_Aacute: return "Aacute"; break; + case XK_Acircumflex: return "Acircumflex"; break; + case XK_Atilde: return "Atilde"; break; + case XK_Adiaeresis: return "Adiaeresis"; break; + case XK_Aring: return "Aring"; break; + case XK_AE: return "AE"; break; + case XK_Ccedilla: return "Ccedilla"; break; + case XK_Egrave: return "Egrave"; break; + case XK_Eacute: return "Eacute"; break; + case XK_Ecircumflex: return "Ecircumflex"; break; + case XK_Ediaeresis: return "Ediaeresis"; break; + case XK_Igrave: return "Igrave"; break; + case XK_Iacute: return "Iacute"; break; + case XK_Icircumflex: return "Icircumflex"; break; + case XK_Idiaeresis: return "Idiaeresis"; break; + case XK_ETH: return "ETH"; break; + case XK_Ntilde: return "Ntilde"; break; + case XK_Ograve: return "Ograve"; break; + case XK_Oacute: return "Oacute"; break; + case XK_Ocircumflex: return "Ocircumflex"; break; + case XK_Otilde: return "Otilde"; break; + case XK_Odiaeresis: return "Odiaeresis"; break; + case XK_multiply: return "multiply"; break; + case XK_Oslash: return "Oslash"; break; + case XK_Ugrave: return "Ugrave"; break; + case XK_Uacute: return "Uacute"; break; + case XK_Ucircumflex: return "Ucircumflex"; break; + case XK_Udiaeresis: return "Udiaeresis"; break; + case XK_Yacute: return "Yacute"; break; + case XK_THORN: return "THORN"; break; + case XK_ssharp: return "ssharp"; break; + case XK_agrave: return "agrave"; break; + case XK_aacute: return "aacute"; break; + case XK_acircumflex: return "acircumflex"; break; + case XK_atilde: return "atilde"; break; + case XK_adiaeresis: return "adiaeresis"; break; + case XK_aring: return "aring"; break; + case XK_ae: return "ae"; break; + case XK_ccedilla: return "ccedilla"; break; + case XK_egrave: return "egrave"; break; + case XK_eacute: return "eacute"; break; + case XK_ecircumflex: return "ecircumflex"; break; + case XK_ediaeresis: return "ediaeresis"; break; + case XK_igrave: return "igrave"; break; + case XK_iacute: return "iacute"; break; + case XK_icircumflex: return "icircumflex"; break; + case XK_idiaeresis: return "idiaeresis"; break; + case XK_eth: return "eth"; break; + case XK_ntilde: return "ntilde"; break; + case XK_ograve: return "ograve"; break; + case XK_oacute: return "oacute"; break; + case XK_ocircumflex: return "ocircumflex"; break; + case XK_otilde: return "otilde"; break; + case XK_odiaeresis: return "odiaeresis"; break; + case XK_division: return "division"; break; + case XK_oslash: return "oslash"; break; + case XK_ugrave: return "ugrave"; break; + case XK_uacute: return "uacute"; break; + case XK_ucircumflex: return "ucircumflex"; break; + case XK_udiaeresis: return "udiaeresis"; break; + case XK_yacute: return "yacute"; break; + case XK_thorn: return "thorn"; break; + case XK_ydiaeresis: return "ydiaeresis"; break; + case XK_Aogonek: return "Aogonek"; break; + case XK_breve: return "breve"; break; + case XK_Lstroke: return "Lstroke"; break; + case XK_Lcaron: return "Lcaron"; break; + case XK_Sacute: return "Sacute"; break; + case XK_Scaron: return "Scaron"; break; + case XK_Tcaron: return "Tcaron"; break; + case XK_Zacute: return "Zacute"; break; + case XK_Zcaron: return "Zcaron"; break; + case XK_Zabovedot: return "Zabovedot"; break; + case XK_aogonek: return "aogonek"; break; + case XK_ogonek: return "ogonek"; break; + case XK_lstroke: return "lstroke"; break; + case XK_lcaron: return "lcaron"; break; + case XK_sacute: return "sacute"; break; + case XK_caron: return "caron"; break; + case XK_scaron: return "scaron"; break; + case XK_scedilla: return "scedilla"; break; + case XK_tcaron: return "tcaron"; break; + case XK_zacute: return "zacute"; break; + case XK_doubleacute: return "doubleacute"; break; + case XK_zcaron: return "zcaron"; break; + case XK_zabovedot: return "zabovedot"; break; + case XK_Racute: return "Racute"; break; + case XK_Abreve: return "Abreve"; break; + case XK_Lacute: return "Lacute"; break; + case XK_Cacute: return "Cacute"; break; + case XK_Ccaron: return "Ccaron"; break; + case XK_Eogonek: return "Eogonek"; break; + case XK_Ecaron: return "Ecaron"; break; + case XK_Dcaron: return "Dcaron"; break; + case XK_Dstroke: return "Dstroke"; break; + case XK_Nacute: return "Nacute"; break; + case XK_Ncaron: return "Ncaron"; break; + case XK_Odoubleacute: return "Odoubleacute"; break; + case XK_Rcaron: return "Rcaron"; break; + case XK_Uring: return "Uring"; break; + case XK_Udoubleacute: return "Udoubleacute"; break; + case XK_Tcedilla: return "Tcedilla"; break; + case XK_racute: return "racute"; break; + case XK_abreve: return "abreve"; break; + case XK_lacute: return "lacute"; break; + case XK_cacute: return "cacute"; break; + case XK_ccaron: return "ccaron"; break; + case XK_eogonek: return "eogonek"; break; + case XK_ecaron: return "ecaron"; break; + case XK_dcaron: return "dcaron"; break; + case XK_dstroke: return "dstroke"; break; + case XK_nacute: return "nacute"; break; + case XK_ncaron: return "ncaron"; break; + case XK_odoubleacute: return "odoubleacute"; break; + case XK_rcaron: return "rcaron"; break; + case XK_uring: return "uring"; break; + case XK_udoubleacute: return "udoubleacute"; break; + case XK_tcedilla: return "tcedilla"; break; + case XK_abovedot: return "abovedot"; break; + case XK_Hstroke: return "Hstroke"; break; + case XK_Hcircumflex: return "Hcircumflex"; break; + case XK_Iabovedot: return "Iabovedot"; break; + case XK_Gbreve: return "Gbreve"; break; + case XK_Jcircumflex: return "Jcircumflex"; break; + case XK_hstroke: return "hstroke"; break; + case XK_hcircumflex: return "hcircumflex"; break; + case XK_idotless: return "idotless"; break; + case XK_gbreve: return "gbreve"; break; + case XK_jcircumflex: return "jcircumflex"; break; + case XK_Cabovedot: return "Cabovedot"; break; + case XK_Ccircumflex: return "Ccircumflex"; break; + case XK_Gabovedot: return "Gabovedot"; break; + case XK_Gcircumflex: return "Gcircumflex"; break; + case XK_Ubreve: return "Ubreve"; break; + case XK_Scircumflex: return "Scircumflex"; break; + case XK_cabovedot: return "cabovedot"; break; + case XK_ccircumflex: return "ccircumflex"; break; + case XK_gabovedot: return "gabovedot"; break; + case XK_gcircumflex: return "gcircumflex"; break; + case XK_ubreve: return "ubreve"; break; + case XK_scircumflex: return "scircumflex"; break; + case XK_kra: return "kra"; break; + case XK_Rcedilla: return "Rcedilla"; break; + case XK_Itilde: return "Itilde"; break; + case XK_Lcedilla: return "Lcedilla"; break; + case XK_Emacron: return "Emacron"; break; + case XK_Gcedilla: return "Gcedilla"; break; + case XK_Tslash: return "Tslash"; break; + case XK_rcedilla: return "rcedilla"; break; + case XK_itilde: return "itilde"; break; + case XK_lcedilla: return "lcedilla"; break; + case XK_emacron: return "emacron"; break; + case XK_gcedilla: return "gcedilla"; break; + case XK_tslash: return "tslash"; break; + case XK_ENG: return "ENG"; break; + case XK_eng: return "eng"; break; + case XK_Amacron: return "Amacron"; break; + case XK_Iogonek: return "Iogonek"; break; + case XK_Eabovedot: return "Eabovedot"; break; + case XK_Imacron: return "Imacron"; break; + case XK_Ncedilla: return "Ncedilla"; break; + case XK_Omacron: return "Omacron"; break; + case XK_Kcedilla: return "Kcedilla"; break; + case XK_Uogonek: return "Uogonek"; break; + case XK_Utilde: return "Utilde"; break; + case XK_Umacron: return "Umacron"; break; + case XK_amacron: return "amacron"; break; + case XK_iogonek: return "iogonek"; break; + case XK_eabovedot: return "eabovedot"; break; + case XK_imacron: return "imacron"; break; + case XK_ncedilla: return "ncedilla"; break; + case XK_omacron: return "omacron"; break; + case XK_kcedilla: return "kcedilla"; break; + case XK_uogonek: return "uogonek"; break; + case XK_utilde: return "utilde"; break; + case XK_umacron: return "umacron"; break; + case XK_Wcircumflex: return "Wcircumflex"; break; + case XK_wcircumflex: return "wcircumflex"; break; + case XK_Ycircumflex: return "Ycircumflex"; break; + case XK_ycircumflex: return "ycircumflex"; break; + case XK_Babovedot: return "Babovedot"; break; + case XK_babovedot: return "babovedot"; break; + case XK_Dabovedot: return "Dabovedot"; break; + case XK_dabovedot: return "dabovedot"; break; + case XK_Fabovedot: return "Fabovedot"; break; + case XK_fabovedot: return "fabovedot"; break; + case XK_Mabovedot: return "Mabovedot"; break; + case XK_mabovedot: return "mabovedot"; break; + case XK_Pabovedot: return "Pabovedot"; break; + case XK_pabovedot: return "pabovedot"; break; + case XK_Sabovedot: return "Sabovedot"; break; + case XK_sabovedot: return "sabovedot"; break; + case XK_Tabovedot: return "Tabovedot"; break; + case XK_tabovedot: return "tabovedot"; break; + case XK_Wgrave: return "Wgrave"; break; + case XK_wgrave: return "wgrave"; break; + case XK_Wacute: return "Wacute"; break; + case XK_wacute: return "wacute"; break; + case XK_Wdiaeresis: return "Wdiaeresis"; break; + case XK_wdiaeresis: return "wdiaeresis"; break; + case XK_Ygrave: return "Ygrave"; break; + case XK_ygrave: return "ygrave"; break; + case XK_OE: return "OE"; break; + case XK_oe: return "oe"; break; + case XK_Ydiaeresis: return "Ydiaeresis"; break; + case XK_overline: return "overline"; break; + case XK_kana_fullstop: return "kana_fullstop"; break; + case XK_kana_openingbracket: return "kana_openingbracket"; break; + case XK_kana_closingbracket: return "kana_closingbracket"; break; + case XK_kana_comma: return "kana_comma"; break; + case XK_kana_conjunctive: return "kana_conjunctive"; break; + case XK_kana_WO: return "kana_WO"; break; + case XK_kana_a: return "kana_a"; break; + case XK_kana_i: return "kana_i"; break; + case XK_kana_u: return "kana_u"; break; + case XK_kana_e: return "kana_e"; break; + case XK_kana_o: return "kana_o"; break; + case XK_kana_ya: return "kana_ya"; break; + case XK_kana_yu: return "kana_yu"; break; + case XK_kana_yo: return "kana_yo"; break; + case XK_kana_tsu: return "kana_tsu"; break; + case XK_prolongedsound: return "prolongedsound"; break; + case XK_kana_A: return "kana_A"; break; + case XK_kana_I: return "kana_I"; break; + case XK_kana_U: return "kana_U"; break; + case XK_kana_E: return "kana_E"; break; + case XK_kana_O: return "kana_O"; break; + case XK_kana_KA: return "kana_KA"; break; + case XK_kana_KI: return "kana_KI"; break; + case XK_kana_KU: return "kana_KU"; break; + case XK_kana_KE: return "kana_KE"; break; + case XK_kana_KO: return "kana_KO"; break; + case XK_kana_SA: return "kana_SA"; break; + case XK_kana_SHI: return "kana_SHI"; break; + case XK_kana_SU: return "kana_SU"; break; + case XK_kana_SE: return "kana_SE"; break; + case XK_kana_SO: return "kana_SO"; break; + case XK_kana_TA: return "kana_TA"; break; + case XK_kana_CHI: return "kana_CHI"; break; + case XK_kana_TSU: return "kana_TSU"; break; + case XK_kana_TE: return "kana_TE"; break; + case XK_kana_TO: return "kana_TO"; break; + case XK_kana_NA: return "kana_NA"; break; + case XK_kana_NI: return "kana_NI"; break; + case XK_kana_NU: return "kana_NU"; break; + case XK_kana_NE: return "kana_NE"; break; + case XK_kana_NO: return "kana_NO"; break; + case XK_kana_HA: return "kana_HA"; break; + case XK_kana_HI: return "kana_HI"; break; + case XK_kana_FU: return "kana_FU"; break; + case XK_kana_HE: return "kana_HE"; break; + case XK_kana_HO: return "kana_HO"; break; + case XK_kana_MA: return "kana_MA"; break; + case XK_kana_MI: return "kana_MI"; break; + case XK_kana_MU: return "kana_MU"; break; + case XK_kana_ME: return "kana_ME"; break; + case XK_kana_MO: return "kana_MO"; break; + case XK_kana_YA: return "kana_YA"; break; + case XK_kana_YU: return "kana_YU"; break; + case XK_kana_YO: return "kana_YO"; break; + case XK_kana_RA: return "kana_RA"; break; + case XK_kana_RI: return "kana_RI"; break; + case XK_kana_RU: return "kana_RU"; break; + case XK_kana_RE: return "kana_RE"; break; + case XK_kana_RO: return "kana_RO"; break; + case XK_kana_WA: return "kana_WA"; break; + case XK_kana_N: return "kana_N"; break; + case XK_voicedsound: return "voicedsound"; break; + case XK_semivoicedsound: return "semivoicedsound"; break; + case XK_Farsi_0: return "Farsi_0"; break; + case XK_Farsi_1: return "Farsi_1"; break; + case XK_Farsi_2: return "Farsi_2"; break; + case XK_Farsi_3: return "Farsi_3"; break; + case XK_Farsi_4: return "Farsi_4"; break; + case XK_Farsi_5: return "Farsi_5"; break; + case XK_Farsi_6: return "Farsi_6"; break; + case XK_Farsi_7: return "Farsi_7"; break; + case XK_Farsi_8: return "Farsi_8"; break; + case XK_Farsi_9: return "Farsi_9"; break; + case XK_Arabic_percent: return "Arabic_percent"; break; + case XK_Arabic_superscript_alef: return "Arabic_superscript_alef"; break; + case XK_Arabic_tteh: return "Arabic_tteh"; break; + case XK_Arabic_peh: return "Arabic_peh"; break; + case XK_Arabic_tcheh: return "Arabic_tcheh"; break; + case XK_Arabic_ddal: return "Arabic_ddal"; break; + case XK_Arabic_rreh: return "Arabic_rreh"; break; + case XK_Arabic_comma: return "Arabic_comma"; break; + case XK_Arabic_fullstop: return "Arabic_fullstop"; break; + case XK_Arabic_0: return "Arabic_0"; break; + case XK_Arabic_1: return "Arabic_1"; break; + case XK_Arabic_2: return "Arabic_2"; break; + case XK_Arabic_3: return "Arabic_3"; break; + case XK_Arabic_4: return "Arabic_4"; break; + case XK_Arabic_5: return "Arabic_5"; break; + case XK_Arabic_6: return "Arabic_6"; break; + case XK_Arabic_7: return "Arabic_7"; break; + case XK_Arabic_8: return "Arabic_8"; break; + case XK_Arabic_9: return "Arabic_9"; break; + case XK_Arabic_semicolon: return "Arabic_semicolon"; break; + case XK_Arabic_question_mark: return "Arabic_question_mark"; break; + case XK_Arabic_hamza: return "Arabic_hamza"; break; + case XK_Arabic_maddaonalef: return "Arabic_maddaonalef"; break; + case XK_Arabic_hamzaonalef: return "Arabic_hamzaonalef"; break; + case XK_Arabic_hamzaonwaw: return "Arabic_hamzaonwaw"; break; + case XK_Arabic_hamzaunderalef: return "Arabic_hamzaunderalef"; break; + case XK_Arabic_hamzaonyeh: return "Arabic_hamzaonyeh"; break; + case XK_Arabic_alef: return "Arabic_alef"; break; + case XK_Arabic_beh: return "Arabic_beh"; break; + case XK_Arabic_tehmarbuta: return "Arabic_tehmarbuta"; break; + case XK_Arabic_teh: return "Arabic_teh"; break; + case XK_Arabic_theh: return "Arabic_theh"; break; + case XK_Arabic_jeem: return "Arabic_jeem"; break; + case XK_Arabic_hah: return "Arabic_hah"; break; + case XK_Arabic_khah: return "Arabic_khah"; break; + case XK_Arabic_dal: return "Arabic_dal"; break; + case XK_Arabic_thal: return "Arabic_thal"; break; + case XK_Arabic_ra: return "Arabic_ra"; break; + case XK_Arabic_zain: return "Arabic_zain"; break; + case XK_Arabic_seen: return "Arabic_seen"; break; + case XK_Arabic_sheen: return "Arabic_sheen"; break; + case XK_Arabic_sad: return "Arabic_sad"; break; + case XK_Arabic_dad: return "Arabic_dad"; break; + case XK_Arabic_tah: return "Arabic_tah"; break; + case XK_Arabic_zah: return "Arabic_zah"; break; + case XK_Arabic_ain: return "Arabic_ain"; break; + case XK_Arabic_ghain: return "Arabic_ghain"; break; + case XK_Arabic_tatweel: return "Arabic_tatweel"; break; + case XK_Arabic_feh: return "Arabic_feh"; break; + case XK_Arabic_qaf: return "Arabic_qaf"; break; + case XK_Arabic_kaf: return "Arabic_kaf"; break; + case XK_Arabic_lam: return "Arabic_lam"; break; + case XK_Arabic_meem: return "Arabic_meem"; break; + case XK_Arabic_noon: return "Arabic_noon"; break; + case XK_Arabic_ha: return "Arabic_ha"; break; + case XK_Arabic_waw: return "Arabic_waw"; break; + case XK_Arabic_alefmaksura: return "Arabic_alefmaksura"; break; + case XK_Arabic_yeh: return "Arabic_yeh"; break; + case XK_Arabic_fathatan: return "Arabic_fathatan"; break; + case XK_Arabic_dammatan: return "Arabic_dammatan"; break; + case XK_Arabic_kasratan: return "Arabic_kasratan"; break; + case XK_Arabic_fatha: return "Arabic_fatha"; break; + case XK_Arabic_damma: return "Arabic_damma"; break; + case XK_Arabic_kasra: return "Arabic_kasra"; break; + case XK_Arabic_shadda: return "Arabic_shadda"; break; + case XK_Arabic_sukun: return "Arabic_sukun"; break; + case XK_Arabic_madda_above: return "Arabic_madda_above"; break; + case XK_Arabic_hamza_above: return "Arabic_hamza_above"; break; + case XK_Arabic_hamza_below: return "Arabic_hamza_below"; break; + case XK_Arabic_jeh: return "Arabic_jeh"; break; + case XK_Arabic_veh: return "Arabic_veh"; break; + case XK_Arabic_keheh: return "Arabic_keheh"; break; + case XK_Arabic_gaf: return "Arabic_gaf"; break; + case XK_Arabic_noon_ghunna: return "Arabic_noon_ghunna"; break; + case XK_Arabic_heh_doachashmee: return "Arabic_heh_doachashmee"; break; + case XK_Farsi_yeh: return "Farsi_yeh"; break; + case XK_Arabic_yeh_baree: return "Arabic_yeh_baree"; break; + case XK_Arabic_heh_goal: return "Arabic_heh_goal"; break; + case XK_Cyrillic_GHE_bar: return "Cyrillic_GHE_bar"; break; + case XK_Cyrillic_ghe_bar: return "Cyrillic_ghe_bar"; break; + case XK_Cyrillic_ZHE_descender: return "Cyrillic_ZHE_descender"; break; + case XK_Cyrillic_zhe_descender: return "Cyrillic_zhe_descender"; break; + case XK_Cyrillic_KA_descender: return "Cyrillic_KA_descender"; break; + case XK_Cyrillic_ka_descender: return "Cyrillic_ka_descender"; break; + case XK_Cyrillic_KA_vertstroke: return "Cyrillic_KA_vertstroke"; break; + case XK_Cyrillic_ka_vertstroke: return "Cyrillic_ka_vertstroke"; break; + case XK_Cyrillic_EN_descender: return "Cyrillic_EN_descender"; break; + case XK_Cyrillic_en_descender: return "Cyrillic_en_descender"; break; + case XK_Cyrillic_U_straight: return "Cyrillic_U_straight"; break; + case XK_Cyrillic_u_straight: return "Cyrillic_u_straight"; break; + case XK_Cyrillic_U_straight_bar: return "Cyrillic_U_straight_bar"; break; + case XK_Cyrillic_u_straight_bar: return "Cyrillic_u_straight_bar"; break; + case XK_Cyrillic_HA_descender: return "Cyrillic_HA_descender"; break; + case XK_Cyrillic_ha_descender: return "Cyrillic_ha_descender"; break; + case XK_Cyrillic_CHE_descender: return "Cyrillic_CHE_descender"; break; + case XK_Cyrillic_che_descender: return "Cyrillic_che_descender"; break; + case XK_Cyrillic_CHE_vertstroke: return "Cyrillic_CHE_vertstroke"; break; + case XK_Cyrillic_che_vertstroke: return "Cyrillic_che_vertstroke"; break; + case XK_Cyrillic_SHHA: return "Cyrillic_SHHA"; break; + case XK_Cyrillic_shha: return "Cyrillic_shha"; break; + case XK_Cyrillic_SCHWA: return "Cyrillic_SCHWA"; break; + case XK_Cyrillic_schwa: return "Cyrillic_schwa"; break; + case XK_Cyrillic_I_macron: return "Cyrillic_I_macron"; break; + case XK_Cyrillic_i_macron: return "Cyrillic_i_macron"; break; + case XK_Cyrillic_O_bar: return "Cyrillic_O_bar"; break; + case XK_Cyrillic_o_bar: return "Cyrillic_o_bar"; break; + case XK_Cyrillic_U_macron: return "Cyrillic_U_macron"; break; + case XK_Cyrillic_u_macron: return "Cyrillic_u_macron"; break; + case XK_Serbian_dje: return "Serbian_dje"; break; + case XK_Macedonia_gje: return "Macedonia_gje"; break; + case XK_Cyrillic_io: return "Cyrillic_io"; break; + case XK_Ukrainian_ie: return "Ukrainian_ie"; break; + case XK_Macedonia_dse: return "Macedonia_dse"; break; + case XK_Ukrainian_i: return "Ukrainian_i"; break; + case XK_Ukrainian_yi: return "Ukrainian_yi"; break; + case XK_Cyrillic_je: return "Cyrillic_je"; break; + case XK_Cyrillic_lje: return "Cyrillic_lje"; break; + case XK_Cyrillic_nje: return "Cyrillic_nje"; break; + case XK_Serbian_tshe: return "Serbian_tshe"; break; + case XK_Macedonia_kje: return "Macedonia_kje"; break; + case XK_Ukrainian_ghe_with_upturn: return "Ukrainian_ghe_with_upturn"; break; + case XK_Byelorussian_shortu: return "Byelorussian_shortu"; break; + case XK_Cyrillic_dzhe: return "Cyrillic_dzhe"; break; + case XK_numerosign: return "numerosign"; break; + case XK_Serbian_DJE: return "Serbian_DJE"; break; + case XK_Macedonia_GJE: return "Macedonia_GJE"; break; + case XK_Cyrillic_IO: return "Cyrillic_IO"; break; + case XK_Ukrainian_IE: return "Ukrainian_IE"; break; + case XK_Macedonia_DSE: return "Macedonia_DSE"; break; + case XK_Ukrainian_I: return "Ukrainian_I"; break; + case XK_Ukrainian_YI: return "Ukrainian_YI"; break; + case XK_Cyrillic_JE: return "Cyrillic_JE"; break; + case XK_Cyrillic_LJE: return "Cyrillic_LJE"; break; + case XK_Cyrillic_NJE: return "Cyrillic_NJE"; break; + case XK_Serbian_TSHE: return "Serbian_TSHE"; break; + case XK_Macedonia_KJE: return "Macedonia_KJE"; break; + case XK_Ukrainian_GHE_WITH_UPTURN: return "Ukrainian_GHE_WITH_UPTURN"; break; + case XK_Byelorussian_SHORTU: return "Byelorussian_SHORTU"; break; + case XK_Cyrillic_DZHE: return "Cyrillic_DZHE"; break; + case XK_Cyrillic_yu: return "Cyrillic_yu"; break; + case XK_Cyrillic_a: return "Cyrillic_a"; break; + case XK_Cyrillic_be: return "Cyrillic_be"; break; + case XK_Cyrillic_tse: return "Cyrillic_tse"; break; + case XK_Cyrillic_de: return "Cyrillic_de"; break; + case XK_Cyrillic_ie: return "Cyrillic_ie"; break; + case XK_Cyrillic_ef: return "Cyrillic_ef"; break; + case XK_Cyrillic_ghe: return "Cyrillic_ghe"; break; + case XK_Cyrillic_ha: return "Cyrillic_ha"; break; + case XK_Cyrillic_i: return "Cyrillic_i"; break; + case XK_Cyrillic_shorti: return "Cyrillic_shorti"; break; + case XK_Cyrillic_ka: return "Cyrillic_ka"; break; + case XK_Cyrillic_el: return "Cyrillic_el"; break; + case XK_Cyrillic_em: return "Cyrillic_em"; break; + case XK_Cyrillic_en: return "Cyrillic_en"; break; + case XK_Cyrillic_o: return "Cyrillic_o"; break; + case XK_Cyrillic_pe: return "Cyrillic_pe"; break; + case XK_Cyrillic_ya: return "Cyrillic_ya"; break; + case XK_Cyrillic_er: return "Cyrillic_er"; break; + case XK_Cyrillic_es: return "Cyrillic_es"; break; + case XK_Cyrillic_te: return "Cyrillic_te"; break; + case XK_Cyrillic_u: return "Cyrillic_u"; break; + case XK_Cyrillic_zhe: return "Cyrillic_zhe"; break; + case XK_Cyrillic_ve: return "Cyrillic_ve"; break; + case XK_Cyrillic_softsign: return "Cyrillic_softsign"; break; + case XK_Cyrillic_yeru: return "Cyrillic_yeru"; break; + case XK_Cyrillic_ze: return "Cyrillic_ze"; break; + case XK_Cyrillic_sha: return "Cyrillic_sha"; break; + case XK_Cyrillic_e: return "Cyrillic_e"; break; + case XK_Cyrillic_shcha: return "Cyrillic_shcha"; break; + case XK_Cyrillic_che: return "Cyrillic_che"; break; + case XK_Cyrillic_hardsign: return "Cyrillic_hardsign"; break; + case XK_Cyrillic_YU: return "Cyrillic_YU"; break; + case XK_Cyrillic_A: return "Cyrillic_A"; break; + case XK_Cyrillic_BE: return "Cyrillic_BE"; break; + case XK_Cyrillic_TSE: return "Cyrillic_TSE"; break; + case XK_Cyrillic_DE: return "Cyrillic_DE"; break; + case XK_Cyrillic_IE: return "Cyrillic_IE"; break; + case XK_Cyrillic_EF: return "Cyrillic_EF"; break; + case XK_Cyrillic_GHE: return "Cyrillic_GHE"; break; + case XK_Cyrillic_HA: return "Cyrillic_HA"; break; + case XK_Cyrillic_I: return "Cyrillic_I"; break; + case XK_Cyrillic_SHORTI: return "Cyrillic_SHORTI"; break; + case XK_Cyrillic_KA: return "Cyrillic_KA"; break; + case XK_Cyrillic_EL: return "Cyrillic_EL"; break; + case XK_Cyrillic_EM: return "Cyrillic_EM"; break; + case XK_Cyrillic_EN: return "Cyrillic_EN"; break; + case XK_Cyrillic_O: return "Cyrillic_O"; break; + case XK_Cyrillic_PE: return "Cyrillic_PE"; break; + case XK_Cyrillic_YA: return "Cyrillic_YA"; break; + case XK_Cyrillic_ER: return "Cyrillic_ER"; break; + case XK_Cyrillic_ES: return "Cyrillic_ES"; break; + case XK_Cyrillic_TE: return "Cyrillic_TE"; break; + case XK_Cyrillic_U: return "Cyrillic_U"; break; + case XK_Cyrillic_ZHE: return "Cyrillic_ZHE"; break; + case XK_Cyrillic_VE: return "Cyrillic_VE"; break; + case XK_Cyrillic_SOFTSIGN: return "Cyrillic_SOFTSIGN"; break; + case XK_Cyrillic_YERU: return "Cyrillic_YERU"; break; + case XK_Cyrillic_ZE: return "Cyrillic_ZE"; break; + case XK_Cyrillic_SHA: return "Cyrillic_SHA"; break; + case XK_Cyrillic_E: return "Cyrillic_E"; break; + case XK_Cyrillic_SHCHA: return "Cyrillic_SHCHA"; break; + case XK_Cyrillic_CHE: return "Cyrillic_CHE"; break; + case XK_Cyrillic_HARDSIGN: return "Cyrillic_HARDSIGN"; break; + case XK_Greek_ALPHAaccent: return "Greek_ALPHAaccent"; break; + case XK_Greek_EPSILONaccent: return "Greek_EPSILONaccent"; break; + case XK_Greek_ETAaccent: return "Greek_ETAaccent"; break; + case XK_Greek_IOTAaccent: return "Greek_IOTAaccent"; break; + case XK_Greek_IOTAdieresis: return "Greek_IOTAdieresis"; break; + case XK_Greek_OMICRONaccent: return "Greek_OMICRONaccent"; break; + case XK_Greek_UPSILONaccent: return "Greek_UPSILONaccent"; break; + case XK_Greek_UPSILONdieresis: return "Greek_UPSILONdieresis"; break; + case XK_Greek_OMEGAaccent: return "Greek_OMEGAaccent"; break; + case XK_Greek_accentdieresis: return "Greek_accentdieresis"; break; + case XK_Greek_horizbar: return "Greek_horizbar"; break; + case XK_Greek_alphaaccent: return "Greek_alphaaccent"; break; + case XK_Greek_epsilonaccent: return "Greek_epsilonaccent"; break; + case XK_Greek_etaaccent: return "Greek_etaaccent"; break; + case XK_Greek_iotaaccent: return "Greek_iotaaccent"; break; + case XK_Greek_iotadieresis: return "Greek_iotadieresis"; break; + case XK_Greek_iotaaccentdieresis: return "Greek_iotaaccentdieresis"; break; + case XK_Greek_omicronaccent: return "Greek_omicronaccent"; break; + case XK_Greek_upsilonaccent: return "Greek_upsilonaccent"; break; + case XK_Greek_upsilondieresis: return "Greek_upsilondieresis"; break; + case XK_Greek_upsilonaccentdieresis: return "Greek_upsilonaccentdieresis"; break; + case XK_Greek_omegaaccent: return "Greek_omegaaccent"; break; + case XK_Greek_ALPHA: return "Greek_ALPHA"; break; + case XK_Greek_BETA: return "Greek_BETA"; break; + case XK_Greek_GAMMA: return "Greek_GAMMA"; break; + case XK_Greek_DELTA: return "Greek_DELTA"; break; + case XK_Greek_EPSILON: return "Greek_EPSILON"; break; + case XK_Greek_ZETA: return "Greek_ZETA"; break; + case XK_Greek_ETA: return "Greek_ETA"; break; + case XK_Greek_THETA: return "Greek_THETA"; break; + case XK_Greek_IOTA: return "Greek_IOTA"; break; + case XK_Greek_KAPPA: return "Greek_KAPPA"; break; + case XK_Greek_LAMDA: return "Greek_LAMDA"; break; + case XK_Greek_MU: return "Greek_MU"; break; + case XK_Greek_NU: return "Greek_NU"; break; + case XK_Greek_XI: return "Greek_XI"; break; + case XK_Greek_OMICRON: return "Greek_OMICRON"; break; + case XK_Greek_PI: return "Greek_PI"; break; + case XK_Greek_RHO: return "Greek_RHO"; break; + case XK_Greek_SIGMA: return "Greek_SIGMA"; break; + case XK_Greek_TAU: return "Greek_TAU"; break; + case XK_Greek_UPSILON: return "Greek_UPSILON"; break; + case XK_Greek_PHI: return "Greek_PHI"; break; + case XK_Greek_CHI: return "Greek_CHI"; break; + case XK_Greek_PSI: return "Greek_PSI"; break; + case XK_Greek_OMEGA: return "Greek_OMEGA"; break; + case XK_Greek_alpha: return "Greek_alpha"; break; + case XK_Greek_beta: return "Greek_beta"; break; + case XK_Greek_gamma: return "Greek_gamma"; break; + case XK_Greek_delta: return "Greek_delta"; break; + case XK_Greek_epsilon: return "Greek_epsilon"; break; + case XK_Greek_zeta: return "Greek_zeta"; break; + case XK_Greek_eta: return "Greek_eta"; break; + case XK_Greek_theta: return "Greek_theta"; break; + case XK_Greek_iota: return "Greek_iota"; break; + case XK_Greek_kappa: return "Greek_kappa"; break; + case XK_Greek_lamda: return "Greek_lamda"; break; + case XK_Greek_mu: return "Greek_mu"; break; + case XK_Greek_nu: return "Greek_nu"; break; + case XK_Greek_xi: return "Greek_xi"; break; + case XK_Greek_omicron: return "Greek_omicron"; break; + case XK_Greek_pi: return "Greek_pi"; break; + case XK_Greek_rho: return "Greek_rho"; break; + case XK_Greek_sigma: return "Greek_sigma"; break; + case XK_Greek_finalsmallsigma: return "Greek_finalsmallsigma"; break; + case XK_Greek_tau: return "Greek_tau"; break; + case XK_Greek_upsilon: return "Greek_upsilon"; break; + case XK_Greek_phi: return "Greek_phi"; break; + case XK_Greek_chi: return "Greek_chi"; break; + case XK_Greek_psi: return "Greek_psi"; break; + case XK_Greek_omega: return "Greek_omega"; break; + case XK_leftradical: return "leftradical"; break; + case XK_topleftradical: return "topleftradical"; break; + case XK_horizconnector: return "horizconnector"; break; + case XK_topintegral: return "topintegral"; break; + case XK_botintegral: return "botintegral"; break; + case XK_vertconnector: return "vertconnector"; break; + case XK_topleftsqbracket: return "topleftsqbracket"; break; + case XK_botleftsqbracket: return "botleftsqbracket"; break; + case XK_toprightsqbracket: return "toprightsqbracket"; break; + case XK_botrightsqbracket: return "botrightsqbracket"; break; + case XK_topleftparens: return "topleftparens"; break; + case XK_botleftparens: return "botleftparens"; break; + case XK_toprightparens: return "toprightparens"; break; + case XK_botrightparens: return "botrightparens"; break; + case XK_leftmiddlecurlybrace: return "leftmiddlecurlybrace"; break; + case XK_rightmiddlecurlybrace: return "rightmiddlecurlybrace"; break; + case XK_topleftsummation: return "topleftsummation"; break; + case XK_botleftsummation: return "botleftsummation"; break; + case XK_topvertsummationconnector: return "topvertsummationconnector"; break; + case XK_botvertsummationconnector: return "botvertsummationconnector"; break; + case XK_toprightsummation: return "toprightsummation"; break; + case XK_botrightsummation: return "botrightsummation"; break; + case XK_rightmiddlesummation: return "rightmiddlesummation"; break; + case XK_lessthanequal: return "lessthanequal"; break; + case XK_notequal: return "notequal"; break; + case XK_greaterthanequal: return "greaterthanequal"; break; + case XK_integral: return "integral"; break; + case XK_therefore: return "therefore"; break; + case XK_variation: return "variation"; break; + case XK_infinity: return "infinity"; break; + case XK_nabla: return "nabla"; break; + case XK_approximate: return "approximate"; break; + case XK_similarequal: return "similarequal"; break; + case XK_ifonlyif: return "ifonlyif"; break; + case XK_implies: return "implies"; break; + case XK_identical: return "identical"; break; + case XK_radical: return "radical"; break; + case XK_includedin: return "includedin"; break; + case XK_includes: return "includes"; break; + case XK_intersection: return "intersection"; break; + case XK_union: return "union"; break; + case XK_logicaland: return "logicaland"; break; + case XK_logicalor: return "logicalor"; break; + case XK_partialderivative: return "partialderivative"; break; + case XK_function: return "function"; break; + case XK_leftarrow: return "leftarrow"; break; + case XK_uparrow: return "uparrow"; break; + case XK_rightarrow: return "rightarrow"; break; + case XK_downarrow: return "downarrow"; break; + case XK_blank: return "blank"; break; + case XK_soliddiamond: return "soliddiamond"; break; + case XK_checkerboard: return "checkerboard"; break; + case XK_ht: return "ht"; break; + case XK_ff: return "ff"; break; + case XK_cr: return "cr"; break; + case XK_lf: return "lf"; break; + case XK_nl: return "nl"; break; + case XK_vt: return "vt"; break; + case XK_lowrightcorner: return "lowrightcorner"; break; + case XK_uprightcorner: return "uprightcorner"; break; + case XK_upleftcorner: return "upleftcorner"; break; + case XK_lowleftcorner: return "lowleftcorner"; break; + case XK_crossinglines: return "crossinglines"; break; + case XK_horizlinescan1: return "horizlinescan1"; break; + case XK_horizlinescan3: return "horizlinescan3"; break; + case XK_horizlinescan5: return "horizlinescan5"; break; + case XK_horizlinescan7: return "horizlinescan7"; break; + case XK_horizlinescan9: return "horizlinescan9"; break; + case XK_leftt: return "leftt"; break; + case XK_rightt: return "rightt"; break; + case XK_bott: return "bott"; break; + case XK_topt: return "topt"; break; + case XK_vertbar: return "vertbar"; break; + case XK_emspace: return "emspace"; break; + case XK_enspace: return "enspace"; break; + case XK_em3space: return "em3space"; break; + case XK_em4space: return "em4space"; break; + case XK_digitspace: return "digitspace"; break; + case XK_punctspace: return "punctspace"; break; + case XK_thinspace: return "thinspace"; break; + case XK_hairspace: return "hairspace"; break; + case XK_emdash: return "emdash"; break; + case XK_endash: return "endash"; break; + case XK_signifblank: return "signifblank"; break; + case XK_ellipsis: return "ellipsis"; break; + case XK_doubbaselinedot: return "doubbaselinedot"; break; + case XK_onethird: return "onethird"; break; + case XK_twothirds: return "twothirds"; break; + case XK_onefifth: return "onefifth"; break; + case XK_twofifths: return "twofifths"; break; + case XK_threefifths: return "threefifths"; break; + case XK_fourfifths: return "fourfifths"; break; + case XK_onesixth: return "onesixth"; break; + case XK_fivesixths: return "fivesixths"; break; + case XK_careof: return "careof"; break; + case XK_figdash: return "figdash"; break; + case XK_leftanglebracket: return "leftanglebracket"; break; + case XK_decimalpoint: return "decimalpoint"; break; + case XK_rightanglebracket: return "rightanglebracket"; break; + case XK_marker: return "marker"; break; + case XK_oneeighth: return "oneeighth"; break; + case XK_threeeighths: return "threeeighths"; break; + case XK_fiveeighths: return "fiveeighths"; break; + case XK_seveneighths: return "seveneighths"; break; + case XK_trademark: return "trademark"; break; + case XK_signaturemark: return "signaturemark"; break; + case XK_trademarkincircle: return "trademarkincircle"; break; + case XK_leftopentriangle: return "leftopentriangle"; break; + case XK_rightopentriangle: return "rightopentriangle"; break; + case XK_emopencircle: return "emopencircle"; break; + case XK_emopenrectangle: return "emopenrectangle"; break; + case XK_leftsinglequotemark: return "leftsinglequotemark"; break; + case XK_rightsinglequotemark: return "rightsinglequotemark"; break; + case XK_leftdoublequotemark: return "leftdoublequotemark"; break; + case XK_rightdoublequotemark: return "rightdoublequotemark"; break; + case XK_prescription: return "prescription"; break; + case XK_permille: return "permille"; break; + case XK_minutes: return "minutes"; break; + case XK_seconds: return "seconds"; break; + case XK_latincross: return "latincross"; break; + case XK_hexagram: return "hexagram"; break; + case XK_filledrectbullet: return "filledrectbullet"; break; + case XK_filledlefttribullet: return "filledlefttribullet"; break; + case XK_filledrighttribullet: return "filledrighttribullet"; break; + case XK_emfilledcircle: return "emfilledcircle"; break; + case XK_emfilledrect: return "emfilledrect"; break; + case XK_enopencircbullet: return "enopencircbullet"; break; + case XK_enopensquarebullet: return "enopensquarebullet"; break; + case XK_openrectbullet: return "openrectbullet"; break; + case XK_opentribulletup: return "opentribulletup"; break; + case XK_opentribulletdown: return "opentribulletdown"; break; + case XK_openstar: return "openstar"; break; + case XK_enfilledcircbullet: return "enfilledcircbullet"; break; + case XK_enfilledsqbullet: return "enfilledsqbullet"; break; + case XK_filledtribulletup: return "filledtribulletup"; break; + case XK_filledtribulletdown: return "filledtribulletdown"; break; + case XK_leftpointer: return "leftpointer"; break; + case XK_rightpointer: return "rightpointer"; break; + case XK_club: return "club"; break; + case XK_diamond: return "diamond"; break; + case XK_heart: return "heart"; break; + case XK_maltesecross: return "maltesecross"; break; + case XK_dagger: return "dagger"; break; + case XK_doubledagger: return "doubledagger"; break; + case XK_checkmark: return "checkmark"; break; + case XK_ballotcross: return "ballotcross"; break; + case XK_musicalsharp: return "musicalsharp"; break; + case XK_musicalflat: return "musicalflat"; break; + case XK_malesymbol: return "malesymbol"; break; + case XK_femalesymbol: return "femalesymbol"; break; + case XK_telephone: return "telephone"; break; + case XK_telephonerecorder: return "telephonerecorder"; break; + case XK_phonographcopyright: return "phonographcopyright"; break; + case XK_caret: return "caret"; break; + case XK_singlelowquotemark: return "singlelowquotemark"; break; + case XK_doublelowquotemark: return "doublelowquotemark"; break; + case XK_cursor: return "cursor"; break; + case XK_leftcaret: return "leftcaret"; break; + case XK_rightcaret: return "rightcaret"; break; + case XK_downcaret: return "downcaret"; break; + case XK_upcaret: return "upcaret"; break; + case XK_overbar: return "overbar"; break; + case XK_downtack: return "downtack"; break; + case XK_upshoe: return "upshoe"; break; + case XK_downstile: return "downstile"; break; + case XK_underbar: return "underbar"; break; + case XK_jot: return "jot"; break; + case XK_quad: return "quad"; break; + case XK_uptack: return "uptack"; break; + case XK_circle: return "circle"; break; + case XK_upstile: return "upstile"; break; + case XK_downshoe: return "downshoe"; break; + case XK_rightshoe: return "rightshoe"; break; + case XK_leftshoe: return "leftshoe"; break; + case XK_lefttack: return "lefttack"; break; + case XK_righttack: return "righttack"; break; + case XK_hebrew_doublelowline: return "hebrew_doublelowline"; break; + case XK_hebrew_aleph: return "hebrew_aleph"; break; + case XK_hebrew_bet: return "hebrew_bet"; break; + case XK_hebrew_gimel: return "hebrew_gimel"; break; + case XK_hebrew_dalet: return "hebrew_dalet"; break; + case XK_hebrew_he: return "hebrew_he"; break; + case XK_hebrew_waw: return "hebrew_waw"; break; + case XK_hebrew_zain: return "hebrew_zain"; break; + case XK_hebrew_chet: return "hebrew_chet"; break; + case XK_hebrew_tet: return "hebrew_tet"; break; + case XK_hebrew_yod: return "hebrew_yod"; break; + case XK_hebrew_finalkaph: return "hebrew_finalkaph"; break; + case XK_hebrew_kaph: return "hebrew_kaph"; break; + case XK_hebrew_lamed: return "hebrew_lamed"; break; + case XK_hebrew_finalmem: return "hebrew_finalmem"; break; + case XK_hebrew_mem: return "hebrew_mem"; break; + case XK_hebrew_finalnun: return "hebrew_finalnun"; break; + case XK_hebrew_nun: return "hebrew_nun"; break; + case XK_hebrew_samech: return "hebrew_samech"; break; + case XK_hebrew_ayin: return "hebrew_ayin"; break; + case XK_hebrew_finalpe: return "hebrew_finalpe"; break; + case XK_hebrew_pe: return "hebrew_pe"; break; + case XK_hebrew_finalzade: return "hebrew_finalzade"; break; + case XK_hebrew_zade: return "hebrew_zade"; break; + case XK_hebrew_qoph: return "hebrew_qoph"; break; + case XK_hebrew_resh: return "hebrew_resh"; break; + case XK_hebrew_shin: return "hebrew_shin"; break; + case XK_hebrew_taw: return "hebrew_taw"; break; + case XK_Thai_kokai: return "Thai_kokai"; break; + case XK_Thai_khokhai: return "Thai_khokhai"; break; + case XK_Thai_khokhuat: return "Thai_khokhuat"; break; + case XK_Thai_khokhwai: return "Thai_khokhwai"; break; + case XK_Thai_khokhon: return "Thai_khokhon"; break; + case XK_Thai_khorakhang: return "Thai_khorakhang"; break; + case XK_Thai_ngongu: return "Thai_ngongu"; break; + case XK_Thai_chochan: return "Thai_chochan"; break; + case XK_Thai_choching: return "Thai_choching"; break; + case XK_Thai_chochang: return "Thai_chochang"; break; + case XK_Thai_soso: return "Thai_soso"; break; + case XK_Thai_chochoe: return "Thai_chochoe"; break; + case XK_Thai_yoying: return "Thai_yoying"; break; + case XK_Thai_dochada: return "Thai_dochada"; break; + case XK_Thai_topatak: return "Thai_topatak"; break; + case XK_Thai_thothan: return "Thai_thothan"; break; + case XK_Thai_thonangmontho: return "Thai_thonangmontho"; break; + case XK_Thai_thophuthao: return "Thai_thophuthao"; break; + case XK_Thai_nonen: return "Thai_nonen"; break; + case XK_Thai_dodek: return "Thai_dodek"; break; + case XK_Thai_totao: return "Thai_totao"; break; + case XK_Thai_thothung: return "Thai_thothung"; break; + case XK_Thai_thothahan: return "Thai_thothahan"; break; + case XK_Thai_thothong: return "Thai_thothong"; break; + case XK_Thai_nonu: return "Thai_nonu"; break; + case XK_Thai_bobaimai: return "Thai_bobaimai"; break; + case XK_Thai_popla: return "Thai_popla"; break; + case XK_Thai_phophung: return "Thai_phophung"; break; + case XK_Thai_fofa: return "Thai_fofa"; break; + case XK_Thai_phophan: return "Thai_phophan"; break; + case XK_Thai_fofan: return "Thai_fofan"; break; + case XK_Thai_phosamphao: return "Thai_phosamphao"; break; + case XK_Thai_moma: return "Thai_moma"; break; + case XK_Thai_yoyak: return "Thai_yoyak"; break; + case XK_Thai_rorua: return "Thai_rorua"; break; + case XK_Thai_ru: return "Thai_ru"; break; + case XK_Thai_loling: return "Thai_loling"; break; + case XK_Thai_lu: return "Thai_lu"; break; + case XK_Thai_wowaen: return "Thai_wowaen"; break; + case XK_Thai_sosala: return "Thai_sosala"; break; + case XK_Thai_sorusi: return "Thai_sorusi"; break; + case XK_Thai_sosua: return "Thai_sosua"; break; + case XK_Thai_hohip: return "Thai_hohip"; break; + case XK_Thai_lochula: return "Thai_lochula"; break; + case XK_Thai_oang: return "Thai_oang"; break; + case XK_Thai_honokhuk: return "Thai_honokhuk"; break; + case XK_Thai_paiyannoi: return "Thai_paiyannoi"; break; + case XK_Thai_saraa: return "Thai_saraa"; break; + case XK_Thai_maihanakat: return "Thai_maihanakat"; break; + case XK_Thai_saraaa: return "Thai_saraaa"; break; + case XK_Thai_saraam: return "Thai_saraam"; break; + case XK_Thai_sarai: return "Thai_sarai"; break; + case XK_Thai_saraii: return "Thai_saraii"; break; + case XK_Thai_saraue: return "Thai_saraue"; break; + case XK_Thai_sarauee: return "Thai_sarauee"; break; + case XK_Thai_sarau: return "Thai_sarau"; break; + case XK_Thai_sarauu: return "Thai_sarauu"; break; + case XK_Thai_phinthu: return "Thai_phinthu"; break; + case XK_Thai_maihanakat_maitho: return "Thai_maihanakat_maitho"; break; + case XK_Thai_baht: return "Thai_baht"; break; + case XK_Thai_sarae: return "Thai_sarae"; break; + case XK_Thai_saraae: return "Thai_saraae"; break; + case XK_Thai_sarao: return "Thai_sarao"; break; + case XK_Thai_saraaimaimuan: return "Thai_saraaimaimuan"; break; + case XK_Thai_saraaimaimalai: return "Thai_saraaimaimalai"; break; + case XK_Thai_lakkhangyao: return "Thai_lakkhangyao"; break; + case XK_Thai_maiyamok: return "Thai_maiyamok"; break; + case XK_Thai_maitaikhu: return "Thai_maitaikhu"; break; + case XK_Thai_maiek: return "Thai_maiek"; break; + case XK_Thai_maitho: return "Thai_maitho"; break; + case XK_Thai_maitri: return "Thai_maitri"; break; + case XK_Thai_maichattawa: return "Thai_maichattawa"; break; + case XK_Thai_thanthakhat: return "Thai_thanthakhat"; break; + case XK_Thai_nikhahit: return "Thai_nikhahit"; break; + case XK_Thai_leksun: return "Thai_leksun"; break; + case XK_Thai_leknung: return "Thai_leknung"; break; + case XK_Thai_leksong: return "Thai_leksong"; break; + case XK_Thai_leksam: return "Thai_leksam"; break; + case XK_Thai_leksi: return "Thai_leksi"; break; + case XK_Thai_lekha: return "Thai_lekha"; break; + case XK_Thai_lekhok: return "Thai_lekhok"; break; + case XK_Thai_lekchet: return "Thai_lekchet"; break; + case XK_Thai_lekpaet: return "Thai_lekpaet"; break; + case XK_Thai_lekkao: return "Thai_lekkao"; break; + case XK_Hangul: return "Hangul"; break; + case XK_Hangul_Start: return "Hangul_Start"; break; + case XK_Hangul_End: return "Hangul_End"; break; + case XK_Hangul_Hanja: return "Hangul_Hanja"; break; + case XK_Hangul_Jamo: return "Hangul_Jamo"; break; + case XK_Hangul_Romaja: return "Hangul_Romaja"; break; + case XK_Hangul_Jeonja: return "Hangul_Jeonja"; break; + case XK_Hangul_Banja: return "Hangul_Banja"; break; + case XK_Hangul_PreHanja: return "Hangul_PreHanja"; break; + case XK_Hangul_PostHanja: return "Hangul_PostHanja"; break; + case XK_Hangul_Special: return "Hangul_Special"; break; + case XK_Hangul_Kiyeog: return "Hangul_Kiyeog"; break; + case XK_Hangul_SsangKiyeog: return "Hangul_SsangKiyeog"; break; + case XK_Hangul_KiyeogSios: return "Hangul_KiyeogSios"; break; + case XK_Hangul_Nieun: return "Hangul_Nieun"; break; + case XK_Hangul_NieunJieuj: return "Hangul_NieunJieuj"; break; + case XK_Hangul_NieunHieuh: return "Hangul_NieunHieuh"; break; + case XK_Hangul_Dikeud: return "Hangul_Dikeud"; break; + case XK_Hangul_SsangDikeud: return "Hangul_SsangDikeud"; break; + case XK_Hangul_Rieul: return "Hangul_Rieul"; break; + case XK_Hangul_RieulKiyeog: return "Hangul_RieulKiyeog"; break; + case XK_Hangul_RieulMieum: return "Hangul_RieulMieum"; break; + case XK_Hangul_RieulPieub: return "Hangul_RieulPieub"; break; + case XK_Hangul_RieulSios: return "Hangul_RieulSios"; break; + case XK_Hangul_RieulTieut: return "Hangul_RieulTieut"; break; + case XK_Hangul_RieulPhieuf: return "Hangul_RieulPhieuf"; break; + case XK_Hangul_RieulHieuh: return "Hangul_RieulHieuh"; break; + case XK_Hangul_Mieum: return "Hangul_Mieum"; break; + case XK_Hangul_Pieub: return "Hangul_Pieub"; break; + case XK_Hangul_SsangPieub: return "Hangul_SsangPieub"; break; + case XK_Hangul_PieubSios: return "Hangul_PieubSios"; break; + case XK_Hangul_Sios: return "Hangul_Sios"; break; + case XK_Hangul_SsangSios: return "Hangul_SsangSios"; break; + case XK_Hangul_Ieung: return "Hangul_Ieung"; break; + case XK_Hangul_Jieuj: return "Hangul_Jieuj"; break; + case XK_Hangul_SsangJieuj: return "Hangul_SsangJieuj"; break; + case XK_Hangul_Cieuc: return "Hangul_Cieuc"; break; + case XK_Hangul_Khieuq: return "Hangul_Khieuq"; break; + case XK_Hangul_Tieut: return "Hangul_Tieut"; break; + case XK_Hangul_Phieuf: return "Hangul_Phieuf"; break; + case XK_Hangul_Hieuh: return "Hangul_Hieuh"; break; + case XK_Hangul_A: return "Hangul_A"; break; + case XK_Hangul_AE: return "Hangul_AE"; break; + case XK_Hangul_YA: return "Hangul_YA"; break; + case XK_Hangul_YAE: return "Hangul_YAE"; break; + case XK_Hangul_EO: return "Hangul_EO"; break; + case XK_Hangul_E: return "Hangul_E"; break; + case XK_Hangul_YEO: return "Hangul_YEO"; break; + case XK_Hangul_YE: return "Hangul_YE"; break; + case XK_Hangul_O: return "Hangul_O"; break; + case XK_Hangul_WA: return "Hangul_WA"; break; + case XK_Hangul_WAE: return "Hangul_WAE"; break; + case XK_Hangul_OE: return "Hangul_OE"; break; + case XK_Hangul_YO: return "Hangul_YO"; break; + case XK_Hangul_U: return "Hangul_U"; break; + case XK_Hangul_WEO: return "Hangul_WEO"; break; + case XK_Hangul_WE: return "Hangul_WE"; break; + case XK_Hangul_WI: return "Hangul_WI"; break; + case XK_Hangul_YU: return "Hangul_YU"; break; + case XK_Hangul_EU: return "Hangul_EU"; break; + case XK_Hangul_YI: return "Hangul_YI"; break; + case XK_Hangul_I: return "Hangul_I"; break; + case XK_Hangul_J_Kiyeog: return "Hangul_J_Kiyeog"; break; + case XK_Hangul_J_SsangKiyeog: return "Hangul_J_SsangKiyeog"; break; + case XK_Hangul_J_KiyeogSios: return "Hangul_J_KiyeogSios"; break; + case XK_Hangul_J_Nieun: return "Hangul_J_Nieun"; break; + case XK_Hangul_J_NieunJieuj: return "Hangul_J_NieunJieuj"; break; + case XK_Hangul_J_NieunHieuh: return "Hangul_J_NieunHieuh"; break; + case XK_Hangul_J_Dikeud: return "Hangul_J_Dikeud"; break; + case XK_Hangul_J_Rieul: return "Hangul_J_Rieul"; break; + case XK_Hangul_J_RieulKiyeog: return "Hangul_J_RieulKiyeog"; break; + case XK_Hangul_J_RieulMieum: return "Hangul_J_RieulMieum"; break; + case XK_Hangul_J_RieulPieub: return "Hangul_J_RieulPieub"; break; + case XK_Hangul_J_RieulSios: return "Hangul_J_RieulSios"; break; + case XK_Hangul_J_RieulTieut: return "Hangul_J_RieulTieut"; break; + case XK_Hangul_J_RieulPhieuf: return "Hangul_J_RieulPhieuf"; break; + case XK_Hangul_J_RieulHieuh: return "Hangul_J_RieulHieuh"; break; + case XK_Hangul_J_Mieum: return "Hangul_J_Mieum"; break; + case XK_Hangul_J_Pieub: return "Hangul_J_Pieub"; break; + case XK_Hangul_J_PieubSios: return "Hangul_J_PieubSios"; break; + case XK_Hangul_J_Sios: return "Hangul_J_Sios"; break; + case XK_Hangul_J_SsangSios: return "Hangul_J_SsangSios"; break; + case XK_Hangul_J_Ieung: return "Hangul_J_Ieung"; break; + case XK_Hangul_J_Jieuj: return "Hangul_J_Jieuj"; break; + case XK_Hangul_J_Cieuc: return "Hangul_J_Cieuc"; break; + case XK_Hangul_J_Khieuq: return "Hangul_J_Khieuq"; break; + case XK_Hangul_J_Tieut: return "Hangul_J_Tieut"; break; + case XK_Hangul_J_Phieuf: return "Hangul_J_Phieuf"; break; + case XK_Hangul_J_Hieuh: return "Hangul_J_Hieuh"; break; + case XK_Hangul_RieulYeorinHieuh: return "Hangul_RieulYeorinHieuh"; break; + case XK_Hangul_SunkyeongeumMieum: return "Hangul_SunkyeongeumMieum"; break; + case XK_Hangul_SunkyeongeumPieub: return "Hangul_SunkyeongeumPieub"; break; + case XK_Hangul_PanSios: return "Hangul_PanSios"; break; + case XK_Hangul_KkogjiDalrinIeung: return "Hangul_KkogjiDalrinIeung"; break; + case XK_Hangul_SunkyeongeumPhieuf: return "Hangul_SunkyeongeumPhieuf"; break; + case XK_Hangul_YeorinHieuh: return "Hangul_YeorinHieuh"; break; + case XK_Hangul_AraeA: return "Hangul_AraeA"; break; + case XK_Hangul_AraeAE: return "Hangul_AraeAE"; break; + case XK_Hangul_J_PanSios: return "Hangul_J_PanSios"; break; + case XK_Hangul_J_KkogjiDalrinIeung: return "Hangul_J_KkogjiDalrinIeung"; break; + case XK_Hangul_J_YeorinHieuh: return "Hangul_J_YeorinHieuh"; break; + case XK_Korean_Won: return "Korean_Won"; break; + case XK_Armenian_ligature_ew: return "Armenian_ligature_ew"; break; + case XK_Armenian_full_stop: return "Armenian_full_stop"; break; + case XK_Armenian_separation_mark: return "Armenian_separation_mark"; break; + case XK_Armenian_hyphen: return "Armenian_hyphen"; break; + case XK_Armenian_exclam: return "Armenian_exclam"; break; + case XK_Armenian_accent: return "Armenian_accent"; break; + case XK_Armenian_question: return "Armenian_question"; break; + case XK_Armenian_AYB: return "Armenian_AYB"; break; + case XK_Armenian_ayb: return "Armenian_ayb"; break; + case XK_Armenian_BEN: return "Armenian_BEN"; break; + case XK_Armenian_ben: return "Armenian_ben"; break; + case XK_Armenian_GIM: return "Armenian_GIM"; break; + case XK_Armenian_gim: return "Armenian_gim"; break; + case XK_Armenian_DA: return "Armenian_DA"; break; + case XK_Armenian_da: return "Armenian_da"; break; + case XK_Armenian_YECH: return "Armenian_YECH"; break; + case XK_Armenian_yech: return "Armenian_yech"; break; + case XK_Armenian_ZA: return "Armenian_ZA"; break; + case XK_Armenian_za: return "Armenian_za"; break; + case XK_Armenian_E: return "Armenian_E"; break; + case XK_Armenian_e: return "Armenian_e"; break; + case XK_Armenian_AT: return "Armenian_AT"; break; + case XK_Armenian_at: return "Armenian_at"; break; + case XK_Armenian_TO: return "Armenian_TO"; break; + case XK_Armenian_to: return "Armenian_to"; break; + case XK_Armenian_ZHE: return "Armenian_ZHE"; break; + case XK_Armenian_zhe: return "Armenian_zhe"; break; + case XK_Armenian_INI: return "Armenian_INI"; break; + case XK_Armenian_ini: return "Armenian_ini"; break; + case XK_Armenian_LYUN: return "Armenian_LYUN"; break; + case XK_Armenian_lyun: return "Armenian_lyun"; break; + case XK_Armenian_KHE: return "Armenian_KHE"; break; + case XK_Armenian_khe: return "Armenian_khe"; break; + case XK_Armenian_TSA: return "Armenian_TSA"; break; + case XK_Armenian_tsa: return "Armenian_tsa"; break; + case XK_Armenian_KEN: return "Armenian_KEN"; break; + case XK_Armenian_ken: return "Armenian_ken"; break; + case XK_Armenian_HO: return "Armenian_HO"; break; + case XK_Armenian_ho: return "Armenian_ho"; break; + case XK_Armenian_DZA: return "Armenian_DZA"; break; + case XK_Armenian_dza: return "Armenian_dza"; break; + case XK_Armenian_GHAT: return "Armenian_GHAT"; break; + case XK_Armenian_ghat: return "Armenian_ghat"; break; + case XK_Armenian_TCHE: return "Armenian_TCHE"; break; + case XK_Armenian_tche: return "Armenian_tche"; break; + case XK_Armenian_MEN: return "Armenian_MEN"; break; + case XK_Armenian_men: return "Armenian_men"; break; + case XK_Armenian_HI: return "Armenian_HI"; break; + case XK_Armenian_hi: return "Armenian_hi"; break; + case XK_Armenian_NU: return "Armenian_NU"; break; + case XK_Armenian_nu: return "Armenian_nu"; break; + case XK_Armenian_SHA: return "Armenian_SHA"; break; + case XK_Armenian_sha: return "Armenian_sha"; break; + case XK_Armenian_VO: return "Armenian_VO"; break; + case XK_Armenian_vo: return "Armenian_vo"; break; + case XK_Armenian_CHA: return "Armenian_CHA"; break; + case XK_Armenian_cha: return "Armenian_cha"; break; + case XK_Armenian_PE: return "Armenian_PE"; break; + case XK_Armenian_pe: return "Armenian_pe"; break; + case XK_Armenian_JE: return "Armenian_JE"; break; + case XK_Armenian_je: return "Armenian_je"; break; + case XK_Armenian_RA: return "Armenian_RA"; break; + case XK_Armenian_ra: return "Armenian_ra"; break; + case XK_Armenian_SE: return "Armenian_SE"; break; + case XK_Armenian_se: return "Armenian_se"; break; + case XK_Armenian_VEV: return "Armenian_VEV"; break; + case XK_Armenian_vev: return "Armenian_vev"; break; + case XK_Armenian_TYUN: return "Armenian_TYUN"; break; + case XK_Armenian_tyun: return "Armenian_tyun"; break; + case XK_Armenian_RE: return "Armenian_RE"; break; + case XK_Armenian_re: return "Armenian_re"; break; + case XK_Armenian_TSO: return "Armenian_TSO"; break; + case XK_Armenian_tso: return "Armenian_tso"; break; + case XK_Armenian_VYUN: return "Armenian_VYUN"; break; + case XK_Armenian_vyun: return "Armenian_vyun"; break; + case XK_Armenian_PYUR: return "Armenian_PYUR"; break; + case XK_Armenian_pyur: return "Armenian_pyur"; break; + case XK_Armenian_KE: return "Armenian_KE"; break; + case XK_Armenian_ke: return "Armenian_ke"; break; + case XK_Armenian_O: return "Armenian_O"; break; + case XK_Armenian_o: return "Armenian_o"; break; + case XK_Armenian_FE: return "Armenian_FE"; break; + case XK_Armenian_fe: return "Armenian_fe"; break; + case XK_Armenian_apostrophe: return "Armenian_apostrophe"; break; + case XK_Georgian_an: return "Georgian_an"; break; + case XK_Georgian_ban: return "Georgian_ban"; break; + case XK_Georgian_gan: return "Georgian_gan"; break; + case XK_Georgian_don: return "Georgian_don"; break; + case XK_Georgian_en: return "Georgian_en"; break; + case XK_Georgian_vin: return "Georgian_vin"; break; + case XK_Georgian_zen: return "Georgian_zen"; break; + case XK_Georgian_tan: return "Georgian_tan"; break; + case XK_Georgian_in: return "Georgian_in"; break; + case XK_Georgian_kan: return "Georgian_kan"; break; + case XK_Georgian_las: return "Georgian_las"; break; + case XK_Georgian_man: return "Georgian_man"; break; + case XK_Georgian_nar: return "Georgian_nar"; break; + case XK_Georgian_on: return "Georgian_on"; break; + case XK_Georgian_par: return "Georgian_par"; break; + case XK_Georgian_zhar: return "Georgian_zhar"; break; + case XK_Georgian_rae: return "Georgian_rae"; break; + case XK_Georgian_san: return "Georgian_san"; break; + case XK_Georgian_tar: return "Georgian_tar"; break; + case XK_Georgian_un: return "Georgian_un"; break; + case XK_Georgian_phar: return "Georgian_phar"; break; + case XK_Georgian_khar: return "Georgian_khar"; break; + case XK_Georgian_ghan: return "Georgian_ghan"; break; + case XK_Georgian_qar: return "Georgian_qar"; break; + case XK_Georgian_shin: return "Georgian_shin"; break; + case XK_Georgian_chin: return "Georgian_chin"; break; + case XK_Georgian_can: return "Georgian_can"; break; + case XK_Georgian_jil: return "Georgian_jil"; break; + case XK_Georgian_cil: return "Georgian_cil"; break; + case XK_Georgian_char: return "Georgian_char"; break; + case XK_Georgian_xan: return "Georgian_xan"; break; + case XK_Georgian_jhan: return "Georgian_jhan"; break; + case XK_Georgian_hae: return "Georgian_hae"; break; + case XK_Georgian_he: return "Georgian_he"; break; + case XK_Georgian_hie: return "Georgian_hie"; break; + case XK_Georgian_we: return "Georgian_we"; break; + case XK_Georgian_har: return "Georgian_har"; break; + case XK_Georgian_hoe: return "Georgian_hoe"; break; + case XK_Georgian_fi: return "Georgian_fi"; break; + case XK_Xabovedot: return "Xabovedot"; break; + case XK_Ibreve: return "Ibreve"; break; + case XK_Zstroke: return "Zstroke"; break; + case XK_Gcaron: return "Gcaron"; break; + case XK_Ocaron: return "Ocaron"; break; + case XK_Obarred: return "Obarred"; break; + case XK_xabovedot: return "xabovedot"; break; + case XK_ibreve: return "ibreve"; break; + case XK_zstroke: return "zstroke"; break; + case XK_gcaron: return "gcaron"; break; + case XK_ocaron: return "ocaron"; break; + case XK_obarred: return "obarred"; break; + case XK_SCHWA: return "SCHWA"; break; + case XK_schwa: return "schwa"; break; + case XK_EZH: return "EZH"; break; + case XK_ezh: return "ezh"; break; + case XK_Lbelowdot: return "Lbelowdot"; break; + case XK_lbelowdot: return "lbelowdot"; break; + case XK_Abelowdot: return "Abelowdot"; break; + case XK_abelowdot: return "abelowdot"; break; + case XK_Ahook: return "Ahook"; break; + case XK_ahook: return "ahook"; break; + case XK_Acircumflexacute: return "Acircumflexacute"; break; + case XK_acircumflexacute: return "acircumflexacute"; break; + case XK_Acircumflexgrave: return "Acircumflexgrave"; break; + case XK_acircumflexgrave: return "acircumflexgrave"; break; + case XK_Acircumflexhook: return "Acircumflexhook"; break; + case XK_acircumflexhook: return "acircumflexhook"; break; + case XK_Acircumflextilde: return "Acircumflextilde"; break; + case XK_acircumflextilde: return "acircumflextilde"; break; + case XK_Acircumflexbelowdot: return "Acircumflexbelowdot"; break; + case XK_acircumflexbelowdot: return "acircumflexbelowdot"; break; + case XK_Abreveacute: return "Abreveacute"; break; + case XK_abreveacute: return "abreveacute"; break; + case XK_Abrevegrave: return "Abrevegrave"; break; + case XK_abrevegrave: return "abrevegrave"; break; + case XK_Abrevehook: return "Abrevehook"; break; + case XK_abrevehook: return "abrevehook"; break; + case XK_Abrevetilde: return "Abrevetilde"; break; + case XK_abrevetilde: return "abrevetilde"; break; + case XK_Abrevebelowdot: return "Abrevebelowdot"; break; + case XK_abrevebelowdot: return "abrevebelowdot"; break; + case XK_Ebelowdot: return "Ebelowdot"; break; + case XK_ebelowdot: return "ebelowdot"; break; + case XK_Ehook: return "Ehook"; break; + case XK_ehook: return "ehook"; break; + case XK_Etilde: return "Etilde"; break; + case XK_etilde: return "etilde"; break; + case XK_Ecircumflexacute: return "Ecircumflexacute"; break; + case XK_ecircumflexacute: return "ecircumflexacute"; break; + case XK_Ecircumflexgrave: return "Ecircumflexgrave"; break; + case XK_ecircumflexgrave: return "ecircumflexgrave"; break; + case XK_Ecircumflexhook: return "Ecircumflexhook"; break; + case XK_ecircumflexhook: return "ecircumflexhook"; break; + case XK_Ecircumflextilde: return "Ecircumflextilde"; break; + case XK_ecircumflextilde: return "ecircumflextilde"; break; + case XK_Ecircumflexbelowdot: return "Ecircumflexbelowdot"; break; + case XK_ecircumflexbelowdot: return "ecircumflexbelowdot"; break; + case XK_Ihook: return "Ihook"; break; + case XK_ihook: return "ihook"; break; + case XK_Ibelowdot: return "Ibelowdot"; break; + case XK_ibelowdot: return "ibelowdot"; break; + case XK_Obelowdot: return "Obelowdot"; break; + case XK_obelowdot: return "obelowdot"; break; + case XK_Ohook: return "Ohook"; break; + case XK_ohook: return "ohook"; break; + case XK_Ocircumflexacute: return "Ocircumflexacute"; break; + case XK_ocircumflexacute: return "ocircumflexacute"; break; + case XK_Ocircumflexgrave: return "Ocircumflexgrave"; break; + case XK_ocircumflexgrave: return "ocircumflexgrave"; break; + case XK_Ocircumflexhook: return "Ocircumflexhook"; break; + case XK_ocircumflexhook: return "ocircumflexhook"; break; + case XK_Ocircumflextilde: return "Ocircumflextilde"; break; + case XK_ocircumflextilde: return "ocircumflextilde"; break; + case XK_Ocircumflexbelowdot: return "Ocircumflexbelowdot"; break; + case XK_ocircumflexbelowdot: return "ocircumflexbelowdot"; break; + case XK_Ohornacute: return "Ohornacute"; break; + case XK_ohornacute: return "ohornacute"; break; + case XK_Ohorngrave: return "Ohorngrave"; break; + case XK_ohorngrave: return "ohorngrave"; break; + case XK_Ohornhook: return "Ohornhook"; break; + case XK_ohornhook: return "ohornhook"; break; + case XK_Ohorntilde: return "Ohorntilde"; break; + case XK_ohorntilde: return "ohorntilde"; break; + case XK_Ohornbelowdot: return "Ohornbelowdot"; break; + case XK_ohornbelowdot: return "ohornbelowdot"; break; + case XK_Ubelowdot: return "Ubelowdot"; break; + case XK_ubelowdot: return "ubelowdot"; break; + case XK_Uhook: return "Uhook"; break; + case XK_uhook: return "uhook"; break; + case XK_Uhornacute: return "Uhornacute"; break; + case XK_uhornacute: return "uhornacute"; break; + case XK_Uhorngrave: return "Uhorngrave"; break; + case XK_uhorngrave: return "uhorngrave"; break; + case XK_Uhornhook: return "Uhornhook"; break; + case XK_uhornhook: return "uhornhook"; break; + case XK_Uhorntilde: return "Uhorntilde"; break; + case XK_uhorntilde: return "uhorntilde"; break; + case XK_Uhornbelowdot: return "Uhornbelowdot"; break; + case XK_uhornbelowdot: return "uhornbelowdot"; break; + case XK_Ybelowdot: return "Ybelowdot"; break; + case XK_ybelowdot: return "ybelowdot"; break; + case XK_Yhook: return "Yhook"; break; + case XK_yhook: return "yhook"; break; + case XK_Ytilde: return "Ytilde"; break; + case XK_ytilde: return "ytilde"; break; + case XK_Ohorn: return "Ohorn"; break; + case XK_ohorn: return "ohorn"; break; + case XK_Uhorn: return "Uhorn"; break; + case XK_uhorn: return "uhorn"; break; + case XK_combining_tilde: return "combining_tilde"; break; + case XK_combining_grave: return "combining_grave"; break; + case XK_combining_acute: return "combining_acute"; break; + case XK_combining_hook: return "combining_hook"; break; + case XK_combining_belowdot: return "combining_belowdot"; break; + case XK_EcuSign: return "EcuSign"; break; + case XK_ColonSign: return "ColonSign"; break; + case XK_CruzeiroSign: return "CruzeiroSign"; break; + case XK_FFrancSign: return "FFrancSign"; break; + case XK_LiraSign: return "LiraSign"; break; + case XK_MillSign: return "MillSign"; break; + case XK_NairaSign: return "NairaSign"; break; + case XK_PesetaSign: return "PesetaSign"; break; + case XK_RupeeSign: return "RupeeSign"; break; + case XK_WonSign: return "WonSign"; break; + case XK_NewSheqelSign: return "NewSheqelSign"; break; + case XK_DongSign: return "DongSign"; break; + case XK_EuroSign: return "EuroSign"; break; + case XK_zerosuperior: return "zerosuperior"; break; + case XK_foursuperior: return "foursuperior"; break; + case XK_fivesuperior: return "fivesuperior"; break; + case XK_sixsuperior: return "sixsuperior"; break; + case XK_sevensuperior: return "sevensuperior"; break; + case XK_eightsuperior: return "eightsuperior"; break; + case XK_ninesuperior: return "ninesuperior"; break; + case XK_zerosubscript: return "zerosubscript"; break; + case XK_onesubscript: return "onesubscript"; break; + case XK_twosubscript: return "twosubscript"; break; + case XK_threesubscript: return "threesubscript"; break; + case XK_foursubscript: return "foursubscript"; break; + case XK_fivesubscript: return "fivesubscript"; break; + case XK_sixsubscript: return "sixsubscript"; break; + case XK_sevensubscript: return "sevensubscript"; break; + case XK_eightsubscript: return "eightsubscript"; break; + case XK_ninesubscript: return "ninesubscript"; break; + case XK_partdifferential: return "partdifferential"; break; + case XK_emptyset: return "emptyset"; break; + case XK_elementof: return "elementof"; break; + case XK_notelementof: return "notelementof"; break; + case XK_containsas: return "containsas"; break; + case XK_squareroot: return "squareroot"; break; + case XK_cuberoot: return "cuberoot"; break; + case XK_fourthroot: return "fourthroot"; break; + case XK_dintegral: return "dintegral"; break; + case XK_tintegral: return "tintegral"; break; + case XK_because: return "because"; break; + case XK_approxeq: return "approxeq"; break; + case XK_notapproxeq: return "notapproxeq"; break; + case XK_notidentical: return "notidentical"; break; + case XK_stricteq: return "stricteq"; break; + case XK_braille_dot_1: return "braille_dot_1"; break; + case XK_braille_dot_2: return "braille_dot_2"; break; + case XK_braille_dot_3: return "braille_dot_3"; break; + case XK_braille_dot_4: return "braille_dot_4"; break; + case XK_braille_dot_5: return "braille_dot_5"; break; + case XK_braille_dot_6: return "braille_dot_6"; break; + case XK_braille_dot_7: return "braille_dot_7"; break; + case XK_braille_dot_8: return "braille_dot_8"; break; + case XK_braille_dot_9: return "braille_dot_9"; break; + case XK_braille_dot_10: return "braille_dot_10"; break; + case XK_braille_blank: return "braille_blank"; break; + case XK_braille_dots_1: return "braille_dots_1"; break; + case XK_braille_dots_2: return "braille_dots_2"; break; + case XK_braille_dots_12: return "braille_dots_12"; break; + case XK_braille_dots_3: return "braille_dots_3"; break; + case XK_braille_dots_13: return "braille_dots_13"; break; + case XK_braille_dots_23: return "braille_dots_23"; break; + case XK_braille_dots_123: return "braille_dots_123"; break; + case XK_braille_dots_4: return "braille_dots_4"; break; + case XK_braille_dots_14: return "braille_dots_14"; break; + case XK_braille_dots_24: return "braille_dots_24"; break; + case XK_braille_dots_124: return "braille_dots_124"; break; + case XK_braille_dots_34: return "braille_dots_34"; break; + case XK_braille_dots_134: return "braille_dots_134"; break; + case XK_braille_dots_234: return "braille_dots_234"; break; + case XK_braille_dots_1234: return "braille_dots_1234"; break; + case XK_braille_dots_5: return "braille_dots_5"; break; + case XK_braille_dots_15: return "braille_dots_15"; break; + case XK_braille_dots_25: return "braille_dots_25"; break; + case XK_braille_dots_125: return "braille_dots_125"; break; + case XK_braille_dots_35: return "braille_dots_35"; break; + case XK_braille_dots_135: return "braille_dots_135"; break; + case XK_braille_dots_235: return "braille_dots_235"; break; + case XK_braille_dots_1235: return "braille_dots_1235"; break; + case XK_braille_dots_45: return "braille_dots_45"; break; + case XK_braille_dots_145: return "braille_dots_145"; break; + case XK_braille_dots_245: return "braille_dots_245"; break; + case XK_braille_dots_1245: return "braille_dots_1245"; break; + case XK_braille_dots_345: return "braille_dots_345"; break; + case XK_braille_dots_1345: return "braille_dots_1345"; break; + case XK_braille_dots_2345: return "braille_dots_2345"; break; + case XK_braille_dots_12345: return "braille_dots_12345"; break; + case XK_braille_dots_6: return "braille_dots_6"; break; + case XK_braille_dots_16: return "braille_dots_16"; break; + case XK_braille_dots_26: return "braille_dots_26"; break; + case XK_braille_dots_126: return "braille_dots_126"; break; + case XK_braille_dots_36: return "braille_dots_36"; break; + case XK_braille_dots_136: return "braille_dots_136"; break; + case XK_braille_dots_236: return "braille_dots_236"; break; + case XK_braille_dots_1236: return "braille_dots_1236"; break; + case XK_braille_dots_46: return "braille_dots_46"; break; + case XK_braille_dots_146: return "braille_dots_146"; break; + case XK_braille_dots_246: return "braille_dots_246"; break; + case XK_braille_dots_1246: return "braille_dots_1246"; break; + case XK_braille_dots_346: return "braille_dots_346"; break; + case XK_braille_dots_1346: return "braille_dots_1346"; break; + case XK_braille_dots_2346: return "braille_dots_2346"; break; + case XK_braille_dots_12346: return "braille_dots_12346"; break; + case XK_braille_dots_56: return "braille_dots_56"; break; + case XK_braille_dots_156: return "braille_dots_156"; break; + case XK_braille_dots_256: return "braille_dots_256"; break; + case XK_braille_dots_1256: return "braille_dots_1256"; break; + case XK_braille_dots_356: return "braille_dots_356"; break; + case XK_braille_dots_1356: return "braille_dots_1356"; break; + case XK_braille_dots_2356: return "braille_dots_2356"; break; + case XK_braille_dots_12356: return "braille_dots_12356"; break; + case XK_braille_dots_456: return "braille_dots_456"; break; + case XK_braille_dots_1456: return "braille_dots_1456"; break; + case XK_braille_dots_2456: return "braille_dots_2456"; break; + case XK_braille_dots_12456: return "braille_dots_12456"; break; + case XK_braille_dots_3456: return "braille_dots_3456"; break; + case XK_braille_dots_13456: return "braille_dots_13456"; break; + case XK_braille_dots_23456: return "braille_dots_23456"; break; + case XK_braille_dots_123456: return "braille_dots_123456"; break; + case XK_braille_dots_7: return "braille_dots_7"; break; + case XK_braille_dots_17: return "braille_dots_17"; break; + case XK_braille_dots_27: return "braille_dots_27"; break; + case XK_braille_dots_127: return "braille_dots_127"; break; + case XK_braille_dots_37: return "braille_dots_37"; break; + case XK_braille_dots_137: return "braille_dots_137"; break; + case XK_braille_dots_237: return "braille_dots_237"; break; + case XK_braille_dots_1237: return "braille_dots_1237"; break; + case XK_braille_dots_47: return "braille_dots_47"; break; + case XK_braille_dots_147: return "braille_dots_147"; break; + case XK_braille_dots_247: return "braille_dots_247"; break; + case XK_braille_dots_1247: return "braille_dots_1247"; break; + case XK_braille_dots_347: return "braille_dots_347"; break; + case XK_braille_dots_1347: return "braille_dots_1347"; break; + case XK_braille_dots_2347: return "braille_dots_2347"; break; + case XK_braille_dots_12347: return "braille_dots_12347"; break; + case XK_braille_dots_57: return "braille_dots_57"; break; + case XK_braille_dots_157: return "braille_dots_157"; break; + case XK_braille_dots_257: return "braille_dots_257"; break; + case XK_braille_dots_1257: return "braille_dots_1257"; break; + case XK_braille_dots_357: return "braille_dots_357"; break; + case XK_braille_dots_1357: return "braille_dots_1357"; break; + case XK_braille_dots_2357: return "braille_dots_2357"; break; + case XK_braille_dots_12357: return "braille_dots_12357"; break; + case XK_braille_dots_457: return "braille_dots_457"; break; + case XK_braille_dots_1457: return "braille_dots_1457"; break; + case XK_braille_dots_2457: return "braille_dots_2457"; break; + case XK_braille_dots_12457: return "braille_dots_12457"; break; + case XK_braille_dots_3457: return "braille_dots_3457"; break; + case XK_braille_dots_13457: return "braille_dots_13457"; break; + case XK_braille_dots_23457: return "braille_dots_23457"; break; + case XK_braille_dots_123457: return "braille_dots_123457"; break; + case XK_braille_dots_67: return "braille_dots_67"; break; + case XK_braille_dots_167: return "braille_dots_167"; break; + case XK_braille_dots_267: return "braille_dots_267"; break; + case XK_braille_dots_1267: return "braille_dots_1267"; break; + case XK_braille_dots_367: return "braille_dots_367"; break; + case XK_braille_dots_1367: return "braille_dots_1367"; break; + case XK_braille_dots_2367: return "braille_dots_2367"; break; + case XK_braille_dots_12367: return "braille_dots_12367"; break; + case XK_braille_dots_467: return "braille_dots_467"; break; + case XK_braille_dots_1467: return "braille_dots_1467"; break; + case XK_braille_dots_2467: return "braille_dots_2467"; break; + case XK_braille_dots_12467: return "braille_dots_12467"; break; + case XK_braille_dots_3467: return "braille_dots_3467"; break; + case XK_braille_dots_13467: return "braille_dots_13467"; break; + case XK_braille_dots_23467: return "braille_dots_23467"; break; + case XK_braille_dots_123467: return "braille_dots_123467"; break; + case XK_braille_dots_567: return "braille_dots_567"; break; + case XK_braille_dots_1567: return "braille_dots_1567"; break; + case XK_braille_dots_2567: return "braille_dots_2567"; break; + case XK_braille_dots_12567: return "braille_dots_12567"; break; + case XK_braille_dots_3567: return "braille_dots_3567"; break; + case XK_braille_dots_13567: return "braille_dots_13567"; break; + case XK_braille_dots_23567: return "braille_dots_23567"; break; + case XK_braille_dots_123567: return "braille_dots_123567"; break; + case XK_braille_dots_4567: return "braille_dots_4567"; break; + case XK_braille_dots_14567: return "braille_dots_14567"; break; + case XK_braille_dots_24567: return "braille_dots_24567"; break; + case XK_braille_dots_124567: return "braille_dots_124567"; break; + case XK_braille_dots_34567: return "braille_dots_34567"; break; + case XK_braille_dots_134567: return "braille_dots_134567"; break; + case XK_braille_dots_234567: return "braille_dots_234567"; break; + case XK_braille_dots_1234567: return "braille_dots_1234567"; break; + case XK_braille_dots_8: return "braille_dots_8"; break; + case XK_braille_dots_18: return "braille_dots_18"; break; + case XK_braille_dots_28: return "braille_dots_28"; break; + case XK_braille_dots_128: return "braille_dots_128"; break; + case XK_braille_dots_38: return "braille_dots_38"; break; + case XK_braille_dots_138: return "braille_dots_138"; break; + case XK_braille_dots_238: return "braille_dots_238"; break; + case XK_braille_dots_1238: return "braille_dots_1238"; break; + case XK_braille_dots_48: return "braille_dots_48"; break; + case XK_braille_dots_148: return "braille_dots_148"; break; + case XK_braille_dots_248: return "braille_dots_248"; break; + case XK_braille_dots_1248: return "braille_dots_1248"; break; + case XK_braille_dots_348: return "braille_dots_348"; break; + case XK_braille_dots_1348: return "braille_dots_1348"; break; + case XK_braille_dots_2348: return "braille_dots_2348"; break; + case XK_braille_dots_12348: return "braille_dots_12348"; break; + case XK_braille_dots_58: return "braille_dots_58"; break; + case XK_braille_dots_158: return "braille_dots_158"; break; + case XK_braille_dots_258: return "braille_dots_258"; break; + case XK_braille_dots_1258: return "braille_dots_1258"; break; + case XK_braille_dots_358: return "braille_dots_358"; break; + case XK_braille_dots_1358: return "braille_dots_1358"; break; + case XK_braille_dots_2358: return "braille_dots_2358"; break; + case XK_braille_dots_12358: return "braille_dots_12358"; break; + case XK_braille_dots_458: return "braille_dots_458"; break; + case XK_braille_dots_1458: return "braille_dots_1458"; break; + case XK_braille_dots_2458: return "braille_dots_2458"; break; + case XK_braille_dots_12458: return "braille_dots_12458"; break; + case XK_braille_dots_3458: return "braille_dots_3458"; break; + case XK_braille_dots_13458: return "braille_dots_13458"; break; + case XK_braille_dots_23458: return "braille_dots_23458"; break; + case XK_braille_dots_123458: return "braille_dots_123458"; break; + case XK_braille_dots_68: return "braille_dots_68"; break; + case XK_braille_dots_168: return "braille_dots_168"; break; + case XK_braille_dots_268: return "braille_dots_268"; break; + case XK_braille_dots_1268: return "braille_dots_1268"; break; + case XK_braille_dots_368: return "braille_dots_368"; break; + case XK_braille_dots_1368: return "braille_dots_1368"; break; + case XK_braille_dots_2368: return "braille_dots_2368"; break; + case XK_braille_dots_12368: return "braille_dots_12368"; break; + case XK_braille_dots_468: return "braille_dots_468"; break; + case XK_braille_dots_1468: return "braille_dots_1468"; break; + case XK_braille_dots_2468: return "braille_dots_2468"; break; + case XK_braille_dots_12468: return "braille_dots_12468"; break; + case XK_braille_dots_3468: return "braille_dots_3468"; break; + case XK_braille_dots_13468: return "braille_dots_13468"; break; + case XK_braille_dots_23468: return "braille_dots_23468"; break; + case XK_braille_dots_123468: return "braille_dots_123468"; break; + case XK_braille_dots_568: return "braille_dots_568"; break; + case XK_braille_dots_1568: return "braille_dots_1568"; break; + case XK_braille_dots_2568: return "braille_dots_2568"; break; + case XK_braille_dots_12568: return "braille_dots_12568"; break; + case XK_braille_dots_3568: return "braille_dots_3568"; break; + case XK_braille_dots_13568: return "braille_dots_13568"; break; + case XK_braille_dots_23568: return "braille_dots_23568"; break; + case XK_braille_dots_123568: return "braille_dots_123568"; break; + case XK_braille_dots_4568: return "braille_dots_4568"; break; + case XK_braille_dots_14568: return "braille_dots_14568"; break; + case XK_braille_dots_24568: return "braille_dots_24568"; break; + case XK_braille_dots_124568: return "braille_dots_124568"; break; + case XK_braille_dots_34568: return "braille_dots_34568"; break; + case XK_braille_dots_134568: return "braille_dots_134568"; break; + case XK_braille_dots_234568: return "braille_dots_234568"; break; + case XK_braille_dots_1234568: return "braille_dots_1234568"; break; + case XK_braille_dots_78: return "braille_dots_78"; break; + case XK_braille_dots_178: return "braille_dots_178"; break; + case XK_braille_dots_278: return "braille_dots_278"; break; + case XK_braille_dots_1278: return "braille_dots_1278"; break; + case XK_braille_dots_378: return "braille_dots_378"; break; + case XK_braille_dots_1378: return "braille_dots_1378"; break; + case XK_braille_dots_2378: return "braille_dots_2378"; break; + case XK_braille_dots_12378: return "braille_dots_12378"; break; + case XK_braille_dots_478: return "braille_dots_478"; break; + case XK_braille_dots_1478: return "braille_dots_1478"; break; + case XK_braille_dots_2478: return "braille_dots_2478"; break; + case XK_braille_dots_12478: return "braille_dots_12478"; break; + case XK_braille_dots_3478: return "braille_dots_3478"; break; + case XK_braille_dots_13478: return "braille_dots_13478"; break; + case XK_braille_dots_23478: return "braille_dots_23478"; break; + case XK_braille_dots_123478: return "braille_dots_123478"; break; + case XK_braille_dots_578: return "braille_dots_578"; break; + case XK_braille_dots_1578: return "braille_dots_1578"; break; + case XK_braille_dots_2578: return "braille_dots_2578"; break; + case XK_braille_dots_12578: return "braille_dots_12578"; break; + case XK_braille_dots_3578: return "braille_dots_3578"; break; + case XK_braille_dots_13578: return "braille_dots_13578"; break; + case XK_braille_dots_23578: return "braille_dots_23578"; break; + case XK_braille_dots_123578: return "braille_dots_123578"; break; + case XK_braille_dots_4578: return "braille_dots_4578"; break; + case XK_braille_dots_14578: return "braille_dots_14578"; break; + case XK_braille_dots_24578: return "braille_dots_24578"; break; + case XK_braille_dots_124578: return "braille_dots_124578"; break; + case XK_braille_dots_34578: return "braille_dots_34578"; break; + case XK_braille_dots_134578: return "braille_dots_134578"; break; + case XK_braille_dots_234578: return "braille_dots_234578"; break; + case XK_braille_dots_1234578: return "braille_dots_1234578"; break; + case XK_braille_dots_678: return "braille_dots_678"; break; + case XK_braille_dots_1678: return "braille_dots_1678"; break; + case XK_braille_dots_2678: return "braille_dots_2678"; break; + case XK_braille_dots_12678: return "braille_dots_12678"; break; + case XK_braille_dots_3678: return "braille_dots_3678"; break; + case XK_braille_dots_13678: return "braille_dots_13678"; break; + case XK_braille_dots_23678: return "braille_dots_23678"; break; + case XK_braille_dots_123678: return "braille_dots_123678"; break; + case XK_braille_dots_4678: return "braille_dots_4678"; break; + case XK_braille_dots_14678: return "braille_dots_14678"; break; + case XK_braille_dots_24678: return "braille_dots_24678"; break; + case XK_braille_dots_124678: return "braille_dots_124678"; break; + case XK_braille_dots_34678: return "braille_dots_34678"; break; + case XK_braille_dots_134678: return "braille_dots_134678"; break; + case XK_braille_dots_234678: return "braille_dots_234678"; break; + case XK_braille_dots_1234678: return "braille_dots_1234678"; break; + case XK_braille_dots_5678: return "braille_dots_5678"; break; + case XK_braille_dots_15678: return "braille_dots_15678"; break; + case XK_braille_dots_25678: return "braille_dots_25678"; break; + case XK_braille_dots_125678: return "braille_dots_125678"; break; + case XK_braille_dots_35678: return "braille_dots_35678"; break; + case XK_braille_dots_135678: return "braille_dots_135678"; break; + case XK_braille_dots_235678: return "braille_dots_235678"; break; + case XK_braille_dots_1235678: return "braille_dots_1235678"; break; + case XK_braille_dots_45678: return "braille_dots_45678"; break; + case XK_braille_dots_145678: return "braille_dots_145678"; break; + case XK_braille_dots_245678: return "braille_dots_245678"; break; + case XK_braille_dots_1245678: return "braille_dots_1245678"; break; + case XK_braille_dots_345678: return "braille_dots_345678"; break; + case XK_braille_dots_1345678: return "braille_dots_1345678"; break; + case XK_braille_dots_2345678: return "braille_dots_2345678"; break; + case XK_braille_dots_12345678: return "braille_dots_12345678"; break; + case XK_Sinh_ng: return "Sinh_ng"; break; + case XK_Sinh_h2: return "Sinh_h2"; break; + case XK_Sinh_a: return "Sinh_a"; break; + case XK_Sinh_aa: return "Sinh_aa"; break; + case XK_Sinh_ae: return "Sinh_ae"; break; + case XK_Sinh_aee: return "Sinh_aee"; break; + case XK_Sinh_i: return "Sinh_i"; break; + case XK_Sinh_ii: return "Sinh_ii"; break; + case XK_Sinh_u: return "Sinh_u"; break; + case XK_Sinh_uu: return "Sinh_uu"; break; + case XK_Sinh_ri: return "Sinh_ri"; break; + case XK_Sinh_rii: return "Sinh_rii"; break; + case XK_Sinh_lu: return "Sinh_lu"; break; + case XK_Sinh_luu: return "Sinh_luu"; break; + case XK_Sinh_e: return "Sinh_e"; break; + case XK_Sinh_ee: return "Sinh_ee"; break; + case XK_Sinh_ai: return "Sinh_ai"; break; + case XK_Sinh_o: return "Sinh_o"; break; + case XK_Sinh_oo: return "Sinh_oo"; break; + case XK_Sinh_au: return "Sinh_au"; break; + case XK_Sinh_ka: return "Sinh_ka"; break; + case XK_Sinh_kha: return "Sinh_kha"; break; + case XK_Sinh_ga: return "Sinh_ga"; break; + case XK_Sinh_gha: return "Sinh_gha"; break; + case XK_Sinh_ng2: return "Sinh_ng2"; break; + case XK_Sinh_nga: return "Sinh_nga"; break; + case XK_Sinh_ca: return "Sinh_ca"; break; + case XK_Sinh_cha: return "Sinh_cha"; break; + case XK_Sinh_ja: return "Sinh_ja"; break; + case XK_Sinh_jha: return "Sinh_jha"; break; + case XK_Sinh_nya: return "Sinh_nya"; break; + case XK_Sinh_jnya: return "Sinh_jnya"; break; + case XK_Sinh_nja: return "Sinh_nja"; break; + case XK_Sinh_tta: return "Sinh_tta"; break; + case XK_Sinh_ttha: return "Sinh_ttha"; break; + case XK_Sinh_dda: return "Sinh_dda"; break; + case XK_Sinh_ddha: return "Sinh_ddha"; break; + case XK_Sinh_nna: return "Sinh_nna"; break; + case XK_Sinh_ndda: return "Sinh_ndda"; break; + case XK_Sinh_tha: return "Sinh_tha"; break; + case XK_Sinh_thha: return "Sinh_thha"; break; + case XK_Sinh_dha: return "Sinh_dha"; break; + case XK_Sinh_dhha: return "Sinh_dhha"; break; + case XK_Sinh_na: return "Sinh_na"; break; + case XK_Sinh_ndha: return "Sinh_ndha"; break; + case XK_Sinh_pa: return "Sinh_pa"; break; + case XK_Sinh_pha: return "Sinh_pha"; break; + case XK_Sinh_ba: return "Sinh_ba"; break; + case XK_Sinh_bha: return "Sinh_bha"; break; + case XK_Sinh_ma: return "Sinh_ma"; break; + case XK_Sinh_mba: return "Sinh_mba"; break; + case XK_Sinh_ya: return "Sinh_ya"; break; + case XK_Sinh_ra: return "Sinh_ra"; break; + case XK_Sinh_la: return "Sinh_la"; break; + case XK_Sinh_va: return "Sinh_va"; break; + case XK_Sinh_sha: return "Sinh_sha"; break; + case XK_Sinh_ssha: return "Sinh_ssha"; break; + case XK_Sinh_sa: return "Sinh_sa"; break; + case XK_Sinh_ha: return "Sinh_ha"; break; + case XK_Sinh_lla: return "Sinh_lla"; break; + case XK_Sinh_fa: return "Sinh_fa"; break; + case XK_Sinh_al: return "Sinh_al"; break; + case XK_Sinh_aa2: return "Sinh_aa2"; break; + case XK_Sinh_ae2: return "Sinh_ae2"; break; + case XK_Sinh_aee2: return "Sinh_aee2"; break; + case XK_Sinh_i2: return "Sinh_i2"; break; + case XK_Sinh_ii2: return "Sinh_ii2"; break; + case XK_Sinh_u2: return "Sinh_u2"; break; + case XK_Sinh_uu2: return "Sinh_uu2"; break; + case XK_Sinh_ru2: return "Sinh_ru2"; break; + case XK_Sinh_e2: return "Sinh_e2"; break; + case XK_Sinh_ee2: return "Sinh_ee2"; break; + case XK_Sinh_ai2: return "Sinh_ai2"; break; + case XK_Sinh_o2: return "Sinh_o2"; break; + case XK_Sinh_oo2: return "Sinh_oo2"; break; + case XK_Sinh_au2: return "Sinh_au2"; break; + case XK_Sinh_lu2: return "Sinh_lu2"; break; + case XK_Sinh_ruu2: return "Sinh_ruu2"; break; + case XK_Sinh_luu2: return "Sinh_luu2"; break; + case XK_Sinh_kunddaliya: return "Sinh_kunddaliya"; break; + default: return ""; break; + } +} |