summaryrefslogtreecommitdiffstats
path: root/webclients/novnc/core/input
diff options
context:
space:
mode:
authorChristian Beier <dontmind@freeshell.org>2018-10-01 20:50:35 +0200
committerChristian Beier <dontmind@freeshell.org>2018-10-01 20:50:35 +0200
commitffe33574918cf31926ed37caef12f24e73b2d478 (patch)
treea5402503529c20741556306aff0275ddaa44b159 /webclients/novnc/core/input
parentde3a2f46b5c4913ba55dfb8c6f7c8b52136bf27a (diff)
downloadlibtdevnc-ffe33574918cf31926ed37caef12f24e73b2d478.tar.gz
libtdevnc-ffe33574918cf31926ed37caef12f24e73b2d478.zip
Update bundled noVNC to latest release 1.0.0
Closes #148
Diffstat (limited to 'webclients/novnc/core/input')
-rw-r--r--webclients/novnc/core/input/domkeytable.js310
-rw-r--r--webclients/novnc/core/input/fixedkeys.js127
-rw-r--r--webclients/novnc/core/input/keyboard.js314
-rw-r--r--webclients/novnc/core/input/keysym.js614
-rw-r--r--webclients/novnc/core/input/keysymdef.js688
-rw-r--r--webclients/novnc/core/input/mouse.js280
-rw-r--r--webclients/novnc/core/input/util.js167
-rw-r--r--webclients/novnc/core/input/vkeys.js116
-rw-r--r--webclients/novnc/core/input/xtscancodes.js171
9 files changed, 2787 insertions, 0 deletions
diff --git a/webclients/novnc/core/input/domkeytable.js b/webclients/novnc/core/input/domkeytable.js
new file mode 100644
index 0000000..7103bba
--- /dev/null
+++ b/webclients/novnc/core/input/domkeytable.js
@@ -0,0 +1,310 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2017 Pierre Ossman for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+import KeyTable from "./keysym.js";
+
+/*
+ * Mapping between HTML key values and VNC/X11 keysyms for "special"
+ * keys that cannot be handled via their Unicode codepoint.
+ *
+ * See https://www.w3.org/TR/uievents-key/ for possible values.
+ */
+
+var DOMKeyTable = {};
+
+function addStandard(key, standard)
+{
+ if (standard === undefined) throw "Undefined keysym for key \"" + key + "\"";
+ if (key in DOMKeyTable) throw "Duplicate entry for key \"" + key + "\"";
+ DOMKeyTable[key] = [standard, standard, standard, standard];
+}
+
+function addLeftRight(key, left, right)
+{
+ if (left === undefined) throw "Undefined keysym for key \"" + key + "\"";
+ if (right === undefined) throw "Undefined keysym for key \"" + key + "\"";
+ if (key in DOMKeyTable) throw "Duplicate entry for key \"" + key + "\"";
+ DOMKeyTable[key] = [left, left, right, left];
+}
+
+function addNumpad(key, standard, numpad)
+{
+ if (standard === undefined) throw "Undefined keysym for key \"" + key + "\"";
+ if (numpad === undefined) throw "Undefined keysym for key \"" + key + "\"";
+ if (key in DOMKeyTable) throw "Duplicate entry for key \"" + key + "\"";
+ DOMKeyTable[key] = [standard, standard, standard, numpad];
+}
+
+// 2.2. Modifier Keys
+
+addLeftRight("Alt", KeyTable.XK_Alt_L, KeyTable.XK_Alt_R);
+addStandard("AltGraph", KeyTable.XK_ISO_Level3_Shift);
+addStandard("CapsLock", KeyTable.XK_Caps_Lock);
+addLeftRight("Control", KeyTable.XK_Control_L, KeyTable.XK_Control_R);
+// - Fn
+// - FnLock
+addLeftRight("Hyper", KeyTable.XK_Super_L, KeyTable.XK_Super_R);
+addLeftRight("Meta", KeyTable.XK_Super_L, KeyTable.XK_Super_R);
+addStandard("NumLock", KeyTable.XK_Num_Lock);
+addStandard("ScrollLock", KeyTable.XK_Scroll_Lock);
+addLeftRight("Shift", KeyTable.XK_Shift_L, KeyTable.XK_Shift_R);
+addLeftRight("Super", KeyTable.XK_Super_L, KeyTable.XK_Super_R);
+// - Symbol
+// - SymbolLock
+
+// 2.3. Whitespace Keys
+
+addNumpad("Enter", KeyTable.XK_Return, KeyTable.XK_KP_Enter);
+addStandard("Tab", KeyTable.XK_Tab);
+addNumpad(" ", KeyTable.XK_space, KeyTable.XK_KP_Space);
+
+// 2.4. Navigation Keys
+
+addNumpad("ArrowDown", KeyTable.XK_Down, KeyTable.XK_KP_Down);
+addNumpad("ArrowUp", KeyTable.XK_Up, KeyTable.XK_KP_Up);
+addNumpad("ArrowLeft", KeyTable.XK_Left, KeyTable.XK_KP_Left);
+addNumpad("ArrowRight", KeyTable.XK_Right, KeyTable.XK_KP_Right);
+addNumpad("End", KeyTable.XK_End, KeyTable.XK_KP_End);
+addNumpad("Home", KeyTable.XK_Home, KeyTable.XK_KP_Home);
+addNumpad("PageDown", KeyTable.XK_Next, KeyTable.XK_KP_Next);
+addNumpad("PageUp", KeyTable.XK_Prior, KeyTable.XK_KP_Prior);
+
+// 2.5. Editing Keys
+
+addStandard("Backspace", KeyTable.XK_BackSpace);
+addStandard("Clear", KeyTable.XK_Clear);
+addStandard("Copy", KeyTable.XF86XK_Copy);
+// - CrSel
+addStandard("Cut", KeyTable.XF86XK_Cut);
+addNumpad("Delete", KeyTable.XK_Delete, KeyTable.XK_KP_Delete);
+// - EraseEof
+// - ExSel
+addNumpad("Insert", KeyTable.XK_Insert, KeyTable.XK_KP_Insert);
+addStandard("Paste", KeyTable.XF86XK_Paste);
+addStandard("Redo", KeyTable.XK_Redo);
+addStandard("Undo", KeyTable.XK_Undo);
+
+// 2.6. UI Keys
+
+// - Accept
+// - Again (could just be XK_Redo)
+// - Attn
+addStandard("Cancel", KeyTable.XK_Cancel);
+addStandard("ContextMenu", KeyTable.XK_Menu);
+addStandard("Escape", KeyTable.XK_Escape);
+addStandard("Execute", KeyTable.XK_Execute);
+addStandard("Find", KeyTable.XK_Find);
+addStandard("Help", KeyTable.XK_Help);
+addStandard("Pause", KeyTable.XK_Pause);
+// - Play
+// - Props
+addStandard("Select", KeyTable.XK_Select);
+addStandard("ZoomIn", KeyTable.XF86XK_ZoomIn);
+addStandard("ZoomOut", KeyTable.XF86XK_ZoomOut);
+
+// 2.7. Device Keys
+
+addStandard("BrightnessDown", KeyTable.XF86XK_MonBrightnessDown);
+addStandard("BrightnessUp", KeyTable.XF86XK_MonBrightnessUp);
+addStandard("Eject", KeyTable.XF86XK_Eject);
+addStandard("LogOff", KeyTable.XF86XK_LogOff);
+addStandard("Power", KeyTable.XF86XK_PowerOff);
+addStandard("PowerOff", KeyTable.XF86XK_PowerDown);
+addStandard("PrintScreen", KeyTable.XK_Print);
+addStandard("Hibernate", KeyTable.XF86XK_Hibernate);
+addStandard("Standby", KeyTable.XF86XK_Standby);
+addStandard("WakeUp", KeyTable.XF86XK_WakeUp);
+
+// 2.8. IME and Composition Keys
+
+addStandard("AllCandidates", KeyTable.XK_MultipleCandidate);
+addStandard("Alphanumeric", KeyTable.XK_Eisu_Shift); // could also be _Eisu_Toggle
+addStandard("CodeInput", KeyTable.XK_Codeinput);
+addStandard("Compose", KeyTable.XK_Multi_key);
+addStandard("Convert", KeyTable.XK_Henkan);
+// - Dead
+// - FinalMode
+addStandard("GroupFirst", KeyTable.XK_ISO_First_Group);
+addStandard("GroupLast", KeyTable.XK_ISO_Last_Group);
+addStandard("GroupNext", KeyTable.XK_ISO_Next_Group);
+addStandard("GroupPrevious", KeyTable.XK_ISO_Prev_Group);
+// - ModeChange (XK_Mode_switch is often used for AltGr)
+// - NextCandidate
+addStandard("NonConvert", KeyTable.XK_Muhenkan);
+addStandard("PreviousCandidate", KeyTable.XK_PreviousCandidate);
+// - Process
+addStandard("SingleCandidate", KeyTable.XK_SingleCandidate);
+addStandard("HangulMode", KeyTable.XK_Hangul);
+addStandard("HanjaMode", KeyTable.XK_Hangul_Hanja);
+addStandard("JunjuaMode", KeyTable.XK_Hangul_Jeonja);
+addStandard("Eisu", KeyTable.XK_Eisu_toggle);
+addStandard("Hankaku", KeyTable.XK_Hankaku);
+addStandard("Hiragana", KeyTable.XK_Hiragana);
+addStandard("HiraganaKatakana", KeyTable.XK_Hiragana_Katakana);
+addStandard("KanaMode", KeyTable.XK_Kana_Shift); // could also be _Kana_Lock
+addStandard("KanjiMode", KeyTable.XK_Kanji);
+addStandard("Katakana", KeyTable.XK_Katakana);
+addStandard("Romaji", KeyTable.XK_Romaji);
+addStandard("Zenkaku", KeyTable.XK_Zenkaku);
+addStandard("ZenkakuHanaku", KeyTable.XK_Zenkaku_Hankaku);
+
+// 2.9. General-Purpose Function Keys
+
+addStandard("F1", KeyTable.XK_F1);
+addStandard("F2", KeyTable.XK_F2);
+addStandard("F3", KeyTable.XK_F3);
+addStandard("F4", KeyTable.XK_F4);
+addStandard("F5", KeyTable.XK_F5);
+addStandard("F6", KeyTable.XK_F6);
+addStandard("F7", KeyTable.XK_F7);
+addStandard("F8", KeyTable.XK_F8);
+addStandard("F9", KeyTable.XK_F9);
+addStandard("F10", KeyTable.XK_F10);
+addStandard("F11", KeyTable.XK_F11);
+addStandard("F12", KeyTable.XK_F12);
+addStandard("F13", KeyTable.XK_F13);
+addStandard("F14", KeyTable.XK_F14);
+addStandard("F15", KeyTable.XK_F15);
+addStandard("F16", KeyTable.XK_F16);
+addStandard("F17", KeyTable.XK_F17);
+addStandard("F18", KeyTable.XK_F18);
+addStandard("F19", KeyTable.XK_F19);
+addStandard("F20", KeyTable.XK_F20);
+addStandard("F21", KeyTable.XK_F21);
+addStandard("F22", KeyTable.XK_F22);
+addStandard("F23", KeyTable.XK_F23);
+addStandard("F24", KeyTable.XK_F24);
+addStandard("F25", KeyTable.XK_F25);
+addStandard("F26", KeyTable.XK_F26);
+addStandard("F27", KeyTable.XK_F27);
+addStandard("F28", KeyTable.XK_F28);
+addStandard("F29", KeyTable.XK_F29);
+addStandard("F30", KeyTable.XK_F30);
+addStandard("F31", KeyTable.XK_F31);
+addStandard("F32", KeyTable.XK_F32);
+addStandard("F33", KeyTable.XK_F33);
+addStandard("F34", KeyTable.XK_F34);
+addStandard("F35", KeyTable.XK_F35);
+// - Soft1...
+
+// 2.10. Multimedia Keys
+
+// - ChannelDown
+// - ChannelUp
+addStandard("Close", KeyTable.XF86XK_Close);
+addStandard("MailForward", KeyTable.XF86XK_MailForward);
+addStandard("MailReply", KeyTable.XF86XK_Reply);
+addStandard("MainSend", KeyTable.XF86XK_Send);
+addStandard("MediaFastForward", KeyTable.XF86XK_AudioForward);
+addStandard("MediaPause", KeyTable.XF86XK_AudioPause);
+addStandard("MediaPlay", KeyTable.XF86XK_AudioPlay);
+addStandard("MediaRecord", KeyTable.XF86XK_AudioRecord);
+addStandard("MediaRewind", KeyTable.XF86XK_AudioRewind);
+addStandard("MediaStop", KeyTable.XF86XK_AudioStop);
+addStandard("MediaTrackNext", KeyTable.XF86XK_AudioNext);
+addStandard("MediaTrackPrevious", KeyTable.XF86XK_AudioPrev);
+addStandard("New", KeyTable.XF86XK_New);
+addStandard("Open", KeyTable.XF86XK_Open);
+addStandard("Print", KeyTable.XK_Print);
+addStandard("Save", KeyTable.XF86XK_Save);
+addStandard("SpellCheck", KeyTable.XF86XK_Spell);
+
+// 2.11. Multimedia Numpad Keys
+
+// - Key11
+// - Key12
+
+// 2.12. Audio Keys
+
+// - AudioBalanceLeft
+// - AudioBalanceRight
+// - AudioBassDown
+// - AudioBassBoostDown
+// - AudioBassBoostToggle
+// - AudioBassBoostUp
+// - AudioBassUp
+// - AudioFaderFront
+// - AudioFaderRear
+// - AudioSurroundModeNext
+// - AudioTrebleDown
+// - AudioTrebleUp
+addStandard("AudioVolumeDown", KeyTable.XF86XK_AudioLowerVolume);
+addStandard("AudioVolumeUp", KeyTable.XF86XK_AudioRaiseVolume);
+addStandard("AudioVolumeMute", KeyTable.XF86XK_AudioMute);
+// - MicrophoneToggle
+// - MicrophoneVolumeDown
+// - MicrophoneVolumeUp
+addStandard("MicrophoneVolumeMute", KeyTable.XF86XK_AudioMicMute);
+
+// 2.13. Speech Keys
+
+// - SpeechCorrectionList
+// - SpeechInputToggle
+
+// 2.14. Application Keys
+
+addStandard("LaunchCalculator", KeyTable.XF86XK_Calculator);
+addStandard("LaunchCalendar", KeyTable.XF86XK_Calendar);
+addStandard("LaunchMail", KeyTable.XF86XK_Mail);
+addStandard("LaunchMediaPlayer", KeyTable.XF86XK_AudioMedia);
+addStandard("LaunchMusicPlayer", KeyTable.XF86XK_Music);
+addStandard("LaunchMyComputer", KeyTable.XF86XK_MyComputer);
+addStandard("LaunchPhone", KeyTable.XF86XK_Phone);
+addStandard("LaunchScreenSaver", KeyTable.XF86XK_ScreenSaver);
+addStandard("LaunchSpreadsheet", KeyTable.XF86XK_Excel);
+addStandard("LaunchWebBrowser", KeyTable.XF86XK_WWW);
+addStandard("LaunchWebCam", KeyTable.XF86XK_WebCam);
+addStandard("LaunchWordProcessor", KeyTable.XF86XK_Word);
+
+// 2.15. Browser Keys
+
+addStandard("BrowserBack", KeyTable.XF86XK_Back);
+addStandard("BrowserFavorites", KeyTable.XF86XK_Favorites);
+addStandard("BrowserForward", KeyTable.XF86XK_Forward);
+addStandard("BrowserHome", KeyTable.XF86XK_HomePage);
+addStandard("BrowserRefresh", KeyTable.XF86XK_Refresh);
+addStandard("BrowserSearch", KeyTable.XF86XK_Search);
+addStandard("BrowserStop", KeyTable.XF86XK_Stop);
+
+// 2.16. Mobile Phone Keys
+
+// - A whole bunch...
+
+// 2.17. TV Keys
+
+// - A whole bunch...
+
+// 2.18. Media Controller Keys
+
+// - A whole bunch...
+addStandard("Dimmer", KeyTable.XF86XK_BrightnessAdjust);
+addStandard("MediaAudioTrack", KeyTable.XF86XK_AudioCycleTrack);
+addStandard("RandomToggle", KeyTable.XF86XK_AudioRandomPlay);
+addStandard("SplitScreenToggle", KeyTable.XF86XK_SplitScreen);
+addStandard("Subtitle", KeyTable.XF86XK_Subtitle);
+addStandard("VideoModeNext", KeyTable.XF86XK_Next_VMode);
+
+// Extra: Numpad
+
+addNumpad("=", KeyTable.XK_equal, KeyTable.XK_KP_Equal);
+addNumpad("+", KeyTable.XK_plus, KeyTable.XK_KP_Add);
+addNumpad("-", KeyTable.XK_minus, KeyTable.XK_KP_Subtract);
+addNumpad("*", KeyTable.XK_asterisk, KeyTable.XK_KP_Multiply);
+addNumpad("/", KeyTable.XK_slash, KeyTable.XK_KP_Divide);
+addNumpad(".", KeyTable.XK_period, KeyTable.XK_KP_Decimal);
+addNumpad(",", KeyTable.XK_comma, KeyTable.XK_KP_Separator);
+addNumpad("0", KeyTable.XK_0, KeyTable.XK_KP_0);
+addNumpad("1", KeyTable.XK_1, KeyTable.XK_KP_1);
+addNumpad("2", KeyTable.XK_2, KeyTable.XK_KP_2);
+addNumpad("3", KeyTable.XK_3, KeyTable.XK_KP_3);
+addNumpad("4", KeyTable.XK_4, KeyTable.XK_KP_4);
+addNumpad("5", KeyTable.XK_5, KeyTable.XK_KP_5);
+addNumpad("6", KeyTable.XK_6, KeyTable.XK_KP_6);
+addNumpad("7", KeyTable.XK_7, KeyTable.XK_KP_7);
+addNumpad("8", KeyTable.XK_8, KeyTable.XK_KP_8);
+addNumpad("9", KeyTable.XK_9, KeyTable.XK_KP_9);
+
+export default DOMKeyTable;
diff --git a/webclients/novnc/core/input/fixedkeys.js b/webclients/novnc/core/input/fixedkeys.js
new file mode 100644
index 0000000..6dd4222
--- /dev/null
+++ b/webclients/novnc/core/input/fixedkeys.js
@@ -0,0 +1,127 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2017 Pierre Ossman for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*
+ * Fallback mapping between HTML key codes (physical keys) and
+ * HTML key values. This only works for keys that don't vary
+ * between layouts. We also omit those who manage fine by mapping the
+ * Unicode representation.
+ *
+ * See https://www.w3.org/TR/uievents-code/ for possible codes.
+ * See https://www.w3.org/TR/uievents-key/ for possible values.
+ */
+
+export default {
+
+// 3.1.1.1. Writing System Keys
+
+ 'Backspace': 'Backspace',
+
+// 3.1.1.2. Functional Keys
+
+ 'AltLeft': 'Alt',
+ 'AltRight': 'Alt', // This could also be 'AltGraph'
+ 'CapsLock': 'CapsLock',
+ 'ContextMenu': 'ContextMenu',
+ 'ControlLeft': 'Control',
+ 'ControlRight': 'Control',
+ 'Enter': 'Enter',
+ 'MetaLeft': 'Meta',
+ 'MetaRight': 'Meta',
+ 'ShiftLeft': 'Shift',
+ 'ShiftRight': 'Shift',
+ 'Tab': 'Tab',
+ // FIXME: Japanese/Korean keys
+
+// 3.1.2. Control Pad Section
+
+ 'Delete': 'Delete',
+ 'End': 'End',
+ 'Help': 'Help',
+ 'Home': 'Home',
+ 'Insert': 'Insert',
+ 'PageDown': 'PageDown',
+ 'PageUp': 'PageUp',
+
+// 3.1.3. Arrow Pad Section
+
+ 'ArrowDown': 'ArrowDown',
+ 'ArrowLeft': 'ArrowLeft',
+ 'ArrowRight': 'ArrowRight',
+ 'ArrowUp': 'ArrowUp',
+
+// 3.1.4. Numpad Section
+
+ 'NumLock': 'NumLock',
+ 'NumpadBackspace': 'Backspace',
+ 'NumpadClear': 'Clear',
+
+// 3.1.5. Function Section
+
+ 'Escape': 'Escape',
+ 'F1': 'F1',
+ 'F2': 'F2',
+ 'F3': 'F3',
+ 'F4': 'F4',
+ 'F5': 'F5',
+ 'F6': 'F6',
+ 'F7': 'F7',
+ 'F8': 'F8',
+ 'F9': 'F9',
+ 'F10': 'F10',
+ 'F11': 'F11',
+ 'F12': 'F12',
+ 'F13': 'F13',
+ 'F14': 'F14',
+ 'F15': 'F15',
+ 'F16': 'F16',
+ 'F17': 'F17',
+ 'F18': 'F18',
+ 'F19': 'F19',
+ 'F20': 'F20',
+ 'F21': 'F21',
+ 'F22': 'F22',
+ 'F23': 'F23',
+ 'F24': 'F24',
+ 'F25': 'F25',
+ 'F26': 'F26',
+ 'F27': 'F27',
+ 'F28': 'F28',
+ 'F29': 'F29',
+ 'F30': 'F30',
+ 'F31': 'F31',
+ 'F32': 'F32',
+ 'F33': 'F33',
+ 'F34': 'F34',
+ 'F35': 'F35',
+ 'PrintScreen': 'PrintScreen',
+ 'ScrollLock': 'ScrollLock',
+ 'Pause': 'Pause',
+
+// 3.1.6. Media Keys
+
+ 'BrowserBack': 'BrowserBack',
+ 'BrowserFavorites': 'BrowserFavorites',
+ 'BrowserForward': 'BrowserForward',
+ 'BrowserHome': 'BrowserHome',
+ 'BrowserRefresh': 'BrowserRefresh',
+ 'BrowserSearch': 'BrowserSearch',
+ 'BrowserStop': 'BrowserStop',
+ 'Eject': 'Eject',
+ 'LaunchApp1': 'LaunchMyComputer',
+ 'LaunchApp2': 'LaunchCalendar',
+ 'LaunchMail': 'LaunchMail',
+ 'MediaPlayPause': 'MediaPlay',
+ 'MediaStop': 'MediaStop',
+ 'MediaTrackNext': 'MediaTrackNext',
+ 'MediaTrackPrevious': 'MediaTrackPrevious',
+ 'Power': 'Power',
+ 'Sleep': 'Sleep',
+ 'AudioVolumeDown': 'AudioVolumeDown',
+ 'AudioVolumeMute': 'AudioVolumeMute',
+ 'AudioVolumeUp': 'AudioVolumeUp',
+ 'WakeUp': 'WakeUp',
+};
diff --git a/webclients/novnc/core/input/keyboard.js b/webclients/novnc/core/input/keyboard.js
new file mode 100644
index 0000000..4e8dc0d
--- /dev/null
+++ b/webclients/novnc/core/input/keyboard.js
@@ -0,0 +1,314 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+import * as Log from '../util/logging.js';
+import { stopEvent } from '../util/events.js';
+import * as KeyboardUtil from "./util.js";
+import KeyTable from "./keysym.js";
+import * as browser from "../util/browser.js";
+
+//
+// Keyboard event handler
+//
+
+export default function Keyboard(target) {
+ this._target = target || null;
+
+ this._keyDownList = {}; // List of depressed keys
+ // (even if they are happy)
+ this._pendingKey = null; // Key waiting for keypress
+
+ // keep these here so we can refer to them later
+ this._eventHandlers = {
+ 'keyup': this._handleKeyUp.bind(this),
+ 'keydown': this._handleKeyDown.bind(this),
+ 'keypress': this._handleKeyPress.bind(this),
+ 'blur': this._allKeysUp.bind(this)
+ };
+};
+
+Keyboard.prototype = {
+ // ===== EVENT HANDLERS =====
+
+ onkeyevent: function () {}, // Handler for key press/release
+
+ // ===== PRIVATE METHODS =====
+
+ _sendKeyEvent: function (keysym, code, down) {
+ Log.Debug("onkeyevent " + (down ? "down" : "up") +
+ ", keysym: " + keysym, ", code: " + code);
+
+ // Windows sends CtrlLeft+AltRight when you press
+ // AltGraph, which tends to confuse the hell out of
+ // remote systems. Fake a release of these keys until
+ // there is a way to detect AltGraph properly.
+ var fakeAltGraph = false;
+ if (down && browser.isWindows()) {
+ if ((code !== 'ControlLeft') &&
+ (code !== 'AltRight') &&
+ ('ControlLeft' in this._keyDownList) &&
+ ('AltRight' in this._keyDownList)) {
+ fakeAltGraph = true;
+ this.onkeyevent(this._keyDownList['AltRight'],
+ 'AltRight', false);
+ this.onkeyevent(this._keyDownList['ControlLeft'],
+ 'ControlLeft', false);
+ }
+ }
+
+ this.onkeyevent(keysym, code, down);
+
+ if (fakeAltGraph) {
+ this.onkeyevent(this._keyDownList['ControlLeft'],
+ 'ControlLeft', true);
+ this.onkeyevent(this._keyDownList['AltRight'],
+ 'AltRight', true);
+ }
+ },
+
+ _getKeyCode: function (e) {
+ var code = KeyboardUtil.getKeycode(e);
+ if (code !== 'Unidentified') {
+ return code;
+ }
+
+ // Unstable, but we don't have anything else to go on
+ // (don't use it for 'keypress' events thought since
+ // WebKit sets it to the same as charCode)
+ if (e.keyCode && (e.type !== 'keypress')) {
+ // 229 is used for composition events
+ if (e.keyCode !== 229) {
+ return 'Platform' + e.keyCode;
+ }
+ }
+
+ // A precursor to the final DOM3 standard. Unfortunately it
+ // is not layout independent, so it is as bad as using keyCode
+ if (e.keyIdentifier) {
+ // Non-character key?
+ if (e.keyIdentifier.substr(0, 2) !== 'U+') {
+ return e.keyIdentifier;
+ }
+
+ var codepoint = parseInt(e.keyIdentifier.substr(2), 16);
+ var char = String.fromCharCode(codepoint);
+ // Some implementations fail to uppercase the symbols
+ char = char.toUpperCase();
+
+ return 'Platform' + char.charCodeAt();
+ }
+
+ return 'Unidentified';
+ },
+
+ _handleKeyDown: function (e) {
+ var code = this._getKeyCode(e);
+ var keysym = KeyboardUtil.getKeysym(e);
+
+ // We cannot handle keys we cannot track, but we also need
+ // to deal with virtual keyboards which omit key info
+ // (iOS omits tracking info on keyup events, which forces us to
+ // special treat that platform here)
+ if ((code === 'Unidentified') || browser.isIOS()) {
+ if (keysym) {
+ // If it's a virtual keyboard then it should be
+ // sufficient to just send press and release right
+ // after each other
+ this._sendKeyEvent(keysym, code, true);
+ this._sendKeyEvent(keysym, code, false);
+ }
+
+ stopEvent(e);
+ return;
+ }
+
+ // Alt behaves more like AltGraph on macOS, so shuffle the
+ // keys around a bit to make things more sane for the remote
+ // server. This method is used by RealVNC and TigerVNC (and
+ // possibly others).
+ if (browser.isMac()) {
+ switch (keysym) {
+ case KeyTable.XK_Super_L:
+ keysym = KeyTable.XK_Alt_L;
+ break;
+ case KeyTable.XK_Super_R:
+ keysym = KeyTable.XK_Super_L;
+ break;
+ case KeyTable.XK_Alt_L:
+ keysym = KeyTable.XK_Mode_switch;
+ break;
+ case KeyTable.XK_Alt_R:
+ keysym = KeyTable.XK_ISO_Level3_Shift;
+ break;
+ }
+ }
+
+ // Is this key already pressed? If so, then we must use the
+ // same keysym or we'll confuse the server
+ if (code in this._keyDownList) {
+ keysym = this._keyDownList[code];
+ }
+
+ // macOS doesn't send proper key events for modifiers, only
+ // state change events. That gets extra confusing for CapsLock
+ // which toggles on each press, but not on release. So pretend
+ // it was a quick press and release of the button.
+ if (browser.isMac() && (code === 'CapsLock')) {
+ this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', true);
+ this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', false);
+ stopEvent(e);
+ return;
+ }
+
+ // If this is a legacy browser then we'll need to wait for
+ // a keypress event as well
+ // (IE and Edge has a broken KeyboardEvent.key, so we can't
+ // just check for the presence of that field)
+ if (!keysym && (!e.key || browser.isIE() || browser.isEdge())) {
+ this._pendingKey = code;
+ // However we might not get a keypress event if the key
+ // is non-printable, which needs some special fallback
+ // handling
+ setTimeout(this._handleKeyPressTimeout.bind(this), 10, e);
+ return;
+ }
+
+ this._pendingKey = null;
+ stopEvent(e);
+
+ this._keyDownList[code] = keysym;
+
+ this._sendKeyEvent(keysym, code, true);
+ },
+
+ // Legacy event for browsers without code/key
+ _handleKeyPress: function (e) {
+ stopEvent(e);
+
+ // Are we expecting a keypress?
+ if (this._pendingKey === null) {
+ return;
+ }
+
+ var code = this._getKeyCode(e);
+ var keysym = KeyboardUtil.getKeysym(e);
+
+ // The key we were waiting for?
+ if ((code !== 'Unidentified') && (code != this._pendingKey)) {
+ return;
+ }
+
+ code = this._pendingKey;
+ this._pendingKey = null;
+
+ if (!keysym) {
+ Log.Info('keypress with no keysym:', e);
+ return;
+ }
+
+ this._keyDownList[code] = keysym;
+
+ this._sendKeyEvent(keysym, code, true);
+ },
+ _handleKeyPressTimeout: function (e) {
+ // Did someone manage to sort out the key already?
+ if (this._pendingKey === null) {
+ return;
+ }
+
+ var code, keysym;
+
+ code = this._pendingKey;
+ this._pendingKey = null;
+
+ // We have no way of knowing the proper keysym with the
+ // information given, but the following are true for most
+ // layouts
+ if ((e.keyCode >= 0x30) && (e.keyCode <= 0x39)) {
+ // Digit
+ keysym = e.keyCode;
+ } else if ((e.keyCode >= 0x41) && (e.keyCode <= 0x5a)) {
+ // Character (A-Z)
+ var char = String.fromCharCode(e.keyCode);
+ // A feeble attempt at the correct case
+ if (e.shiftKey)
+ char = char.toUpperCase();
+ else
+ char = char.toLowerCase();
+ keysym = char.charCodeAt();
+ } else {
+ // Unknown, give up
+ keysym = 0;
+ }
+
+ this._keyDownList[code] = keysym;
+
+ this._sendKeyEvent(keysym, code, true);
+ },
+
+ _handleKeyUp: function (e) {
+ stopEvent(e);
+
+ var code = this._getKeyCode(e);
+
+ // See comment in _handleKeyDown()
+ if (browser.isMac() && (code === 'CapsLock')) {
+ this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', true);
+ this._sendKeyEvent(KeyTable.XK_Caps_Lock, 'CapsLock', false);
+ return;
+ }
+
+ // Do we really think this key is down?
+ if (!(code in this._keyDownList)) {
+ return;
+ }
+
+ this._sendKeyEvent(this._keyDownList[code], code, false);
+
+ delete this._keyDownList[code];
+ },
+
+ _allKeysUp: function () {
+ Log.Debug(">> Keyboard.allKeysUp");
+ for (var code in this._keyDownList) {
+ this._sendKeyEvent(this._keyDownList[code], code, false);
+ };
+ this._keyDownList = {};
+ Log.Debug("<< Keyboard.allKeysUp");
+ },
+
+ // ===== PUBLIC METHODS =====
+
+ grab: function () {
+ //Log.Debug(">> Keyboard.grab");
+ var c = this._target;
+
+ c.addEventListener('keydown', this._eventHandlers.keydown);
+ c.addEventListener('keyup', this._eventHandlers.keyup);
+ c.addEventListener('keypress', this._eventHandlers.keypress);
+
+ // Release (key up) if window loses focus
+ window.addEventListener('blur', this._eventHandlers.blur);
+
+ //Log.Debug("<< Keyboard.grab");
+ },
+
+ ungrab: function () {
+ //Log.Debug(">> Keyboard.ungrab");
+ var c = this._target;
+
+ c.removeEventListener('keydown', this._eventHandlers.keydown);
+ c.removeEventListener('keyup', this._eventHandlers.keyup);
+ c.removeEventListener('keypress', this._eventHandlers.keypress);
+ window.removeEventListener('blur', this._eventHandlers.blur);
+
+ // Release (key up) all keys that are in a down state
+ this._allKeysUp();
+
+ //Log.Debug(">> Keyboard.ungrab");
+ },
+};
diff --git a/webclients/novnc/core/input/keysym.js b/webclients/novnc/core/input/keysym.js
new file mode 100644
index 0000000..ba58be6
--- /dev/null
+++ b/webclients/novnc/core/input/keysym.js
@@ -0,0 +1,614 @@
+export default {
+ XK_VoidSymbol: 0xffffff, /* Void symbol */
+
+ XK_BackSpace: 0xff08, /* Back space, back char */
+ XK_Tab: 0xff09,
+ XK_Linefeed: 0xff0a, /* Linefeed, LF */
+ XK_Clear: 0xff0b,
+ XK_Return: 0xff0d, /* Return, enter */
+ XK_Pause: 0xff13, /* Pause, hold */
+ XK_Scroll_Lock: 0xff14,
+ XK_Sys_Req: 0xff15,
+ XK_Escape: 0xff1b,
+ XK_Delete: 0xffff, /* Delete, rubout */
+
+ /* International & multi-key character composition */
+
+ XK_Multi_key: 0xff20, /* Multi-key character compose */
+ XK_Codeinput: 0xff37,
+ XK_SingleCandidate: 0xff3c,
+ XK_MultipleCandidate: 0xff3d,
+ XK_PreviousCandidate: 0xff3e,
+
+ /* Japanese keyboard support */
+
+ XK_Kanji: 0xff21, /* Kanji, Kanji convert */
+ XK_Muhenkan: 0xff22, /* Cancel Conversion */
+ XK_Henkan_Mode: 0xff23, /* Start/Stop Conversion */
+ XK_Henkan: 0xff23, /* Alias for Henkan_Mode */
+ XK_Romaji: 0xff24, /* to Romaji */
+ XK_Hiragana: 0xff25, /* to Hiragana */
+ XK_Katakana: 0xff26, /* to Katakana */
+ XK_Hiragana_Katakana: 0xff27, /* Hiragana/Katakana toggle */
+ XK_Zenkaku: 0xff28, /* to Zenkaku */
+ XK_Hankaku: 0xff29, /* to Hankaku */
+ XK_Zenkaku_Hankaku: 0xff2a, /* Zenkaku/Hankaku toggle */
+ XK_Touroku: 0xff2b, /* Add to Dictionary */
+ XK_Massyo: 0xff2c, /* Delete from Dictionary */
+ XK_Kana_Lock: 0xff2d, /* Kana Lock */
+ XK_Kana_Shift: 0xff2e, /* Kana Shift */
+ XK_Eisu_Shift: 0xff2f, /* Alphanumeric Shift */
+ XK_Eisu_toggle: 0xff30, /* Alphanumeric toggle */
+ XK_Kanji_Bangou: 0xff37, /* Codeinput */
+ XK_Zen_Koho: 0xff3d, /* Multiple/All Candidate(s) */
+ XK_Mae_Koho: 0xff3e, /* Previous Candidate */
+
+ /* Cursor control & motion */
+
+ XK_Home: 0xff50,
+ XK_Left: 0xff51, /* Move left, left arrow */
+ XK_Up: 0xff52, /* Move up, up arrow */
+ XK_Right: 0xff53, /* Move right, right arrow */
+ XK_Down: 0xff54, /* Move down, down arrow */
+ XK_Prior: 0xff55, /* Prior, previous */
+ XK_Page_Up: 0xff55,
+ XK_Next: 0xff56, /* Next */
+ XK_Page_Down: 0xff56,
+ XK_End: 0xff57, /* EOL */
+ XK_Begin: 0xff58, /* BOL */
+
+
+ /* Misc functions */
+
+ XK_Select: 0xff60, /* Select, mark */
+ XK_Print: 0xff61,
+ XK_Execute: 0xff62, /* Execute, run, do */
+ XK_Insert: 0xff63, /* Insert, insert here */
+ XK_Undo: 0xff65,
+ XK_Redo: 0xff66, /* Redo, again */
+ XK_Menu: 0xff67,
+ XK_Find: 0xff68, /* Find, search */
+ XK_Cancel: 0xff69, /* Cancel, stop, abort, exit */
+ XK_Help: 0xff6a, /* Help */
+ XK_Break: 0xff6b,
+ XK_Mode_switch: 0xff7e, /* Character set switch */
+ XK_script_switch: 0xff7e, /* Alias for mode_switch */
+ XK_Num_Lock: 0xff7f,
+
+ /* Keypad functions, keypad numbers cleverly chosen to map to ASCII */
+
+ XK_KP_Space: 0xff80, /* Space */
+ XK_KP_Tab: 0xff89,
+ XK_KP_Enter: 0xff8d, /* Enter */
+ XK_KP_F1: 0xff91, /* PF1, KP_A, ... */
+ XK_KP_F2: 0xff92,
+ XK_KP_F3: 0xff93,
+ XK_KP_F4: 0xff94,
+ XK_KP_Home: 0xff95,
+ XK_KP_Left: 0xff96,
+ XK_KP_Up: 0xff97,
+ XK_KP_Right: 0xff98,
+ XK_KP_Down: 0xff99,
+ XK_KP_Prior: 0xff9a,
+ XK_KP_Page_Up: 0xff9a,
+ XK_KP_Next: 0xff9b,
+ XK_KP_Page_Down: 0xff9b,
+ XK_KP_End: 0xff9c,
+ XK_KP_Begin: 0xff9d,
+ XK_KP_Insert: 0xff9e,
+ XK_KP_Delete: 0xff9f,
+ XK_KP_Equal: 0xffbd, /* Equals */
+ XK_KP_Multiply: 0xffaa,
+ XK_KP_Add: 0xffab,
+ XK_KP_Separator: 0xffac, /* Separator, often comma */
+ XK_KP_Subtract: 0xffad,
+ XK_KP_Decimal: 0xffae,
+ XK_KP_Divide: 0xffaf,
+
+ XK_KP_0: 0xffb0,
+ XK_KP_1: 0xffb1,
+ XK_KP_2: 0xffb2,
+ XK_KP_3: 0xffb3,
+ XK_KP_4: 0xffb4,
+ XK_KP_5: 0xffb5,
+ XK_KP_6: 0xffb6,
+ XK_KP_7: 0xffb7,
+ XK_KP_8: 0xffb8,
+ XK_KP_9: 0xffb9,
+
+ /*
+ * Auxiliary functions; note the duplicate definitions for left and right
+ * function keys; Sun keyboards and a few other manufacturers have such
+ * function key groups on the left and/or right sides of the keyboard.
+ * We've not found a keyboard with more than 35 function keys total.
+ */
+
+ XK_F1: 0xffbe,
+ XK_F2: 0xffbf,
+ XK_F3: 0xffc0,
+ XK_F4: 0xffc1,
+ XK_F5: 0xffc2,
+ XK_F6: 0xffc3,
+ XK_F7: 0xffc4,
+ XK_F8: 0xffc5,
+ XK_F9: 0xffc6,
+ XK_F10: 0xffc7,
+ XK_F11: 0xffc8,
+ XK_L1: 0xffc8,
+ XK_F12: 0xffc9,
+ XK_L2: 0xffc9,
+ XK_F13: 0xffca,
+ XK_L3: 0xffca,
+ XK_F14: 0xffcb,
+ XK_L4: 0xffcb,
+ XK_F15: 0xffcc,
+ XK_L5: 0xffcc,
+ XK_F16: 0xffcd,
+ XK_L6: 0xffcd,
+ XK_F17: 0xffce,
+ XK_L7: 0xffce,
+ XK_F18: 0xffcf,
+ XK_L8: 0xffcf,
+ XK_F19: 0xffd0,
+ XK_L9: 0xffd0,
+ XK_F20: 0xffd1,
+ XK_L10: 0xffd1,
+ XK_F21: 0xffd2,
+ XK_R1: 0xffd2,
+ XK_F22: 0xffd3,
+ XK_R2: 0xffd3,
+ XK_F23: 0xffd4,
+ XK_R3: 0xffd4,
+ XK_F24: 0xffd5,
+ XK_R4: 0xffd5,
+ XK_F25: 0xffd6,
+ XK_R5: 0xffd6,
+ XK_F26: 0xffd7,
+ XK_R6: 0xffd7,
+ XK_F27: 0xffd8,
+ XK_R7: 0xffd8,
+ XK_F28: 0xffd9,
+ XK_R8: 0xffd9,
+ XK_F29: 0xffda,
+ XK_R9: 0xffda,
+ XK_F30: 0xffdb,
+ XK_R10: 0xffdb,
+ XK_F31: 0xffdc,
+ XK_R11: 0xffdc,
+ XK_F32: 0xffdd,
+ XK_R12: 0xffdd,
+ XK_F33: 0xffde,
+ XK_R13: 0xffde,
+ XK_F34: 0xffdf,
+ XK_R14: 0xffdf,
+ XK_F35: 0xffe0,
+ XK_R15: 0xffe0,
+
+ /* Modifiers */
+
+ XK_Shift_L: 0xffe1, /* Left shift */
+ XK_Shift_R: 0xffe2, /* Right shift */
+ XK_Control_L: 0xffe3, /* Left control */
+ XK_Control_R: 0xffe4, /* Right control */
+ XK_Caps_Lock: 0xffe5, /* Caps lock */
+ XK_Shift_Lock: 0xffe6, /* Shift lock */
+
+ XK_Meta_L: 0xffe7, /* Left meta */
+ XK_Meta_R: 0xffe8, /* Right meta */
+ XK_Alt_L: 0xffe9, /* Left alt */
+ XK_Alt_R: 0xffea, /* Right alt */
+ XK_Super_L: 0xffeb, /* Left super */
+ XK_Super_R: 0xffec, /* Right super */
+ XK_Hyper_L: 0xffed, /* Left hyper */
+ XK_Hyper_R: 0xffee, /* Right hyper */
+
+ /*
+ * Keyboard (XKB) Extension function and modifier keys
+ * (from Appendix C of "The X Keyboard Extension: Protocol Specification")
+ * Byte 3 = 0xfe
+ */
+
+ XK_ISO_Level3_Shift: 0xfe03, /* AltGr */
+ XK_ISO_Next_Group: 0xfe08,
+ XK_ISO_Prev_Group: 0xfe0a,
+ XK_ISO_First_Group: 0xfe0c,
+ XK_ISO_Last_Group: 0xfe0e,
+
+ /*
+ * Latin 1
+ * (ISO/IEC 8859-1: Unicode U+0020..U+00FF)
+ * Byte 3: 0
+ */
+
+ XK_space: 0x0020, /* U+0020 SPACE */
+ XK_exclam: 0x0021, /* U+0021 EXCLAMATION MARK */
+ XK_quotedbl: 0x0022, /* U+0022 QUOTATION MARK */
+ XK_numbersign: 0x0023, /* U+0023 NUMBER SIGN */
+ XK_dollar: 0x0024, /* U+0024 DOLLAR SIGN */
+ XK_percent: 0x0025, /* U+0025 PERCENT SIGN */
+ XK_ampersand: 0x0026, /* U+0026 AMPERSAND */
+ XK_apostrophe: 0x0027, /* U+0027 APOSTROPHE */
+ XK_quoteright: 0x0027, /* deprecated */
+ XK_parenleft: 0x0028, /* U+0028 LEFT PARENTHESIS */
+ XK_parenright: 0x0029, /* U+0029 RIGHT PARENTHESIS */
+ XK_asterisk: 0x002a, /* U+002A ASTERISK */
+ XK_plus: 0x002b, /* U+002B PLUS SIGN */
+ XK_comma: 0x002c, /* U+002C COMMA */
+ XK_minus: 0x002d, /* U+002D HYPHEN-MINUS */
+ XK_period: 0x002e, /* U+002E FULL STOP */
+ XK_slash: 0x002f, /* U+002F SOLIDUS */
+ XK_0: 0x0030, /* U+0030 DIGIT ZERO */
+ XK_1: 0x0031, /* U+0031 DIGIT ONE */
+ XK_2: 0x0032, /* U+0032 DIGIT TWO */
+ XK_3: 0x0033, /* U+0033 DIGIT THREE */
+ XK_4: 0x0034, /* U+0034 DIGIT FOUR */
+ XK_5: 0x0035, /* U+0035 DIGIT FIVE */
+ XK_6: 0x0036, /* U+0036 DIGIT SIX */
+ XK_7: 0x0037, /* U+0037 DIGIT SEVEN */
+ XK_8: 0x0038, /* U+0038 DIGIT EIGHT */
+ XK_9: 0x0039, /* U+0039 DIGIT NINE */
+ XK_colon: 0x003a, /* U+003A COLON */
+ XK_semicolon: 0x003b, /* U+003B SEMICOLON */
+ XK_less: 0x003c, /* U+003C LESS-THAN SIGN */
+ XK_equal: 0x003d, /* U+003D EQUALS SIGN */
+ XK_greater: 0x003e, /* U+003E GREATER-THAN SIGN */
+ XK_question: 0x003f, /* U+003F QUESTION MARK */
+ XK_at: 0x0040, /* U+0040 COMMERCIAL AT */
+ XK_A: 0x0041, /* U+0041 LATIN CAPITAL LETTER A */
+ XK_B: 0x0042, /* U+0042 LATIN CAPITAL LETTER B */
+ XK_C: 0x0043, /* U+0043 LATIN CAPITAL LETTER C */
+ XK_D: 0x0044, /* U+0044 LATIN CAPITAL LETTER D */
+ XK_E: 0x0045, /* U+0045 LATIN CAPITAL LETTER E */
+ XK_F: 0x0046, /* U+0046 LATIN CAPITAL LETTER F */
+ XK_G: 0x0047, /* U+0047 LATIN CAPITAL LETTER G */
+ XK_H: 0x0048, /* U+0048 LATIN CAPITAL LETTER H */
+ XK_I: 0x0049, /* U+0049 LATIN CAPITAL LETTER I */
+ XK_J: 0x004a, /* U+004A LATIN CAPITAL LETTER J */
+ XK_K: 0x004b, /* U+004B LATIN CAPITAL LETTER K */
+ XK_L: 0x004c, /* U+004C LATIN CAPITAL LETTER L */
+ XK_M: 0x004d, /* U+004D LATIN CAPITAL LETTER M */
+ XK_N: 0x004e, /* U+004E LATIN CAPITAL LETTER N */
+ XK_O: 0x004f, /* U+004F LATIN CAPITAL LETTER O */
+ XK_P: 0x0050, /* U+0050 LATIN CAPITAL LETTER P */
+ XK_Q: 0x0051, /* U+0051 LATIN CAPITAL LETTER Q */
+ XK_R: 0x0052, /* U+0052 LATIN CAPITAL LETTER R */
+ XK_S: 0x0053, /* U+0053 LATIN CAPITAL LETTER S */
+ XK_T: 0x0054, /* U+0054 LATIN CAPITAL LETTER T */
+ XK_U: 0x0055, /* U+0055 LATIN CAPITAL LETTER U */
+ XK_V: 0x0056, /* U+0056 LATIN CAPITAL LETTER V */
+ XK_W: 0x0057, /* U+0057 LATIN CAPITAL LETTER W */
+ XK_X: 0x0058, /* U+0058 LATIN CAPITAL LETTER X */
+ XK_Y: 0x0059, /* U+0059 LATIN CAPITAL LETTER Y */
+ XK_Z: 0x005a, /* U+005A LATIN CAPITAL LETTER Z */
+ XK_bracketleft: 0x005b, /* U+005B LEFT SQUARE BRACKET */
+ XK_backslash: 0x005c, /* U+005C REVERSE SOLIDUS */
+ XK_bracketright: 0x005d, /* U+005D RIGHT SQUARE BRACKET */
+ XK_asciicircum: 0x005e, /* U+005E CIRCUMFLEX ACCENT */
+ XK_underscore: 0x005f, /* U+005F LOW LINE */
+ XK_grave: 0x0060, /* U+0060 GRAVE ACCENT */
+ XK_quoteleft: 0x0060, /* deprecated */
+ XK_a: 0x0061, /* U+0061 LATIN SMALL LETTER A */
+ XK_b: 0x0062, /* U+0062 LATIN SMALL LETTER B */
+ XK_c: 0x0063, /* U+0063 LATIN SMALL LETTER C */
+ XK_d: 0x0064, /* U+0064 LATIN SMALL LETTER D */
+ XK_e: 0x0065, /* U+0065 LATIN SMALL LETTER E */
+ XK_f: 0x0066, /* U+0066 LATIN SMALL LETTER F */
+ XK_g: 0x0067, /* U+0067 LATIN SMALL LETTER G */
+ XK_h: 0x0068, /* U+0068 LATIN SMALL LETTER H */
+ XK_i: 0x0069, /* U+0069 LATIN SMALL LETTER I */
+ XK_j: 0x006a, /* U+006A LATIN SMALL LETTER J */
+ XK_k: 0x006b, /* U+006B LATIN SMALL LETTER K */
+ XK_l: 0x006c, /* U+006C LATIN SMALL LETTER L */
+ XK_m: 0x006d, /* U+006D LATIN SMALL LETTER M */
+ XK_n: 0x006e, /* U+006E LATIN SMALL LETTER N */
+ XK_o: 0x006f, /* U+006F LATIN SMALL LETTER O */
+ XK_p: 0x0070, /* U+0070 LATIN SMALL LETTER P */
+ XK_q: 0x0071, /* U+0071 LATIN SMALL LETTER Q */
+ XK_r: 0x0072, /* U+0072 LATIN SMALL LETTER R */
+ XK_s: 0x0073, /* U+0073 LATIN SMALL LETTER S */
+ XK_t: 0x0074, /* U+0074 LATIN SMALL LETTER T */
+ XK_u: 0x0075, /* U+0075 LATIN SMALL LETTER U */
+ XK_v: 0x0076, /* U+0076 LATIN SMALL LETTER V */
+ XK_w: 0x0077, /* U+0077 LATIN SMALL LETTER W */
+ XK_x: 0x0078, /* U+0078 LATIN SMALL LETTER X */
+ XK_y: 0x0079, /* U+0079 LATIN SMALL LETTER Y */
+ XK_z: 0x007a, /* U+007A LATIN SMALL LETTER Z */
+ XK_braceleft: 0x007b, /* U+007B LEFT CURLY BRACKET */
+ XK_bar: 0x007c, /* U+007C VERTICAL LINE */
+ XK_braceright: 0x007d, /* U+007D RIGHT CURLY BRACKET */
+ XK_asciitilde: 0x007e, /* U+007E TILDE */
+
+ XK_nobreakspace: 0x00a0, /* U+00A0 NO-BREAK SPACE */
+ XK_exclamdown: 0x00a1, /* U+00A1 INVERTED EXCLAMATION MARK */
+ XK_cent: 0x00a2, /* U+00A2 CENT SIGN */
+ XK_sterling: 0x00a3, /* U+00A3 POUND SIGN */
+ XK_currency: 0x00a4, /* U+00A4 CURRENCY SIGN */
+ XK_yen: 0x00a5, /* U+00A5 YEN SIGN */
+ XK_brokenbar: 0x00a6, /* U+00A6 BROKEN BAR */
+ XK_section: 0x00a7, /* U+00A7 SECTION SIGN */
+ XK_diaeresis: 0x00a8, /* U+00A8 DIAERESIS */
+ XK_copyright: 0x00a9, /* U+00A9 COPYRIGHT SIGN */
+ XK_ordfeminine: 0x00aa, /* U+00AA FEMININE ORDINAL INDICATOR */
+ XK_guillemotleft: 0x00ab, /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
+ XK_notsign: 0x00ac, /* U+00AC NOT SIGN */
+ XK_hyphen: 0x00ad, /* U+00AD SOFT HYPHEN */
+ XK_registered: 0x00ae, /* U+00AE REGISTERED SIGN */
+ XK_macron: 0x00af, /* U+00AF MACRON */
+ XK_degree: 0x00b0, /* U+00B0 DEGREE SIGN */
+ XK_plusminus: 0x00b1, /* U+00B1 PLUS-MINUS SIGN */
+ XK_twosuperior: 0x00b2, /* U+00B2 SUPERSCRIPT TWO */
+ XK_threesuperior: 0x00b3, /* U+00B3 SUPERSCRIPT THREE */
+ XK_acute: 0x00b4, /* U+00B4 ACUTE ACCENT */
+ XK_mu: 0x00b5, /* U+00B5 MICRO SIGN */
+ XK_paragraph: 0x00b6, /* U+00B6 PILCROW SIGN */
+ XK_periodcentered: 0x00b7, /* U+00B7 MIDDLE DOT */
+ XK_cedilla: 0x00b8, /* U+00B8 CEDILLA */
+ XK_onesuperior: 0x00b9, /* U+00B9 SUPERSCRIPT ONE */
+ XK_masculine: 0x00ba, /* U+00BA MASCULINE ORDINAL INDICATOR */
+ XK_guillemotright: 0x00bb, /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
+ XK_onequarter: 0x00bc, /* U+00BC VULGAR FRACTION ONE QUARTER */
+ XK_onehalf: 0x00bd, /* U+00BD VULGAR FRACTION ONE HALF */
+ XK_threequarters: 0x00be, /* U+00BE VULGAR FRACTION THREE QUARTERS */
+ XK_questiondown: 0x00bf, /* U+00BF INVERTED QUESTION MARK */
+ XK_Agrave: 0x00c0, /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */
+ XK_Aacute: 0x00c1, /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */
+ XK_Acircumflex: 0x00c2, /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
+ XK_Atilde: 0x00c3, /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */
+ XK_Adiaeresis: 0x00c4, /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */
+ XK_Aring: 0x00c5, /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */
+ XK_AE: 0x00c6, /* U+00C6 LATIN CAPITAL LETTER AE */
+ XK_Ccedilla: 0x00c7, /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */
+ XK_Egrave: 0x00c8, /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */
+ XK_Eacute: 0x00c9, /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
+ XK_Ecircumflex: 0x00ca, /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
+ XK_Ediaeresis: 0x00cb, /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */
+ XK_Igrave: 0x00cc, /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */
+ XK_Iacute: 0x00cd, /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */
+ XK_Icircumflex: 0x00ce, /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
+ XK_Idiaeresis: 0x00cf, /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */
+ XK_ETH: 0x00d0, /* U+00D0 LATIN CAPITAL LETTER ETH */
+ XK_Eth: 0x00d0, /* deprecated */
+ XK_Ntilde: 0x00d1, /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */
+ XK_Ograve: 0x00d2, /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */
+ XK_Oacute: 0x00d3, /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */
+ XK_Ocircumflex: 0x00d4, /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
+ XK_Otilde: 0x00d5, /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */
+ XK_Odiaeresis: 0x00d6, /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */
+ XK_multiply: 0x00d7, /* U+00D7 MULTIPLICATION SIGN */
+ XK_Oslash: 0x00d8, /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+ XK_Ooblique: 0x00d8, /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
+ XK_Ugrave: 0x00d9, /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */
+ XK_Uacute: 0x00da, /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */
+ XK_Ucircumflex: 0x00db, /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
+ XK_Udiaeresis: 0x00dc, /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */
+ XK_Yacute: 0x00dd, /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */
+ XK_THORN: 0x00de, /* U+00DE LATIN CAPITAL LETTER THORN */
+ XK_Thorn: 0x00de, /* deprecated */
+ XK_ssharp: 0x00df, /* U+00DF LATIN SMALL LETTER SHARP S */
+ XK_agrave: 0x00e0, /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */
+ XK_aacute: 0x00e1, /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */
+ XK_acircumflex: 0x00e2, /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */
+ XK_atilde: 0x00e3, /* U+00E3 LATIN SMALL LETTER A WITH TILDE */
+ XK_adiaeresis: 0x00e4, /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */
+ XK_aring: 0x00e5, /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */
+ XK_ae: 0x00e6, /* U+00E6 LATIN SMALL LETTER AE */
+ XK_ccedilla: 0x00e7, /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */
+ XK_egrave: 0x00e8, /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */
+ XK_eacute: 0x00e9, /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
+ XK_ecircumflex: 0x00ea, /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */
+ XK_ediaeresis: 0x00eb, /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */
+ XK_igrave: 0x00ec, /* U+00EC LATIN SMALL LETTER I WITH GRAVE */
+ XK_iacute: 0x00ed, /* U+00ED LATIN SMALL LETTER I WITH ACUTE */
+ XK_icircumflex: 0x00ee, /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */
+ XK_idiaeresis: 0x00ef, /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */
+ XK_eth: 0x00f0, /* U+00F0 LATIN SMALL LETTER ETH */
+ XK_ntilde: 0x00f1, /* U+00F1 LATIN SMALL LETTER N WITH TILDE */
+ XK_ograve: 0x00f2, /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */
+ XK_oacute: 0x00f3, /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */
+ XK_ocircumflex: 0x00f4, /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */
+ XK_otilde: 0x00f5, /* U+00F5 LATIN SMALL LETTER O WITH TILDE */
+ XK_odiaeresis: 0x00f6, /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */
+ XK_division: 0x00f7, /* U+00F7 DIVISION SIGN */
+ XK_oslash: 0x00f8, /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+ XK_ooblique: 0x00f8, /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
+ XK_ugrave: 0x00f9, /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */
+ XK_uacute: 0x00fa, /* U+00FA LATIN SMALL LETTER U WITH ACUTE */
+ XK_ucircumflex: 0x00fb, /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */
+ XK_udiaeresis: 0x00fc, /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */
+ XK_yacute: 0x00fd, /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */
+ XK_thorn: 0x00fe, /* U+00FE LATIN SMALL LETTER THORN */
+ XK_ydiaeresis: 0x00ff, /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
+
+ /*
+ * Korean
+ * Byte 3 = 0x0e
+ */
+
+ XK_Hangul: 0xff31, /* Hangul start/stop(toggle) */
+ XK_Hangul_Hanja: 0xff34, /* Start Hangul->Hanja Conversion */
+ XK_Hangul_Jeonja: 0xff38, /* Jeonja mode */
+
+ /*
+ * XFree86 vendor specific keysyms.
+ *
+ * The XFree86 keysym range is 0x10080001 - 0x1008FFFF.
+ */
+
+ XF86XK_ModeLock: 0x1008FF01,
+ XF86XK_MonBrightnessUp: 0x1008FF02,
+ XF86XK_MonBrightnessDown: 0x1008FF03,
+ XF86XK_KbdLightOnOff: 0x1008FF04,
+ XF86XK_KbdBrightnessUp: 0x1008FF05,
+ XF86XK_KbdBrightnessDown: 0x1008FF06,
+ XF86XK_Standby: 0x1008FF10,
+ XF86XK_AudioLowerVolume: 0x1008FF11,
+ XF86XK_AudioMute: 0x1008FF12,
+ XF86XK_AudioRaiseVolume: 0x1008FF13,
+ XF86XK_AudioPlay: 0x1008FF14,
+ XF86XK_AudioStop: 0x1008FF15,
+ XF86XK_AudioPrev: 0x1008FF16,
+ XF86XK_AudioNext: 0x1008FF17,
+ XF86XK_HomePage: 0x1008FF18,
+ XF86XK_Mail: 0x1008FF19,
+ XF86XK_Start: 0x1008FF1A,
+ XF86XK_Search: 0x1008FF1B,
+ XF86XK_AudioRecord: 0x1008FF1C,
+ XF86XK_Calculator: 0x1008FF1D,
+ XF86XK_Memo: 0x1008FF1E,
+ XF86XK_ToDoList: 0x1008FF1F,
+ XF86XK_Calendar: 0x1008FF20,
+ XF86XK_PowerDown: 0x1008FF21,
+ XF86XK_ContrastAdjust: 0x1008FF22,
+ XF86XK_RockerUp: 0x1008FF23,
+ XF86XK_RockerDown: 0x1008FF24,
+ XF86XK_RockerEnter: 0x1008FF25,
+ XF86XK_Back: 0x1008FF26,
+ XF86XK_Forward: 0x1008FF27,
+ XF86XK_Stop: 0x1008FF28,
+ XF86XK_Refresh: 0x1008FF29,
+ XF86XK_PowerOff: 0x1008FF2A,
+ XF86XK_WakeUp: 0x1008FF2B,
+ XF86XK_Eject: 0x1008FF2C,
+ XF86XK_ScreenSaver: 0x1008FF2D,
+ XF86XK_WWW: 0x1008FF2E,
+ XF86XK_Sleep: 0x1008FF2F,
+ XF86XK_Favorites: 0x1008FF30,
+ XF86XK_AudioPause: 0x1008FF31,
+ XF86XK_AudioMedia: 0x1008FF32,
+ XF86XK_MyComputer: 0x1008FF33,
+ XF86XK_VendorHome: 0x1008FF34,
+ XF86XK_LightBulb: 0x1008FF35,
+ XF86XK_Shop: 0x1008FF36,
+ XF86XK_History: 0x1008FF37,
+ XF86XK_OpenURL: 0x1008FF38,
+ XF86XK_AddFavorite: 0x1008FF39,
+ XF86XK_HotLinks: 0x1008FF3A,
+ XF86XK_BrightnessAdjust: 0x1008FF3B,
+ XF86XK_Finance: 0x1008FF3C,
+ XF86XK_Community: 0x1008FF3D,
+ XF86XK_AudioRewind: 0x1008FF3E,
+ XF86XK_BackForward: 0x1008FF3F,
+ XF86XK_Launch0: 0x1008FF40,
+ XF86XK_Launch1: 0x1008FF41,
+ XF86XK_Launch2: 0x1008FF42,
+ XF86XK_Launch3: 0x1008FF43,
+ XF86XK_Launch4: 0x1008FF44,
+ XF86XK_Launch5: 0x1008FF45,
+ XF86XK_Launch6: 0x1008FF46,
+ XF86XK_Launch7: 0x1008FF47,
+ XF86XK_Launch8: 0x1008FF48,
+ XF86XK_Launch9: 0x1008FF49,
+ XF86XK_LaunchA: 0x1008FF4A,
+ XF86XK_LaunchB: 0x1008FF4B,
+ XF86XK_LaunchC: 0x1008FF4C,
+ XF86XK_LaunchD: 0x1008FF4D,
+ XF86XK_LaunchE: 0x1008FF4E,
+ XF86XK_LaunchF: 0x1008FF4F,
+ XF86XK_ApplicationLeft: 0x1008FF50,
+ XF86XK_ApplicationRight: 0x1008FF51,
+ XF86XK_Book: 0x1008FF52,
+ XF86XK_CD: 0x1008FF53,
+ XF86XK_Calculater: 0x1008FF54,
+ XF86XK_Clear: 0x1008FF55,
+ XF86XK_Close: 0x1008FF56,
+ XF86XK_Copy: 0x1008FF57,
+ XF86XK_Cut: 0x1008FF58,
+ XF86XK_Display: 0x1008FF59,
+ XF86XK_DOS: 0x1008FF5A,
+ XF86XK_Documents: 0x1008FF5B,
+ XF86XK_Excel: 0x1008FF5C,
+ XF86XK_Explorer: 0x1008FF5D,
+ XF86XK_Game: 0x1008FF5E,
+ XF86XK_Go: 0x1008FF5F,
+ XF86XK_iTouch: 0x1008FF60,
+ XF86XK_LogOff: 0x1008FF61,
+ XF86XK_Market: 0x1008FF62,
+ XF86XK_Meeting: 0x1008FF63,
+ XF86XK_MenuKB: 0x1008FF65,
+ XF86XK_MenuPB: 0x1008FF66,
+ XF86XK_MySites: 0x1008FF67,
+ XF86XK_New: 0x1008FF68,
+ XF86XK_News: 0x1008FF69,
+ XF86XK_OfficeHome: 0x1008FF6A,
+ XF86XK_Open: 0x1008FF6B,
+ XF86XK_Option: 0x1008FF6C,
+ XF86XK_Paste: 0x1008FF6D,
+ XF86XK_Phone: 0x1008FF6E,
+ XF86XK_Q: 0x1008FF70,
+ XF86XK_Reply: 0x1008FF72,
+ XF86XK_Reload: 0x1008FF73,
+ XF86XK_RotateWindows: 0x1008FF74,
+ XF86XK_RotationPB: 0x1008FF75,
+ XF86XK_RotationKB: 0x1008FF76,
+ XF86XK_Save: 0x1008FF77,
+ XF86XK_ScrollUp: 0x1008FF78,
+ XF86XK_ScrollDown: 0x1008FF79,
+ XF86XK_ScrollClick: 0x1008FF7A,
+ XF86XK_Send: 0x1008FF7B,
+ XF86XK_Spell: 0x1008FF7C,
+ XF86XK_SplitScreen: 0x1008FF7D,
+ XF86XK_Support: 0x1008FF7E,
+ XF86XK_TaskPane: 0x1008FF7F,
+ XF86XK_Terminal: 0x1008FF80,
+ XF86XK_Tools: 0x1008FF81,
+ XF86XK_Travel: 0x1008FF82,
+ XF86XK_UserPB: 0x1008FF84,
+ XF86XK_User1KB: 0x1008FF85,
+ XF86XK_User2KB: 0x1008FF86,
+ XF86XK_Video: 0x1008FF87,
+ XF86XK_WheelButton: 0x1008FF88,
+ XF86XK_Word: 0x1008FF89,
+ XF86XK_Xfer: 0x1008FF8A,
+ XF86XK_ZoomIn: 0x1008FF8B,
+ XF86XK_ZoomOut: 0x1008FF8C,
+ XF86XK_Away: 0x1008FF8D,
+ XF86XK_Messenger: 0x1008FF8E,
+ XF86XK_WebCam: 0x1008FF8F,
+ XF86XK_MailForward: 0x1008FF90,
+ XF86XK_Pictures: 0x1008FF91,
+ XF86XK_Music: 0x1008FF92,
+ XF86XK_Battery: 0x1008FF93,
+ XF86XK_Bluetooth: 0x1008FF94,
+ XF86XK_WLAN: 0x1008FF95,
+ XF86XK_UWB: 0x1008FF96,
+ XF86XK_AudioForward: 0x1008FF97,
+ XF86XK_AudioRepeat: 0x1008FF98,
+ XF86XK_AudioRandomPlay: 0x1008FF99,
+ XF86XK_Subtitle: 0x1008FF9A,
+ XF86XK_AudioCycleTrack: 0x1008FF9B,
+ XF86XK_CycleAngle: 0x1008FF9C,
+ XF86XK_FrameBack: 0x1008FF9D,
+ XF86XK_FrameForward: 0x1008FF9E,
+ XF86XK_Time: 0x1008FF9F,
+ XF86XK_Select: 0x1008FFA0,
+ XF86XK_View: 0x1008FFA1,
+ XF86XK_TopMenu: 0x1008FFA2,
+ XF86XK_Red: 0x1008FFA3,
+ XF86XK_Green: 0x1008FFA4,
+ XF86XK_Yellow: 0x1008FFA5,
+ XF86XK_Blue: 0x1008FFA6,
+ XF86XK_Suspend: 0x1008FFA7,
+ XF86XK_Hibernate: 0x1008FFA8,
+ XF86XK_TouchpadToggle: 0x1008FFA9,
+ XF86XK_TouchpadOn: 0x1008FFB0,
+ XF86XK_TouchpadOff: 0x1008FFB1,
+ XF86XK_AudioMicMute: 0x1008FFB2,
+ XF86XK_Switch_VT_1: 0x1008FE01,
+ XF86XK_Switch_VT_2: 0x1008FE02,
+ XF86XK_Switch_VT_3: 0x1008FE03,
+ XF86XK_Switch_VT_4: 0x1008FE04,
+ XF86XK_Switch_VT_5: 0x1008FE05,
+ XF86XK_Switch_VT_6: 0x1008FE06,
+ XF86XK_Switch_VT_7: 0x1008FE07,
+ XF86XK_Switch_VT_8: 0x1008FE08,
+ XF86XK_Switch_VT_9: 0x1008FE09,
+ XF86XK_Switch_VT_10: 0x1008FE0A,
+ XF86XK_Switch_VT_11: 0x1008FE0B,
+ XF86XK_Switch_VT_12: 0x1008FE0C,
+ XF86XK_Ungrab: 0x1008FE20,
+ XF86XK_ClearGrab: 0x1008FE21,
+ XF86XK_Next_VMode: 0x1008FE22,
+ XF86XK_Prev_VMode: 0x1008FE23,
+ XF86XK_LogWindowTree: 0x1008FE24,
+ XF86XK_LogGrabInfo: 0x1008FE25,
+};
diff --git a/webclients/novnc/core/input/keysymdef.js b/webclients/novnc/core/input/keysymdef.js
new file mode 100644
index 0000000..95922b3
--- /dev/null
+++ b/webclients/novnc/core/input/keysymdef.js
@@ -0,0 +1,688 @@
+/*
+ * Mapping from Unicode codepoints to X11/RFB keysyms
+ *
+ * This file was automatically generated from keysymdef.h
+ * DO NOT EDIT!
+ */
+
+/* Functions at the bottom */
+
+var codepoints = {
+ 0x0100: 0x03c0, // XK_Amacron
+ 0x0101: 0x03e0, // XK_amacron
+ 0x0102: 0x01c3, // XK_Abreve
+ 0x0103: 0x01e3, // XK_abreve
+ 0x0104: 0x01a1, // XK_Aogonek
+ 0x0105: 0x01b1, // XK_aogonek
+ 0x0106: 0x01c6, // XK_Cacute
+ 0x0107: 0x01e6, // XK_cacute
+ 0x0108: 0x02c6, // XK_Ccircumflex
+ 0x0109: 0x02e6, // XK_ccircumflex
+ 0x010a: 0x02c5, // XK_Cabovedot
+ 0x010b: 0x02e5, // XK_cabovedot
+ 0x010c: 0x01c8, // XK_Ccaron
+ 0x010d: 0x01e8, // XK_ccaron
+ 0x010e: 0x01cf, // XK_Dcaron
+ 0x010f: 0x01ef, // XK_dcaron
+ 0x0110: 0x01d0, // XK_Dstroke
+ 0x0111: 0x01f0, // XK_dstroke
+ 0x0112: 0x03aa, // XK_Emacron
+ 0x0113: 0x03ba, // XK_emacron
+ 0x0116: 0x03cc, // XK_Eabovedot
+ 0x0117: 0x03ec, // XK_eabovedot
+ 0x0118: 0x01ca, // XK_Eogonek
+ 0x0119: 0x01ea, // XK_eogonek
+ 0x011a: 0x01cc, // XK_Ecaron
+ 0x011b: 0x01ec, // XK_ecaron
+ 0x011c: 0x02d8, // XK_Gcircumflex
+ 0x011d: 0x02f8, // XK_gcircumflex
+ 0x011e: 0x02ab, // XK_Gbreve
+ 0x011f: 0x02bb, // XK_gbreve
+ 0x0120: 0x02d5, // XK_Gabovedot
+ 0x0121: 0x02f5, // XK_gabovedot
+ 0x0122: 0x03ab, // XK_Gcedilla
+ 0x0123: 0x03bb, // XK_gcedilla
+ 0x0124: 0x02a6, // XK_Hcircumflex
+ 0x0125: 0x02b6, // XK_hcircumflex
+ 0x0126: 0x02a1, // XK_Hstroke
+ 0x0127: 0x02b1, // XK_hstroke
+ 0x0128: 0x03a5, // XK_Itilde
+ 0x0129: 0x03b5, // XK_itilde
+ 0x012a: 0x03cf, // XK_Imacron
+ 0x012b: 0x03ef, // XK_imacron
+ 0x012e: 0x03c7, // XK_Iogonek
+ 0x012f: 0x03e7, // XK_iogonek
+ 0x0130: 0x02a9, // XK_Iabovedot
+ 0x0131: 0x02b9, // XK_idotless
+ 0x0134: 0x02ac, // XK_Jcircumflex
+ 0x0135: 0x02bc, // XK_jcircumflex
+ 0x0136: 0x03d3, // XK_Kcedilla
+ 0x0137: 0x03f3, // XK_kcedilla
+ 0x0138: 0x03a2, // XK_kra
+ 0x0139: 0x01c5, // XK_Lacute
+ 0x013a: 0x01e5, // XK_lacute
+ 0x013b: 0x03a6, // XK_Lcedilla
+ 0x013c: 0x03b6, // XK_lcedilla
+ 0x013d: 0x01a5, // XK_Lcaron
+ 0x013e: 0x01b5, // XK_lcaron
+ 0x0141: 0x01a3, // XK_Lstroke
+ 0x0142: 0x01b3, // XK_lstroke
+ 0x0143: 0x01d1, // XK_Nacute
+ 0x0144: 0x01f1, // XK_nacute
+ 0x0145: 0x03d1, // XK_Ncedilla
+ 0x0146: 0x03f1, // XK_ncedilla
+ 0x0147: 0x01d2, // XK_Ncaron
+ 0x0148: 0x01f2, // XK_ncaron
+ 0x014a: 0x03bd, // XK_ENG
+ 0x014b: 0x03bf, // XK_eng
+ 0x014c: 0x03d2, // XK_Omacron
+ 0x014d: 0x03f2, // XK_omacron
+ 0x0150: 0x01d5, // XK_Odoubleacute
+ 0x0151: 0x01f5, // XK_odoubleacute
+ 0x0152: 0x13bc, // XK_OE
+ 0x0153: 0x13bd, // XK_oe
+ 0x0154: 0x01c0, // XK_Racute
+ 0x0155: 0x01e0, // XK_racute
+ 0x0156: 0x03a3, // XK_Rcedilla
+ 0x0157: 0x03b3, // XK_rcedilla
+ 0x0158: 0x01d8, // XK_Rcaron
+ 0x0159: 0x01f8, // XK_rcaron
+ 0x015a: 0x01a6, // XK_Sacute
+ 0x015b: 0x01b6, // XK_sacute
+ 0x015c: 0x02de, // XK_Scircumflex
+ 0x015d: 0x02fe, // XK_scircumflex
+ 0x015e: 0x01aa, // XK_Scedilla
+ 0x015f: 0x01ba, // XK_scedilla
+ 0x0160: 0x01a9, // XK_Scaron
+ 0x0161: 0x01b9, // XK_scaron
+ 0x0162: 0x01de, // XK_Tcedilla
+ 0x0163: 0x01fe, // XK_tcedilla
+ 0x0164: 0x01ab, // XK_Tcaron
+ 0x0165: 0x01bb, // XK_tcaron
+ 0x0166: 0x03ac, // XK_Tslash
+ 0x0167: 0x03bc, // XK_tslash
+ 0x0168: 0x03dd, // XK_Utilde
+ 0x0169: 0x03fd, // XK_utilde
+ 0x016a: 0x03de, // XK_Umacron
+ 0x016b: 0x03fe, // XK_umacron
+ 0x016c: 0x02dd, // XK_Ubreve
+ 0x016d: 0x02fd, // XK_ubreve
+ 0x016e: 0x01d9, // XK_Uring
+ 0x016f: 0x01f9, // XK_uring
+ 0x0170: 0x01db, // XK_Udoubleacute
+ 0x0171: 0x01fb, // XK_udoubleacute
+ 0x0172: 0x03d9, // XK_Uogonek
+ 0x0173: 0x03f9, // XK_uogonek
+ 0x0178: 0x13be, // XK_Ydiaeresis
+ 0x0179: 0x01ac, // XK_Zacute
+ 0x017a: 0x01bc, // XK_zacute
+ 0x017b: 0x01af, // XK_Zabovedot
+ 0x017c: 0x01bf, // XK_zabovedot
+ 0x017d: 0x01ae, // XK_Zcaron
+ 0x017e: 0x01be, // XK_zcaron
+ 0x0192: 0x08f6, // XK_function
+ 0x01d2: 0x10001d1, // XK_Ocaron
+ 0x02c7: 0x01b7, // XK_caron
+ 0x02d8: 0x01a2, // XK_breve
+ 0x02d9: 0x01ff, // XK_abovedot
+ 0x02db: 0x01b2, // XK_ogonek
+ 0x02dd: 0x01bd, // XK_doubleacute
+ 0x0385: 0x07ae, // XK_Greek_accentdieresis
+ 0x0386: 0x07a1, // XK_Greek_ALPHAaccent
+ 0x0388: 0x07a2, // XK_Greek_EPSILONaccent
+ 0x0389: 0x07a3, // XK_Greek_ETAaccent
+ 0x038a: 0x07a4, // XK_Greek_IOTAaccent
+ 0x038c: 0x07a7, // XK_Greek_OMICRONaccent
+ 0x038e: 0x07a8, // XK_Greek_UPSILONaccent
+ 0x038f: 0x07ab, // XK_Greek_OMEGAaccent
+ 0x0390: 0x07b6, // XK_Greek_iotaaccentdieresis
+ 0x0391: 0x07c1, // XK_Greek_ALPHA
+ 0x0392: 0x07c2, // XK_Greek_BETA
+ 0x0393: 0x07c3, // XK_Greek_GAMMA
+ 0x0394: 0x07c4, // XK_Greek_DELTA
+ 0x0395: 0x07c5, // XK_Greek_EPSILON
+ 0x0396: 0x07c6, // XK_Greek_ZETA
+ 0x0397: 0x07c7, // XK_Greek_ETA
+ 0x0398: 0x07c8, // XK_Greek_THETA
+ 0x0399: 0x07c9, // XK_Greek_IOTA
+ 0x039a: 0x07ca, // XK_Greek_KAPPA
+ 0x039b: 0x07cb, // XK_Greek_LAMDA
+ 0x039c: 0x07cc, // XK_Greek_MU
+ 0x039d: 0x07cd, // XK_Greek_NU
+ 0x039e: 0x07ce, // XK_Greek_XI
+ 0x039f: 0x07cf, // XK_Greek_OMICRON
+ 0x03a0: 0x07d0, // XK_Greek_PI
+ 0x03a1: 0x07d1, // XK_Greek_RHO
+ 0x03a3: 0x07d2, // XK_Greek_SIGMA
+ 0x03a4: 0x07d4, // XK_Greek_TAU
+ 0x03a5: 0x07d5, // XK_Greek_UPSILON
+ 0x03a6: 0x07d6, // XK_Greek_PHI
+ 0x03a7: 0x07d7, // XK_Greek_CHI
+ 0x03a8: 0x07d8, // XK_Greek_PSI
+ 0x03a9: 0x07d9, // XK_Greek_OMEGA
+ 0x03aa: 0x07a5, // XK_Greek_IOTAdieresis
+ 0x03ab: 0x07a9, // XK_Greek_UPSILONdieresis
+ 0x03ac: 0x07b1, // XK_Greek_alphaaccent
+ 0x03ad: 0x07b2, // XK_Greek_epsilonaccent
+ 0x03ae: 0x07b3, // XK_Greek_etaaccent
+ 0x03af: 0x07b4, // XK_Greek_iotaaccent
+ 0x03b0: 0x07ba, // XK_Greek_upsilonaccentdieresis
+ 0x03b1: 0x07e1, // XK_Greek_alpha
+ 0x03b2: 0x07e2, // XK_Greek_beta
+ 0x03b3: 0x07e3, // XK_Greek_gamma
+ 0x03b4: 0x07e4, // XK_Greek_delta
+ 0x03b5: 0x07e5, // XK_Greek_epsilon
+ 0x03b6: 0x07e6, // XK_Greek_zeta
+ 0x03b7: 0x07e7, // XK_Greek_eta
+ 0x03b8: 0x07e8, // XK_Greek_theta
+ 0x03b9: 0x07e9, // XK_Greek_iota
+ 0x03ba: 0x07ea, // XK_Greek_kappa
+ 0x03bb: 0x07eb, // XK_Greek_lamda
+ 0x03bc: 0x07ec, // XK_Greek_mu
+ 0x03bd: 0x07ed, // XK_Greek_nu
+ 0x03be: 0x07ee, // XK_Greek_xi
+ 0x03bf: 0x07ef, // XK_Greek_omicron
+ 0x03c0: 0x07f0, // XK_Greek_pi
+ 0x03c1: 0x07f1, // XK_Greek_rho
+ 0x03c2: 0x07f3, // XK_Greek_finalsmallsigma
+ 0x03c3: 0x07f2, // XK_Greek_sigma
+ 0x03c4: 0x07f4, // XK_Greek_tau
+ 0x03c5: 0x07f5, // XK_Greek_upsilon
+ 0x03c6: 0x07f6, // XK_Greek_phi
+ 0x03c7: 0x07f7, // XK_Greek_chi
+ 0x03c8: 0x07f8, // XK_Greek_psi
+ 0x03c9: 0x07f9, // XK_Greek_omega
+ 0x03ca: 0x07b5, // XK_Greek_iotadieresis
+ 0x03cb: 0x07b9, // XK_Greek_upsilondieresis
+ 0x03cc: 0x07b7, // XK_Greek_omicronaccent
+ 0x03cd: 0x07b8, // XK_Greek_upsilonaccent
+ 0x03ce: 0x07bb, // XK_Greek_omegaaccent
+ 0x0401: 0x06b3, // XK_Cyrillic_IO
+ 0x0402: 0x06b1, // XK_Serbian_DJE
+ 0x0403: 0x06b2, // XK_Macedonia_GJE
+ 0x0404: 0x06b4, // XK_Ukrainian_IE
+ 0x0405: 0x06b5, // XK_Macedonia_DSE
+ 0x0406: 0x06b6, // XK_Ukrainian_I
+ 0x0407: 0x06b7, // XK_Ukrainian_YI
+ 0x0408: 0x06b8, // XK_Cyrillic_JE
+ 0x0409: 0x06b9, // XK_Cyrillic_LJE
+ 0x040a: 0x06ba, // XK_Cyrillic_NJE
+ 0x040b: 0x06bb, // XK_Serbian_TSHE
+ 0x040c: 0x06bc, // XK_Macedonia_KJE
+ 0x040e: 0x06be, // XK_Byelorussian_SHORTU
+ 0x040f: 0x06bf, // XK_Cyrillic_DZHE
+ 0x0410: 0x06e1, // XK_Cyrillic_A
+ 0x0411: 0x06e2, // XK_Cyrillic_BE
+ 0x0412: 0x06f7, // XK_Cyrillic_VE
+ 0x0413: 0x06e7, // XK_Cyrillic_GHE
+ 0x0414: 0x06e4, // XK_Cyrillic_DE
+ 0x0415: 0x06e5, // XK_Cyrillic_IE
+ 0x0416: 0x06f6, // XK_Cyrillic_ZHE
+ 0x0417: 0x06fa, // XK_Cyrillic_ZE
+ 0x0418: 0x06e9, // XK_Cyrillic_I
+ 0x0419: 0x06ea, // XK_Cyrillic_SHORTI
+ 0x041a: 0x06eb, // XK_Cyrillic_KA
+ 0x041b: 0x06ec, // XK_Cyrillic_EL
+ 0x041c: 0x06ed, // XK_Cyrillic_EM
+ 0x041d: 0x06ee, // XK_Cyrillic_EN
+ 0x041e: 0x06ef, // XK_Cyrillic_O
+ 0x041f: 0x06f0, // XK_Cyrillic_PE
+ 0x0420: 0x06f2, // XK_Cyrillic_ER
+ 0x0421: 0x06f3, // XK_Cyrillic_ES
+ 0x0422: 0x06f4, // XK_Cyrillic_TE
+ 0x0423: 0x06f5, // XK_Cyrillic_U
+ 0x0424: 0x06e6, // XK_Cyrillic_EF
+ 0x0425: 0x06e8, // XK_Cyrillic_HA
+ 0x0426: 0x06e3, // XK_Cyrillic_TSE
+ 0x0427: 0x06fe, // XK_Cyrillic_CHE
+ 0x0428: 0x06fb, // XK_Cyrillic_SHA
+ 0x0429: 0x06fd, // XK_Cyrillic_SHCHA
+ 0x042a: 0x06ff, // XK_Cyrillic_HARDSIGN
+ 0x042b: 0x06f9, // XK_Cyrillic_YERU
+ 0x042c: 0x06f8, // XK_Cyrillic_SOFTSIGN
+ 0x042d: 0x06fc, // XK_Cyrillic_E
+ 0x042e: 0x06e0, // XK_Cyrillic_YU
+ 0x042f: 0x06f1, // XK_Cyrillic_YA
+ 0x0430: 0x06c1, // XK_Cyrillic_a
+ 0x0431: 0x06c2, // XK_Cyrillic_be
+ 0x0432: 0x06d7, // XK_Cyrillic_ve
+ 0x0433: 0x06c7, // XK_Cyrillic_ghe
+ 0x0434: 0x06c4, // XK_Cyrillic_de
+ 0x0435: 0x06c5, // XK_Cyrillic_ie
+ 0x0436: 0x06d6, // XK_Cyrillic_zhe
+ 0x0437: 0x06da, // XK_Cyrillic_ze
+ 0x0438: 0x06c9, // XK_Cyrillic_i
+ 0x0439: 0x06ca, // XK_Cyrillic_shorti
+ 0x043a: 0x06cb, // XK_Cyrillic_ka
+ 0x043b: 0x06cc, // XK_Cyrillic_el
+ 0x043c: 0x06cd, // XK_Cyrillic_em
+ 0x043d: 0x06ce, // XK_Cyrillic_en
+ 0x043e: 0x06cf, // XK_Cyrillic_o
+ 0x043f: 0x06d0, // XK_Cyrillic_pe
+ 0x0440: 0x06d2, // XK_Cyrillic_er
+ 0x0441: 0x06d3, // XK_Cyrillic_es
+ 0x0442: 0x06d4, // XK_Cyrillic_te
+ 0x0443: 0x06d5, // XK_Cyrillic_u
+ 0x0444: 0x06c6, // XK_Cyrillic_ef
+ 0x0445: 0x06c8, // XK_Cyrillic_ha
+ 0x0446: 0x06c3, // XK_Cyrillic_tse
+ 0x0447: 0x06de, // XK_Cyrillic_che
+ 0x0448: 0x06db, // XK_Cyrillic_sha
+ 0x0449: 0x06dd, // XK_Cyrillic_shcha
+ 0x044a: 0x06df, // XK_Cyrillic_hardsign
+ 0x044b: 0x06d9, // XK_Cyrillic_yeru
+ 0x044c: 0x06d8, // XK_Cyrillic_softsign
+ 0x044d: 0x06dc, // XK_Cyrillic_e
+ 0x044e: 0x06c0, // XK_Cyrillic_yu
+ 0x044f: 0x06d1, // XK_Cyrillic_ya
+ 0x0451: 0x06a3, // XK_Cyrillic_io
+ 0x0452: 0x06a1, // XK_Serbian_dje
+ 0x0453: 0x06a2, // XK_Macedonia_gje
+ 0x0454: 0x06a4, // XK_Ukrainian_ie
+ 0x0455: 0x06a5, // XK_Macedonia_dse
+ 0x0456: 0x06a6, // XK_Ukrainian_i
+ 0x0457: 0x06a7, // XK_Ukrainian_yi
+ 0x0458: 0x06a8, // XK_Cyrillic_je
+ 0x0459: 0x06a9, // XK_Cyrillic_lje
+ 0x045a: 0x06aa, // XK_Cyrillic_nje
+ 0x045b: 0x06ab, // XK_Serbian_tshe
+ 0x045c: 0x06ac, // XK_Macedonia_kje
+ 0x045e: 0x06ae, // XK_Byelorussian_shortu
+ 0x045f: 0x06af, // XK_Cyrillic_dzhe
+ 0x0490: 0x06bd, // XK_Ukrainian_GHE_WITH_UPTURN
+ 0x0491: 0x06ad, // XK_Ukrainian_ghe_with_upturn
+ 0x05d0: 0x0ce0, // XK_hebrew_aleph
+ 0x05d1: 0x0ce1, // XK_hebrew_bet
+ 0x05d2: 0x0ce2, // XK_hebrew_gimel
+ 0x05d3: 0x0ce3, // XK_hebrew_dalet
+ 0x05d4: 0x0ce4, // XK_hebrew_he
+ 0x05d5: 0x0ce5, // XK_hebrew_waw
+ 0x05d6: 0x0ce6, // XK_hebrew_zain
+ 0x05d7: 0x0ce7, // XK_hebrew_chet
+ 0x05d8: 0x0ce8, // XK_hebrew_tet
+ 0x05d9: 0x0ce9, // XK_hebrew_yod
+ 0x05da: 0x0cea, // XK_hebrew_finalkaph
+ 0x05db: 0x0ceb, // XK_hebrew_kaph
+ 0x05dc: 0x0cec, // XK_hebrew_lamed
+ 0x05dd: 0x0ced, // XK_hebrew_finalmem
+ 0x05de: 0x0cee, // XK_hebrew_mem
+ 0x05df: 0x0cef, // XK_hebrew_finalnun
+ 0x05e0: 0x0cf0, // XK_hebrew_nun
+ 0x05e1: 0x0cf1, // XK_hebrew_samech
+ 0x05e2: 0x0cf2, // XK_hebrew_ayin
+ 0x05e3: 0x0cf3, // XK_hebrew_finalpe
+ 0x05e4: 0x0cf4, // XK_hebrew_pe
+ 0x05e5: 0x0cf5, // XK_hebrew_finalzade
+ 0x05e6: 0x0cf6, // XK_hebrew_zade
+ 0x05e7: 0x0cf7, // XK_hebrew_qoph
+ 0x05e8: 0x0cf8, // XK_hebrew_resh
+ 0x05e9: 0x0cf9, // XK_hebrew_shin
+ 0x05ea: 0x0cfa, // XK_hebrew_taw
+ 0x060c: 0x05ac, // XK_Arabic_comma
+ 0x061b: 0x05bb, // XK_Arabic_semicolon
+ 0x061f: 0x05bf, // XK_Arabic_question_mark
+ 0x0621: 0x05c1, // XK_Arabic_hamza
+ 0x0622: 0x05c2, // XK_Arabic_maddaonalef
+ 0x0623: 0x05c3, // XK_Arabic_hamzaonalef
+ 0x0624: 0x05c4, // XK_Arabic_hamzaonwaw
+ 0x0625: 0x05c5, // XK_Arabic_hamzaunderalef
+ 0x0626: 0x05c6, // XK_Arabic_hamzaonyeh
+ 0x0627: 0x05c7, // XK_Arabic_alef
+ 0x0628: 0x05c8, // XK_Arabic_beh
+ 0x0629: 0x05c9, // XK_Arabic_tehmarbuta
+ 0x062a: 0x05ca, // XK_Arabic_teh
+ 0x062b: 0x05cb, // XK_Arabic_theh
+ 0x062c: 0x05cc, // XK_Arabic_jeem
+ 0x062d: 0x05cd, // XK_Arabic_hah
+ 0x062e: 0x05ce, // XK_Arabic_khah
+ 0x062f: 0x05cf, // XK_Arabic_dal
+ 0x0630: 0x05d0, // XK_Arabic_thal
+ 0x0631: 0x05d1, // XK_Arabic_ra
+ 0x0632: 0x05d2, // XK_Arabic_zain
+ 0x0633: 0x05d3, // XK_Arabic_seen
+ 0x0634: 0x05d4, // XK_Arabic_sheen
+ 0x0635: 0x05d5, // XK_Arabic_sad
+ 0x0636: 0x05d6, // XK_Arabic_dad
+ 0x0637: 0x05d7, // XK_Arabic_tah
+ 0x0638: 0x05d8, // XK_Arabic_zah
+ 0x0639: 0x05d9, // XK_Arabic_ain
+ 0x063a: 0x05da, // XK_Arabic_ghain
+ 0x0640: 0x05e0, // XK_Arabic_tatweel
+ 0x0641: 0x05e1, // XK_Arabic_feh
+ 0x0642: 0x05e2, // XK_Arabic_qaf
+ 0x0643: 0x05e3, // XK_Arabic_kaf
+ 0x0644: 0x05e4, // XK_Arabic_lam
+ 0x0645: 0x05e5, // XK_Arabic_meem
+ 0x0646: 0x05e6, // XK_Arabic_noon
+ 0x0647: 0x05e7, // XK_Arabic_ha
+ 0x0648: 0x05e8, // XK_Arabic_waw
+ 0x0649: 0x05e9, // XK_Arabic_alefmaksura
+ 0x064a: 0x05ea, // XK_Arabic_yeh
+ 0x064b: 0x05eb, // XK_Arabic_fathatan
+ 0x064c: 0x05ec, // XK_Arabic_dammatan
+ 0x064d: 0x05ed, // XK_Arabic_kasratan
+ 0x064e: 0x05ee, // XK_Arabic_fatha
+ 0x064f: 0x05ef, // XK_Arabic_damma
+ 0x0650: 0x05f0, // XK_Arabic_kasra
+ 0x0651: 0x05f1, // XK_Arabic_shadda
+ 0x0652: 0x05f2, // XK_Arabic_sukun
+ 0x0e01: 0x0da1, // XK_Thai_kokai
+ 0x0e02: 0x0da2, // XK_Thai_khokhai
+ 0x0e03: 0x0da3, // XK_Thai_khokhuat
+ 0x0e04: 0x0da4, // XK_Thai_khokhwai
+ 0x0e05: 0x0da5, // XK_Thai_khokhon
+ 0x0e06: 0x0da6, // XK_Thai_khorakhang
+ 0x0e07: 0x0da7, // XK_Thai_ngongu
+ 0x0e08: 0x0da8, // XK_Thai_chochan
+ 0x0e09: 0x0da9, // XK_Thai_choching
+ 0x0e0a: 0x0daa, // XK_Thai_chochang
+ 0x0e0b: 0x0dab, // XK_Thai_soso
+ 0x0e0c: 0x0dac, // XK_Thai_chochoe
+ 0x0e0d: 0x0dad, // XK_Thai_yoying
+ 0x0e0e: 0x0dae, // XK_Thai_dochada
+ 0x0e0f: 0x0daf, // XK_Thai_topatak
+ 0x0e10: 0x0db0, // XK_Thai_thothan
+ 0x0e11: 0x0db1, // XK_Thai_thonangmontho
+ 0x0e12: 0x0db2, // XK_Thai_thophuthao
+ 0x0e13: 0x0db3, // XK_Thai_nonen
+ 0x0e14: 0x0db4, // XK_Thai_dodek
+ 0x0e15: 0x0db5, // XK_Thai_totao
+ 0x0e16: 0x0db6, // XK_Thai_thothung
+ 0x0e17: 0x0db7, // XK_Thai_thothahan
+ 0x0e18: 0x0db8, // XK_Thai_thothong
+ 0x0e19: 0x0db9, // XK_Thai_nonu
+ 0x0e1a: 0x0dba, // XK_Thai_bobaimai
+ 0x0e1b: 0x0dbb, // XK_Thai_popla
+ 0x0e1c: 0x0dbc, // XK_Thai_phophung
+ 0x0e1d: 0x0dbd, // XK_Thai_fofa
+ 0x0e1e: 0x0dbe, // XK_Thai_phophan
+ 0x0e1f: 0x0dbf, // XK_Thai_fofan
+ 0x0e20: 0x0dc0, // XK_Thai_phosamphao
+ 0x0e21: 0x0dc1, // XK_Thai_moma
+ 0x0e22: 0x0dc2, // XK_Thai_yoyak
+ 0x0e23: 0x0dc3, // XK_Thai_rorua
+ 0x0e24: 0x0dc4, // XK_Thai_ru
+ 0x0e25: 0x0dc5, // XK_Thai_loling
+ 0x0e26: 0x0dc6, // XK_Thai_lu
+ 0x0e27: 0x0dc7, // XK_Thai_wowaen
+ 0x0e28: 0x0dc8, // XK_Thai_sosala
+ 0x0e29: 0x0dc9, // XK_Thai_sorusi
+ 0x0e2a: 0x0dca, // XK_Thai_sosua
+ 0x0e2b: 0x0dcb, // XK_Thai_hohip
+ 0x0e2c: 0x0dcc, // XK_Thai_lochula
+ 0x0e2d: 0x0dcd, // XK_Thai_oang
+ 0x0e2e: 0x0dce, // XK_Thai_honokhuk
+ 0x0e2f: 0x0dcf, // XK_Thai_paiyannoi
+ 0x0e30: 0x0dd0, // XK_Thai_saraa
+ 0x0e31: 0x0dd1, // XK_Thai_maihanakat
+ 0x0e32: 0x0dd2, // XK_Thai_saraaa
+ 0x0e33: 0x0dd3, // XK_Thai_saraam
+ 0x0e34: 0x0dd4, // XK_Thai_sarai
+ 0x0e35: 0x0dd5, // XK_Thai_saraii
+ 0x0e36: 0x0dd6, // XK_Thai_saraue
+ 0x0e37: 0x0dd7, // XK_Thai_sarauee
+ 0x0e38: 0x0dd8, // XK_Thai_sarau
+ 0x0e39: 0x0dd9, // XK_Thai_sarauu
+ 0x0e3a: 0x0dda, // XK_Thai_phinthu
+ 0x0e3f: 0x0ddf, // XK_Thai_baht
+ 0x0e40: 0x0de0, // XK_Thai_sarae
+ 0x0e41: 0x0de1, // XK_Thai_saraae
+ 0x0e42: 0x0de2, // XK_Thai_sarao
+ 0x0e43: 0x0de3, // XK_Thai_saraaimaimuan
+ 0x0e44: 0x0de4, // XK_Thai_saraaimaimalai
+ 0x0e45: 0x0de5, // XK_Thai_lakkhangyao
+ 0x0e46: 0x0de6, // XK_Thai_maiyamok
+ 0x0e47: 0x0de7, // XK_Thai_maitaikhu
+ 0x0e48: 0x0de8, // XK_Thai_maiek
+ 0x0e49: 0x0de9, // XK_Thai_maitho
+ 0x0e4a: 0x0dea, // XK_Thai_maitri
+ 0x0e4b: 0x0deb, // XK_Thai_maichattawa
+ 0x0e4c: 0x0dec, // XK_Thai_thanthakhat
+ 0x0e4d: 0x0ded, // XK_Thai_nikhahit
+ 0x0e50: 0x0df0, // XK_Thai_leksun
+ 0x0e51: 0x0df1, // XK_Thai_leknung
+ 0x0e52: 0x0df2, // XK_Thai_leksong
+ 0x0e53: 0x0df3, // XK_Thai_leksam
+ 0x0e54: 0x0df4, // XK_Thai_leksi
+ 0x0e55: 0x0df5, // XK_Thai_lekha
+ 0x0e56: 0x0df6, // XK_Thai_lekhok
+ 0x0e57: 0x0df7, // XK_Thai_lekchet
+ 0x0e58: 0x0df8, // XK_Thai_lekpaet
+ 0x0e59: 0x0df9, // XK_Thai_lekkao
+ 0x2002: 0x0aa2, // XK_enspace
+ 0x2003: 0x0aa1, // XK_emspace
+ 0x2004: 0x0aa3, // XK_em3space
+ 0x2005: 0x0aa4, // XK_em4space
+ 0x2007: 0x0aa5, // XK_digitspace
+ 0x2008: 0x0aa6, // XK_punctspace
+ 0x2009: 0x0aa7, // XK_thinspace
+ 0x200a: 0x0aa8, // XK_hairspace
+ 0x2012: 0x0abb, // XK_figdash
+ 0x2013: 0x0aaa, // XK_endash
+ 0x2014: 0x0aa9, // XK_emdash
+ 0x2015: 0x07af, // XK_Greek_horizbar
+ 0x2017: 0x0cdf, // XK_hebrew_doublelowline
+ 0x2018: 0x0ad0, // XK_leftsinglequotemark
+ 0x2019: 0x0ad1, // XK_rightsinglequotemark
+ 0x201a: 0x0afd, // XK_singlelowquotemark
+ 0x201c: 0x0ad2, // XK_leftdoublequotemark
+ 0x201d: 0x0ad3, // XK_rightdoublequotemark
+ 0x201e: 0x0afe, // XK_doublelowquotemark
+ 0x2020: 0x0af1, // XK_dagger
+ 0x2021: 0x0af2, // XK_doubledagger
+ 0x2022: 0x0ae6, // XK_enfilledcircbullet
+ 0x2025: 0x0aaf, // XK_doubbaselinedot
+ 0x2026: 0x0aae, // XK_ellipsis
+ 0x2030: 0x0ad5, // XK_permille
+ 0x2032: 0x0ad6, // XK_minutes
+ 0x2033: 0x0ad7, // XK_seconds
+ 0x2038: 0x0afc, // XK_caret
+ 0x203e: 0x047e, // XK_overline
+ 0x20a9: 0x0eff, // XK_Korean_Won
+ 0x20ac: 0x20ac, // XK_EuroSign
+ 0x2105: 0x0ab8, // XK_careof
+ 0x2116: 0x06b0, // XK_numerosign
+ 0x2117: 0x0afb, // XK_phonographcopyright
+ 0x211e: 0x0ad4, // XK_prescription
+ 0x2122: 0x0ac9, // XK_trademark
+ 0x2153: 0x0ab0, // XK_onethird
+ 0x2154: 0x0ab1, // XK_twothirds
+ 0x2155: 0x0ab2, // XK_onefifth
+ 0x2156: 0x0ab3, // XK_twofifths
+ 0x2157: 0x0ab4, // XK_threefifths
+ 0x2158: 0x0ab5, // XK_fourfifths
+ 0x2159: 0x0ab6, // XK_onesixth
+ 0x215a: 0x0ab7, // XK_fivesixths
+ 0x215b: 0x0ac3, // XK_oneeighth
+ 0x215c: 0x0ac4, // XK_threeeighths
+ 0x215d: 0x0ac5, // XK_fiveeighths
+ 0x215e: 0x0ac6, // XK_seveneighths
+ 0x2190: 0x08fb, // XK_leftarrow
+ 0x2191: 0x08fc, // XK_uparrow
+ 0x2192: 0x08fd, // XK_rightarrow
+ 0x2193: 0x08fe, // XK_downarrow
+ 0x21d2: 0x08ce, // XK_implies
+ 0x21d4: 0x08cd, // XK_ifonlyif
+ 0x2202: 0x08ef, // XK_partialderivative
+ 0x2207: 0x08c5, // XK_nabla
+ 0x2218: 0x0bca, // XK_jot
+ 0x221a: 0x08d6, // XK_radical
+ 0x221d: 0x08c1, // XK_variation
+ 0x221e: 0x08c2, // XK_infinity
+ 0x2227: 0x08de, // XK_logicaland
+ 0x2228: 0x08df, // XK_logicalor
+ 0x2229: 0x08dc, // XK_intersection
+ 0x222a: 0x08dd, // XK_union
+ 0x222b: 0x08bf, // XK_integral
+ 0x2234: 0x08c0, // XK_therefore
+ 0x223c: 0x08c8, // XK_approximate
+ 0x2243: 0x08c9, // XK_similarequal
+ 0x2245: 0x1002248, // XK_approxeq
+ 0x2260: 0x08bd, // XK_notequal
+ 0x2261: 0x08cf, // XK_identical
+ 0x2264: 0x08bc, // XK_lessthanequal
+ 0x2265: 0x08be, // XK_greaterthanequal
+ 0x2282: 0x08da, // XK_includedin
+ 0x2283: 0x08db, // XK_includes
+ 0x22a2: 0x0bfc, // XK_righttack
+ 0x22a3: 0x0bdc, // XK_lefttack
+ 0x22a4: 0x0bc2, // XK_downtack
+ 0x22a5: 0x0bce, // XK_uptack
+ 0x2308: 0x0bd3, // XK_upstile
+ 0x230a: 0x0bc4, // XK_downstile
+ 0x2315: 0x0afa, // XK_telephonerecorder
+ 0x2320: 0x08a4, // XK_topintegral
+ 0x2321: 0x08a5, // XK_botintegral
+ 0x2395: 0x0bcc, // XK_quad
+ 0x239b: 0x08ab, // XK_topleftparens
+ 0x239d: 0x08ac, // XK_botleftparens
+ 0x239e: 0x08ad, // XK_toprightparens
+ 0x23a0: 0x08ae, // XK_botrightparens
+ 0x23a1: 0x08a7, // XK_topleftsqbracket
+ 0x23a3: 0x08a8, // XK_botleftsqbracket
+ 0x23a4: 0x08a9, // XK_toprightsqbracket
+ 0x23a6: 0x08aa, // XK_botrightsqbracket
+ 0x23a8: 0x08af, // XK_leftmiddlecurlybrace
+ 0x23ac: 0x08b0, // XK_rightmiddlecurlybrace
+ 0x23b7: 0x08a1, // XK_leftradical
+ 0x23ba: 0x09ef, // XK_horizlinescan1
+ 0x23bb: 0x09f0, // XK_horizlinescan3
+ 0x23bc: 0x09f2, // XK_horizlinescan7
+ 0x23bd: 0x09f3, // XK_horizlinescan9
+ 0x2409: 0x09e2, // XK_ht
+ 0x240a: 0x09e5, // XK_lf
+ 0x240b: 0x09e9, // XK_vt
+ 0x240c: 0x09e3, // XK_ff
+ 0x240d: 0x09e4, // XK_cr
+ 0x2423: 0x0aac, // XK_signifblank
+ 0x2424: 0x09e8, // XK_nl
+ 0x2500: 0x08a3, // XK_horizconnector
+ 0x2502: 0x08a6, // XK_vertconnector
+ 0x250c: 0x08a2, // XK_topleftradical
+ 0x2510: 0x09eb, // XK_uprightcorner
+ 0x2514: 0x09ed, // XK_lowleftcorner
+ 0x2518: 0x09ea, // XK_lowrightcorner
+ 0x251c: 0x09f4, // XK_leftt
+ 0x2524: 0x09f5, // XK_rightt
+ 0x252c: 0x09f7, // XK_topt
+ 0x2534: 0x09f6, // XK_bott
+ 0x253c: 0x09ee, // XK_crossinglines
+ 0x2592: 0x09e1, // XK_checkerboard
+ 0x25aa: 0x0ae7, // XK_enfilledsqbullet
+ 0x25ab: 0x0ae1, // XK_enopensquarebullet
+ 0x25ac: 0x0adb, // XK_filledrectbullet
+ 0x25ad: 0x0ae2, // XK_openrectbullet
+ 0x25ae: 0x0adf, // XK_emfilledrect
+ 0x25af: 0x0acf, // XK_emopenrectangle
+ 0x25b2: 0x0ae8, // XK_filledtribulletup
+ 0x25b3: 0x0ae3, // XK_opentribulletup
+ 0x25b6: 0x0add, // XK_filledrighttribullet
+ 0x25b7: 0x0acd, // XK_rightopentriangle
+ 0x25bc: 0x0ae9, // XK_filledtribulletdown
+ 0x25bd: 0x0ae4, // XK_opentribulletdown
+ 0x25c0: 0x0adc, // XK_filledlefttribullet
+ 0x25c1: 0x0acc, // XK_leftopentriangle
+ 0x25c6: 0x09e0, // XK_soliddiamond
+ 0x25cb: 0x0ace, // XK_emopencircle
+ 0x25cf: 0x0ade, // XK_emfilledcircle
+ 0x25e6: 0x0ae0, // XK_enopencircbullet
+ 0x2606: 0x0ae5, // XK_openstar
+ 0x260e: 0x0af9, // XK_telephone
+ 0x2613: 0x0aca, // XK_signaturemark
+ 0x261c: 0x0aea, // XK_leftpointer
+ 0x261e: 0x0aeb, // XK_rightpointer
+ 0x2640: 0x0af8, // XK_femalesymbol
+ 0x2642: 0x0af7, // XK_malesymbol
+ 0x2663: 0x0aec, // XK_club
+ 0x2665: 0x0aee, // XK_heart
+ 0x2666: 0x0aed, // XK_diamond
+ 0x266d: 0x0af6, // XK_musicalflat
+ 0x266f: 0x0af5, // XK_musicalsharp
+ 0x2713: 0x0af3, // XK_checkmark
+ 0x2717: 0x0af4, // XK_ballotcross
+ 0x271d: 0x0ad9, // XK_latincross
+ 0x2720: 0x0af0, // XK_maltesecross
+ 0x27e8: 0x0abc, // XK_leftanglebracket
+ 0x27e9: 0x0abe, // XK_rightanglebracket
+ 0x3001: 0x04a4, // XK_kana_comma
+ 0x3002: 0x04a1, // XK_kana_fullstop
+ 0x300c: 0x04a2, // XK_kana_openingbracket
+ 0x300d: 0x04a3, // XK_kana_closingbracket
+ 0x309b: 0x04de, // XK_voicedsound
+ 0x309c: 0x04df, // XK_semivoicedsound
+ 0x30a1: 0x04a7, // XK_kana_a
+ 0x30a2: 0x04b1, // XK_kana_A
+ 0x30a3: 0x04a8, // XK_kana_i
+ 0x30a4: 0x04b2, // XK_kana_I
+ 0x30a5: 0x04a9, // XK_kana_u
+ 0x30a6: 0x04b3, // XK_kana_U
+ 0x30a7: 0x04aa, // XK_kana_e
+ 0x30a8: 0x04b4, // XK_kana_E
+ 0x30a9: 0x04ab, // XK_kana_o
+ 0x30aa: 0x04b5, // XK_kana_O
+ 0x30ab: 0x04b6, // XK_kana_KA
+ 0x30ad: 0x04b7, // XK_kana_KI
+ 0x30af: 0x04b8, // XK_kana_KU
+ 0x30b1: 0x04b9, // XK_kana_KE
+ 0x30b3: 0x04ba, // XK_kana_KO
+ 0x30b5: 0x04bb, // XK_kana_SA
+ 0x30b7: 0x04bc, // XK_kana_SHI
+ 0x30b9: 0x04bd, // XK_kana_SU
+ 0x30bb: 0x04be, // XK_kana_SE
+ 0x30bd: 0x04bf, // XK_kana_SO
+ 0x30bf: 0x04c0, // XK_kana_TA
+ 0x30c1: 0x04c1, // XK_kana_CHI
+ 0x30c3: 0x04af, // XK_kana_tsu
+ 0x30c4: 0x04c2, // XK_kana_TSU
+ 0x30c6: 0x04c3, // XK_kana_TE
+ 0x30c8: 0x04c4, // XK_kana_TO
+ 0x30ca: 0x04c5, // XK_kana_NA
+ 0x30cb: 0x04c6, // XK_kana_NI
+ 0x30cc: 0x04c7, // XK_kana_NU
+ 0x30cd: 0x04c8, // XK_kana_NE
+ 0x30ce: 0x04c9, // XK_kana_NO
+ 0x30cf: 0x04ca, // XK_kana_HA
+ 0x30d2: 0x04cb, // XK_kana_HI
+ 0x30d5: 0x04cc, // XK_kana_FU
+ 0x30d8: 0x04cd, // XK_kana_HE
+ 0x30db: 0x04ce, // XK_kana_HO
+ 0x30de: 0x04cf, // XK_kana_MA
+ 0x30df: 0x04d0, // XK_kana_MI
+ 0x30e0: 0x04d1, // XK_kana_MU
+ 0x30e1: 0x04d2, // XK_kana_ME
+ 0x30e2: 0x04d3, // XK_kana_MO
+ 0x30e3: 0x04ac, // XK_kana_ya
+ 0x30e4: 0x04d4, // XK_kana_YA
+ 0x30e5: 0x04ad, // XK_kana_yu
+ 0x30e6: 0x04d5, // XK_kana_YU
+ 0x30e7: 0x04ae, // XK_kana_yo
+ 0x30e8: 0x04d6, // XK_kana_YO
+ 0x30e9: 0x04d7, // XK_kana_RA
+ 0x30ea: 0x04d8, // XK_kana_RI
+ 0x30eb: 0x04d9, // XK_kana_RU
+ 0x30ec: 0x04da, // XK_kana_RE
+ 0x30ed: 0x04db, // XK_kana_RO
+ 0x30ef: 0x04dc, // XK_kana_WA
+ 0x30f2: 0x04a6, // XK_kana_WO
+ 0x30f3: 0x04dd, // XK_kana_N
+ 0x30fb: 0x04a5, // XK_kana_conjunctive
+ 0x30fc: 0x04b0, // XK_prolongedsound
+};
+
+export default {
+ lookup : function(u) {
+ // Latin-1 is one-to-one mapping
+ if ((u >= 0x20) && (u <= 0xff)) {
+ return u;
+ }
+
+ // Lookup table (fairly random)
+ var keysym = codepoints[u];
+ if (keysym !== undefined) {
+ return keysym;
+ }
+
+ // General mapping as final fallback
+ return 0x01000000 | u;
+ },
+};
diff --git a/webclients/novnc/core/input/mouse.js b/webclients/novnc/core/input/mouse.js
new file mode 100644
index 0000000..524b065
--- /dev/null
+++ b/webclients/novnc/core/input/mouse.js
@@ -0,0 +1,280 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2012 Joel Martin
+ * Copyright (C) 2013 Samuel Mannehed for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+import * as Log from '../util/logging.js';
+import { isTouchDevice } from '../util/browser.js';
+import { setCapture, stopEvent, getPointerEvent } from '../util/events.js';
+
+var WHEEL_STEP = 10; // Delta threshold for a mouse wheel step
+var WHEEL_STEP_TIMEOUT = 50; // ms
+var WHEEL_LINE_HEIGHT = 19;
+
+export default function Mouse(target) {
+ this._target = target || document;
+
+ this._doubleClickTimer = null;
+ this._lastTouchPos = null;
+
+ this._pos = null;
+ this._wheelStepXTimer = null;
+ this._wheelStepYTimer = null;
+ this._accumulatedWheelDeltaX = 0;
+ this._accumulatedWheelDeltaY = 0;
+
+ this._eventHandlers = {
+ 'mousedown': this._handleMouseDown.bind(this),
+ 'mouseup': this._handleMouseUp.bind(this),
+ 'mousemove': this._handleMouseMove.bind(this),
+ 'mousewheel': this._handleMouseWheel.bind(this),
+ 'mousedisable': this._handleMouseDisable.bind(this)
+ };
+};
+
+Mouse.prototype = {
+ // ===== PROPERTIES =====
+
+ touchButton: 1, // Button mask (1, 2, 4) for touch devices (0 means ignore clicks)
+
+ // ===== EVENT HANDLERS =====
+
+ onmousebutton: function () {}, // Handler for mouse button click/release
+ onmousemove: function () {}, // Handler for mouse movement
+
+ // ===== PRIVATE METHODS =====
+
+ _resetDoubleClickTimer: function () {
+ this._doubleClickTimer = null;
+ },
+
+ _handleMouseButton: function (e, down) {
+ this._updateMousePosition(e);
+ var pos = this._pos;
+
+ var bmask;
+ if (e.touches || e.changedTouches) {
+ // Touch device
+
+ // When two touches occur within 500 ms of each other and are
+ // close enough together a double click is triggered.
+ if (down == 1) {
+ if (this._doubleClickTimer === null) {
+ this._lastTouchPos = pos;
+ } else {
+ clearTimeout(this._doubleClickTimer);
+
+ // When the distance between the two touches is small enough
+ // force the position of the latter touch to the position of
+ // the first.
+
+ var xs = this._lastTouchPos.x - pos.x;
+ var ys = this._lastTouchPos.y - pos.y;
+ var d = Math.sqrt((xs * xs) + (ys * ys));
+
+ // The goal is to trigger on a certain physical width, the
+ // devicePixelRatio brings us a bit closer but is not optimal.
+ var threshold = 20 * (window.devicePixelRatio || 1);
+ if (d < threshold) {
+ pos = this._lastTouchPos;
+ }
+ }
+ this._doubleClickTimer = setTimeout(this._resetDoubleClickTimer.bind(this), 500);
+ }
+ bmask = this.touchButton;
+ // If bmask is set
+ } else if (e.which) {
+ /* everything except IE */
+ bmask = 1 << e.button;
+ } else {
+ /* IE including 9 */
+ bmask = (e.button & 0x1) + // Left
+ (e.button & 0x2) * 2 + // Right
+ (e.button & 0x4) / 2; // Middle
+ }
+
+ Log.Debug("onmousebutton " + (down ? "down" : "up") +
+ ", x: " + pos.x + ", y: " + pos.y + ", bmask: " + bmask);
+ this.onmousebutton(pos.x, pos.y, down, bmask);
+
+ stopEvent(e);
+ },
+
+ _handleMouseDown: function (e) {
+ // Touch events have implicit capture
+ if (e.type === "mousedown") {
+ setCapture(this._target);
+ }
+
+ this._handleMouseButton(e, 1);
+ },
+
+ _handleMouseUp: function (e) {
+ this._handleMouseButton(e, 0);
+ },
+
+ // Mouse wheel events are sent in steps over VNC. This means that the VNC
+ // protocol can't handle a wheel event with specific distance or speed.
+ // Therefor, if we get a lot of small mouse wheel events we combine them.
+ _generateWheelStepX: function () {
+
+ if (this._accumulatedWheelDeltaX < 0) {
+ this.onmousebutton(this._pos.x, this._pos.y, 1, 1 << 5);
+ this.onmousebutton(this._pos.x, this._pos.y, 0, 1 << 5);
+ } else if (this._accumulatedWheelDeltaX > 0) {
+ this.onmousebutton(this._pos.x, this._pos.y, 1, 1 << 6);
+ this.onmousebutton(this._pos.x, this._pos.y, 0, 1 << 6);
+ }
+
+ this._accumulatedWheelDeltaX = 0;
+ },
+
+ _generateWheelStepY: function () {
+
+ if (this._accumulatedWheelDeltaY < 0) {
+ this.onmousebutton(this._pos.x, this._pos.y, 1, 1 << 3);
+ this.onmousebutton(this._pos.x, this._pos.y, 0, 1 << 3);
+ } else if (this._accumulatedWheelDeltaY > 0) {
+ this.onmousebutton(this._pos.x, this._pos.y, 1, 1 << 4);
+ this.onmousebutton(this._pos.x, this._pos.y, 0, 1 << 4);
+ }
+
+ this._accumulatedWheelDeltaY = 0;
+ },
+
+ _resetWheelStepTimers: function () {
+ window.clearTimeout(this._wheelStepXTimer);
+ window.clearTimeout(this._wheelStepYTimer);
+ this._wheelStepXTimer = null;
+ this._wheelStepYTimer = null;
+ },
+
+ _handleMouseWheel: function (e) {
+ this._resetWheelStepTimers();
+
+ this._updateMousePosition(e);
+
+ var dX = e.deltaX;
+ var dY = e.deltaY;
+
+ // Pixel units unless it's non-zero.
+ // Note that if deltamode is line or page won't matter since we aren't
+ // sending the mouse wheel delta to the server anyway.
+ // The difference between pixel and line can be important however since
+ // we have a threshold that can be smaller than the line height.
+ if (e.deltaMode !== 0) {
+ dX *= WHEEL_LINE_HEIGHT;
+ dY *= WHEEL_LINE_HEIGHT;
+ }
+
+ this._accumulatedWheelDeltaX += dX;
+ this._accumulatedWheelDeltaY += dY;
+
+ // Generate a mouse wheel step event when the accumulated delta
+ // for one of the axes is large enough.
+ // Small delta events that do not pass the threshold get sent
+ // after a timeout.
+ if (Math.abs(this._accumulatedWheelDeltaX) > WHEEL_STEP) {
+ this._generateWheelStepX();
+ } else {
+ this._wheelStepXTimer =
+ window.setTimeout(this._generateWheelStepX.bind(this),
+ WHEEL_STEP_TIMEOUT);
+ }
+ if (Math.abs(this._accumulatedWheelDeltaY) > WHEEL_STEP) {
+ this._generateWheelStepY();
+ } else {
+ this._wheelStepYTimer =
+ window.setTimeout(this._generateWheelStepY.bind(this),
+ WHEEL_STEP_TIMEOUT);
+ }
+
+ stopEvent(e);
+ },
+
+ _handleMouseMove: function (e) {
+ this._updateMousePosition(e);
+ this.onmousemove(this._pos.x, this._pos.y);
+ stopEvent(e);
+ },
+
+ _handleMouseDisable: function (e) {
+ /*
+ * Stop propagation if inside canvas area
+ * Note: This is only needed for the 'click' event as it fails
+ * to fire properly for the target element so we have
+ * to listen on the document element instead.
+ */
+ if (e.target == this._target) {
+ stopEvent(e);
+ }
+ },
+
+ // Update coordinates relative to target
+ _updateMousePosition: function(e) {
+ e = getPointerEvent(e);
+ var bounds = this._target.getBoundingClientRect();
+ var x, y;
+ // Clip to target bounds
+ if (e.clientX < bounds.left) {
+ x = 0;
+ } else if (e.clientX >= bounds.right) {
+ x = bounds.width - 1;
+ } else {
+ x = e.clientX - bounds.left;
+ }
+ if (e.clientY < bounds.top) {
+ y = 0;
+ } else if (e.clientY >= bounds.bottom) {
+ y = bounds.height - 1;
+ } else {
+ y = e.clientY - bounds.top;
+ }
+ this._pos = {x:x, y:y};
+ },
+
+ // ===== PUBLIC METHODS =====
+
+ grab: function () {
+ var c = this._target;
+
+ if (isTouchDevice) {
+ c.addEventListener('touchstart', this._eventHandlers.mousedown);
+ c.addEventListener('touchend', this._eventHandlers.mouseup);
+ c.addEventListener('touchmove', this._eventHandlers.mousemove);
+ }
+ c.addEventListener('mousedown', this._eventHandlers.mousedown);
+ c.addEventListener('mouseup', this._eventHandlers.mouseup);
+ c.addEventListener('mousemove', this._eventHandlers.mousemove);
+ c.addEventListener('wheel', this._eventHandlers.mousewheel);
+
+ /* Prevent middle-click pasting (see above for why we bind to document) */
+ document.addEventListener('click', this._eventHandlers.mousedisable);
+
+ /* preventDefault() on mousedown doesn't stop this event for some
+ reason so we have to explicitly block it */
+ c.addEventListener('contextmenu', this._eventHandlers.mousedisable);
+ },
+
+ ungrab: function () {
+ var c = this._target;
+
+ this._resetWheelStepTimers();
+
+ if (isTouchDevice) {
+ c.removeEventListener('touchstart', this._eventHandlers.mousedown);
+ c.removeEventListener('touchend', this._eventHandlers.mouseup);
+ c.removeEventListener('touchmove', this._eventHandlers.mousemove);
+ }
+ c.removeEventListener('mousedown', this._eventHandlers.mousedown);
+ c.removeEventListener('mouseup', this._eventHandlers.mouseup);
+ c.removeEventListener('mousemove', this._eventHandlers.mousemove);
+ c.removeEventListener('wheel', this._eventHandlers.mousewheel);
+
+ document.removeEventListener('click', this._eventHandlers.mousedisable);
+
+ c.removeEventListener('contextmenu', this._eventHandlers.mousedisable);
+ }
+};
diff --git a/webclients/novnc/core/input/util.js b/webclients/novnc/core/input/util.js
new file mode 100644
index 0000000..96a5a23
--- /dev/null
+++ b/webclients/novnc/core/input/util.js
@@ -0,0 +1,167 @@
+import KeyTable from "./keysym.js";
+import keysyms from "./keysymdef.js";
+import vkeys from "./vkeys.js";
+import fixedkeys from "./fixedkeys.js";
+import DOMKeyTable from "./domkeytable.js";
+import * as browser from "../util/browser.js";
+
+// Get 'KeyboardEvent.code', handling legacy browsers
+export function getKeycode(evt){
+ // Are we getting proper key identifiers?
+ // (unfortunately Firefox and Chrome are crappy here and gives
+ // us an empty string on some platforms, rather than leaving it
+ // undefined)
+ if (evt.code) {
+ // Mozilla isn't fully in sync with the spec yet
+ switch (evt.code) {
+ case 'OSLeft': return 'MetaLeft';
+ case 'OSRight': return 'MetaRight';
+ }
+
+ return evt.code;
+ }
+
+ // The de-facto standard is to use Windows Virtual-Key codes
+ // in the 'keyCode' field for non-printable characters. However
+ // Webkit sets it to the same as charCode in 'keypress' events.
+ if ((evt.type !== 'keypress') && (evt.keyCode in vkeys)) {
+ var code = vkeys[evt.keyCode];
+
+ // macOS has messed up this code for some reason
+ if (browser.isMac() && (code === 'ContextMenu')) {
+ code = 'MetaRight';
+ }
+
+ // The keyCode doesn't distinguish between left and right
+ // for the standard modifiers
+ if (evt.location === 2) {
+ switch (code) {
+ case 'ShiftLeft': return 'ShiftRight';
+ case 'ControlLeft': return 'ControlRight';
+ case 'AltLeft': return 'AltRight';
+ }
+ }
+
+ // Nor a bunch of the numpad keys
+ if (evt.location === 3) {
+ switch (code) {
+ case 'Delete': return 'NumpadDecimal';
+ case 'Insert': return 'Numpad0';
+ case 'End': return 'Numpad1';
+ case 'ArrowDown': return 'Numpad2';
+ case 'PageDown': return 'Numpad3';
+ case 'ArrowLeft': return 'Numpad4';
+ case 'ArrowRight': return 'Numpad6';
+ case 'Home': return 'Numpad7';
+ case 'ArrowUp': return 'Numpad8';
+ case 'PageUp': return 'Numpad9';
+ case 'Enter': return 'NumpadEnter';
+ }
+ }
+
+ return code;
+ }
+
+ return 'Unidentified';
+}
+
+// Get 'KeyboardEvent.key', handling legacy browsers
+export function getKey(evt) {
+ // Are we getting a proper key value?
+ if (evt.key !== undefined) {
+ // IE and Edge use some ancient version of the spec
+ // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8860571/
+ switch (evt.key) {
+ case 'Spacebar': return ' ';
+ case 'Esc': return 'Escape';
+ case 'Scroll': return 'ScrollLock';
+ case 'Win': return 'Meta';
+ case 'Apps': return 'ContextMenu';
+ case 'Up': return 'ArrowUp';
+ case 'Left': return 'ArrowLeft';
+ case 'Right': return 'ArrowRight';
+ case 'Down': return 'ArrowDown';
+ case 'Del': return 'Delete';
+ case 'Divide': return '/';
+ case 'Multiply': return '*';
+ case 'Subtract': return '-';
+ case 'Add': return '+';
+ case 'Decimal': return evt.char;
+ }
+
+ // Mozilla isn't fully in sync with the spec yet
+ switch (evt.key) {
+ case 'OS': return 'Meta';
+ }
+
+ // iOS leaks some OS names
+ switch (evt.key) {
+ case 'UIKeyInputUpArrow': return 'ArrowUp';
+ case 'UIKeyInputDownArrow': return 'ArrowDown';
+ case 'UIKeyInputLeftArrow': return 'ArrowLeft';
+ case 'UIKeyInputRightArrow': return 'ArrowRight';
+ case 'UIKeyInputEscape': return 'Escape';
+ }
+
+ // IE and Edge have broken handling of AltGraph so we cannot
+ // trust them for printable characters
+ if ((evt.key.length !== 1) || (!browser.isIE() && !browser.isEdge())) {
+ return evt.key;
+ }
+ }
+
+ // Try to deduce it based on the physical key
+ var code = getKeycode(evt);
+ if (code in fixedkeys) {
+ return fixedkeys[code];
+ }
+
+ // If that failed, then see if we have a printable character
+ if (evt.charCode) {
+ return String.fromCharCode(evt.charCode);
+ }
+
+ // At this point we have nothing left to go on
+ return 'Unidentified';
+}
+
+// Get the most reliable keysym value we can get from a key event
+export function getKeysym(evt){
+ var key = getKey(evt);
+
+ if (key === 'Unidentified') {
+ return null;
+ }
+
+ // First look up special keys
+ if (key in DOMKeyTable) {
+ var location = evt.location;
+
+ // Safari screws up location for the right cmd key
+ if ((key === 'Meta') && (location === 0)) {
+ location = 2;
+ }
+
+ if ((location === undefined) || (location > 3)) {
+ location = 0;
+ }
+
+ return DOMKeyTable[key][location];
+ }
+
+ // Now we need to look at the Unicode symbol instead
+
+ var codepoint;
+
+ // Special key? (FIXME: Should have been caught earlier)
+ if (key.length !== 1) {
+ return null;
+ }
+
+ codepoint = key.charCodeAt();
+ if (codepoint) {
+ return keysyms.lookup(codepoint);
+ }
+
+ return null;
+}
diff --git a/webclients/novnc/core/input/vkeys.js b/webclients/novnc/core/input/vkeys.js
new file mode 100644
index 0000000..dc784ff
--- /dev/null
+++ b/webclients/novnc/core/input/vkeys.js
@@ -0,0 +1,116 @@
+/*
+ * noVNC: HTML5 VNC client
+ * Copyright (C) 2017 Pierre Ossman for Cendio AB
+ * Licensed under MPL 2.0 or any later version (see LICENSE.txt)
+ */
+
+/*
+ * Mapping between Microsoft® Windows® Virtual-Key codes and
+ * HTML key codes.
+ */
+
+export default {
+ 0x08: 'Backspace',
+ 0x09: 'Tab',
+ 0x0a: 'NumpadClear',
+ 0x0d: 'Enter',
+ 0x10: 'ShiftLeft',
+ 0x11: 'ControlLeft',
+ 0x12: 'AltLeft',
+ 0x13: 'Pause',
+ 0x14: 'CapsLock',
+ 0x15: 'Lang1',
+ 0x19: 'Lang2',
+ 0x1b: 'Escape',
+ 0x1c: 'Convert',
+ 0x1d: 'NonConvert',
+ 0x20: 'Space',
+ 0x21: 'PageUp',
+ 0x22: 'PageDown',
+ 0x23: 'End',
+ 0x24: 'Home',
+ 0x25: 'ArrowLeft',
+ 0x26: 'ArrowUp',
+ 0x27: 'ArrowRight',
+ 0x28: 'ArrowDown',
+ 0x29: 'Select',
+ 0x2c: 'PrintScreen',
+ 0x2d: 'Insert',
+ 0x2e: 'Delete',
+ 0x2f: 'Help',
+ 0x30: 'Digit0',
+ 0x31: 'Digit1',
+ 0x32: 'Digit2',
+ 0x33: 'Digit3',
+ 0x34: 'Digit4',
+ 0x35: 'Digit5',
+ 0x36: 'Digit6',
+ 0x37: 'Digit7',
+ 0x38: 'Digit8',
+ 0x39: 'Digit9',
+ 0x5b: 'MetaLeft',
+ 0x5c: 'MetaRight',
+ 0x5d: 'ContextMenu',
+ 0x5f: 'Sleep',
+ 0x60: 'Numpad0',
+ 0x61: 'Numpad1',
+ 0x62: 'Numpad2',
+ 0x63: 'Numpad3',
+ 0x64: 'Numpad4',
+ 0x65: 'Numpad5',
+ 0x66: 'Numpad6',
+ 0x67: 'Numpad7',
+ 0x68: 'Numpad8',
+ 0x69: 'Numpad9',
+ 0x6a: 'NumpadMultiply',
+ 0x6b: 'NumpadAdd',
+ 0x6c: 'NumpadDecimal',
+ 0x6d: 'NumpadSubtract',
+ 0x6e: 'NumpadDecimal', // Duplicate, because buggy on Windows
+ 0x6f: 'NumpadDivide',
+ 0x70: 'F1',
+ 0x71: 'F2',
+ 0x72: 'F3',
+ 0x73: 'F4',
+ 0x74: 'F5',
+ 0x75: 'F6',
+ 0x76: 'F7',
+ 0x77: 'F8',
+ 0x78: 'F9',
+ 0x79: 'F10',
+ 0x7a: 'F11',
+ 0x7b: 'F12',
+ 0x7c: 'F13',
+ 0x7d: 'F14',
+ 0x7e: 'F15',
+ 0x7f: 'F16',
+ 0x80: 'F17',
+ 0x81: 'F18',
+ 0x82: 'F19',
+ 0x83: 'F20',
+ 0x84: 'F21',
+ 0x85: 'F22',
+ 0x86: 'F23',
+ 0x87: 'F24',
+ 0x90: 'NumLock',
+ 0x91: 'ScrollLock',
+ 0xa6: 'BrowserBack',
+ 0xa7: 'BrowserForward',
+ 0xa8: 'BrowserRefresh',
+ 0xa9: 'BrowserStop',
+ 0xaa: 'BrowserSearch',
+ 0xab: 'BrowserFavorites',
+ 0xac: 'BrowserHome',
+ 0xad: 'AudioVolumeMute',
+ 0xae: 'AudioVolumeDown',
+ 0xaf: 'AudioVolumeUp',
+ 0xb0: 'MediaTrackNext',
+ 0xb1: 'MediaTrackPrevious',
+ 0xb2: 'MediaStop',
+ 0xb3: 'MediaPlayPause',
+ 0xb4: 'LaunchMail',
+ 0xb5: 'MediaSelect',
+ 0xb6: 'LaunchApp1',
+ 0xb7: 'LaunchApp2',
+ 0xe1: 'AltRight', // Only when it is AltGraph
+};
diff --git a/webclients/novnc/core/input/xtscancodes.js b/webclients/novnc/core/input/xtscancodes.js
new file mode 100644
index 0000000..514809c
--- /dev/null
+++ b/webclients/novnc/core/input/xtscancodes.js
@@ -0,0 +1,171 @@
+/*
+ * This file is auto-generated from keymaps.csv on 2017-05-31 16:20
+ * Database checksum sha256(92fd165507f2a3b8c5b3fa56e425d45788dbcb98cf067a307527d91ce22cab94)
+ * To re-generate, run:
+ * keymap-gen --lang=js code-map keymaps.csv html atset1
+*/
+export default {
+ "Again": 0xe005, /* html:Again (Again) -> linux:129 (KEY_AGAIN) -> atset1:57349 */
+ "AltLeft": 0x38, /* html:AltLeft (AltLeft) -> linux:56 (KEY_LEFTALT) -> atset1:56 */
+ "AltRight": 0xe038, /* html:AltRight (AltRight) -> linux:100 (KEY_RIGHTALT) -> atset1:57400 */
+ "ArrowDown": 0xe050, /* html:ArrowDown (ArrowDown) -> linux:108 (KEY_DOWN) -> atset1:57424 */
+ "ArrowLeft": 0xe04b, /* html:ArrowLeft (ArrowLeft) -> linux:105 (KEY_LEFT) -> atset1:57419 */
+ "ArrowRight": 0xe04d, /* html:ArrowRight (ArrowRight) -> linux:106 (KEY_RIGHT) -> atset1:57421 */
+ "ArrowUp": 0xe048, /* html:ArrowUp (ArrowUp) -> linux:103 (KEY_UP) -> atset1:57416 */
+ "AudioVolumeDown": 0xe02e, /* html:AudioVolumeDown (AudioVolumeDown) -> linux:114 (KEY_VOLUMEDOWN) -> atset1:57390 */
+ "AudioVolumeMute": 0xe020, /* html:AudioVolumeMute (AudioVolumeMute) -> linux:113 (KEY_MUTE) -> atset1:57376 */
+ "AudioVolumeUp": 0xe030, /* html:AudioVolumeUp (AudioVolumeUp) -> linux:115 (KEY_VOLUMEUP) -> atset1:57392 */
+ "Backquote": 0x29, /* html:Backquote (Backquote) -> linux:41 (KEY_GRAVE) -> atset1:41 */
+ "Backslash": 0x2b, /* html:Backslash (Backslash) -> linux:43 (KEY_BACKSLASH) -> atset1:43 */
+ "Backspace": 0xe, /* html:Backspace (Backspace) -> linux:14 (KEY_BACKSPACE) -> atset1:14 */
+ "BracketLeft": 0x1a, /* html:BracketLeft (BracketLeft) -> linux:26 (KEY_LEFTBRACE) -> atset1:26 */
+ "BracketRight": 0x1b, /* html:BracketRight (BracketRight) -> linux:27 (KEY_RIGHTBRACE) -> atset1:27 */
+ "BrowserBack": 0xe06a, /* html:BrowserBack (BrowserBack) -> linux:158 (KEY_BACK) -> atset1:57450 */
+ "BrowserFavorites": 0xe066, /* html:BrowserFavorites (BrowserFavorites) -> linux:156 (KEY_BOOKMARKS) -> atset1:57446 */
+ "BrowserForward": 0xe069, /* html:BrowserForward (BrowserForward) -> linux:159 (KEY_FORWARD) -> atset1:57449 */
+ "BrowserHome": 0xe032, /* html:BrowserHome (BrowserHome) -> linux:172 (KEY_HOMEPAGE) -> atset1:57394 */
+ "BrowserRefresh": 0xe067, /* html:BrowserRefresh (BrowserRefresh) -> linux:173 (KEY_REFRESH) -> atset1:57447 */
+ "BrowserSearch": 0xe065, /* html:BrowserSearch (BrowserSearch) -> linux:217 (KEY_SEARCH) -> atset1:57445 */
+ "BrowserStop": 0xe068, /* html:BrowserStop (BrowserStop) -> linux:128 (KEY_STOP) -> atset1:57448 */
+ "CapsLock": 0x3a, /* html:CapsLock (CapsLock) -> linux:58 (KEY_CAPSLOCK) -> atset1:58 */
+ "Comma": 0x33, /* html:Comma (Comma) -> linux:51 (KEY_COMMA) -> atset1:51 */
+ "ContextMenu": 0xe05d, /* html:ContextMenu (ContextMenu) -> linux:127 (KEY_COMPOSE) -> atset1:57437 */
+ "ControlLeft": 0x1d, /* html:ControlLeft (ControlLeft) -> linux:29 (KEY_LEFTCTRL) -> atset1:29 */
+ "ControlRight": 0xe01d, /* html:ControlRight (ControlRight) -> linux:97 (KEY_RIGHTCTRL) -> atset1:57373 */
+ "Convert": 0x79, /* html:Convert (Convert) -> linux:92 (KEY_HENKAN) -> atset1:121 */
+ "Copy": 0xe078, /* html:Copy (Copy) -> linux:133 (KEY_COPY) -> atset1:57464 */
+ "Cut": 0xe03c, /* html:Cut (Cut) -> linux:137 (KEY_CUT) -> atset1:57404 */
+ "Delete": 0xe053, /* html:Delete (Delete) -> linux:111 (KEY_DELETE) -> atset1:57427 */
+ "Digit0": 0xb, /* html:Digit0 (Digit0) -> linux:11 (KEY_0) -> atset1:11 */
+ "Digit1": 0x2, /* html:Digit1 (Digit1) -> linux:2 (KEY_1) -> atset1:2 */
+ "Digit2": 0x3, /* html:Digit2 (Digit2) -> linux:3 (KEY_2) -> atset1:3 */
+ "Digit3": 0x4, /* html:Digit3 (Digit3) -> linux:4 (KEY_3) -> atset1:4 */
+ "Digit4": 0x5, /* html:Digit4 (Digit4) -> linux:5 (KEY_4) -> atset1:5 */
+ "Digit5": 0x6, /* html:Digit5 (Digit5) -> linux:6 (KEY_5) -> atset1:6 */
+ "Digit6": 0x7, /* html:Digit6 (Digit6) -> linux:7 (KEY_6) -> atset1:7 */
+ "Digit7": 0x8, /* html:Digit7 (Digit7) -> linux:8 (KEY_7) -> atset1:8 */
+ "Digit8": 0x9, /* html:Digit8 (Digit8) -> linux:9 (KEY_8) -> atset1:9 */
+ "Digit9": 0xa, /* html:Digit9 (Digit9) -> linux:10 (KEY_9) -> atset1:10 */
+ "Eject": 0xe07d, /* html:Eject (Eject) -> linux:162 (KEY_EJECTCLOSECD) -> atset1:57469 */
+ "End": 0xe04f, /* html:End (End) -> linux:107 (KEY_END) -> atset1:57423 */
+ "Enter": 0x1c, /* html:Enter (Enter) -> linux:28 (KEY_ENTER) -> atset1:28 */
+ "Equal": 0xd, /* html:Equal (Equal) -> linux:13 (KEY_EQUAL) -> atset1:13 */
+ "Escape": 0x1, /* html:Escape (Escape) -> linux:1 (KEY_ESC) -> atset1:1 */
+ "F1": 0x3b, /* html:F1 (F1) -> linux:59 (KEY_F1) -> atset1:59 */
+ "F10": 0x44, /* html:F10 (F10) -> linux:68 (KEY_F10) -> atset1:68 */
+ "F11": 0x57, /* html:F11 (F11) -> linux:87 (KEY_F11) -> atset1:87 */
+ "F12": 0x58, /* html:F12 (F12) -> linux:88 (KEY_F12) -> atset1:88 */
+ "F13": 0x5d, /* html:F13 (F13) -> linux:183 (KEY_F13) -> atset1:93 */
+ "F14": 0x5e, /* html:F14 (F14) -> linux:184 (KEY_F14) -> atset1:94 */
+ "F15": 0x5f, /* html:F15 (F15) -> linux:185 (KEY_F15) -> atset1:95 */
+ "F16": 0x55, /* html:F16 (F16) -> linux:186 (KEY_F16) -> atset1:85 */
+ "F17": 0xe003, /* html:F17 (F17) -> linux:187 (KEY_F17) -> atset1:57347 */
+ "F18": 0xe077, /* html:F18 (F18) -> linux:188 (KEY_F18) -> atset1:57463 */
+ "F19": 0xe004, /* html:F19 (F19) -> linux:189 (KEY_F19) -> atset1:57348 */
+ "F2": 0x3c, /* html:F2 (F2) -> linux:60 (KEY_F2) -> atset1:60 */
+ "F20": 0x5a, /* html:F20 (F20) -> linux:190 (KEY_F20) -> atset1:90 */
+ "F21": 0x74, /* html:F21 (F21) -> linux:191 (KEY_F21) -> atset1:116 */
+ "F22": 0xe079, /* html:F22 (F22) -> linux:192 (KEY_F22) -> atset1:57465 */
+ "F23": 0x6d, /* html:F23 (F23) -> linux:193 (KEY_F23) -> atset1:109 */
+ "F24": 0x6f, /* html:F24 (F24) -> linux:194 (KEY_F24) -> atset1:111 */
+ "F3": 0x3d, /* html:F3 (F3) -> linux:61 (KEY_F3) -> atset1:61 */
+ "F4": 0x3e, /* html:F4 (F4) -> linux:62 (KEY_F4) -> atset1:62 */
+ "F5": 0x3f, /* html:F5 (F5) -> linux:63 (KEY_F5) -> atset1:63 */
+ "F6": 0x40, /* html:F6 (F6) -> linux:64 (KEY_F6) -> atset1:64 */
+ "F7": 0x41, /* html:F7 (F7) -> linux:65 (KEY_F7) -> atset1:65 */
+ "F8": 0x42, /* html:F8 (F8) -> linux:66 (KEY_F8) -> atset1:66 */
+ "F9": 0x43, /* html:F9 (F9) -> linux:67 (KEY_F9) -> atset1:67 */
+ "Find": 0xe041, /* html:Find (Find) -> linux:136 (KEY_FIND) -> atset1:57409 */
+ "Help": 0xe075, /* html:Help (Help) -> linux:138 (KEY_HELP) -> atset1:57461 */
+ "Hiragana": 0x77, /* html:Hiragana (Lang4) -> linux:91 (KEY_HIRAGANA) -> atset1:119 */
+ "Home": 0xe047, /* html:Home (Home) -> linux:102 (KEY_HOME) -> atset1:57415 */
+ "Insert": 0xe052, /* html:Insert (Insert) -> linux:110 (KEY_INSERT) -> atset1:57426 */
+ "IntlBackslash": 0x56, /* html:IntlBackslash (IntlBackslash) -> linux:86 (KEY_102ND) -> atset1:86 */
+ "IntlRo": 0x73, /* html:IntlRo (IntlRo) -> linux:89 (KEY_RO) -> atset1:115 */
+ "IntlYen": 0x7d, /* html:IntlYen (IntlYen) -> linux:124 (KEY_YEN) -> atset1:125 */
+ "KanaMode": 0x70, /* html:KanaMode (KanaMode) -> linux:93 (KEY_KATAKANAHIRAGANA) -> atset1:112 */
+ "Katakana": 0x78, /* html:Katakana (Lang3) -> linux:90 (KEY_KATAKANA) -> atset1:120 */
+ "KeyA": 0x1e, /* html:KeyA (KeyA) -> linux:30 (KEY_A) -> atset1:30 */
+ "KeyB": 0x30, /* html:KeyB (KeyB) -> linux:48 (KEY_B) -> atset1:48 */
+ "KeyC": 0x2e, /* html:KeyC (KeyC) -> linux:46 (KEY_C) -> atset1:46 */
+ "KeyD": 0x20, /* html:KeyD (KeyD) -> linux:32 (KEY_D) -> atset1:32 */
+ "KeyE": 0x12, /* html:KeyE (KeyE) -> linux:18 (KEY_E) -> atset1:18 */
+ "KeyF": 0x21, /* html:KeyF (KeyF) -> linux:33 (KEY_F) -> atset1:33 */
+ "KeyG": 0x22, /* html:KeyG (KeyG) -> linux:34 (KEY_G) -> atset1:34 */
+ "KeyH": 0x23, /* html:KeyH (KeyH) -> linux:35 (KEY_H) -> atset1:35 */
+ "KeyI": 0x17, /* html:KeyI (KeyI) -> linux:23 (KEY_I) -> atset1:23 */
+ "KeyJ": 0x24, /* html:KeyJ (KeyJ) -> linux:36 (KEY_J) -> atset1:36 */
+ "KeyK": 0x25, /* html:KeyK (KeyK) -> linux:37 (KEY_K) -> atset1:37 */
+ "KeyL": 0x26, /* html:KeyL (KeyL) -> linux:38 (KEY_L) -> atset1:38 */
+ "KeyM": 0x32, /* html:KeyM (KeyM) -> linux:50 (KEY_M) -> atset1:50 */
+ "KeyN": 0x31, /* html:KeyN (KeyN) -> linux:49 (KEY_N) -> atset1:49 */
+ "KeyO": 0x18, /* html:KeyO (KeyO) -> linux:24 (KEY_O) -> atset1:24 */
+ "KeyP": 0x19, /* html:KeyP (KeyP) -> linux:25 (KEY_P) -> atset1:25 */
+ "KeyQ": 0x10, /* html:KeyQ (KeyQ) -> linux:16 (KEY_Q) -> atset1:16 */
+ "KeyR": 0x13, /* html:KeyR (KeyR) -> linux:19 (KEY_R) -> atset1:19 */
+ "KeyS": 0x1f, /* html:KeyS (KeyS) -> linux:31 (KEY_S) -> atset1:31 */
+ "KeyT": 0x14, /* html:KeyT (KeyT) -> linux:20 (KEY_T) -> atset1:20 */
+ "KeyU": 0x16, /* html:KeyU (KeyU) -> linux:22 (KEY_U) -> atset1:22 */
+ "KeyV": 0x2f, /* html:KeyV (KeyV) -> linux:47 (KEY_V) -> atset1:47 */
+ "KeyW": 0x11, /* html:KeyW (KeyW) -> linux:17 (KEY_W) -> atset1:17 */
+ "KeyX": 0x2d, /* html:KeyX (KeyX) -> linux:45 (KEY_X) -> atset1:45 */
+ "KeyY": 0x15, /* html:KeyY (KeyY) -> linux:21 (KEY_Y) -> atset1:21 */
+ "KeyZ": 0x2c, /* html:KeyZ (KeyZ) -> linux:44 (KEY_Z) -> atset1:44 */
+ "Lang3": 0x78, /* html:Lang3 (Lang3) -> linux:90 (KEY_KATAKANA) -> atset1:120 */
+ "Lang4": 0x77, /* html:Lang4 (Lang4) -> linux:91 (KEY_HIRAGANA) -> atset1:119 */
+ "Lang5": 0x76, /* html:Lang5 (Lang5) -> linux:85 (KEY_ZENKAKUHANKAKU) -> atset1:118 */
+ "LaunchApp1": 0xe06b, /* html:LaunchApp1 (LaunchApp1) -> linux:157 (KEY_COMPUTER) -> atset1:57451 */
+ "LaunchApp2": 0xe021, /* html:LaunchApp2 (LaunchApp2) -> linux:140 (KEY_CALC) -> atset1:57377 */
+ "LaunchMail": 0xe06c, /* html:LaunchMail (LaunchMail) -> linux:155 (KEY_MAIL) -> atset1:57452 */
+ "MediaPlayPause": 0xe022, /* html:MediaPlayPause (MediaPlayPause) -> linux:164 (KEY_PLAYPAUSE) -> atset1:57378 */
+ "MediaSelect": 0xe06d, /* html:MediaSelect (MediaSelect) -> linux:226 (KEY_MEDIA) -> atset1:57453 */
+ "MediaStop": 0xe024, /* html:MediaStop (MediaStop) -> linux:166 (KEY_STOPCD) -> atset1:57380 */
+ "MediaTrackNext": 0xe019, /* html:MediaTrackNext (MediaTrackNext) -> linux:163 (KEY_NEXTSONG) -> atset1:57369 */
+ "MediaTrackPrevious": 0xe010, /* html:MediaTrackPrevious (MediaTrackPrevious) -> linux:165 (KEY_PREVIOUSSONG) -> atset1:57360 */
+ "MetaLeft": 0xe05b, /* html:MetaLeft (MetaLeft) -> linux:125 (KEY_LEFTMETA) -> atset1:57435 */
+ "MetaRight": 0xe05c, /* html:MetaRight (MetaRight) -> linux:126 (KEY_RIGHTMETA) -> atset1:57436 */
+ "Minus": 0xc, /* html:Minus (Minus) -> linux:12 (KEY_MINUS) -> atset1:12 */
+ "NonConvert": 0x7b, /* html:NonConvert (NonConvert) -> linux:94 (KEY_MUHENKAN) -> atset1:123 */
+ "NumLock": 0x45, /* html:NumLock (NumLock) -> linux:69 (KEY_NUMLOCK) -> atset1:69 */
+ "Numpad0": 0x52, /* html:Numpad0 (Numpad0) -> linux:82 (KEY_KP0) -> atset1:82 */
+ "Numpad1": 0x4f, /* html:Numpad1 (Numpad1) -> linux:79 (KEY_KP1) -> atset1:79 */
+ "Numpad2": 0x50, /* html:Numpad2 (Numpad2) -> linux:80 (KEY_KP2) -> atset1:80 */
+ "Numpad3": 0x51, /* html:Numpad3 (Numpad3) -> linux:81 (KEY_KP3) -> atset1:81 */
+ "Numpad4": 0x4b, /* html:Numpad4 (Numpad4) -> linux:75 (KEY_KP4) -> atset1:75 */
+ "Numpad5": 0x4c, /* html:Numpad5 (Numpad5) -> linux:76 (KEY_KP5) -> atset1:76 */
+ "Numpad6": 0x4d, /* html:Numpad6 (Numpad6) -> linux:77 (KEY_KP6) -> atset1:77 */
+ "Numpad7": 0x47, /* html:Numpad7 (Numpad7) -> linux:71 (KEY_KP7) -> atset1:71 */
+ "Numpad8": 0x48, /* html:Numpad8 (Numpad8) -> linux:72 (KEY_KP8) -> atset1:72 */
+ "Numpad9": 0x49, /* html:Numpad9 (Numpad9) -> linux:73 (KEY_KP9) -> atset1:73 */
+ "NumpadAdd": 0x4e, /* html:NumpadAdd (NumpadAdd) -> linux:78 (KEY_KPPLUS) -> atset1:78 */
+ "NumpadComma": 0x7e, /* html:NumpadComma (NumpadComma) -> linux:121 (KEY_KPCOMMA) -> atset1:126 */
+ "NumpadDecimal": 0x53, /* html:NumpadDecimal (NumpadDecimal) -> linux:83 (KEY_KPDOT) -> atset1:83 */
+ "NumpadDivide": 0xe035, /* html:NumpadDivide (NumpadDivide) -> linux:98 (KEY_KPSLASH) -> atset1:57397 */
+ "NumpadEnter": 0xe01c, /* html:NumpadEnter (NumpadEnter) -> linux:96 (KEY_KPENTER) -> atset1:57372 */
+ "NumpadEqual": 0x59, /* html:NumpadEqual (NumpadEqual) -> linux:117 (KEY_KPEQUAL) -> atset1:89 */
+ "NumpadMultiply": 0x37, /* html:NumpadMultiply (NumpadMultiply) -> linux:55 (KEY_KPASTERISK) -> atset1:55 */
+ "NumpadParenLeft": 0xe076, /* html:NumpadParenLeft (NumpadParenLeft) -> linux:179 (KEY_KPLEFTPAREN) -> atset1:57462 */
+ "NumpadParenRight": 0xe07b, /* html:NumpadParenRight (NumpadParenRight) -> linux:180 (KEY_KPRIGHTPAREN) -> atset1:57467 */
+ "NumpadSubtract": 0x4a, /* html:NumpadSubtract (NumpadSubtract) -> linux:74 (KEY_KPMINUS) -> atset1:74 */
+ "Open": 0x64, /* html:Open (Open) -> linux:134 (KEY_OPEN) -> atset1:100 */
+ "PageDown": 0xe051, /* html:PageDown (PageDown) -> linux:109 (KEY_PAGEDOWN) -> atset1:57425 */
+ "PageUp": 0xe049, /* html:PageUp (PageUp) -> linux:104 (KEY_PAGEUP) -> atset1:57417 */
+ "Paste": 0x65, /* html:Paste (Paste) -> linux:135 (KEY_PASTE) -> atset1:101 */
+ "Pause": 0xe046, /* html:Pause (Pause) -> linux:119 (KEY_PAUSE) -> atset1:57414 */
+ "Period": 0x34, /* html:Period (Period) -> linux:52 (KEY_DOT) -> atset1:52 */
+ "Power": 0xe05e, /* html:Power (Power) -> linux:116 (KEY_POWER) -> atset1:57438 */
+ "PrintScreen": 0x54, /* html:PrintScreen (PrintScreen) -> linux:99 (KEY_SYSRQ) -> atset1:84 */
+ "Props": 0xe006, /* html:Props (Props) -> linux:130 (KEY_PROPS) -> atset1:57350 */
+ "Quote": 0x28, /* html:Quote (Quote) -> linux:40 (KEY_APOSTROPHE) -> atset1:40 */
+ "ScrollLock": 0x46, /* html:ScrollLock (ScrollLock) -> linux:70 (KEY_SCROLLLOCK) -> atset1:70 */
+ "Semicolon": 0x27, /* html:Semicolon (Semicolon) -> linux:39 (KEY_SEMICOLON) -> atset1:39 */
+ "ShiftLeft": 0x2a, /* html:ShiftLeft (ShiftLeft) -> linux:42 (KEY_LEFTSHIFT) -> atset1:42 */
+ "ShiftRight": 0x36, /* html:ShiftRight (ShiftRight) -> linux:54 (KEY_RIGHTSHIFT) -> atset1:54 */
+ "Slash": 0x35, /* html:Slash (Slash) -> linux:53 (KEY_SLASH) -> atset1:53 */
+ "Sleep": 0xe05f, /* html:Sleep (Sleep) -> linux:142 (KEY_SLEEP) -> atset1:57439 */
+ "Space": 0x39, /* html:Space (Space) -> linux:57 (KEY_SPACE) -> atset1:57 */
+ "Suspend": 0xe025, /* html:Suspend (Suspend) -> linux:205 (KEY_SUSPEND) -> atset1:57381 */
+ "Tab": 0xf, /* html:Tab (Tab) -> linux:15 (KEY_TAB) -> atset1:15 */
+ "Undo": 0xe007, /* html:Undo (Undo) -> linux:131 (KEY_UNDO) -> atset1:57351 */
+ "WakeUp": 0xe063, /* html:WakeUp (WakeUp) -> linux:143 (KEY_WAKEUP) -> atset1:57443 */
+};
generated by cgit v1.2.3 (git 2.46.0) at 2025-11-29 05:35:24 +0000