/* * This source file is part of RmlUi, the HTML/CSS Interface Middleware * * For the latest information, see http://github.com/mikke89/RmlUi * * Copyright (c) 2008-2010 CodePoint Ltd, Shift Technology Ltd * Copyright (c) 2019-2023 The RmlUi Team, and contributors * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. * */ #include "RmlUi_Platform_X11.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAS_X11XKBLIB #include #endif // HAS_X11XKBLIB #include static Rml::Character GetCharacterCode(Rml::Input::KeyIdentifier key_identifier, int key_modifier_state); SystemInterface_X11::SystemInterface_X11(Display* display) : display(display) { // Create cursors cursor_default = XCreateFontCursor(display, XC_left_ptr); cursor_move = XCreateFontCursor(display, XC_fleur); cursor_pointer = XCreateFontCursor(display, XC_hand1); cursor_resize = XCreateFontCursor(display, XC_sizing); cursor_cross = XCreateFontCursor(display, XC_crosshair); cursor_text = XCreateFontCursor(display, XC_xterm); cursor_unavailable = XCreateFontCursor(display, XC_X_cursor); // For copy & paste functions UTF8_atom = XInternAtom(display, "UTF8_STRING", 1); XSEL_DATA_atom = XInternAtom(display, "XSEL_DATA", 0); CLIPBOARD_atom = XInternAtom(display, "CLIPBOARD", 0); TARGETS_atom = XInternAtom(display, "TARGETS", 0); TEXT_atom = XInternAtom(display, "TEXT", 0); gettimeofday(&start_time, nullptr); } void SystemInterface_X11::SetWindow(Window in_window) { window = in_window; } bool SystemInterface_X11::HandleSelectionRequest(const XEvent& ev) { if (ev.type == SelectionRequest && XGetSelectionOwner(display, CLIPBOARD_atom) == window && ev.xselectionrequest.selection == CLIPBOARD_atom) { XCopy(clipboard_text, ev); return false; } return true; } double SystemInterface_X11::GetElapsedTime() { struct timeval now; gettimeofday(&now, nullptr); double sec = now.tv_sec - start_time.tv_sec; double usec = now.tv_usec - start_time.tv_usec; double result = sec + (usec / 1000000.0); return result; } void SystemInterface_X11::SetMouseCursor(const Rml::String& cursor_name) { if (display && window) { Cursor cursor_handle = 0; if (cursor_name.empty() || cursor_name == "arrow") cursor_handle = cursor_default; else if (cursor_name == "move") cursor_handle = cursor_move; else if (cursor_name == "pointer") cursor_handle = cursor_pointer; else if (cursor_name == "resize") cursor_handle = cursor_resize; else if (cursor_name == "cross") cursor_handle = cursor_cross; else if (cursor_name == "text") cursor_handle = cursor_text; else if (cursor_name == "rmlui-scroll-idle") cursor_handle = cursor_move; else if (cursor_name == "rmlui-scroll-up") cursor_handle = cursor_move; else if (cursor_name == "rmlui-scroll-down") cursor_handle = cursor_move; else if (cursor_name == "unavailable") cursor_handle = cursor_unavailable; if (cursor_handle) { XDefineCursor(display, window, cursor_handle); } } } void SystemInterface_X11::SetClipboardText(const Rml::String& text) { clipboard_text = text; XSetSelectionOwner(display, CLIPBOARD_atom, window, 0); } void SystemInterface_X11::GetClipboardText(Rml::String& text) { if (XGetSelectionOwner(display, CLIPBOARD_atom) != window) { if (!UTF8_atom || !XPaste(UTF8_atom, text)) { // fallback XPaste(XA_STRING_atom, text); } } else { text = clipboard_text; } } void SystemInterface_X11::XCopy(const Rml::String& clipboard_data, const XEvent& event) { Atom format = (UTF8_atom ? UTF8_atom : XA_STRING_atom); XSelectionEvent ev = { SelectionNotify, // the event type that will be sent to the requestor 0, // serial 0, // send_event event.xselectionrequest.display, event.xselectionrequest.requestor, event.xselectionrequest.selection, event.xselectionrequest.target, event.xselectionrequest.property, 0 // time }; int retval = 0; if (ev.target == TARGETS_atom) { retval = XChangeProperty(ev.display, ev.requestor, ev.property, XA_atom, 32, PropModeReplace, (unsigned char*)&format, 1); } else if (ev.target == XA_STRING_atom || ev.target == TEXT_atom) { retval = XChangeProperty(ev.display, ev.requestor, ev.property, XA_STRING_atom, 8, PropModeReplace, (unsigned char*)clipboard_data.c_str(), clipboard_data.size()); } else if (ev.target == UTF8_atom) { retval = XChangeProperty(ev.display, ev.requestor, ev.property, UTF8_atom, 8, PropModeReplace, (unsigned char*)clipboard_data.c_str(), clipboard_data.size()); } else { ev.property = 0; } if ((retval & 2) == 0) { // Notify the requestor that clipboard data is available XSendEvent(display, ev.requestor, 0, 0, (XEvent*)&ev); } } bool SystemInterface_X11::XPaste(Atom target_atom, Rml::String& clipboard_data) { XEvent ev; // A SelectionRequest event will be sent to the clipboard owner, which should respond with SelectionNotify XConvertSelection(display, CLIPBOARD_atom, target_atom, XSEL_DATA_atom, window, CurrentTime); XSync(display, 0); XNextEvent(display, &ev); if (ev.type == SelectionNotify) { if (ev.xselection.property == 0) { // If no owner for the specified selection exists, the X server generates // a SelectionNotify event with property None (0). return false; } if (ev.xselection.selection == CLIPBOARD_atom) { int actual_format; unsigned long bytes_after, nitems; char* prop = nullptr; Atom actual_type; XGetWindowProperty(ev.xselection.display, ev.xselection.requestor, ev.xselection.property, 0L, // offset (~0L), // length 0, // delete? AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, (unsigned char**)&prop); if (actual_type == UTF8_atom || actual_type == XA_STRING_atom) { clipboard_data = Rml::String(prop, prop + nitems); XFree(prop); } XDeleteProperty(ev.xselection.display, ev.xselection.requestor, ev.xselection.property); return true; } } return false; } bool RmlX11::HandleInputEvent(Rml::Context* context, Display* display, const XEvent& ev) { switch (ev.type) { case ButtonPress: { switch (ev.xbutton.button) { case Button1: case Button2: case Button3: return context->ProcessMouseButtonDown(ConvertMouseButton(ev.xbutton.button), RmlX11::GetKeyModifierState(ev.xbutton.state)); case Button4: return context->ProcessMouseWheel(-1, RmlX11::GetKeyModifierState(ev.xbutton.state)); case Button5: return context->ProcessMouseWheel(1, RmlX11::GetKeyModifierState(ev.xbutton.state)); default: return true; } } break; case ButtonRelease: { switch (ev.xbutton.button) { case Button1: case Button2: case Button3: return context->ProcessMouseButtonUp(ConvertMouseButton(ev.xbutton.button), RmlX11::GetKeyModifierState(ev.xbutton.state)); default: return true; } } break; case MotionNotify: { return context->ProcessMouseMove(ev.xmotion.x, ev.xmotion.y, RmlX11::GetKeyModifierState(ev.xmotion.state)); } break; case LeaveNotify: { return context->ProcessMouseLeave(); } break; case KeyPress: { Rml::Input::KeyIdentifier key_identifier = RmlX11::ConvertKey(display, ev.xkey.keycode); const int key_modifier_state = RmlX11::GetKeyModifierState(ev.xkey.state); bool propagates = true; if (key_identifier != Rml::Input::KI_UNKNOWN) propagates = context->ProcessKeyDown(key_identifier, key_modifier_state); Rml::Character character = GetCharacterCode(key_identifier, key_modifier_state); if (character != Rml::Character::Null && !(key_modifier_state & Rml::Input::KM_CTRL)) propagates &= context->ProcessTextInput(character); return propagates; } break; case KeyRelease: { Rml::Input::KeyIdentifier key_identifier = RmlX11::ConvertKey(display, ev.xkey.keycode); const int key_modifier_state = RmlX11::GetKeyModifierState(ev.xkey.state); bool propagates = true; if (key_identifier != Rml::Input::KI_UNKNOWN) propagates = context->ProcessKeyUp(key_identifier, key_modifier_state); return propagates; } break; default: break; } return true; } int RmlX11::GetKeyModifierState(int x11_state) { int key_modifier_state = 0; if (x11_state & ShiftMask) key_modifier_state |= Rml::Input::KM_SHIFT; if (x11_state & LockMask) key_modifier_state |= Rml::Input::KM_CAPSLOCK; if (x11_state & ControlMask) key_modifier_state |= Rml::Input::KM_CTRL; if (x11_state & Mod5Mask) key_modifier_state |= Rml::Input::KM_ALT; if (x11_state & Mod2Mask) key_modifier_state |= Rml::Input::KM_NUMLOCK; return key_modifier_state; } /** X11 Key data used for key code conversion. */ struct XKeyData { #ifdef HAS_X11XKBLIB bool has_xkblib = false; #endif // HAS_X11XKBLIB bool initialized = false; int min_keycode = 0, max_keycode = 0, keysyms_per_keycode = 0; KeySym* x11_key_mapping = nullptr; }; // Get the key data, which is initialized and filled on the first fetch. static const XKeyData& GetXKeyData(Display* display) { RMLUI_ASSERT(display); static XKeyData data; if (!data.initialized) { data.initialized = true; #ifdef HAS_X11XKBLIB int opcode_rtrn = -1; int event_rtrn = -1; int error_rtrn = -1; int major_in_out = -1; int minor_in_out = -1; // Xkb extension may not exist in the server. This checks for its existence and initializes the extension if available. data.has_xkblib = XkbQueryExtension(display, &opcode_rtrn, &event_rtrn, &error_rtrn, &major_in_out, &minor_in_out); // if Xkb isn't available, fall back to using XGetKeyboardMapping, which may occur if RmlUi is compiled with Xkb support but the server // doesn't support it. This occurs with older X11 servers or virtual framebuffers such as x11vnc server. if (!data.has_xkblib) #endif // HAS_X11XKBLIB { XDisplayKeycodes(display, &data.min_keycode, &data.max_keycode); data.x11_key_mapping = XGetKeyboardMapping(display, data.min_keycode, data.max_keycode + 1 - data.min_keycode, &data.keysyms_per_keycode); } } return data; } Rml::Input::KeyIdentifier RmlX11::ConvertKey(Display* display, unsigned int x11_key_code) { RMLUI_ASSERT(display); const XKeyData& key_data = GetXKeyData(display); const int group_index = 0; // this is always 0 for our limited example KeySym sym = {}; #ifdef HAS_X11XKBLIB if (key_data.has_xkblib) { sym = XkbKeycodeToKeysym(display, x11_key_code, 0, group_index); } else #endif // HAS_X11XKBLIB { KeySym sym_full = key_data.x11_key_mapping[(x11_key_code - key_data.min_keycode) * key_data.keysyms_per_keycode + group_index]; KeySym lower_sym, upper_sym; XConvertCase(sym_full, &lower_sym, &upper_sym); sym = lower_sym; } // clang-format off switch (sym & 0xFF) { case XK_BackSpace & 0xFF: return Rml::Input::KI_BACK; case XK_Tab & 0xFF: return Rml::Input::KI_TAB; case XK_Clear & 0xFF: return Rml::Input::KI_CLEAR; case XK_Return & 0xFF: return Rml::Input::KI_RETURN; case XK_Pause & 0xFF: return Rml::Input::KI_PAUSE; case XK_Scroll_Lock & 0xFF: return Rml::Input::KI_SCROLL; case XK_Escape & 0xFF: return Rml::Input::KI_ESCAPE; case XK_Delete & 0xFF: return Rml::Input::KI_DELETE; case XK_Kanji & 0xFF: return Rml::Input::KI_KANJI; // case XK_Muhenkan & 0xFF: return Rml::Input::; /* Cancel Conversion */ // case XK_Henkan_Mode & 0xFF: return Rml::Input::; /* Start/Stop Conversion */ // case XK_Henkan & 0xFF: return Rml::Input::; /* Alias for Henkan_Mode */ // case XK_Romaji & 0xFF: return Rml::Input::; /* to Romaji */ // case XK_Hiragana & 0xFF: return Rml::Input::; /* to Hiragana */ // case XK_Katakana & 0xFF: return Rml::Input::; /* to Katakana */ // case XK_Hiragana_Katakana & 0xFF: return Rml::Input::; /* Hiragana/Katakana toggle */ // case XK_Zenkaku & 0xFF: return Rml::Input::; /* to Zenkaku */ // case XK_Hankaku & 0xFF: return Rml::Input::; /* to Hankaku */ // case XK_Zenkaku_Hankaku & 0xFF: return Rml::Input::; /* Zenkaku/Hankaku toggle */ case XK_Touroku & 0xFF: return Rml::Input::KI_OEM_FJ_TOUROKU; // case XK_Massyo & 0xFF: return Rml::Input::KI_OEM_FJ_MASSHOU; // case XK_Kana_Lock & 0xFF: return Rml::Input::; /* Kana Lock */ // case XK_Kana_Shift & 0xFF: return Rml::Input::; /* Kana Shift */ // case XK_Eisu_Shift & 0xFF: return Rml::Input::; /* Alphanumeric Shift */ // case XK_Eisu_toggle & 0xFF: return Rml::Input::; /* Alphanumeric toggle */ case XK_Home & 0xFF: return Rml::Input::KI_HOME; case XK_Left & 0xFF: return Rml::Input::KI_LEFT; case XK_Up & 0xFF: return Rml::Input::KI_UP; case XK_Right & 0xFF: return Rml::Input::KI_RIGHT; case XK_Down & 0xFF: return Rml::Input::KI_DOWN; case XK_Prior & 0xFF: return Rml::Input::KI_PRIOR; case XK_Next & 0xFF: return Rml::Input::KI_NEXT; case XK_End & 0xFF: return Rml::Input::KI_END; case XK_Begin & 0xFF: return Rml::Input::KI_HOME; // case XK_Print & 0xFF: return Rml::Input::KI_SNAPSHOT; // case XK_Insert & 0xFF: return Rml::Input::KI_INSERT; case XK_Num_Lock & 0xFF: return Rml::Input::KI_NUMLOCK; case XK_KP_Space & 0xFF: return Rml::Input::KI_SPACE; case XK_KP_Tab & 0xFF: return Rml::Input::KI_TAB; case XK_KP_Enter & 0xFF: return Rml::Input::KI_NUMPADENTER; case XK_KP_F1 & 0xFF: return Rml::Input::KI_F1; case XK_KP_F2 & 0xFF: return Rml::Input::KI_F2; case XK_KP_F3 & 0xFF: return Rml::Input::KI_F3; case XK_KP_F4 & 0xFF: return Rml::Input::KI_F4; case XK_KP_Home & 0xFF: return Rml::Input::KI_NUMPAD7; case XK_KP_Left & 0xFF: return Rml::Input::KI_NUMPAD4; case XK_KP_Up & 0xFF: return Rml::Input::KI_NUMPAD8; case XK_KP_Right & 0xFF: return Rml::Input::KI_NUMPAD6; case XK_KP_Down & 0xFF: return Rml::Input::KI_NUMPAD2; case XK_KP_Prior & 0xFF: return Rml::Input::KI_NUMPAD9; case XK_KP_Next & 0xFF: return Rml::Input::KI_NUMPAD3; case XK_KP_End & 0xFF: return Rml::Input::KI_NUMPAD1; case XK_KP_Begin & 0xFF: return Rml::Input::KI_NUMPAD5; case XK_KP_Insert & 0xFF: return Rml::Input::KI_NUMPAD0; case XK_KP_Delete & 0xFF: return Rml::Input::KI_DECIMAL; case XK_KP_Equal & 0xFF: return Rml::Input::KI_OEM_NEC_EQUAL; case XK_KP_Multiply & 0xFF: return Rml::Input::KI_MULTIPLY; case XK_KP_Add & 0xFF: return Rml::Input::KI_ADD; case XK_KP_Separator & 0xFF: return Rml::Input::KI_SEPARATOR; case XK_KP_Subtract & 0xFF: return Rml::Input::KI_SUBTRACT; case XK_KP_Decimal & 0xFF: return Rml::Input::KI_DECIMAL; case XK_KP_Divide & 0xFF: return Rml::Input::KI_DIVIDE; case XK_F1 & 0xFF: return Rml::Input::KI_F1; case XK_F2 & 0xFF: return Rml::Input::KI_F2; case XK_F3 & 0xFF: return Rml::Input::KI_F3; case XK_F4 & 0xFF: return Rml::Input::KI_F4; case XK_F5 & 0xFF: return Rml::Input::KI_F5; case XK_F6 & 0xFF: return Rml::Input::KI_F6; case XK_F7 & 0xFF: return Rml::Input::KI_F7; case XK_F8 & 0xFF: return Rml::Input::KI_F8; case XK_F9 & 0xFF: return Rml::Input::KI_F9; case XK_F10 & 0xFF: return Rml::Input::KI_F10; case XK_F11 & 0xFF: return Rml::Input::KI_F11; case XK_F12 & 0xFF: return Rml::Input::KI_F12; case XK_F13 & 0xFF: return Rml::Input::KI_F13; case XK_F14 & 0xFF: return Rml::Input::KI_F14; case XK_F15 & 0xFF: return Rml::Input::KI_F15; case XK_F16 & 0xFF: return Rml::Input::KI_F16; case XK_F17 & 0xFF: return Rml::Input::KI_F17; case XK_F18 & 0xFF: return Rml::Input::KI_F18; case XK_F19 & 0xFF: return Rml::Input::KI_F19; case XK_F20 & 0xFF: return Rml::Input::KI_F20; case XK_F21 & 0xFF: return Rml::Input::KI_F21; case XK_F22 & 0xFF: return Rml::Input::KI_F22; case XK_F23 & 0xFF: return Rml::Input::KI_F23; case XK_F24 & 0xFF: return Rml::Input::KI_F24; case XK_Shift_L & 0xFF: return Rml::Input::KI_LSHIFT; case XK_Shift_R & 0xFF: return Rml::Input::KI_RSHIFT; case XK_Control_L & 0xFF: return Rml::Input::KI_LCONTROL; case XK_Control_R & 0xFF: return Rml::Input::KI_RCONTROL; case XK_Caps_Lock & 0xFF: return Rml::Input::KI_CAPITAL; case XK_Alt_L & 0xFF: return Rml::Input::KI_LMENU; case XK_Alt_R & 0xFF: return Rml::Input::KI_RMENU; case XK_space & 0xFF: return Rml::Input::KI_SPACE; case XK_apostrophe & 0xFF: return Rml::Input::KI_OEM_7; case XK_comma & 0xFF: return Rml::Input::KI_OEM_COMMA; case XK_minus & 0xFF: return Rml::Input::KI_OEM_MINUS; case XK_period & 0xFF: return Rml::Input::KI_OEM_PERIOD; case XK_slash & 0xFF: return Rml::Input::KI_OEM_2; case XK_0 & 0xFF: return Rml::Input::KI_0; case XK_1 & 0xFF: return Rml::Input::KI_1; case XK_2 & 0xFF: return Rml::Input::KI_2; case XK_3 & 0xFF: return Rml::Input::KI_3; case XK_4 & 0xFF: return Rml::Input::KI_4; case XK_5 & 0xFF: return Rml::Input::KI_5; case XK_6 & 0xFF: return Rml::Input::KI_6; case XK_7 & 0xFF: return Rml::Input::KI_7; case XK_8 & 0xFF: return Rml::Input::KI_8; case XK_9 & 0xFF: return Rml::Input::KI_9; case XK_semicolon & 0xFF: return Rml::Input::KI_OEM_1; case XK_equal & 0xFF: return Rml::Input::KI_OEM_PLUS; case XK_bracketleft & 0xFF: return Rml::Input::KI_OEM_4; case XK_backslash & 0xFF: return Rml::Input::KI_OEM_5; case XK_bracketright & 0xFF: return Rml::Input::KI_OEM_6; case XK_grave & 0xFF: return Rml::Input::KI_OEM_3; case XK_a & 0xFF: return Rml::Input::KI_A; case XK_b & 0xFF: return Rml::Input::KI_B; case XK_c & 0xFF: return Rml::Input::KI_C; case XK_d & 0xFF: return Rml::Input::KI_D; case XK_e & 0xFF: return Rml::Input::KI_E; case XK_f & 0xFF: return Rml::Input::KI_F; case XK_g & 0xFF: return Rml::Input::KI_G; case XK_h & 0xFF: return Rml::Input::KI_H; case XK_i & 0xFF: return Rml::Input::KI_I; case XK_j & 0xFF: return Rml::Input::KI_J; case XK_k & 0xFF: return Rml::Input::KI_K; case XK_l & 0xFF: return Rml::Input::KI_L; case XK_m & 0xFF: return Rml::Input::KI_M; case XK_n & 0xFF: return Rml::Input::KI_N; case XK_o & 0xFF: return Rml::Input::KI_O; case XK_p & 0xFF: return Rml::Input::KI_P; case XK_q & 0xFF: return Rml::Input::KI_Q; case XK_r & 0xFF: return Rml::Input::KI_R; case XK_s & 0xFF: return Rml::Input::KI_S; case XK_t & 0xFF: return Rml::Input::KI_T; case XK_u & 0xFF: return Rml::Input::KI_U; case XK_v & 0xFF: return Rml::Input::KI_V; case XK_w & 0xFF: return Rml::Input::KI_W; case XK_x & 0xFF: return Rml::Input::KI_X; case XK_y & 0xFF: return Rml::Input::KI_Y; case XK_z & 0xFF: return Rml::Input::KI_Z; default: break; } // clang-format on return Rml::Input::KI_UNKNOWN; } int RmlX11::ConvertMouseButton(unsigned int x11_mouse_button) { switch (x11_mouse_button) { case Button1: return 0; case Button2: return 2; case Button3: return 1; default: break; } return 0; } /** This map contains 4 different mappings from key identifiers to character codes. Each entry represents a different combination of shift and capslock state. */ static char ascii_map[4][51] = { // shift off and capslock off {0, ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ';', '=', ',', '-', '.', '/', '`', '[', '\\', ']', '\'', 0, 0}, // shift on and capslock off {0, ' ', ')', '!', '@', '#', '$', '%', '^', '&', '*', '(', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ':', '+', '<', '_', '>', '?', '~', '{', '|', '}', '"', 0, 0}, // shift on and capslock on {0, ' ', ')', '!', '@', '#', '$', '%', '^', '&', '*', '(', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ':', '+', '<', '_', '>', '?', '~', '{', '|', '}', '"', 0, 0}, // shift off and capslock on {0, ' ', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ';', '=', ',', '-', '.', '/', '`', '[', '\\', ']', '\'', 0, 0}}; static char keypad_map[2][18] = {{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '\n', '*', '+', 0, '-', '.', '/', '='}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, '\n', '*', '+', 0, '-', 0, '/', '='}}; // Returns the character code for a key identifer / key modifier combination. static Rml::Character GetCharacterCode(Rml::Input::KeyIdentifier key_identifier, int key_modifier_state) { using Rml::Character; // Check if we have a keycode capable of generating characters on the main keyboard (ie, not on the numeric // keypad; that is dealt with below). if (key_identifier <= Rml::Input::KI_OEM_102) { // Get modifier states bool shift = (key_modifier_state & Rml::Input::KM_SHIFT) > 0; bool capslock = (key_modifier_state & Rml::Input::KM_CAPSLOCK) > 0; // Return character code based on identifier and modifiers if (shift && !capslock) return (Character)ascii_map[1][key_identifier]; if (shift && capslock) return (Character)ascii_map[2][key_identifier]; if (!shift && capslock) return (Character)ascii_map[3][key_identifier]; return (Character)ascii_map[0][key_identifier]; } // Check if we have a keycode from the numeric keypad. else if (key_identifier <= Rml::Input::KI_OEM_NEC_EQUAL) { if (key_modifier_state & Rml::Input::KM_NUMLOCK) return (Character)keypad_map[0][key_identifier - Rml::Input::KI_NUMPAD0]; else return (Character)keypad_map[1][key_identifier - Rml::Input::KI_NUMPAD0]; } else if (key_identifier == Rml::Input::KI_RETURN) return (Character)'\n'; return Character::Null; }