Refactoring and implementation changes to keyboard and mouse handling
See issue #505
diff --git a/java/com/tigervnc/rfb/UnicodeToKeysym.java b/java/com/tigervnc/rfb/Keysym2ucs.java
similarity index 93%
rename from java/com/tigervnc/rfb/UnicodeToKeysym.java
rename to java/com/tigervnc/rfb/Keysym2ucs.java
index 72b8896..907f3fe 100644
--- a/java/com/tigervnc/rfb/UnicodeToKeysym.java
+++ b/java/com/tigervnc/rfb/Keysym2ucs.java
@@ -1,6 +1,4 @@
-/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
- * Copyright (C) 2013 Brian P. Hinz
- * Copyright (C) 2001 Markus G. Kuhn, University of Cambridge
+/* Copyright (C) 2017 Brian P. Hinz
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -16,14 +14,38 @@
* along with this software; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
* USA.
+ *
+ * This module converts keysym values into the corresponding ISO 10646
+ * (UCS, Unicode) values.
+ *
+ * The array keysymtab[] contains pairs of X11 keysym values for graphical
+ * characters and the corresponding Unicode value. The function
+ * keysym2ucs() maps a keysym onto a Unicode value using a binary search,
+ * therefore keysymtab[] must remain SORTED by keysym value.
+ *
+ * The keysym -> UTF-8 conversion will hopefully one day be provided
+ * by Xlib via XmbLookupString() and should ideally not have to be
+ * done in X applications. But we are not there yet.
+ *
+ * We allow to represent any UCS character in the range U-00000000 to
+ * U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff.
+ * This admittedly does not cover the entire 31-bit space of UCS, but
+ * it does cover all of the characters up to U-10FFFF, which can be
+ * represented by UTF-16, and more, and it is very unlikely that higher
+ * UCS codes will ever be assigned by ISO. So to get Unicode character
+ * U+ABCD you can directly use keysym 0x0100abcd.
+ *
+ * NOTE: The comments in the table below contain the actual character
+ * encoded in UTF-8, so for viewing and editing best use an editor in
+ * UTF-8 mode.
+ *
+ * Derived from keysym2ucs.c, originally authored by Markus G, Kuhn
+ *
*/
-//
-// Derived from keysym2ucs.c, originally authored by Markus G, Kuhn
-//
package com.tigervnc.rfb;
-public class UnicodeToKeysym {
+public class Keysym2ucs {
private static class codepair {
public codepair(int keysym_, int ucs_) {
@@ -34,6 +56,15 @@
int ucs;
}
+ private static class combiningpair {
+ public combiningpair(int spacing_, int combining_) {
+ spacing = spacing_;
+ combining = combining_;
+ }
+ int spacing;
+ int combining;
+ }
+
public static codepair[] keysymtab = {
new codepair(0x01a1, 0x0104), /* Aogonek Ą LATIN CAPITAL LETTER A WITH OGONEK */
new codepair(0x01a2, 0x02d8), /* breve ˘ BREVE */
@@ -826,6 +857,63 @@
new codepair(0xfe60, 0x0323), /* COMBINING DOT BELOW */
};
+ public static combiningpair[] combinetab = {
+ new combiningpair(0x0060, 0x0300), /* GRAVE ACCENT ` COMBINING GRAVE ACCENT */
+ new combiningpair(0x00b4, 0x0301), /* ACUTE ACCENT ´ COMBINING ACUTE ACCENT */
+ new combiningpair(0x0027, 0x0301), /* APOSTROPHE ' COMBINING ACUTE ACCENT */
+ new combiningpair(0x0384, 0x0301), /* GREEK TONOS ΄ COMBINING ACUTE ACCENT */
+ new combiningpair(0x005e, 0x0302), /* CIRCUMFLEX ACCENT ^ COMBINING CIRCUMFLEX ACCENT */
+ new combiningpair(0x007e, 0x0303), /* TILDE ~ COMBINING TILDE */
+ new combiningpair(0x00af, 0x0304), /* MACRON ¯ COMBINING MACRON */
+ new combiningpair(0x02d8, 0x0306), /* BREVE ˘ COMBINING BREVE */
+ new combiningpair(0x02d9, 0x0307), /* DOT ABOVE ˙ COMBINING DOT ABOVE */
+ new combiningpair(0x00a8, 0x0308), /* DIAERESIS ¨ COMBINING DIAERESIS */
+ new combiningpair(0x0022, 0x0308), /* QUOTATION MARK " COMBINING DIAERESIS */
+ new combiningpair(0x02da, 0x030a), /* RING ABOVE ˚ COMBINING RING ABOVE */
+ new combiningpair(0x00b0, 0x030a), /* DEGREE SIGN ° COMBINING RING ABOVE */
+ new combiningpair(0x02dd, 0x030b), /* DOUBLE ACUTE ACCENT ˝ COMBINING DOUBLE ACUTE ACCENT */
+ new combiningpair(0x02c7, 0x030c), /* CARON ˇ COMBINING CARON */
+ new combiningpair(0x00b8, 0x0327), /* CEDILLA ¸ COMBINING CEDILLA */
+ new combiningpair(0x02db, 0x0328), /* OGONEK ¸ COMBINING OGONEK */
+ new combiningpair(0x037a, 0x0345), /* GREEK YPOGEGRAMMENI ͺ COMBINING GREEK YPOGEGRAMMENI */
+ new combiningpair(0x309b, 0x3099), /* KATAKANA-HIRAGANA VOICED SOUND MARK ゛COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK */
+ new combiningpair(0x309c, 0x309a), /* KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK ゜COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */
+ new combiningpair(0x002e, 0x0323), /* FULL STOP . COMBINING DOT BELOW */
+ new combiningpair(0x0385, 0x0344), /* GREEK DIALYTIKA TONOS ΅ COMBINING GREEK DIALYTIKA TONOS */
+ };
+
+ public static int keysym2ucs(int keysym)
+ {
+ int min = 0;
+ int max = keysymtab.length - 1;
+ int mid;
+
+ /* first check for Latin-1 characters (1:1 mapping) */
+ if ((keysym >= 0x0020 && keysym <= 0x007e) ||
+ (keysym >= 0x00a0 && keysym <= 0x00ff))
+ return keysym;
+
+ /* also check for directly encoded 24-bit UCS characters */
+ if ((keysym & 0xff000000) == 0x01000000)
+ return keysym & 0x00ffffff;
+
+ /* binary search in table */
+ while (max >= min) {
+ mid = (min + max) / 2;
+ if (keysymtab[mid].keysym < keysym)
+ min = mid + 1;
+ else if (keysymtab[mid].keysym > keysym)
+ max = mid - 1;
+ else {
+ /* found it */
+ return keysymtab[mid].ucs;
+ }
+ }
+
+ /* no matching Unicode value found */
+ return -1;
+ }
+
public static int ucs2keysym(int ucs) {
int cur = 0;
int max = keysymtab.length - 1;
@@ -847,6 +935,24 @@
return ucs | 0x01000000;
/* no matching Unicode value found */
- return 0xffffff;
+ return NoSymbol;
}
+
+ public static int ucs2combining(int spacing)
+ {
+ int cur = 0;
+ int max = combinetab.length - 1;
+
+ /* linear search in table */
+ while (cur <= max) {
+ if (combinetab[cur].spacing == spacing)
+ return combinetab[cur].combining;
+ cur++;
+ }
+
+ /* no matching Unicode value found */
+ return -1;
+ }
+
+ private static final int NoSymbol = 0;
}
diff --git a/java/com/tigervnc/rfb/Keysymdef.java b/java/com/tigervnc/rfb/Keysymdef.java
new file mode 100644
index 0000000..164e791
--- /dev/null
+++ b/java/com/tigervnc/rfb/Keysymdef.java
@@ -0,0 +1,1526 @@
+/* Copyright (C) 2017 Brian P. Hinz
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+package com.tigervnc.rfb;
+
+public class Keysymdef {
+
+ public static final int XK_VoidSymbol = 0xFFFFFF; /* void symbol */
+
+ /*
+ * TTY Functions, cleverly chosen to map to ascii, for convenience of
+ * programming, but could have been arbitrary (at the cost of lookup
+ * tables in client code.
+ */
+
+ public static final int XK_BackSpace = 0xFF08; /* back space, back char */
+ public static final int XK_Tab = 0xFF09;
+ public static final int XK_Linefeed = 0xFF0A; /* Linefeed, LF */
+ public static final int XK_Clear = 0xFF0B;
+ public static final int XK_Return = 0xFF0D; /* Return, enter */
+ public static final int XK_Pause = 0xFF13; /* Pause, hold */
+ public static final int XK_Scroll_Lock = 0xFF14;
+ public static final int XK_Sys_Req = 0xFF15;
+ public static final int XK_Escape = 0xFF1B;
+ public static final int XK_Delete = 0xFFFF; /* Delete, rubout */
+
+ /* International & multi-key character composition */
+
+ public static final int XK_Multi_key = 0xFF20; /* Multi-key character compose */
+ public static final int XK_Codeinput = 0xFF37;
+ public static final int XK_SingleCandidate = 0xFF3C;
+ public static final int XK_MultipleCandidate = 0xFF3D;
+ public static final int XK_PreviousCandidate = 0xFF3E;
+
+ /* Japanese keyboard support */
+
+ public static final int XK_Kanji = 0xFF21; /* Kanji, Kanji convert */
+ public static final int XK_Muhenkan = 0xFF22; /* Cancel Conversion */
+ public static final int XK_Henkan_Mode = 0xFF23; /* Start/Stop Conversion */
+ public static final int XK_Henkan = 0xFF23; /* Alias for Henkan_Mode */
+ public static final int XK_Romaji = 0xFF24; /* to Romaji */
+ public static final int XK_Hiragana = 0xFF25; /* to Hiragana */
+ public static final int XK_Katakana = 0xFF26; /* to Katakana */
+ public static final int XK_Hiragana_Katakana = 0xFF27; /* Hiragana/Katakana toggle */
+ public static final int XK_Zenkaku = 0xFF28; /* to Zenkaku */
+ public static final int XK_Hankaku = 0xFF29; /* to Hankaku */
+ public static final int XK_Zenkaku_Hankaku = 0xFF2A; /* Zenkaku/Hankaku toggle */
+ public static final int XK_Touroku = 0xFF2B; /* Add to Dictionary */
+ public static final int XK_Massyo = 0xFF2C; /* Delete from Dictionary */
+ public static final int XK_Kana_Lock = 0xFF2D; /* Kana Lock */
+ public static final int XK_Kana_Shift = 0xFF2E; /* Kana Shift */
+ public static final int XK_Eisu_Shift = 0xFF2F; /* Alphanumeric Shift */
+ public static final int XK_Eisu_toggle = 0xFF30; /* Alphanumeric toggle */
+ public static final int XK_Kanji_Bangou = 0xFF37; /* Codeinput */
+ public static final int XK_Zen_Koho = 0xFF3D; /* Multiple/All Candidate(s) */
+ public static final int XK_Mae_Koho = 0xFF3E; /* Previous Candidate */
+
+ /* 0xFF31 thru 0xFF3F are under XK_KOREAN */
+
+ /* Cursor control & motion */
+
+ public static final int XK_Home = 0xFF50;
+ public static final int XK_Left = 0xFF51; /* Move left, left arrow */
+ public static final int XK_Up = 0xFF52; /* Move up, up arrow */
+ public static final int XK_Right = 0xFF53; /* Move right, right arrow */
+ public static final int XK_Down = 0xFF54; /* Move down, down arrow */
+ public static final int XK_Prior = 0xFF55; /* Prior, previous */
+ public static final int XK_Page_Up = 0xFF55;
+ public static final int XK_Next = 0xFF56; /* Next */
+ public static final int XK_Page_Down = 0xFF56;
+ public static final int XK_End = 0xFF57; /* EOL */
+ public static final int XK_Begin = 0xFF58; /* BOL */
+
+
+ /* Misc Functions */
+
+ public static final int XK_Select = 0xFF60; /* Select, mark */
+ public static final int XK_Print = 0xFF61;
+ public static final int XK_Execute = 0xFF62; /* Execute, run, do */
+ public static final int XK_Insert = 0xFF63; /* Insert, insert here */
+ public static final int XK_Undo = 0xFF65; /* Undo, oops */
+ public static final int XK_Redo = 0xFF66; /* redo, again */
+ public static final int XK_Menu = 0xFF67;
+ public static final int XK_Find = 0xFF68; /* Find, search */
+ public static final int XK_Cancel = 0xFF69; /* Cancel, stop, abort, exit */
+ public static final int XK_Help = 0xFF6A; /* Help */
+ public static final int XK_Break = 0xFF6B;
+ public static final int XK_Mode_switch = 0xFF7E; /* Character set switch */
+ public static final int XK_script_switch = 0xFF7E; /* Alias for mode_switch */
+ public static final int XK_Num_Lock = 0xFF7F;
+
+ /* Keypad Functions, keypad numbers cleverly chosen to map to ascii */
+
+ public static final int XK_KP_Space = 0xFF80; /* space */
+ public static final int XK_KP_Tab = 0xFF89;
+ public static final int XK_KP_Enter = 0xFF8D; /* enter */
+ public static final int XK_KP_F1 = 0xFF91; /* PF1, KP_A, ... */
+ public static final int XK_KP_F2 = 0xFF92;
+ public static final int XK_KP_F3 = 0xFF93;
+ public static final int XK_KP_F4 = 0xFF94;
+ public static final int XK_KP_Home = 0xFF95;
+ public static final int XK_KP_Left = 0xFF96;
+ public static final int XK_KP_Up = 0xFF97;
+ public static final int XK_KP_Right = 0xFF98;
+ public static final int XK_KP_Down = 0xFF99;
+ public static final int XK_KP_Prior = 0xFF9A;
+ public static final int XK_KP_Page_Up = 0xFF9A;
+ public static final int XK_KP_Next = 0xFF9B;
+ public static final int XK_KP_Page_Down = 0xFF9B;
+ public static final int XK_KP_End = 0xFF9C;
+ public static final int XK_KP_Begin = 0xFF9D;
+ public static final int XK_KP_Insert = 0xFF9E;
+ public static final int XK_KP_Delete = 0xFF9F;
+ public static final int XK_KP_Equal = 0xFFBD; /* equals */
+ public static final int XK_KP_Multiply = 0xFFAA;
+ public static final int XK_KP_Add = 0xFFAB;
+ public static final int XK_KP_Separator = 0xFFAC; /* separator, often comma */
+ public static final int XK_KP_Subtract = 0xFFAD;
+ public static final int XK_KP_Decimal = 0xFFAE;
+ public static final int XK_KP_Divide = 0xFFAF;
+
+ public static final int XK_KP_0 = 0xFFB0;
+ public static final int XK_KP_1 = 0xFFB1;
+ public static final int XK_KP_2 = 0xFFB2;
+ public static final int XK_KP_3 = 0xFFB3;
+ public static final int XK_KP_4 = 0xFFB4;
+ public static final int XK_KP_5 = 0xFFB5;
+ public static final int XK_KP_6 = 0xFFB6;
+ public static final int XK_KP_7 = 0xFFB7;
+ public static final int XK_KP_8 = 0xFFB8;
+ public static final int XK_KP_9 = 0xFFB9;
+
+ /*
+ * Auxiliary Functions; note the duplicate definitions for left and right;
+ * function keys; Sun keyboards and a few other manufactures 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.
+ */
+
+ public static final int XK_F1 = 0xFFBE;
+ public static final int XK_F2 = 0xFFBF;
+ public static final int XK_F3 = 0xFFC0;
+ public static final int XK_F4 = 0xFFC1;
+ public static final int XK_F5 = 0xFFC2;
+ public static final int XK_F6 = 0xFFC3;
+ public static final int XK_F7 = 0xFFC4;
+ public static final int XK_F8 = 0xFFC5;
+ public static final int XK_F9 = 0xFFC6;
+ public static final int XK_F10 = 0xFFC7;
+ public static final int XK_F11 = 0xFFC8;
+ public static final int XK_L1 = 0xFFC8;
+ public static final int XK_F12 = 0xFFC9;
+ public static final int XK_L2 = 0xFFC9;
+ public static final int XK_F13 = 0xFFCA;
+ public static final int XK_L3 = 0xFFCA;
+ public static final int XK_F14 = 0xFFCB;
+ public static final int XK_L4 = 0xFFCB;
+ public static final int XK_F15 = 0xFFCC;
+ public static final int XK_L5 = 0xFFCC;
+ public static final int XK_F16 = 0xFFCD;
+ public static final int XK_L6 = 0xFFCD;
+ public static final int XK_F17 = 0xFFCE;
+ public static final int XK_L7 = 0xFFCE;
+ public static final int XK_F18 = 0xFFCF;
+ public static final int XK_L8 = 0xFFCF;
+ public static final int XK_F19 = 0xFFD0;
+ public static final int XK_L9 = 0xFFD0;
+ public static final int XK_F20 = 0xFFD1;
+ public static final int XK_L10 = 0xFFD1;
+ public static final int XK_F21 = 0xFFD2;
+ public static final int XK_R1 = 0xFFD2;
+ public static final int XK_F22 = 0xFFD3;
+ public static final int XK_R2 = 0xFFD3;
+ public static final int XK_F23 = 0xFFD4;
+ public static final int XK_R3 = 0xFFD4;
+ public static final int XK_F24 = 0xFFD5;
+ public static final int XK_R4 = 0xFFD5;
+ public static final int XK_F25 = 0xFFD6;
+ public static final int XK_R5 = 0xFFD6;
+ public static final int XK_F26 = 0xFFD7;
+ public static final int XK_R6 = 0xFFD7;
+ public static final int XK_F27 = 0xFFD8;
+ public static final int XK_R7 = 0xFFD8;
+ public static final int XK_F28 = 0xFFD9;
+ public static final int XK_R8 = 0xFFD9;
+ public static final int XK_F29 = 0xFFDA;
+ public static final int XK_R9 = 0xFFDA;
+ public static final int XK_F30 = 0xFFDB;
+ public static final int XK_R10 = 0xFFDB;
+ public static final int XK_F31 = 0xFFDC;
+ public static final int XK_R11 = 0xFFDC;
+ public static final int XK_F32 = 0xFFDD;
+ public static final int XK_R12 = 0xFFDD;
+ public static final int XK_F33 = 0xFFDE;
+ public static final int XK_R13 = 0xFFDE;
+ public static final int XK_F34 = 0xFFDF;
+ public static final int XK_R14 = 0xFFDF;
+ public static final int XK_F35 = 0xFFE0;
+ public static final int XK_R15 = 0xFFE0;
+
+ /* Modifiers */
+
+ public static final int XK_Shift_L = 0xFFE1; /* Left shift */
+ public static final int XK_Shift_R = 0xFFE2; /* Right shift */
+ public static final int XK_Control_L = 0xFFE3; /* Left control */
+ public static final int XK_Control_R = 0xFFE4; /* Right control */
+ public static final int XK_Caps_Lock = 0xFFE5; /* Caps lock */
+ public static final int XK_Shift_Lock = 0xFFE6; /* Shift lock */
+
+ public static final int XK_Meta_L = 0xFFE7; /* Left meta */
+ public static final int XK_Meta_R = 0xFFE8; /* Right meta */
+ public static final int XK_Alt_L = 0xFFE9; /* Left alt */
+ public static final int XK_Alt_R = 0xFFEA; /* Right alt */
+ public static final int XK_Super_L = 0xFFEB; /* Left super */
+ public static final int XK_Super_R = 0xFFEC; /* Right super */
+ public static final int XK_Hyper_L = 0xFFED; /* Left hyper */
+ public static final int XK_Hyper_R = 0xFFEE; /* Right hyper */
+
+ /*
+ * ISO 9995 Function and Modifier Keys;
+ * Byte 3 = 0xFE;
+ */
+
+ public static final int XK_ISO_Lock = 0xFE01;
+ public static final int XK_ISO_Level2_Latch = 0xFE02;
+ public static final int XK_ISO_Level3_Shift = 0xFE03;
+ public static final int XK_ISO_Level3_Latch = 0xFE04;
+ public static final int XK_ISO_Level3_Lock = 0xFE05;
+ public static final int XK_ISO_Group_Shift = 0xFF7E; /* Alias for mode_switch */
+ public static final int XK_ISO_Group_Latch = 0xFE06;
+ public static final int XK_ISO_Group_Lock = 0xFE07;
+ public static final int XK_ISO_Next_Group = 0xFE08;
+ public static final int XK_ISO_Next_Group_Lock = 0xFE09;
+ public static final int XK_ISO_Prev_Group = 0xFE0A;
+ public static final int XK_ISO_Prev_Group_Lock = 0xFE0B;
+ public static final int XK_ISO_First_Group = 0xFE0C;
+ public static final int XK_ISO_First_Group_Lock = 0xFE0D;
+ public static final int XK_ISO_Last_Group = 0xFE0E;
+ public static final int XK_ISO_Last_Group_Lock = 0xFE0F;
+
+ public static final int XK_ISO_Left_Tab = 0xFE20;
+ public static final int XK_ISO_Move_Line_Up = 0xFE21;
+ public static final int XK_ISO_Move_Line_Down = 0xFE22;
+ public static final int XK_ISO_Partial_Line_Up = 0xFE23;
+ public static final int XK_ISO_Partial_Line_Down = 0xFE24;
+ public static final int XK_ISO_Partial_Space_Left = 0xFE25;
+ public static final int XK_ISO_Partial_Space_Right = 0xFE26;
+ public static final int XK_ISO_Set_Margin_Left = 0xFE27;
+ public static final int XK_ISO_Set_Margin_Right = 0xFE28;
+ public static final int XK_ISO_Release_Margin_Left = 0xFE29;
+ public static final int XK_ISO_Release_Margin_Right = 0xFE2A;
+ public static final int XK_ISO_Release_Both_Margins = 0xFE2B;
+ public static final int XK_ISO_Fast_Cursor_Left = 0xFE2C;
+ public static final int XK_ISO_Fast_Cursor_Right = 0xFE2D;
+ public static final int XK_ISO_Fast_Cursor_Up = 0xFE2E;
+ public static final int XK_ISO_Fast_Cursor_Down = 0xFE2F;
+ public static final int XK_ISO_Continuous_Underline = 0xFE30;
+ public static final int XK_ISO_Discontinuous_Underline = 0xFE31;
+ public static final int XK_ISO_Emphasize = 0xFE32;
+ public static final int XK_ISO_Center_Object = 0xFE33;
+ public static final int XK_ISO_Enter = 0xFE34;
+
+ public static final int XK_dead_grave = 0xFE50;
+ public static final int XK_dead_acute = 0xFE51;
+ public static final int XK_dead_circumflex = 0xFE52;
+ public static final int XK_dead_tilde = 0xFE53;
+ public static final int XK_dead_macron = 0xFE54;
+ public static final int XK_dead_breve = 0xFE55;
+ public static final int XK_dead_abovedot = 0xFE56;
+ public static final int XK_dead_diaeresis = 0xFE57;
+ public static final int XK_dead_abovering = 0xFE58;
+ public static final int XK_dead_doubleacute = 0xFE59;
+ public static final int XK_dead_caron = 0xFE5A;
+ public static final int XK_dead_cedilla = 0xFE5B;
+ public static final int XK_dead_ogonek = 0xFE5C;
+ public static final int XK_dead_iota = 0xFE5D;
+ public static final int XK_dead_voiced_sound = 0xFE5E;
+ public static final int XK_dead_semivoiced_sound = 0xFE5F;
+ public static final int XK_dead_belowdot = 0xFE60;
+
+ public static final int XK_First_Virtual_Screen = 0xFED0;
+ public static final int XK_Prev_Virtual_Screen = 0xFED1;
+ public static final int XK_Next_Virtual_Screen = 0xFED2;
+ public static final int XK_Last_Virtual_Screen = 0xFED4;
+ public static final int XK_Terminate_Server = 0xFED5;
+
+ public static final int XK_AccessX_Enable = 0xFE70;
+ public static final int XK_AccessX_Feedback_Enable = 0xFE71;
+ public static final int XK_RepeatKeys_Enable = 0xFE72;
+ public static final int XK_SlowKeys_Enable = 0xFE73;
+ public static final int XK_BounceKeys_Enable = 0xFE74;
+ public static final int XK_StickyKeys_Enable = 0xFE75;
+ public static final int XK_MouseKeys_Enable = 0xFE76;
+ public static final int XK_MouseKeys_Accel_Enable = 0xFE77;
+ public static final int XK_Overlay1_Enable = 0xFE78;
+ public static final int XK_Overlay2_Enable = 0xFE79;
+ public static final int XK_AudibleBell_Enable = 0xFE7A;
+
+ public static final int XK_Pointer_Left = 0xFEE0;
+ public static final int XK_Pointer_Right = 0xFEE1;
+ public static final int XK_Pointer_Up = 0xFEE2;
+ public static final int XK_Pointer_Down = 0xFEE3;
+ public static final int XK_Pointer_UpLeft = 0xFEE4;
+ public static final int XK_Pointer_UpRight = 0xFEE5;
+ public static final int XK_Pointer_DownLeft = 0xFEE6;
+ public static final int XK_Pointer_DownRight = 0xFEE7;
+ public static final int XK_Pointer_Button_Dflt = 0xFEE8;
+ public static final int XK_Pointer_Button1 = 0xFEE9;
+ public static final int XK_Pointer_Button2 = 0xFEEA;
+ public static final int XK_Pointer_Button3 = 0xFEEB;
+ public static final int XK_Pointer_Button4 = 0xFEEC;
+ public static final int XK_Pointer_Button5 = 0xFEED;
+ public static final int XK_Pointer_DblClick_Dflt = 0xFEEE;
+ public static final int XK_Pointer_DblClick1 = 0xFEEF;
+ public static final int XK_Pointer_DblClick2 = 0xFEF0;
+ public static final int XK_Pointer_DblClick3 = 0xFEF1;
+ public static final int XK_Pointer_DblClick4 = 0xFEF2;
+ public static final int XK_Pointer_DblClick5 = 0xFEF3;
+ public static final int XK_Pointer_Drag_Dflt = 0xFEF4;
+ public static final int XK_Pointer_Drag1 = 0xFEF5;
+ public static final int XK_Pointer_Drag2 = 0xFEF6;
+ public static final int XK_Pointer_Drag3 = 0xFEF7;
+ public static final int XK_Pointer_Drag4 = 0xFEF8;
+ public static final int XK_Pointer_Drag5 = 0xFEFD;
+
+ public static final int XK_Pointer_EnableKeys = 0xFEF9;
+ public static final int XK_Pointer_Accelerate = 0xFEFA;
+ public static final int XK_Pointer_DfltBtnNext = 0xFEFB;
+ public static final int XK_Pointer_DfltBtnPrev = 0xFEFC;
+
+ /*
+ * 3270 Terminal Keys;
+ * Byte 3 = 0xFD;
+ */
+
+ public static final int XK_3270_Duplicate = 0xFD01;
+ public static final int XK_3270_FieldMark = 0xFD02;
+ public static final int XK_3270_Right2 = 0xFD03;
+ public static final int XK_3270_Left2 = 0xFD04;
+ public static final int XK_3270_BackTab = 0xFD05;
+ public static final int XK_3270_EraseEOF = 0xFD06;
+ public static final int XK_3270_EraseInput = 0xFD07;
+ public static final int XK_3270_Reset = 0xFD08;
+ public static final int XK_3270_Quit = 0xFD09;
+ public static final int XK_3270_PA1 = 0xFD0A;
+ public static final int XK_3270_PA2 = 0xFD0B;
+ public static final int XK_3270_PA3 = 0xFD0C;
+ public static final int XK_3270_Test = 0xFD0D;
+ public static final int XK_3270_Attn = 0xFD0E;
+ public static final int XK_3270_CursorBlink = 0xFD0F;
+ public static final int XK_3270_AltCursor = 0xFD10;
+ public static final int XK_3270_KeyClick = 0xFD11;
+ public static final int XK_3270_Jump = 0xFD12;
+ public static final int XK_3270_Ident = 0xFD13;
+ public static final int XK_3270_Rule = 0xFD14;
+ public static final int XK_3270_Copy = 0xFD15;
+ public static final int XK_3270_Play = 0xFD16;
+ public static final int XK_3270_Setup = 0xFD17;
+ public static final int XK_3270_Record = 0xFD18;
+ public static final int XK_3270_ChangeScreen = 0xFD19;
+ public static final int XK_3270_DeleteWord = 0xFD1A;
+ public static final int XK_3270_ExSelect = 0xFD1B;
+ public static final int XK_3270_CursorSelect = 0xFD1C;
+ public static final int XK_3270_PrintScreen = 0xFD1D;
+ public static final int XK_3270_Enter = 0xFD1E;
+
+ /*
+ * Latin 1;
+ * Byte 3 = 0;
+ */
+ public static final int XK_space = 0x020;
+ public static final int XK_exclam = 0x021;
+ public static final int XK_quotedbl = 0x022;
+ public static final int XK_numbersign = 0x023;
+ public static final int XK_dollar = 0x024;
+ public static final int XK_percent = 0x025;
+ public static final int XK_ampersand = 0x026;
+ public static final int XK_apostrophe = 0x027;
+ public static final int XK_quoteright = 0x027; /* deprecated */
+ public static final int XK_parenleft = 0x028;
+ public static final int XK_parenright = 0x029;
+ public static final int XK_asterisk = 0x02a;
+ public static final int XK_plus = 0x02b;
+ public static final int XK_comma = 0x02c;
+ public static final int XK_minus = 0x02d;
+ public static final int XK_period = 0x02e;
+ public static final int XK_slash = 0x02f;
+ public static final int XK_0 = 0x030;
+ public static final int XK_1 = 0x031;
+ public static final int XK_2 = 0x032;
+ public static final int XK_3 = 0x033;
+ public static final int XK_4 = 0x034;
+ public static final int XK_5 = 0x035;
+ public static final int XK_6 = 0x036;
+ public static final int XK_7 = 0x037;
+ public static final int XK_8 = 0x038;
+ public static final int XK_9 = 0x039;
+ public static final int XK_colon = 0x03a;
+ public static final int XK_semicolon = 0x03b;
+ public static final int XK_less = 0x03c;
+ public static final int XK_equal = 0x03d;
+ public static final int XK_greater = 0x03e;
+ public static final int XK_question = 0x03f;
+ public static final int XK_at = 0x040;
+ public static final int XK_A = 0x041;
+ public static final int XK_B = 0x042;
+ public static final int XK_C = 0x043;
+ public static final int XK_D = 0x044;
+ public static final int XK_E = 0x045;
+ public static final int XK_F = 0x046;
+ public static final int XK_G = 0x047;
+ public static final int XK_H = 0x048;
+ public static final int XK_I = 0x049;
+ public static final int XK_J = 0x04a;
+ public static final int XK_K = 0x04b;
+ public static final int XK_L = 0x04c;
+ public static final int XK_M = 0x04d;
+ public static final int XK_N = 0x04e;
+ public static final int XK_O = 0x04f;
+ public static final int XK_P = 0x050;
+ public static final int XK_Q = 0x051;
+ public static final int XK_R = 0x052;
+ public static final int XK_S = 0x053;
+ public static final int XK_T = 0x054;
+ public static final int XK_U = 0x055;
+ public static final int XK_V = 0x056;
+ public static final int XK_W = 0x057;
+ public static final int XK_X = 0x058;
+ public static final int XK_Y = 0x059;
+ public static final int XK_Z = 0x05a;
+ public static final int XK_bracketleft = 0x05b;
+ public static final int XK_backslash = 0x05c;
+ public static final int XK_bracketright = 0x05d;
+ public static final int XK_asciicircum = 0x05e;
+ public static final int XK_underscore = 0x05f;
+ public static final int XK_grave = 0x060;
+ public static final int XK_quoteleft = 0x060; /* deprecated */
+ public static final int XK_a = 0x061;
+ public static final int XK_b = 0x062;
+ public static final int XK_c = 0x063;
+ public static final int XK_d = 0x064;
+ public static final int XK_e = 0x065;
+ public static final int XK_f = 0x066;
+ public static final int XK_g = 0x067;
+ public static final int XK_h = 0x068;
+ public static final int XK_i = 0x069;
+ public static final int XK_j = 0x06a;
+ public static final int XK_k = 0x06b;
+ public static final int XK_l = 0x06c;
+ public static final int XK_m = 0x06d;
+ public static final int XK_n = 0x06e;
+ public static final int XK_o = 0x06f;
+ public static final int XK_p = 0x070;
+ public static final int XK_q = 0x071;
+ public static final int XK_r = 0x072;
+ public static final int XK_s = 0x073;
+ public static final int XK_t = 0x074;
+ public static final int XK_u = 0x075;
+ public static final int XK_v = 0x076;
+ public static final int XK_w = 0x077;
+ public static final int XK_x = 0x078;
+ public static final int XK_y = 0x079;
+ public static final int XK_z = 0x07a;
+ public static final int XK_braceleft = 0x07b;
+ public static final int XK_bar = 0x07c;
+ public static final int XK_braceright = 0x07d;
+ public static final int XK_asciitilde = 0x07e;
+
+ public static final int XK_nobreakspace = 0x0a0;
+ public static final int XK_exclamdown = 0x0a1;
+ public static final int XK_cent = 0x0a2;
+ public static final int XK_sterling = 0x0a3;
+ public static final int XK_currency = 0x0a4;
+ public static final int XK_yen = 0x0a5;
+ public static final int XK_brokenbar = 0x0a6;
+ public static final int XK_section = 0x0a7;
+ public static final int XK_diaeresis = 0x0a8;
+ public static final int XK_copyright = 0x0a9;
+ public static final int XK_ordfeminine = 0x0aa;
+ public static final int XK_guillemotleft = 0x0ab; /* left angle quotation mark */
+ public static final int XK_notsign = 0x0ac;
+ public static final int XK_hyphen = 0x0ad;
+ public static final int XK_registered = 0x0ae;
+ public static final int XK_macron = 0x0af;
+ public static final int XK_degree = 0x0b0;
+ public static final int XK_plusminus = 0x0b1;
+ public static final int XK_twosuperior = 0x0b2;
+ public static final int XK_threesuperior = 0x0b3;
+ public static final int XK_acute = 0x0b4;
+ public static final int XK_mu = 0x0b5;
+ public static final int XK_paragraph = 0x0b6;
+ public static final int XK_periodcentered = 0x0b7;
+ public static final int XK_cedilla = 0x0b8;
+ public static final int XK_onesuperior = 0x0b9;
+ public static final int XK_masculine = 0x0ba;
+ public static final int XK_guillemotright = 0x0bb; /* right angle quotation mark */
+ public static final int XK_onequarter = 0x0bc;
+ public static final int XK_onehalf = 0x0bd;
+ public static final int XK_threequarters = 0x0be;
+ public static final int XK_questiondown = 0x0bf;
+ public static final int XK_Agrave = 0x0c0;
+ public static final int XK_Aacute = 0x0c1;
+ public static final int XK_Acircumflex = 0x0c2;
+ public static final int XK_Atilde = 0x0c3;
+ public static final int XK_Adiaeresis = 0x0c4;
+ public static final int XK_Aring = 0x0c5;
+ public static final int XK_AE = 0x0c6;
+ public static final int XK_Ccedilla = 0x0c7;
+ public static final int XK_Egrave = 0x0c8;
+ public static final int XK_Eacute = 0x0c9;
+ public static final int XK_Ecircumflex = 0x0ca;
+ public static final int XK_Ediaeresis = 0x0cb;
+ public static final int XK_Igrave = 0x0cc;
+ public static final int XK_Iacute = 0x0cd;
+ public static final int XK_Icircumflex = 0x0ce;
+ public static final int XK_Idiaeresis = 0x0cf;
+ public static final int XK_ETH = 0x0d0;
+ public static final int XK_Eth = 0x0d0; /* deprecated */
+ public static final int XK_Ntilde = 0x0d1;
+ public static final int XK_Ograve = 0x0d2;
+ public static final int XK_Oacute = 0x0d3;
+ public static final int XK_Ocircumflex = 0x0d4;
+ public static final int XK_Otilde = 0x0d5;
+ public static final int XK_Odiaeresis = 0x0d6;
+ public static final int XK_multiply = 0x0d7;
+ public static final int XK_Ooblique = 0x0d8;
+ public static final int XK_Ugrave = 0x0d9;
+ public static final int XK_Uacute = 0x0da;
+ public static final int XK_Ucircumflex = 0x0db;
+ public static final int XK_Udiaeresis = 0x0dc;
+ public static final int XK_Yacute = 0x0dd;
+ public static final int XK_THORN = 0x0de;
+ public static final int XK_Thorn = 0x0de; /* deprecated */
+ public static final int XK_ssharp = 0x0df;
+ public static final int XK_agrave = 0x0e0;
+ public static final int XK_aacute = 0x0e1;
+ public static final int XK_acircumflex = 0x0e2;
+ public static final int XK_atilde = 0x0e3;
+ public static final int XK_adiaeresis = 0x0e4;
+ public static final int XK_aring = 0x0e5;
+ public static final int XK_ae = 0x0e6;
+ public static final int XK_ccedilla = 0x0e7;
+ public static final int XK_egrave = 0x0e8;
+ public static final int XK_eacute = 0x0e9;
+ public static final int XK_ecircumflex = 0x0ea;
+ public static final int XK_ediaeresis = 0x0eb;
+ public static final int XK_igrave = 0x0ec;
+ public static final int XK_iacute = 0x0ed;
+ public static final int XK_icircumflex = 0x0ee;
+ public static final int XK_idiaeresis = 0x0ef;
+ public static final int XK_eth = 0x0f0;
+ public static final int XK_ntilde = 0x0f1;
+ public static final int XK_ograve = 0x0f2;
+ public static final int XK_oacute = 0x0f3;
+ public static final int XK_ocircumflex = 0x0f4;
+ public static final int XK_otilde = 0x0f5;
+ public static final int XK_odiaeresis = 0x0f6;
+ public static final int XK_division = 0x0f7;
+ public static final int XK_oslash = 0x0f8;
+ public static final int XK_ugrave = 0x0f9;
+ public static final int XK_uacute = 0x0fa;
+ public static final int XK_ucircumflex = 0x0fb;
+ public static final int XK_udiaeresis = 0x0fc;
+ public static final int XK_yacute = 0x0fd;
+ public static final int XK_thorn = 0x0fe;
+ public static final int XK_ydiaeresis = 0x0ff;
+
+ /*
+ * Latin 2;
+ * Byte 3 = 1;
+ */
+
+ public static final int XK_Aogonek = 0x1a1;
+ public static final int XK_breve = 0x1a2;
+ public static final int XK_Lstroke = 0x1a3;
+ public static final int XK_Lcaron = 0x1a5;
+ public static final int XK_Sacute = 0x1a6;
+ public static final int XK_Scaron = 0x1a9;
+ public static final int XK_Scedilla = 0x1aa;
+ public static final int XK_Tcaron = 0x1ab;
+ public static final int XK_Zacute = 0x1ac;
+ public static final int XK_Zcaron = 0x1ae;
+ public static final int XK_Zabovedot = 0x1af;
+ public static final int XK_aogonek = 0x1b1;
+ public static final int XK_ogonek = 0x1b2;
+ public static final int XK_lstroke = 0x1b3;
+ public static final int XK_lcaron = 0x1b5;
+ public static final int XK_sacute = 0x1b6;
+ public static final int XK_caron = 0x1b7;
+ public static final int XK_scaron = 0x1b9;
+ public static final int XK_scedilla = 0x1ba;
+ public static final int XK_tcaron = 0x1bb;
+ public static final int XK_zacute = 0x1bc;
+ public static final int XK_doubleacute = 0x1bd;
+ public static final int XK_zcaron = 0x1be;
+ public static final int XK_zabovedot = 0x1bf;
+ public static final int XK_Racute = 0x1c0;
+ public static final int XK_Abreve = 0x1c3;
+ public static final int XK_Lacute = 0x1c5;
+ public static final int XK_Cacute = 0x1c6;
+ public static final int XK_Ccaron = 0x1c8;
+ public static final int XK_Eogonek = 0x1ca;
+ public static final int XK_Ecaron = 0x1cc;
+ public static final int XK_Dcaron = 0x1cf;
+ public static final int XK_Dstroke = 0x1d0;
+ public static final int XK_Nacute = 0x1d1;
+ public static final int XK_Ncaron = 0x1d2;
+ public static final int XK_Odoubleacute = 0x1d5;
+ public static final int XK_Rcaron = 0x1d8;
+ public static final int XK_Uring = 0x1d9;
+ public static final int XK_Udoubleacute = 0x1db;
+ public static final int XK_Tcedilla = 0x1de;
+ public static final int XK_racute = 0x1e0;
+ public static final int XK_abreve = 0x1e3;
+ public static final int XK_lacute = 0x1e5;
+ public static final int XK_cacute = 0x1e6;
+ public static final int XK_ccaron = 0x1e8;
+ public static final int XK_eogonek = 0x1ea;
+ public static final int XK_ecaron = 0x1ec;
+ public static final int XK_dcaron = 0x1ef;
+ public static final int XK_dstroke = 0x1f0;
+ public static final int XK_nacute = 0x1f1;
+ public static final int XK_ncaron = 0x1f2;
+ public static final int XK_odoubleacute = 0x1f5;
+ public static final int XK_udoubleacute = 0x1fb;
+ public static final int XK_rcaron = 0x1f8;
+ public static final int XK_uring = 0x1f9;
+ public static final int XK_tcedilla = 0x1fe;
+ public static final int XK_abovedot = 0x1ff;
+
+ /*
+ * Latin 3;
+ * Byte 3 = 2;
+ */
+
+ public static final int XK_Hstroke = 0x2a1;
+ public static final int XK_Hcircumflex = 0x2a6;
+ public static final int XK_Iabovedot = 0x2a9;
+ public static final int XK_Gbreve = 0x2ab;
+ public static final int XK_Jcircumflex = 0x2ac;
+ public static final int XK_hstroke = 0x2b1;
+ public static final int XK_hcircumflex = 0x2b6;
+ public static final int XK_idotless = 0x2b9;
+ public static final int XK_gbreve = 0x2bb;
+ public static final int XK_jcircumflex = 0x2bc;
+ public static final int XK_Cabovedot = 0x2c5;
+ public static final int XK_Ccircumflex = 0x2c6;
+ public static final int XK_Gabovedot = 0x2d5;
+ public static final int XK_Gcircumflex = 0x2d8;
+ public static final int XK_Ubreve = 0x2dd;
+ public static final int XK_Scircumflex = 0x2de;
+ public static final int XK_cabovedot = 0x2e5;
+ public static final int XK_ccircumflex = 0x2e6;
+ public static final int XK_gabovedot = 0x2f5;
+ public static final int XK_gcircumflex = 0x2f8;
+ public static final int XK_ubreve = 0x2fd;
+ public static final int XK_scircumflex = 0x2fe;
+
+
+ /*
+ * Latin 4;
+ * Byte 3 = 3;
+ */
+
+ public static final int XK_kra = 0x3a2;
+ public static final int XK_kappa = 0x3a2; /* deprecated */
+ public static final int XK_Rcedilla = 0x3a3;
+ public static final int XK_Itilde = 0x3a5;
+ public static final int XK_Lcedilla = 0x3a6;
+ public static final int XK_Emacron = 0x3aa;
+ public static final int XK_Gcedilla = 0x3ab;
+ public static final int XK_Tslash = 0x3ac;
+ public static final int XK_rcedilla = 0x3b3;
+ public static final int XK_itilde = 0x3b5;
+ public static final int XK_lcedilla = 0x3b6;
+ public static final int XK_emacron = 0x3ba;
+ public static final int XK_gcedilla = 0x3bb;
+ public static final int XK_tslash = 0x3bc;
+ public static final int XK_ENG = 0x3bd;
+ public static final int XK_eng = 0x3bf;
+ public static final int XK_Amacron = 0x3c0;
+ public static final int XK_Iogonek = 0x3c7;
+ public static final int XK_Eabovedot = 0x3cc;
+ public static final int XK_Imacron = 0x3cf;
+ public static final int XK_Ncedilla = 0x3d1;
+ public static final int XK_Omacron = 0x3d2;
+ public static final int XK_Kcedilla = 0x3d3;
+ public static final int XK_Uogonek = 0x3d9;
+ public static final int XK_Utilde = 0x3dd;
+ public static final int XK_Umacron = 0x3de;
+ public static final int XK_amacron = 0x3e0;
+ public static final int XK_iogonek = 0x3e7;
+ public static final int XK_eabovedot = 0x3ec;
+ public static final int XK_imacron = 0x3ef;
+ public static final int XK_ncedilla = 0x3f1;
+ public static final int XK_omacron = 0x3f2;
+ public static final int XK_kcedilla = 0x3f3;
+ public static final int XK_uogonek = 0x3f9;
+ public static final int XK_utilde = 0x3fd;
+ public static final int XK_umacron = 0x3fe;
+
+ /*
+ * Latin-9 (a.k.a. Latin-0)
+ * Byte 3 = 19;
+ */
+
+ public static final int XK_OE = 0x13bc;
+ public static final int XK_oe = 0x13bd;
+ public static final int XK_Ydiaeresis = 0x13be;
+
+ /*
+ * Katakana;
+ * Byte 3 = 4;
+ */
+
+ public static final int XK_overline = 0x47e;
+ public static final int XK_kana_fullstop = 0x4a1;
+ public static final int XK_kana_openingbracket = 0x4a2;
+ public static final int XK_kana_closingbracket = 0x4a3;
+ public static final int XK_kana_comma = 0x4a4;
+ public static final int XK_kana_conjunctive = 0x4a5;
+ public static final int XK_kana_middledot = 0x4a5; /* deprecated */
+ public static final int XK_kana_WO = 0x4a6;
+ public static final int XK_kana_a = 0x4a7;
+ public static final int XK_kana_i = 0x4a8;
+ public static final int XK_kana_u = 0x4a9;
+ public static final int XK_kana_e = 0x4aa;
+ public static final int XK_kana_o = 0x4ab;
+ public static final int XK_kana_ya = 0x4ac;
+ public static final int XK_kana_yu = 0x4ad;
+ public static final int XK_kana_yo = 0x4ae;
+ public static final int XK_kana_tsu = 0x4af;
+ public static final int XK_kana_tu = 0x4af; /* deprecated */
+ public static final int XK_prolongedsound = 0x4b0;
+ public static final int XK_kana_A = 0x4b1;
+ public static final int XK_kana_I = 0x4b2;
+ public static final int XK_kana_U = 0x4b3;
+ public static final int XK_kana_E = 0x4b4;
+ public static final int XK_kana_O = 0x4b5;
+ public static final int XK_kana_KA = 0x4b6;
+ public static final int XK_kana_KI = 0x4b7;
+ public static final int XK_kana_KU = 0x4b8;
+ public static final int XK_kana_KE = 0x4b9;
+ public static final int XK_kana_KO = 0x4ba;
+ public static final int XK_kana_SA = 0x4bb;
+ public static final int XK_kana_SHI = 0x4bc;
+ public static final int XK_kana_SU = 0x4bd;
+ public static final int XK_kana_SE = 0x4be;
+ public static final int XK_kana_SO = 0x4bf;
+ public static final int XK_kana_TA = 0x4c0;
+ public static final int XK_kana_CHI = 0x4c1;
+ public static final int XK_kana_TI = 0x4c1; /* deprecated */
+ public static final int XK_kana_TSU = 0x4c2;
+ public static final int XK_kana_TU = 0x4c2; /* deprecated */
+ public static final int XK_kana_TE = 0x4c3;
+ public static final int XK_kana_TO = 0x4c4;
+ public static final int XK_kana_NA = 0x4c5;
+ public static final int XK_kana_NI = 0x4c6;
+ public static final int XK_kana_NU = 0x4c7;
+ public static final int XK_kana_NE = 0x4c8;
+ public static final int XK_kana_NO = 0x4c9;
+ public static final int XK_kana_HA = 0x4ca;
+ public static final int XK_kana_HI = 0x4cb;
+ public static final int XK_kana_FU = 0x4cc;
+ public static final int XK_kana_HU = 0x4cc; /* deprecated */
+ public static final int XK_kana_HE = 0x4cd;
+ public static final int XK_kana_HO = 0x4ce;
+ public static final int XK_kana_MA = 0x4cf;
+ public static final int XK_kana_MI = 0x4d0;
+ public static final int XK_kana_MU = 0x4d1;
+ public static final int XK_kana_ME = 0x4d2;
+ public static final int XK_kana_MO = 0x4d3;
+ public static final int XK_kana_YA = 0x4d4;
+ public static final int XK_kana_YU = 0x4d5;
+ public static final int XK_kana_YO = 0x4d6;
+ public static final int XK_kana_RA = 0x4d7;
+ public static final int XK_kana_RI = 0x4d8;
+ public static final int XK_kana_RU = 0x4d9;
+ public static final int XK_kana_RE = 0x4da;
+ public static final int XK_kana_RO = 0x4db;
+ public static final int XK_kana_WA = 0x4dc;
+ public static final int XK_kana_N = 0x4dd;
+ public static final int XK_voicedsound = 0x4de;
+ public static final int XK_semivoicedsound = 0x4df;
+ public static final int XK_kana_switch = 0xFF7E; /* Alias for mode_switch */
+
+ /*
+ * Arabic;
+ * Byte 3 = 5;
+ */
+
+ public static final int XK_Arabic_comma = 0x5ac;
+ public static final int XK_Arabic_semicolon = 0x5bb;
+ public static final int XK_Arabic_question_mark = 0x5bf;
+ public static final int XK_Arabic_hamza = 0x5c1;
+ public static final int XK_Arabic_maddaonalef = 0x5c2;
+ public static final int XK_Arabic_hamzaonalef = 0x5c3;
+ public static final int XK_Arabic_hamzaonwaw = 0x5c4;
+ public static final int XK_Arabic_hamzaunderalef = 0x5c5;
+ public static final int XK_Arabic_hamzaonyeh = 0x5c6;
+ public static final int XK_Arabic_alef = 0x5c7;
+ public static final int XK_Arabic_beh = 0x5c8;
+ public static final int XK_Arabic_tehmarbuta = 0x5c9;
+ public static final int XK_Arabic_teh = 0x5ca;
+ public static final int XK_Arabic_theh = 0x5cb;
+ public static final int XK_Arabic_jeem = 0x5cc;
+ public static final int XK_Arabic_hah = 0x5cd;
+ public static final int XK_Arabic_khah = 0x5ce;
+ public static final int XK_Arabic_dal = 0x5cf;
+ public static final int XK_Arabic_thal = 0x5d0;
+ public static final int XK_Arabic_ra = 0x5d1;
+ public static final int XK_Arabic_zain = 0x5d2;
+ public static final int XK_Arabic_seen = 0x5d3;
+ public static final int XK_Arabic_sheen = 0x5d4;
+ public static final int XK_Arabic_sad = 0x5d5;
+ public static final int XK_Arabic_dad = 0x5d6;
+ public static final int XK_Arabic_tah = 0x5d7;
+ public static final int XK_Arabic_zah = 0x5d8;
+ public static final int XK_Arabic_ain = 0x5d9;
+ public static final int XK_Arabic_ghain = 0x5da;
+ public static final int XK_Arabic_tatweel = 0x5e0;
+ public static final int XK_Arabic_feh = 0x5e1;
+ public static final int XK_Arabic_qaf = 0x5e2;
+ public static final int XK_Arabic_kaf = 0x5e3;
+ public static final int XK_Arabic_lam = 0x5e4;
+ public static final int XK_Arabic_meem = 0x5e5;
+ public static final int XK_Arabic_noon = 0x5e6;
+ public static final int XK_Arabic_ha = 0x5e7;
+ public static final int XK_Arabic_heh = 0x5e7; /* deprecated */
+ public static final int XK_Arabic_waw = 0x5e8;
+ public static final int XK_Arabic_alefmaksura = 0x5e9;
+ public static final int XK_Arabic_yeh = 0x5ea;
+ public static final int XK_Arabic_fathatan = 0x5eb;
+ public static final int XK_Arabic_dammatan = 0x5ec;
+ public static final int XK_Arabic_kasratan = 0x5ed;
+ public static final int XK_Arabic_fatha = 0x5ee;
+ public static final int XK_Arabic_damma = 0x5ef;
+ public static final int XK_Arabic_kasra = 0x5f0;
+ public static final int XK_Arabic_shadda = 0x5f1;
+ public static final int XK_Arabic_sukun = 0x5f2;
+ public static final int XK_Arabic_switch = 0xFF7E; /* Alias for mode_switch */
+
+ /*
+ * Cyrillic;
+ * Byte 3 = 6;
+ */
+ public static final int XK_Serbian_dje = 0x6a1;
+ public static final int XK_Macedonia_gje = 0x6a2;
+ public static final int XK_Cyrillic_io = 0x6a3;
+ public static final int XK_Ukrainian_ie = 0x6a4;
+ public static final int XK_Ukranian_je = 0x6a4; /* deprecated */
+ public static final int XK_Macedonia_dse = 0x6a5;
+ public static final int XK_Ukrainian_i = 0x6a6;
+ public static final int XK_Ukranian_i = 0x6a6; /* deprecated */
+ public static final int XK_Ukrainian_yi = 0x6a7;
+ public static final int XK_Ukranian_yi = 0x6a7; /* deprecated */
+ public static final int XK_Cyrillic_je = 0x6a8;
+ public static final int XK_Serbian_je = 0x6a8; /* deprecated */
+ public static final int XK_Cyrillic_lje = 0x6a9;
+ public static final int XK_Serbian_lje = 0x6a9; /* deprecated */
+ public static final int XK_Cyrillic_nje = 0x6aa;
+ public static final int XK_Serbian_nje = 0x6aa; /* deprecated */
+ public static final int XK_Serbian_tshe = 0x6ab;
+ public static final int XK_Macedonia_kje = 0x6ac;
+ public static final int XK_Byelorussian_shortu = 0x6ae;
+ public static final int XK_Cyrillic_dzhe = 0x6af;
+ public static final int XK_Serbian_dze = 0x6af; /* deprecated */
+ public static final int XK_numerosign = 0x6b0;
+ public static final int XK_Serbian_DJE = 0x6b1;
+ public static final int XK_Macedonia_GJE = 0x6b2;
+ public static final int XK_Cyrillic_IO = 0x6b3;
+ public static final int XK_Ukrainian_IE = 0x6b4;
+ public static final int XK_Ukranian_JE = 0x6b4; /* deprecated */
+ public static final int XK_Macedonia_DSE = 0x6b5;
+ public static final int XK_Ukrainian_I = 0x6b6;
+ public static final int XK_Ukranian_I = 0x6b6; /* deprecated */
+ public static final int XK_Ukrainian_YI = 0x6b7;
+ public static final int XK_Ukranian_YI = 0x6b7; /* deprecated */
+ public static final int XK_Cyrillic_JE = 0x6b8;
+ public static final int XK_Serbian_JE = 0x6b8; /* deprecated */
+ public static final int XK_Cyrillic_LJE = 0x6b9;
+ public static final int XK_Serbian_LJE = 0x6b9; /* deprecated */
+ public static final int XK_Cyrillic_NJE = 0x6ba;
+ public static final int XK_Serbian_NJE = 0x6ba; /* deprecated */
+ public static final int XK_Serbian_TSHE = 0x6bb;
+ public static final int XK_Macedonia_KJE = 0x6bc;
+ public static final int XK_Byelorussian_SHORTU = 0x6be;
+ public static final int XK_Cyrillic_DZHE = 0x6bf;
+ public static final int XK_Serbian_DZE = 0x6bf; /* deprecated */
+ public static final int XK_Cyrillic_yu = 0x6c0;
+ public static final int XK_Cyrillic_a = 0x6c1;
+ public static final int XK_Cyrillic_be = 0x6c2;
+ public static final int XK_Cyrillic_tse = 0x6c3;
+ public static final int XK_Cyrillic_de = 0x6c4;
+ public static final int XK_Cyrillic_ie = 0x6c5;
+ public static final int XK_Cyrillic_ef = 0x6c6;
+ public static final int XK_Cyrillic_ghe = 0x6c7;
+ public static final int XK_Cyrillic_ha = 0x6c8;
+ public static final int XK_Cyrillic_i = 0x6c9;
+ public static final int XK_Cyrillic_shorti = 0x6ca;
+ public static final int XK_Cyrillic_ka = 0x6cb;
+ public static final int XK_Cyrillic_el = 0x6cc;
+ public static final int XK_Cyrillic_em = 0x6cd;
+ public static final int XK_Cyrillic_en = 0x6ce;
+ public static final int XK_Cyrillic_o = 0x6cf;
+ public static final int XK_Cyrillic_pe = 0x6d0;
+ public static final int XK_Cyrillic_ya = 0x6d1;
+ public static final int XK_Cyrillic_er = 0x6d2;
+ public static final int XK_Cyrillic_es = 0x6d3;
+ public static final int XK_Cyrillic_te = 0x6d4;
+ public static final int XK_Cyrillic_u = 0x6d5;
+ public static final int XK_Cyrillic_zhe = 0x6d6;
+ public static final int XK_Cyrillic_ve = 0x6d7;
+ public static final int XK_Cyrillic_softsign = 0x6d8;
+ public static final int XK_Cyrillic_yeru = 0x6d9;
+ public static final int XK_Cyrillic_ze = 0x6da;
+ public static final int XK_Cyrillic_sha = 0x6db;
+ public static final int XK_Cyrillic_e = 0x6dc;
+ public static final int XK_Cyrillic_shcha = 0x6dd;
+ public static final int XK_Cyrillic_che = 0x6de;
+ public static final int XK_Cyrillic_hardsign = 0x6df;
+ public static final int XK_Cyrillic_YU = 0x6e0;
+ public static final int XK_Cyrillic_A = 0x6e1;
+ public static final int XK_Cyrillic_BE = 0x6e2;
+ public static final int XK_Cyrillic_TSE = 0x6e3;
+ public static final int XK_Cyrillic_DE = 0x6e4;
+ public static final int XK_Cyrillic_IE = 0x6e5;
+ public static final int XK_Cyrillic_EF = 0x6e6;
+ public static final int XK_Cyrillic_GHE = 0x6e7;
+ public static final int XK_Cyrillic_HA = 0x6e8;
+ public static final int XK_Cyrillic_I = 0x6e9;
+ public static final int XK_Cyrillic_SHORTI = 0x6ea;
+ public static final int XK_Cyrillic_KA = 0x6eb;
+ public static final int XK_Cyrillic_EL = 0x6ec;
+ public static final int XK_Cyrillic_EM = 0x6ed;
+ public static final int XK_Cyrillic_EN = 0x6ee;
+ public static final int XK_Cyrillic_O = 0x6ef;
+ public static final int XK_Cyrillic_PE = 0x6f0;
+ public static final int XK_Cyrillic_YA = 0x6f1;
+ public static final int XK_Cyrillic_ER = 0x6f2;
+ public static final int XK_Cyrillic_ES = 0x6f3;
+ public static final int XK_Cyrillic_TE = 0x6f4;
+ public static final int XK_Cyrillic_U = 0x6f5;
+ public static final int XK_Cyrillic_ZHE = 0x6f6;
+ public static final int XK_Cyrillic_VE = 0x6f7;
+ public static final int XK_Cyrillic_SOFTSIGN = 0x6f8;
+ public static final int XK_Cyrillic_YERU = 0x6f9;
+ public static final int XK_Cyrillic_ZE = 0x6fa;
+ public static final int XK_Cyrillic_SHA = 0x6fb;
+ public static final int XK_Cyrillic_E = 0x6fc;
+ public static final int XK_Cyrillic_SHCHA = 0x6fd;
+ public static final int XK_Cyrillic_CHE = 0x6fe;
+ public static final int XK_Cyrillic_HARDSIGN = 0x6ff;
+
+ /*
+ * Greek;
+ * Byte 3 = 7;
+ */
+
+ public static final int XK_Greek_ALPHAaccent = 0x7a1;
+ public static final int XK_Greek_EPSILONaccent = 0x7a2;
+ public static final int XK_Greek_ETAaccent = 0x7a3;
+ public static final int XK_Greek_IOTAaccent = 0x7a4;
+ public static final int XK_Greek_IOTAdiaeresis = 0x7a5;
+ public static final int XK_Greek_OMICRONaccent = 0x7a7;
+ public static final int XK_Greek_UPSILONaccent = 0x7a8;
+ public static final int XK_Greek_UPSILONdieresis = 0x7a9;
+ public static final int XK_Greek_OMEGAaccent = 0x7ab;
+ public static final int XK_Greek_accentdieresis = 0x7ae;
+ public static final int XK_Greek_horizbar = 0x7af;
+ public static final int XK_Greek_alphaaccent = 0x7b1;
+ public static final int XK_Greek_epsilonaccent = 0x7b2;
+ public static final int XK_Greek_etaaccent = 0x7b3;
+ public static final int XK_Greek_iotaaccent = 0x7b4;
+ public static final int XK_Greek_iotadieresis = 0x7b5;
+ public static final int XK_Greek_iotaaccentdieresis = 0x7b6;
+ public static final int XK_Greek_omicronaccent = 0x7b7;
+ public static final int XK_Greek_upsilonaccent = 0x7b8;
+ public static final int XK_Greek_upsilondieresis = 0x7b9;
+ public static final int XK_Greek_upsilonaccentdieresis = 0x7ba;
+ public static final int XK_Greek_omegaaccent = 0x7bb;
+ public static final int XK_Greek_ALPHA = 0x7c1;
+ public static final int XK_Greek_BETA = 0x7c2;
+ public static final int XK_Greek_GAMMA = 0x7c3;
+ public static final int XK_Greek_DELTA = 0x7c4;
+ public static final int XK_Greek_EPSILON = 0x7c5;
+ public static final int XK_Greek_ZETA = 0x7c6;
+ public static final int XK_Greek_ETA = 0x7c7;
+ public static final int XK_Greek_THETA = 0x7c8;
+ public static final int XK_Greek_IOTA = 0x7c9;
+ public static final int XK_Greek_KAPPA = 0x7ca;
+ public static final int XK_Greek_LAMDA = 0x7cb;
+ public static final int XK_Greek_LAMBDA = 0x7cb;
+ public static final int XK_Greek_MU = 0x7cc;
+ public static final int XK_Greek_NU = 0x7cd;
+ public static final int XK_Greek_XI = 0x7ce;
+ public static final int XK_Greek_OMICRON = 0x7cf;
+ public static final int XK_Greek_PI = 0x7d0;
+ public static final int XK_Greek_RHO = 0x7d1;
+ public static final int XK_Greek_SIGMA = 0x7d2;
+ public static final int XK_Greek_TAU = 0x7d4;
+ public static final int XK_Greek_UPSILON = 0x7d5;
+ public static final int XK_Greek_PHI = 0x7d6;
+ public static final int XK_Greek_CHI = 0x7d7;
+ public static final int XK_Greek_PSI = 0x7d8;
+ public static final int XK_Greek_OMEGA = 0x7d9;
+ public static final int XK_Greek_alpha = 0x7e1;
+ public static final int XK_Greek_beta = 0x7e2;
+ public static final int XK_Greek_gamma = 0x7e3;
+ public static final int XK_Greek_delta = 0x7e4;
+ public static final int XK_Greek_epsilon = 0x7e5;
+ public static final int XK_Greek_zeta = 0x7e6;
+ public static final int XK_Greek_eta = 0x7e7;
+ public static final int XK_Greek_theta = 0x7e8;
+ public static final int XK_Greek_iota = 0x7e9;
+ public static final int XK_Greek_kappa = 0x7ea;
+ public static final int XK_Greek_lamda = 0x7eb;
+ public static final int XK_Greek_lambda = 0x7eb;
+ public static final int XK_Greek_mu = 0x7ec;
+ public static final int XK_Greek_nu = 0x7ed;
+ public static final int XK_Greek_xi = 0x7ee;
+ public static final int XK_Greek_omicron = 0x7ef;
+ public static final int XK_Greek_pi = 0x7f0;
+ public static final int XK_Greek_rho = 0x7f1;
+ public static final int XK_Greek_sigma = 0x7f2;
+ public static final int XK_Greek_finalsmallsigma = 0x7f3;
+ public static final int XK_Greek_tau = 0x7f4;
+ public static final int XK_Greek_upsilon = 0x7f5;
+ public static final int XK_Greek_phi = 0x7f6;
+ public static final int XK_Greek_chi = 0x7f7;
+ public static final int XK_Greek_psi = 0x7f8;
+ public static final int XK_Greek_omega = 0x7f9;
+ public static final int XK_Greek_switch = 0xFF7E; /* Alias for mode_switch */
+
+ /*
+ * Technical;
+ * Byte 3 = 8;
+ */
+
+ public static final int XK_leftradical = 0x8a1;
+ public static final int XK_topleftradical = 0x8a2;
+ public static final int XK_horizconnector = 0x8a3;
+ public static final int XK_topintegral = 0x8a4;
+ public static final int XK_botintegral = 0x8a5;
+ public static final int XK_vertconnector = 0x8a6;
+ public static final int XK_topleftsqbracket = 0x8a7;
+ public static final int XK_botleftsqbracket = 0x8a8;
+ public static final int XK_toprightsqbracket = 0x8a9;
+ public static final int XK_botrightsqbracket = 0x8aa;
+ public static final int XK_topleftparens = 0x8ab;
+ public static final int XK_botleftparens = 0x8ac;
+ public static final int XK_toprightparens = 0x8ad;
+ public static final int XK_botrightparens = 0x8ae;
+ public static final int XK_leftmiddlecurlybrace = 0x8af;
+ public static final int XK_rightmiddlecurlybrace = 0x8b0;
+ public static final int XK_topleftsummation = 0x8b1;
+ public static final int XK_botleftsummation = 0x8b2;
+ public static final int XK_topvertsummationconnector = 0x8b3;
+ public static final int XK_botvertsummationconnector = 0x8b4;
+ public static final int XK_toprightsummation = 0x8b5;
+ public static final int XK_botrightsummation = 0x8b6;
+ public static final int XK_rightmiddlesummation = 0x8b7;
+ public static final int XK_lessthanequal = 0x8bc;
+ public static final int XK_notequal = 0x8bd;
+ public static final int XK_greaterthanequal = 0x8be;
+ public static final int XK_integral = 0x8bf;
+ public static final int XK_therefore = 0x8c0;
+ public static final int XK_variation = 0x8c1;
+ public static final int XK_infinity = 0x8c2;
+ public static final int XK_nabla = 0x8c5;
+ public static final int XK_approximate = 0x8c8;
+ public static final int XK_similarequal = 0x8c9;
+ public static final int XK_ifonlyif = 0x8cd;
+ public static final int XK_implies = 0x8ce;
+ public static final int XK_identical = 0x8cf;
+ public static final int XK_radical = 0x8d6;
+ public static final int XK_includedin = 0x8da;
+ public static final int XK_includes = 0x8db;
+ public static final int XK_intersection = 0x8dc;
+ public static final int XK_union = 0x8dd;
+ public static final int XK_logicaland = 0x8de;
+ public static final int XK_logicalor = 0x8df;
+ public static final int XK_partialderivative = 0x8ef;
+ public static final int XK_function = 0x8f6;
+ public static final int XK_leftarrow = 0x8fb;
+ public static final int XK_uparrow = 0x8fc;
+ public static final int XK_rightarrow = 0x8fd;
+ public static final int XK_downarrow = 0x8fe;
+
+ /*
+ * Special;
+ * Byte 3 = 9;
+ */
+
+ public static final int XK_blank = 0x9df;
+ public static final int XK_soliddiamond = 0x9e0;
+ public static final int XK_checkerboard = 0x9e1;
+ public static final int XK_ht = 0x9e2;
+ public static final int XK_ff = 0x9e3;
+ public static final int XK_cr = 0x9e4;
+ public static final int XK_lf = 0x9e5;
+ public static final int XK_nl = 0x9e8;
+ public static final int XK_vt = 0x9e9;
+ public static final int XK_lowrightcorner = 0x9ea;
+ public static final int XK_uprightcorner = 0x9eb;
+ public static final int XK_upleftcorner = 0x9ec;
+ public static final int XK_lowleftcorner = 0x9ed;
+ public static final int XK_crossinglines = 0x9ee;
+ public static final int XK_horizlinescan1 = 0x9ef;
+ public static final int XK_horizlinescan3 = 0x9f0;
+ public static final int XK_horizlinescan5 = 0x9f1;
+ public static final int XK_horizlinescan7 = 0x9f2;
+ public static final int XK_horizlinescan9 = 0x9f3;
+ public static final int XK_leftt = 0x9f4;
+ public static final int XK_rightt = 0x9f5;
+ public static final int XK_bott = 0x9f6;
+ public static final int XK_topt = 0x9f7;
+ public static final int XK_vertbar = 0x9f8;
+
+ /*
+ * Publishing;
+ * Byte 3 = a;
+ */
+
+ public static final int XK_emspace = 0xaa1;
+ public static final int XK_enspace = 0xaa2;
+ public static final int XK_em3space = 0xaa3;
+ public static final int XK_em4space = 0xaa4;
+ public static final int XK_digitspace = 0xaa5;
+ public static final int XK_punctspace = 0xaa6;
+ public static final int XK_thinspace = 0xaa7;
+ public static final int XK_hairspace = 0xaa8;
+ public static final int XK_emdash = 0xaa9;
+ public static final int XK_endash = 0xaaa;
+ public static final int XK_signifblank = 0xaac;
+ public static final int XK_ellipsis = 0xaae;
+ public static final int XK_doubbaselinedot = 0xaaf;
+ public static final int XK_onethird = 0xab0;
+ public static final int XK_twothirds = 0xab1;
+ public static final int XK_onefifth = 0xab2;
+ public static final int XK_twofifths = 0xab3;
+ public static final int XK_threefifths = 0xab4;
+ public static final int XK_fourfifths = 0xab5;
+ public static final int XK_onesixth = 0xab6;
+ public static final int XK_fivesixths = 0xab7;
+ public static final int XK_careof = 0xab8;
+ public static final int XK_figdash = 0xabb;
+ public static final int XK_leftanglebracket = 0xabc;
+ public static final int XK_decimalpoint = 0xabd;
+ public static final int XK_rightanglebracket = 0xabe;
+ public static final int XK_marker = 0xabf;
+ public static final int XK_oneeighth = 0xac3;
+ public static final int XK_threeeighths = 0xac4;
+ public static final int XK_fiveeighths = 0xac5;
+ public static final int XK_seveneighths = 0xac6;
+ public static final int XK_trademark = 0xac9;
+ public static final int XK_signaturemark = 0xaca;
+ public static final int XK_trademarkincircle = 0xacb;
+ public static final int XK_leftopentriangle = 0xacc;
+ public static final int XK_rightopentriangle = 0xacd;
+ public static final int XK_emopencircle = 0xace;
+ public static final int XK_emopenrectangle = 0xacf;
+ public static final int XK_leftsinglequotemark = 0xad0;
+ public static final int XK_rightsinglequotemark = 0xad1;
+ public static final int XK_leftdoublequotemark = 0xad2;
+ public static final int XK_rightdoublequotemark = 0xad3;
+ public static final int XK_prescription = 0xad4;
+ public static final int XK_minutes = 0xad6;
+ public static final int XK_seconds = 0xad7;
+ public static final int XK_latincross = 0xad9;
+ public static final int XK_hexagram = 0xada;
+ public static final int XK_filledrectbullet = 0xadb;
+ public static final int XK_filledlefttribullet = 0xadc;
+ public static final int XK_filledrighttribullet = 0xadd;
+ public static final int XK_emfilledcircle = 0xade;
+ public static final int XK_emfilledrect = 0xadf;
+ public static final int XK_enopencircbullet = 0xae0;
+ public static final int XK_enopensquarebullet = 0xae1;
+ public static final int XK_openrectbullet = 0xae2;
+ public static final int XK_opentribulletup = 0xae3;
+ public static final int XK_opentribulletdown = 0xae4;
+ public static final int XK_openstar = 0xae5;
+ public static final int XK_enfilledcircbullet = 0xae6;
+ public static final int XK_enfilledsqbullet = 0xae7;
+ public static final int XK_filledtribulletup = 0xae8;
+ public static final int XK_filledtribulletdown = 0xae9;
+ public static final int XK_leftpointer = 0xaea;
+ public static final int XK_rightpointer = 0xaeb;
+ public static final int XK_club = 0xaec;
+ public static final int XK_diamond = 0xaed;
+ public static final int XK_heart = 0xaee;
+ public static final int XK_maltesecross = 0xaf0;
+ public static final int XK_dagger = 0xaf1;
+ public static final int XK_doubledagger = 0xaf2;
+ public static final int XK_checkmark = 0xaf3;
+ public static final int XK_ballotcross = 0xaf4;
+ public static final int XK_musicalsharp = 0xaf5;
+ public static final int XK_musicalflat = 0xaf6;
+ public static final int XK_malesymbol = 0xaf7;
+ public static final int XK_femalesymbol = 0xaf8;
+ public static final int XK_telephone = 0xaf9;
+ public static final int XK_telephonerecorder = 0xafa;
+ public static final int XK_phonographcopyright = 0xafb;
+ public static final int XK_caret = 0xafc;
+ public static final int XK_singlelowquotemark = 0xafd;
+ public static final int XK_doublelowquotemark = 0xafe;
+ public static final int XK_cursor = 0xaff;
+
+ /*
+ * APL;
+ * Byte 3 = b;
+ */
+
+ public static final int XK_leftcaret = 0xba3;
+ public static final int XK_rightcaret = 0xba6;
+ public static final int XK_downcaret = 0xba8;
+ public static final int XK_upcaret = 0xba9;
+ public static final int XK_overbar = 0xbc0;
+ public static final int XK_downtack = 0xbc2;
+ public static final int XK_upshoe = 0xbc3;
+ public static final int XK_downstile = 0xbc4;
+ public static final int XK_underbar = 0xbc6;
+ public static final int XK_jot = 0xbca;
+ public static final int XK_quad = 0xbcc;
+ public static final int XK_uptack = 0xbce;
+ public static final int XK_circle = 0xbcf;
+ public static final int XK_upstile = 0xbd3;
+ public static final int XK_downshoe = 0xbd6;
+ public static final int XK_rightshoe = 0xbd8;
+ public static final int XK_leftshoe = 0xbda;
+ public static final int XK_lefttack = 0xbdc;
+ public static final int XK_righttack = 0xbfc;
+
+ /*
+ * Hebrew;
+ * Byte 3 = c;
+ */
+
+ public static final int XK_hebrew_doublelowline = 0xcdf;
+ public static final int XK_hebrew_aleph = 0xce0;
+ public static final int XK_hebrew_bet = 0xce1;
+ public static final int XK_hebrew_beth = 0xce1; /* deprecated */
+ public static final int XK_hebrew_gimel = 0xce2;
+ public static final int XK_hebrew_gimmel = 0xce2; /* deprecated */
+ public static final int XK_hebrew_dalet = 0xce3;
+ public static final int XK_hebrew_daleth = 0xce3; /* deprecated */
+ public static final int XK_hebrew_he = 0xce4;
+ public static final int XK_hebrew_waw = 0xce5;
+ public static final int XK_hebrew_zain = 0xce6;
+ public static final int XK_hebrew_zayin = 0xce6; /* deprecated */
+ public static final int XK_hebrew_chet = 0xce7;
+ public static final int XK_hebrew_het = 0xce7; /* deprecated */
+ public static final int XK_hebrew_tet = 0xce8;
+ public static final int XK_hebrew_teth = 0xce8; /* deprecated */
+ public static final int XK_hebrew_yod = 0xce9;
+ public static final int XK_hebrew_finalkaph = 0xcea;
+ public static final int XK_hebrew_kaph = 0xceb;
+ public static final int XK_hebrew_lamed = 0xcec;
+ public static final int XK_hebrew_finalmem = 0xced;
+ public static final int XK_hebrew_mem = 0xcee;
+ public static final int XK_hebrew_finalnun = 0xcef;
+ public static final int XK_hebrew_nun = 0xcf0;
+ public static final int XK_hebrew_samech = 0xcf1;
+ public static final int XK_hebrew_samekh = 0xcf1; /* deprecated */
+ public static final int XK_hebrew_ayin = 0xcf2;
+ public static final int XK_hebrew_finalpe = 0xcf3;
+ public static final int XK_hebrew_pe = 0xcf4;
+ public static final int XK_hebrew_finalzade = 0xcf5;
+ public static final int XK_hebrew_finalzadi = 0xcf5; /* deprecated */
+ public static final int XK_hebrew_zade = 0xcf6;
+ public static final int XK_hebrew_zadi = 0xcf6; /* deprecated */
+ public static final int XK_hebrew_qoph = 0xcf7;
+ public static final int XK_hebrew_kuf = 0xcf7; /* deprecated */
+ public static final int XK_hebrew_resh = 0xcf8;
+ public static final int XK_hebrew_shin = 0xcf9;
+ public static final int XK_hebrew_taw = 0xcfa;
+ public static final int XK_hebrew_taf = 0xcfa; /* deprecated */
+ public static final int XK_Hebrew_switch = 0xFF7E; /* Alias for mode_switch */
+
+ /*
+ * Thai;
+ * Byte 3 = d;
+ */
+
+ public static final int XK_Thai_kokai = 0xda1;
+ public static final int XK_Thai_khokhai = 0xda2;
+ public static final int XK_Thai_khokhuat = 0xda3;
+ public static final int XK_Thai_khokhwai = 0xda4;
+ public static final int XK_Thai_khokhon = 0xda5;
+ public static final int XK_Thai_khorakhang = 0xda6;
+ public static final int XK_Thai_ngongu = 0xda7;
+ public static final int XK_Thai_chochan = 0xda8;
+ public static final int XK_Thai_choching = 0xda9;
+ public static final int XK_Thai_chochang = 0xdaa;
+ public static final int XK_Thai_soso = 0xdab;
+ public static final int XK_Thai_chochoe = 0xdac;
+ public static final int XK_Thai_yoying = 0xdad;
+ public static final int XK_Thai_dochada = 0xdae;
+ public static final int XK_Thai_topatak = 0xdaf;
+ public static final int XK_Thai_thothan = 0xdb0;
+ public static final int XK_Thai_thonangmontho = 0xdb1;
+ public static final int XK_Thai_thophuthao = 0xdb2;
+ public static final int XK_Thai_nonen = 0xdb3;
+ public static final int XK_Thai_dodek = 0xdb4;
+ public static final int XK_Thai_totao = 0xdb5;
+ public static final int XK_Thai_thothung = 0xdb6;
+ public static final int XK_Thai_thothahan = 0xdb7;
+ public static final int XK_Thai_thothong = 0xdb8;
+ public static final int XK_Thai_nonu = 0xdb9;
+ public static final int XK_Thai_bobaimai = 0xdba;
+ public static final int XK_Thai_popla = 0xdbb;
+ public static final int XK_Thai_phophung = 0xdbc;
+ public static final int XK_Thai_fofa = 0xdbd;
+ public static final int XK_Thai_phophan = 0xdbe;
+ public static final int XK_Thai_fofan = 0xdbf;
+ public static final int XK_Thai_phosamphao = 0xdc0;
+ public static final int XK_Thai_moma = 0xdc1;
+ public static final int XK_Thai_yoyak = 0xdc2;
+ public static final int XK_Thai_rorua = 0xdc3;
+ public static final int XK_Thai_ru = 0xdc4;
+ public static final int XK_Thai_loling = 0xdc5;
+ public static final int XK_Thai_lu = 0xdc6;
+ public static final int XK_Thai_wowaen = 0xdc7;
+ public static final int XK_Thai_sosala = 0xdc8;
+ public static final int XK_Thai_sorusi = 0xdc9;
+ public static final int XK_Thai_sosua = 0xdca;
+ public static final int XK_Thai_hohip = 0xdcb;
+ public static final int XK_Thai_lochula = 0xdcc;
+ public static final int XK_Thai_oang = 0xdcd;
+ public static final int XK_Thai_honokhuk = 0xdce;
+ public static final int XK_Thai_paiyannoi = 0xdcf;
+ public static final int XK_Thai_saraa = 0xdd0;
+ public static final int XK_Thai_maihanakat = 0xdd1;
+ public static final int XK_Thai_saraaa = 0xdd2;
+ public static final int XK_Thai_saraam = 0xdd3;
+ public static final int XK_Thai_sarai = 0xdd4;
+ public static final int XK_Thai_saraii = 0xdd5;
+ public static final int XK_Thai_saraue = 0xdd6;
+ public static final int XK_Thai_sarauee = 0xdd7;
+ public static final int XK_Thai_sarau = 0xdd8;
+ public static final int XK_Thai_sarauu = 0xdd9;
+ public static final int XK_Thai_phinthu = 0xdda;
+ public static final int XK_Thai_maihanakat_maitho = 0xdde;
+ public static final int XK_Thai_baht = 0xddf;
+ public static final int XK_Thai_sarae = 0xde0;
+ public static final int XK_Thai_saraae = 0xde1;
+ public static final int XK_Thai_sarao = 0xde2;
+ public static final int XK_Thai_saraaimaimuan = 0xde3;
+ public static final int XK_Thai_saraaimaimalai = 0xde4;
+ public static final int XK_Thai_lakkhangyao = 0xde5;
+ public static final int XK_Thai_maiyamok = 0xde6;
+ public static final int XK_Thai_maitaikhu = 0xde7;
+ public static final int XK_Thai_maiek = 0xde8;
+ public static final int XK_Thai_maitho = 0xde9;
+ public static final int XK_Thai_maitri = 0xdea;
+ public static final int XK_Thai_maichattawa = 0xdeb;
+ public static final int XK_Thai_thanthakhat = 0xdec;
+ public static final int XK_Thai_nikhahit = 0xded;
+ public static final int XK_Thai_leksun = 0xdf0;
+ public static final int XK_Thai_leknung = 0xdf1;
+ public static final int XK_Thai_leksong = 0xdf2;
+ public static final int XK_Thai_leksam = 0xdf3;
+ public static final int XK_Thai_leksi = 0xdf4;
+ public static final int XK_Thai_lekha = 0xdf5;
+ public static final int XK_Thai_lekhok = 0xdf6;
+ public static final int XK_Thai_lekchet = 0xdf7;
+ public static final int XK_Thai_lekpaet = 0xdf8;
+ public static final int XK_Thai_lekkao = 0xdf9;
+
+ /*
+ * Korean;
+ * Byte 3 = e;
+ */
+
+ public static final int XK_Hangul = 0xff31; /* Hangul start/stop(toggle) */
+ public static final int XK_Hangul_Start = 0xff32; /* Hangul start */
+ public static final int XK_Hangul_End = 0xff33; /* Hangul end, English start */
+ public static final int XK_Hangul_Hanja = 0xff34; /* Start Hangul->Hanja Conversion */
+ public static final int XK_Hangul_Jamo = 0xff35; /* Hangul Jamo mode */
+ public static final int XK_Hangul_Romaja = 0xff36; /* Hangul Romaja mode */
+ public static final int XK_Hangul_Codeinput = 0xff37; /* Hangul code input mode */
+ public static final int XK_Hangul_Jeonja = 0xff38; /* Jeonja mode */
+ public static final int XK_Hangul_Banja = 0xff39; /* Banja mode */
+ public static final int XK_Hangul_PreHanja = 0xff3a; /* Pre Hanja conversion */
+ public static final int XK_Hangul_PostHanja = 0xff3b; /* Post Hanja conversion */
+ public static final int XK_Hangul_SingleCandidate = 0xff3c; /* Single candidate */
+ public static final int XK_Hangul_MultipleCandidate = 0xff3d; /* Multiple candidate */
+ public static final int XK_Hangul_PreviousCandidate = 0xff3e; /* Previous candidate */
+ public static final int XK_Hangul_Special = 0xff3f; /* Special symbols */
+ public static final int XK_Hangul_switch = 0xFF7E; /* Alias for mode_switch */
+
+ /* Hangul Consonant Characters */
+ public static final int XK_Hangul_Kiyeog = 0xea1;
+ public static final int XK_Hangul_SsangKiyeog = 0xea2;
+ public static final int XK_Hangul_KiyeogSios = 0xea3;
+ public static final int XK_Hangul_Nieun = 0xea4;
+ public static final int XK_Hangul_NieunJieuj = 0xea5;
+ public static final int XK_Hangul_NieunHieuh = 0xea6;
+ public static final int XK_Hangul_Dikeud = 0xea7;
+ public static final int XK_Hangul_SsangDikeud = 0xea8;
+ public static final int XK_Hangul_Rieul = 0xea9;
+ public static final int XK_Hangul_RieulKiyeog = 0xeaa;
+ public static final int XK_Hangul_RieulMieum = 0xeab;
+ public static final int XK_Hangul_RieulPieub = 0xeac;
+ public static final int XK_Hangul_RieulSios = 0xead;
+ public static final int XK_Hangul_RieulTieut = 0xeae;
+ public static final int XK_Hangul_RieulPhieuf = 0xeaf;
+ public static final int XK_Hangul_RieulHieuh = 0xeb0;
+ public static final int XK_Hangul_Mieum = 0xeb1;
+ public static final int XK_Hangul_Pieub = 0xeb2;
+ public static final int XK_Hangul_SsangPieub = 0xeb3;
+ public static final int XK_Hangul_PieubSios = 0xeb4;
+ public static final int XK_Hangul_Sios = 0xeb5;
+ public static final int XK_Hangul_SsangSios = 0xeb6;
+ public static final int XK_Hangul_Ieung = 0xeb7;
+ public static final int XK_Hangul_Jieuj = 0xeb8;
+ public static final int XK_Hangul_SsangJieuj = 0xeb9;
+ public static final int XK_Hangul_Cieuc = 0xeba;
+ public static final int XK_Hangul_Khieuq = 0xebb;
+ public static final int XK_Hangul_Tieut = 0xebc;
+ public static final int XK_Hangul_Phieuf = 0xebd;
+ public static final int XK_Hangul_Hieuh = 0xebe;
+
+ /* Hangul Vowel Characters */
+ public static final int XK_Hangul_A = 0xebf;
+ public static final int XK_Hangul_AE = 0xec0;
+ public static final int XK_Hangul_YA = 0xec1;
+ public static final int XK_Hangul_YAE = 0xec2;
+ public static final int XK_Hangul_EO = 0xec3;
+ public static final int XK_Hangul_E = 0xec4;
+ public static final int XK_Hangul_YEO = 0xec5;
+ public static final int XK_Hangul_YE = 0xec6;
+ public static final int XK_Hangul_O = 0xec7;
+ public static final int XK_Hangul_WA = 0xec8;
+ public static final int XK_Hangul_WAE = 0xec9;
+ public static final int XK_Hangul_OE = 0xeca;
+ public static final int XK_Hangul_YO = 0xecb;
+ public static final int XK_Hangul_U = 0xecc;
+ public static final int XK_Hangul_WEO = 0xecd;
+ public static final int XK_Hangul_WE = 0xece;
+ public static final int XK_Hangul_WI = 0xecf;
+ public static final int XK_Hangul_YU = 0xed0;
+ public static final int XK_Hangul_EU = 0xed1;
+ public static final int XK_Hangul_YI = 0xed2;
+ public static final int XK_Hangul_I = 0xed3;
+
+ /* Hangul syllable-final (JongSeong) Characters */
+ public static final int XK_Hangul_J_Kiyeog = 0xed4;
+ public static final int XK_Hangul_J_SsangKiyeog = 0xed5;
+ public static final int XK_Hangul_J_KiyeogSios = 0xed6;
+ public static final int XK_Hangul_J_Nieun = 0xed7;
+ public static final int XK_Hangul_J_NieunJieuj = 0xed8;
+ public static final int XK_Hangul_J_NieunHieuh = 0xed9;
+ public static final int XK_Hangul_J_Dikeud = 0xeda;
+ public static final int XK_Hangul_J_Rieul = 0xedb;
+ public static final int XK_Hangul_J_RieulKiyeog = 0xedc;
+ public static final int XK_Hangul_J_RieulMieum = 0xedd;
+ public static final int XK_Hangul_J_RieulPieub = 0xede;
+ public static final int XK_Hangul_J_RieulSios = 0xedf;
+ public static final int XK_Hangul_J_RieulTieut = 0xee0;
+ public static final int XK_Hangul_J_RieulPhieuf = 0xee1;
+ public static final int XK_Hangul_J_RieulHieuh = 0xee2;
+ public static final int XK_Hangul_J_Mieum = 0xee3;
+ public static final int XK_Hangul_J_Pieub = 0xee4;
+ public static final int XK_Hangul_J_PieubSios = 0xee5;
+ public static final int XK_Hangul_J_Sios = 0xee6;
+ public static final int XK_Hangul_J_SsangSios = 0xee7;
+ public static final int XK_Hangul_J_Ieung = 0xee8;
+ public static final int XK_Hangul_J_Jieuj = 0xee9;
+ public static final int XK_Hangul_J_Cieuc = 0xeea;
+ public static final int XK_Hangul_J_Khieuq = 0xeeb;
+ public static final int XK_Hangul_J_Tieut = 0xeec;
+ public static final int XK_Hangul_J_Phieuf = 0xeed;
+ public static final int XK_Hangul_J_Hieuh = 0xeee;
+
+ /* Ancient Hangul Consonant Characters */
+ public static final int XK_Hangul_RieulYeorinHieuh = 0xeef;
+ public static final int XK_Hangul_SunkyeongeumMieum = 0xef0;
+ public static final int XK_Hangul_SunkyeongeumPieub = 0xef1;
+ public static final int XK_Hangul_PanSios = 0xef2;
+ public static final int XK_Hangul_KkogjiDalrinIeung = 0xef3;
+ public static final int XK_Hangul_SunkyeongeumPhieuf = 0xef4;
+ public static final int XK_Hangul_YeorinHieuh = 0xef5;
+
+ /* Ancient Hangul Vowel Characters */
+ public static final int XK_Hangul_AraeA = 0xef6;
+ public static final int XK_Hangul_AraeAE = 0xef7;
+
+ /* Ancient Hangul syllable-final (JongSeong) Characters */
+ public static final int XK_Hangul_J_PanSios = 0xef8;
+ public static final int XK_Hangul_J_KkogjiDalrinIeung = 0xef9;
+ public static final int XK_Hangul_J_YeorinHieuh = 0xefa;
+
+ /* Korean currency symbol */
+ public static final int XK_Korean_Won = 0xeff;
+
+ public static final int XK_EcuSign = 0x20a0;
+ public static final int XK_ColonSign = 0x20a1;
+ public static final int XK_CruzeiroSign = 0x20a2;
+ public static final int XK_FFrancSign = 0x20a3;
+ public static final int XK_LiraSign = 0x20a4;
+ public static final int XK_MillSign = 0x20a5;
+ public static final int XK_NairaSign = 0x20a6;
+ public static final int XK_PesetaSign = 0x20a7;
+ public static final int XK_RupeeSign = 0x20a8;
+ public static final int XK_WonSign = 0x20a9;
+ public static final int XK_NewSheqelSign = 0x20aa;
+ public static final int XK_DongSign = 0x20ab;
+ public static final int XK_EuroSign = 0x20ac;
+
+}
diff --git a/java/com/tigervnc/rfb/Keysyms.java b/java/com/tigervnc/rfb/Keysyms.java
deleted file mode 100644
index 05f4682..0000000
--- a/java/com/tigervnc/rfb/Keysyms.java
+++ /dev/null
@@ -1,391 +0,0 @@
-/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
- * Copyright (C) 2012-2013 D. R. Commander. All Rights Reserved.
- * Copyright (C) 2013 Brian P. Hinz
- * Copyright (C) 2013 Pierre Ossman <ossman@cendio.se> for Cendio AB
- *
- * This is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this software; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
- * USA.
- */
-
-//
-// Keysyms - defines X keysyms for non-character keys. All keysyms
-// corresponding to characters should be generated by calling
-// UnicodeToKeysym.ucs2keysym().
-//
-
-package com.tigervnc.rfb;
-
-import java.awt.event.KeyEvent;
-import com.tigervnc.vncviewer.VncViewer;
-
-public class Keysyms {
-
- public static final int VoidSymbol = 0xffffff;
- /*
- * TTY Functions, cleverly chosen to map to ascii, for convenience of
- * programming, but could have been arbitrary (at the cost of lookup
- * tables in client code.
- */
- public static final int BackSpace = 0xFF08;
- public static final int Tab = 0xFF09;
- public static final int Linefeed = 0xFF0A;
- public static final int Clear = 0xFF0B;
- public static final int Return = 0xFF0D;
- public static final int Pause = 0xFF13;
- public static final int Scroll_Lock = 0xFF14;
- public static final int Sys_Req = 0xFF15;
- public static final int Escape = 0xFF1B;
- public static final int Delete = 0xFFFF;
-
- /* International & multi-key character composition */
- public static final int Multi_key = 0xFF20; /* Multi-key character compose */
- public static final int Codeinput = 0xFF37;
- public static final int SingleCandidate = 0xFF3C;
- public static final int MultipleCandidate = 0xFF3D;
- public static final int PreviousCandidate = 0xFF3E;
-
- /* Japanese keyboard support */
- public static final int Kanji = 0xFF21; /* Kanji, Kanji convert */
- public static final int Muhenkan = 0xFF22; /* Cancel Conversion */
- public static final int Henkan_Mode = 0xFF23; /* Start/Stop Conversion */
- public static final int Henkan = 0xFF23; /* Alias for Henkan_Mode */
- public static final int Romaji = 0xFF24; /* to Romaji */
- public static final int Hiragana = 0xFF25; /* to Hiragana */
- public static final int Katakana = 0xFF26; /* to Katakana */
- public static final int Hiragana_Katakana = 0xFF27; /* Hiragana/Katakana toggle */
- public static final int Zenkaku = 0xFF28; /* to Zenkaku */
- public static final int Hankaku = 0xFF29; /* to Hankaku */
- public static final int Zenkaku_Hankaku = 0xFF2A; /* Zenkaku/Hankaku toggle */
- public static final int Touroku = 0xFF2B; /* Add to Dictionary */
- public static final int Massyo = 0xFF2C; /* Delete from Dictionary */
- public static final int Kana_Lock = 0xFF2D; /* Kana Lock */
- public static final int Kana_Shift = 0xFF2E; /* Kana Shift */
- public static final int Eisu_Shift = 0xFF2F; /* Alphanumeric Shift */
- public static final int Eisu_toggle = 0xFF30; /* Alphanumeric toggle */
- public static final int Kanji_Bangou = 0xFF37; /* Codeinput */
- public static final int Zen_Koho = 0xFF3D; /* Multiple/All Candidate(s) */
- public static final int Mae_Koho = 0xFF3E; /* Previous Candidate */
-
- /* Cursor control & motion */
- public static final int Home = 0xFF50;
- public static final int Left = 0xFF51;
- public static final int Up = 0xFF52;
- public static final int Right = 0xFF53;
- public static final int Down = 0xFF54;
- public static final int Prior = 0xFF55;
- public static final int Page_Up = 0xFF55;
- public static final int Next = 0xFF56;
- public static final int Page_Down = 0xFF56;
- public static final int End = 0xFF57;
- public static final int Begin = 0xFF58;
-
- /* Misc Functions */
- public static final int Select = 0xFF60;
- public static final int Print = 0xFF61;
- public static final int Execute = 0xFF62;
- public static final int Insert = 0xFF63;
- public static final int Undo = 0xFF65;
- public static final int Redo = 0xFF66;
- public static final int Menu = 0xFF67;
- public static final int Find = 0xFF68;
- public static final int Cancel = 0xFF69;
- public static final int Help = 0xFF6A;
- public static final int Break = 0xFF6B;
- public static final int Mode_switch = 0xFF7E;
- public static final int script_switch = 0xFF7E;
- public static final int Num_Lock = 0xFF7F;
-
- /* Keypad Functions, keypad numbers cleverly chosen to map to ascii */
- public static final int KP_Enter = 0xFF8D;
- public static final int KP_Home = 0xFF95;
- public static final int KP_Left = 0xFF96;
- public static final int KP_Up = 0xFF97;
- public static final int KP_Right = 0xFF98;
- public static final int KP_Down = 0xFF99;
- public static final int KP_Page_Up = 0xFF9A;
- public static final int KP_Page_Down = 0xFF9B;
- public static final int KP_End = 0xFF9C;
- public static final int KP_Begin = 0xFF9D;
- public static final int KP_Insert = 0xFF9E;
- public static final int KP_Delete = 0xFF9F;
- public static final int KP_Equal = 0xFFBD;
- public static final int KP_0 = 0xFFB0;
- public static final int KP_1 = 0xFFB1;
- public static final int KP_2 = 0xFFB2;
- public static final int KP_3 = 0xFFB3;
- public static final int KP_4 = 0xFFB4;
- public static final int KP_5 = 0xFFB5;
- public static final int KP_6 = 0xFFB6;
- public static final int KP_7 = 0xFFB7;
- public static final int KP_8 = 0xFFB8;
- public static final int KP_9 = 0xFFB9;
- public static final int KP_Decimal = 0xFFAE;
- public static final int KP_Add = 0xFFAB;
- public static final int KP_Subtract = 0xFFAD;
- public static final int KP_Multiply = 0xFFAA;
- public static final int KP_Divide = 0xFFAF;
-
- /*
- * Auxilliary Functions; note the duplicate definitions for left and right
- * function keys; Sun keyboards and a few other manufactures 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.
- */
- public static final int F1 = 0xFFBE;
- public static final int F2 = 0xFFBF;
- public static final int F3 = 0xFFC0;
- public static final int F4 = 0xFFC1;
- public static final int F5 = 0xFFC2;
- public static final int F6 = 0xFFC3;
- public static final int F7 = 0xFFC4;
- public static final int F8 = 0xFFC5;
- public static final int F9 = 0xFFC6;
- public static final int F10 = 0xFFC7;
- public static final int F11 = 0xFFC8;
- public static final int F12 = 0xFFC9;
- public static final int F13 = 0xFFCA;
- public static final int F14 = 0xFFCB;
- public static final int F15 = 0xFFCC;
- public static final int F16 = 0xFFCD;
- public static final int F17 = 0xFFCE;
- public static final int F18 = 0xFFCF;
- public static final int F19 = 0xFFD0;
- public static final int F20 = 0xFFD1;
- public static final int F21 = 0xFFD2;
- public static final int F22 = 0xFFD3;
- public static final int F23 = 0xFFD4;
- public static final int F24 = 0xFFD5;
-
- /* Modifiers */
- public static final int Shift_L = 0xFFE1;
- public static final int Shift_R = 0xFFE2;
- public static final int Control_L = 0xFFE3;
- public static final int Control_R = 0xFFE4;
- public static final int Caps_Lock = 0xFFE5;
- public static final int Shift_Lock = 0xFFE6;
-
- public static final int Meta_L = 0xFFE7;
- public static final int Meta_R = 0xFFE8;
- public static final int Alt_L = 0xFFE9;
- public static final int Alt_R = 0xFFEA;
- public static final int Super_L = 0xFFEB;
- public static final int Super_R = 0xFFEC;
- public static final int Hyper_L = 0xFFED;
- public static final int Hyper_R = 0xFFEE;
-
- /*
- * ISO 9995 Function and Modifier Keys
- * Byte 3 = 0xFE
- */
- public static final int ISO_Level3_Shift = 0xFE03;
-
- /*
- * Dead Modifier Keys
- */
- public static final int Dead_Grave = 0xfe50; /* COMBINING GRAVE ACCENT */
- public static final int Dead_Acute = 0xfe51; /* COMBINING ACUTE ACCENT */
- public static final int Dead_Circumflex = 0xfe52; /* COMBINING CIRCUMFLEX ACCENT */
- public static final int Dead_Tilde = 0xfe53; /* COMBINING TILDE */
- public static final int Dead_Macron = 0xfe54; /* COMBINING MACRON */
- public static final int Dead_Breve = 0xfe55; /* COMBINING BREVE */
- public static final int Dead_AboveDot = 0xfe56; /* COMBINING DOT ABOVE */
- public static final int Dead_Diaeresis = 0xfe57; /* COMBINING DIAERESIS */
- public static final int Dead_AboveRing = 0xfe58; /* COMBINING RING ABOVE */
- public static final int Dead_DoubleAcute = 0xfe59; /* COMBINING DOUBLE ACUTE ACCENT */
- public static final int Dead_Caron = 0xfe5a; /* COMBINING CARON */
- public static final int Dead_Cedilla = 0xfe5b; /* COMBINING CEDILLA */
- public static final int Dead_Ogonek = 0xfe5c; /* COMBINING OGONEK */
- public static final int Dead_Iota = 0xfe5d; /* MODIFIER LETTER SMALL IOTA */
- public static final int Dead_Voiced_Sound = 0xfe5e; /* COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK */
- public static final int Dead_SemiVoiced_Sound = 0xfe5f; /* COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */
- public static final int Dead_BelowDot = 0xfe60; /* COMBINING DOT BELOW */
-
- private static class KeySymbol {
- public KeySymbol(int keycode_, int[] keysym_) {
- keycode = keycode_;
- keysym = new int[5];
- System.arraycopy(keysym_, 0, keysym, 0, 5);
- }
- int keycode;
- int[] keysym;
- }
-
- private static KeySymbol[] keySymbols = {
- /* KEYCODE LOCATION */
- /* UNKNOWN STANDARD LEFT RIGHT NUMPAD */
- new KeySymbol(KeyEvent.VK_BACK_SPACE, new int[]{VoidSymbol, BackSpace, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_TAB, new int[]{VoidSymbol, Tab, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_ENTER, new int[]{VoidSymbol, Return, VoidSymbol, VoidSymbol, KP_Enter}),
- new KeySymbol(KeyEvent.VK_ESCAPE, new int[]{VoidSymbol, Escape, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_CONTROL, new int[]{VoidSymbol, Control_L, Control_L, Control_R, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_ALT_GRAPH, new int[]{VoidSymbol, ISO_Level3_Shift, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_ALT, new int[]{VoidSymbol, ISO_Level3_Shift, Alt_L, Alt_R, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_SHIFT, new int[]{VoidSymbol, Shift_L, Shift_L, Shift_R, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_META, new int[]{VoidSymbol, Meta_L, Meta_L, Meta_R, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_NUMPAD0, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_0}),
- new KeySymbol(KeyEvent.VK_NUMPAD1, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_1}),
- new KeySymbol(KeyEvent.VK_NUMPAD2, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_2}),
- new KeySymbol(KeyEvent.VK_NUMPAD3, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_3}),
- new KeySymbol(KeyEvent.VK_NUMPAD4, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_4}),
- new KeySymbol(KeyEvent.VK_NUMPAD5, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_5}),
- new KeySymbol(KeyEvent.VK_NUMPAD6, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_6}),
- new KeySymbol(KeyEvent.VK_NUMPAD7, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_7}),
- new KeySymbol(KeyEvent.VK_NUMPAD8, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_8}),
- new KeySymbol(KeyEvent.VK_NUMPAD9, new int[]{VoidSymbol, VoidSymbol, VoidSymbol, VoidSymbol, KP_9}),
- new KeySymbol(KeyEvent.VK_DECIMAL, new int[]{VoidSymbol, KP_Decimal, VoidSymbol, VoidSymbol, KP_Decimal}),
- new KeySymbol(KeyEvent.VK_ADD, new int[]{VoidSymbol, KP_Add, VoidSymbol, VoidSymbol, KP_Add}),
- new KeySymbol(KeyEvent.VK_SUBTRACT, new int[]{VoidSymbol, KP_Subtract, VoidSymbol, VoidSymbol, KP_Subtract}),
- new KeySymbol(KeyEvent.VK_MULTIPLY, new int[]{VoidSymbol, KP_Multiply, VoidSymbol, VoidSymbol, KP_Multiply}),
- new KeySymbol(KeyEvent.VK_DIVIDE, new int[]{VoidSymbol, KP_Divide, VoidSymbol, VoidSymbol, KP_Divide}),
- new KeySymbol(KeyEvent.VK_DELETE, new int[]{VoidSymbol, Delete, VoidSymbol, VoidSymbol, KP_Delete}),
- new KeySymbol(KeyEvent.VK_CLEAR, new int[]{VoidSymbol, Clear, VoidSymbol, VoidSymbol, KP_Begin}),
- new KeySymbol(KeyEvent.VK_HOME, new int[]{VoidSymbol, Home, VoidSymbol, VoidSymbol, KP_Home}),
- new KeySymbol(KeyEvent.VK_END, new int[]{VoidSymbol, End, VoidSymbol, VoidSymbol, KP_End}),
- new KeySymbol(KeyEvent.VK_PAGE_UP, new int[]{VoidSymbol, Page_Up, VoidSymbol, VoidSymbol, KP_Page_Up}),
- new KeySymbol(KeyEvent.VK_PAGE_DOWN, new int[]{VoidSymbol, Page_Down, VoidSymbol, VoidSymbol, KP_Page_Down}),
- new KeySymbol(KeyEvent.VK_UP, new int[]{VoidSymbol, Up, VoidSymbol, VoidSymbol, KP_Up}),
- new KeySymbol(KeyEvent.VK_DOWN, new int[]{VoidSymbol, Down, VoidSymbol, VoidSymbol, KP_Down}),
- new KeySymbol(KeyEvent.VK_LEFT, new int[]{VoidSymbol, Left, VoidSymbol, VoidSymbol, KP_Left}),
- new KeySymbol(KeyEvent.VK_RIGHT, new int[]{VoidSymbol, Right, VoidSymbol, VoidSymbol, KP_Right}),
- new KeySymbol(KeyEvent.VK_BEGIN, new int[]{VoidSymbol, Begin, VoidSymbol, VoidSymbol, KP_Begin}),
- new KeySymbol(KeyEvent.VK_KP_LEFT, new int[]{VoidSymbol, KP_Left, VoidSymbol, VoidSymbol, KP_Left}),
- new KeySymbol(KeyEvent.VK_KP_UP, new int[]{VoidSymbol, KP_Up, VoidSymbol, VoidSymbol, KP_Up}),
- new KeySymbol(KeyEvent.VK_KP_RIGHT, new int[]{VoidSymbol, KP_Right, VoidSymbol, VoidSymbol, KP_Right}),
- new KeySymbol(KeyEvent.VK_KP_DOWN, new int[]{VoidSymbol, KP_Down, VoidSymbol, VoidSymbol, KP_Down}),
- new KeySymbol(KeyEvent.VK_PRINTSCREEN, new int[]{VoidSymbol, Print, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_SCROLL_LOCK, new int[]{VoidSymbol, Scroll_Lock, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_CAPS_LOCK, new int[]{VoidSymbol, Caps_Lock, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_NUM_LOCK, new int[]{VoidSymbol, Num_Lock, VoidSymbol, VoidSymbol, Num_Lock}),
- new KeySymbol(KeyEvent.VK_INSERT, new int[]{VoidSymbol, Insert, VoidSymbol, VoidSymbol, KP_Insert}),
- new KeySymbol(KeyEvent.VK_AGAIN, new int[]{VoidSymbol, Redo, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_UNDO, new int[]{VoidSymbol, Undo, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_FIND, new int[]{VoidSymbol, Find, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_STOP, new int[]{VoidSymbol, Cancel, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_HELP, new int[]{VoidSymbol, Help, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_WINDOWS, new int[]{VoidSymbol, Super_L, Super_L, Super_R, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_CONTEXT_MENU, new int[]{VoidSymbol, Menu, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_KANJI, new int[]{VoidSymbol, Kanji, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_KATAKANA, new int[]{VoidSymbol, Katakana, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_HIRAGANA, new int[]{VoidSymbol, Hiragana, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_PREVIOUS_CANDIDATE,
- new int[]{VoidSymbol, PreviousCandidate,VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_CODE_INPUT, new int[]{VoidSymbol, Codeinput, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_JAPANESE_ROMAN,
- new int[]{VoidSymbol, Romaji, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_KANA_LOCK, new int[]{VoidSymbol, Kana_Lock, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_ABOVEDOT,new int[]{VoidSymbol, Dead_AboveDot, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_ABOVERING,
- new int[]{VoidSymbol, Dead_AboveRing, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_ACUTE, new int[]{VoidSymbol, Dead_Acute, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_BREVE, new int[]{VoidSymbol, Dead_Breve, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_CARON, new int[]{VoidSymbol, Dead_Caron, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_CIRCUMFLEX,
- new int[]{VoidSymbol, Dead_Circumflex, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_DIAERESIS,
- new int[]{VoidSymbol, Dead_Diaeresis, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_DOUBLEACUTE,
- new int[]{VoidSymbol, Dead_DoubleAcute, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_GRAVE, new int[]{VoidSymbol, Dead_Grave, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_IOTA, new int[]{VoidSymbol, Dead_Iota, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_MACRON, new int[]{VoidSymbol, Dead_Macron, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_OGONEK, new int[]{VoidSymbol, Dead_Ogonek, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_SEMIVOICED_SOUND,
- new int[]{VoidSymbol, Dead_SemiVoiced_Sound,VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_TILDE, new int[]{VoidSymbol, Dead_Tilde, VoidSymbol, VoidSymbol, VoidSymbol}),
- new KeySymbol(KeyEvent.VK_DEAD_VOICED_SOUND,
- new int[]{VoidSymbol, Dead_Voiced_Sound, VoidSymbol, VoidSymbol, VoidSymbol}),
- };
-
- public static int translateKeyEvent(KeyEvent ev) {
- int location = ev.getKeyLocation();
- int keyCode = ev.getKeyCode();
-
- // First check for function keys
- if (keyCode >= KeyEvent.VK_F1 && keyCode <= KeyEvent.VK_F12)
- return Keysyms.F1 + keyCode - KeyEvent.VK_F1;
- if (keyCode >= KeyEvent.VK_F13 && keyCode <= KeyEvent.VK_F24)
- return Keysyms.F13 + keyCode - KeyEvent.VK_F13;
-
- // Numpad numbers
- if (keyCode >= KeyEvent.VK_0 && keyCode <= KeyEvent.VK_9 &&
- location == KeyEvent.KEY_LOCATION_NUMPAD)
- return Keysyms.KP_0 + keyCode - KeyEvent.VK_0;
-
- if (VncViewer.os.startsWith("mac os x")) {
- // Alt on OS X behaves more like AltGr on other systems, and to get
- // sane behaviour we should translate things in that manner for the
- // remote VNC server. However that means we lose the ability to use
- // Alt as a shortcut modifier. Do what RealVNC does and hijack the
- // left command key as an Alt replacement.
- switch (keyCode) {
- case KeyEvent.VK_META:
- if (location == KeyEvent.KEY_LOCATION_LEFT)
- return Alt_L;
- else
- return Super_L;
- case KeyEvent.VK_ALT:
- if (location == KeyEvent.KEY_LOCATION_LEFT)
- return Alt_L;
- else
- return ISO_Level3_Shift;
- }
- }
-
- // Then other special keys
- if (keyCode == KeyEvent.VK_PAUSE)
- return (ev.isControlDown() ? Break : Pause);
- else if (keyCode == KeyEvent.VK_PRINTSCREEN)
- return (ev.isControlDown() ? Sys_Req : Print);
- else
- for(int i = 0; i < keySymbols.length; i++)
- if (keySymbols[i].keycode == keyCode)
- return (keySymbols[i].keysym)[location];
-
- // Unknown special key?
- if (KeyEvent.getKeyText(keyCode).isEmpty()) {
- vlog.error("Unknown key code:");
- String fmt = ev.paramString().replaceAll("%","%%");
- vlog.error(String.format(fmt.replaceAll(",","%n ")));
- return VoidSymbol;
- }
-
- char keyChar = ev.getKeyChar();
- if (!ev.isControlDown() && keyChar != KeyEvent.CHAR_UNDEFINED)
- return UnicodeToKeysym.ucs2keysym(Character.toString(keyChar).codePointAt(0));
-
- int key = keyChar;
- if (ev.isControlDown()) {
- // For CTRL-<letter>, CTRL is sent separately, so just send <letter>.
- if ((key >= 1 && key <= 26 && !ev.isShiftDown()) ||
- // CTRL-{, CTRL-|, CTRL-} also map to ASCII 96-127
- (key >= 27 && key <= 29 && ev.isShiftDown()))
- key += 96;
- // For CTRL-SHIFT-<letter>, send capital <letter> to emulate behavior
- // of Linux. For CTRL-@, send @. For CTRL-_, send _. For CTRL-^,
- // send ^.
- else if (key < 32)
- key += 64;
- // Windows and Mac sometimes return CHAR_UNDEFINED with CTRL-SHIFT
- // combinations, so best we can do is send the key code if it is
- // a valid ASCII symbol.
- else if (ev.getKeyChar() == KeyEvent.CHAR_UNDEFINED && keyCode >= 0 &&
- keyCode <= 127)
- key = keyCode;
- }
- return UnicodeToKeysym.ucs2keysym(key);
- }
-
- static LogWriter vlog = new LogWriter("Keysyms");
-}
diff --git a/java/com/tigervnc/vncviewer/CConn.java b/java/com/tigervnc/vncviewer/CConn.java
index 398ba9d..d71c307 100644
--- a/java/com/tigervnc/vncviewer/CConn.java
+++ b/java/com/tigervnc/vncviewer/CConn.java
@@ -1,7 +1,7 @@
/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
* Copyright 2009-2013 Pierre Ossman <ossman@cendio.se> for Cendio AB
* Copyright (C) 2011-2013 D. R. Commander. All Rights Reserved.
- * Copyright (C) 2011-2015 Brian P. Hinz
+ * Copyright (C) 2011-2017 Brian P. Hinz
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -77,10 +77,6 @@
static final PixelFormat mediumColorPF =
new PixelFormat(8, 8, false, true, 7, 7, 3, 5, 2, 0);
- static final int KEY_LOC_SHIFT_R = 0;
- static final int KEY_LOC_SHIFT_L = 16;
- static final int SUPER_MASK = 1<<15;
-
////////////////////////////////////////////////////////////////////
// The following methods are all called from the RFB thread
@@ -95,7 +91,6 @@
setShared(shared.getValue());
sock = socket;
- downKeySym = new HashMap<Integer, Integer>();
upg = this;
@@ -706,47 +701,6 @@
}
}
- void showInfo() {
- Window fullScreenWindow = DesktopWindow.getFullScreenWindow();
- if (fullScreenWindow != null)
- DesktopWindow.setFullScreenWindow(null);
- String info = new String("Desktop name: %s%n"+
- "Host: %s:%d%n"+
- "Size: %dx%d%n"+
- "Pixel format: %s%n"+
- " (server default: %s)%n"+
- "Requested encoding: %s%n"+
- "Last used encoding: %s%n"+
- "Line speed estimate: %d kbit/s%n"+
- "Protocol version: %d.%d%n"+
- "Security method: %s [%s]%n");
- String msg =
- String.format(info, cp.name(),
- sock.getPeerName(), sock.getPeerPort(),
- cp.width, cp.height,
- cp.pf().print(),
- serverPF.print(),
- Encodings.encodingName(currentEncoding),
- Encodings.encodingName(lastServerEncoding),
- sock.inStream().kbitsPerSecond(),
- cp.majorVersion, cp.minorVersion,
- Security.secTypeName(csecurity.getType()),
- csecurity.description());
- JOptionPane op = new JOptionPane(msg, JOptionPane.PLAIN_MESSAGE,
- JOptionPane.DEFAULT_OPTION);
- JDialog dlg = op.createDialog(desktop, "VNC connection info");
- dlg.setIconImage(VncViewer.frameIcon);
- dlg.setAlwaysOnTop(true);
- dlg.setVisible(true);
- if (fullScreenWindow != null)
- DesktopWindow.setFullScreenWindow(fullScreenWindow);
- }
-
- public void refresh() {
- writer().writeFramebufferUpdateRequest(new Rect(0,0,cp.width,cp.height), false);
- pendingUpdate = true;
- }
-
// writeClientCutText() is called from the clipboard dialog
public void writeClientCutText(String str, int len) {
if (state() != RFBSTATE_NORMAL || shuttingDown)
@@ -754,147 +708,6 @@
writer().writeClientCutText(str, len);
}
- public void writeKeyEvent(int keysym, boolean down) {
- if (state() != RFBSTATE_NORMAL || shuttingDown)
- return;
- writer().keyEvent(keysym, down);
- }
-
- public void writeKeyEvent(KeyEvent ev) {
- if (viewOnly.getValue() || shuttingDown)
- return;
-
- boolean down = (ev.getID() == KeyEvent.KEY_PRESSED);
-
- int keySym, keyCode = ev.getKeyCode();
-
- // If neither the keyCode or keyChar are defined, then there's
- // really nothing that we can do with this. The fn key on OS-X
- // fires events like this when pressed but does not fire a
- // corresponding release event.
- if (keyCode == 0 && ev.getKeyChar() == KeyEvent.CHAR_UNDEFINED)
- return;
-
- if (!down) {
- Integer iter = downKeySym.get(keyCode);
- if (iter == null) {
- // Note that dead keys will raise this sort of error falsely
- // See https://bugs.openjdk.java.net/browse/JDK-6534883
- vlog.debug("Unexpected key release of keyCode "+keyCode);
- String fmt = ev.paramString().replaceAll("%","%%");
- vlog.debug(String.format(fmt.replaceAll(",","%n ")));
-
- return;
- }
-
- vlog.debug(String.format("Key released: 0x%04x => 0x%04x",
- keyCode, iter));
-
- writeKeyEvent(iter, false);
- downKeySym.remove(keyCode);
-
- return;
- }
-
- keySym = Keysyms.translateKeyEvent(ev);
- if (keySym == Keysyms.VoidSymbol)
- return;
-
- boolean need_cheat = true;
- if (VncViewer.os.startsWith("windows")) {
- // Windows doesn't have a proper AltGr, but handles it using fake
- // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
- // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
- // get everything in the correct state. Cheat and temporarily release
- // Ctrl and Alt whenever we get a key with a symbol.
- if (KeyEvent.getKeyText(keyCode).isEmpty())
- need_cheat = false;
- else if (!downKeySym.containsValue(Keysyms.Control_L) &&
- !downKeySym.containsValue(Keysyms.Control_R))
- need_cheat = false;
- else if (!downKeySym.containsValue(Keysyms.Alt_L) &&
- !downKeySym.containsValue(Keysyms.Alt_R))
- need_cheat = false;
-
- if (need_cheat) {
- vlog.info("Faking release of AltGr (Ctrl+Alt)");
- if (downKeySym.containsValue(Keysyms.Control_L))
- writeKeyEvent(Keysyms.Control_L, false);
- if (downKeySym.containsValue(Keysyms.Control_R))
- writeKeyEvent(Keysyms.Control_R, false);
- if (downKeySym.containsValue(Keysyms.Alt_L))
- writeKeyEvent(Keysyms.Alt_L, false);
- if (downKeySym.containsValue(Keysyms.Alt_R))
- writeKeyEvent(Keysyms.Alt_R, false);
- }
- }
-
- vlog.debug(String.format("Key pressed: 0x%04x '%s' => 0x%04x",
- keyCode, Character.toString(ev.getKeyChar()), keySym));
-
- downKeySym.put(keyCode, keySym);
-
- writeKeyEvent(keySym, down);
-
- if (VncViewer.os.startsWith("windows")) {
- if (need_cheat) {
- vlog.debug("Restoring AltGr state");
- if (downKeySym.containsValue(Keysyms.Control_L))
- writeKeyEvent(Keysyms.Control_L, true);
- if (downKeySym.containsValue(Keysyms.Control_R))
- writeKeyEvent(Keysyms.Control_R, true);
- if (downKeySym.containsValue(Keysyms.Alt_L))
- writeKeyEvent(Keysyms.Alt_L, true);
- if (downKeySym.containsValue(Keysyms.Alt_R))
- writeKeyEvent(Keysyms.Alt_R, true);
- }
- }
- }
-
- public void writePointerEvent(MouseEvent ev) {
- if (state() != RFBSTATE_NORMAL || shuttingDown)
- return;
-
- switch (ev.getID()) {
- case MouseEvent.MOUSE_PRESSED:
- buttonMask = 1;
- if ((ev.getModifiers() & KeyEvent.ALT_MASK) != 0) buttonMask = 2;
- if ((ev.getModifiers() & KeyEvent.META_MASK) != 0) buttonMask = 4;
- break;
- case MouseEvent.MOUSE_RELEASED:
- buttonMask = 0;
- break;
- }
-
- writer().pointerEvent(new Point(ev.getX(), ev.getY()), buttonMask);
- }
-
- public void writeWheelEvent(MouseWheelEvent ev) {
- if (state() != RFBSTATE_NORMAL || shuttingDown)
- return;
- int x, y;
- int clicks = ev.getWheelRotation();
- if (clicks < 0) {
- buttonMask = 8;
- } else {
- buttonMask = 16;
- }
- for (int i = 0; i < Math.abs(clicks); i++) {
- x = ev.getX();
- y = ev.getY();
- writer().pointerEvent(new Point(x, y), buttonMask);
- buttonMask = 0;
- writer().pointerEvent(new Point(x, y), buttonMask);
- }
-
- }
-
- synchronized void releaseDownKeys() {
- for (Map.Entry<Integer, Integer> entry : downKeySym.entrySet())
- writeKeyEvent(entry.getValue(), false);
- downKeySym.clear();
- }
-
// this is a special ActionListener passed in by the
// Java Plug-in software to control applet's close behavior
public void setCloseListener(ActionListener cl) {
@@ -930,8 +743,6 @@
// from when constructed).
// the following are only ever accessed by the GUI thread:
- int buttonMask;
-
private String serverHost;
private int serverPort;
private Socket sock;
@@ -957,7 +768,6 @@
private boolean supportsSyncFence;
- private HashMap<Integer, Integer> downKeySym;
public ActionListener closeListener = null;
static LogWriter vlog = new LogWriter("CConn");
diff --git a/java/com/tigervnc/vncviewer/DesktopWindow.java b/java/com/tigervnc/vncviewer/DesktopWindow.java
index 4169c76..42ecad8 100644
--- a/java/com/tigervnc/vncviewer/DesktopWindow.java
+++ b/java/com/tigervnc/vncviewer/DesktopWindow.java
@@ -81,7 +81,7 @@
scroll.getViewport().getView().requestFocusInWindow();
}
public void windowLostFocus(WindowEvent e) {
- cc.releaseDownKeys();
+ viewport.releaseDownKeys();
}
});
diff --git a/java/com/tigervnc/vncviewer/F8Menu.java b/java/com/tigervnc/vncviewer/F8Menu.java
deleted file mode 100644
index 0c67305..0000000
--- a/java/com/tigervnc/vncviewer/F8Menu.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/* Copyright (C) 2002-2005 RealVNC Ltd. All Rights Reserved.
- * Copyright (C) 2011-2014 Brian P. Hinz
- *
- * This is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this software; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
- * USA.
- */
-
-package com.tigervnc.vncviewer;
-
-import java.awt.*;
-import java.awt.Cursor;
-import java.awt.event.*;
-import java.io.File;
-import javax.swing.filechooser.*;
-import javax.swing.JCheckBoxMenuItem;
-import javax.swing.JDialog;
-import javax.swing.JFrame;
-import javax.swing.JFileChooser;
-import javax.swing.JMenuItem;
-import javax.swing.JOptionPane;
-import javax.swing.JPopupMenu;
-
-import com.tigervnc.rfb.*;
-
-import static com.tigervnc.vncviewer.Parameters.*;
-
-public class F8Menu extends JPopupMenu implements ActionListener {
- public F8Menu(CConn cc) {
- super("VNC Menu");
- setLightWeightPopupEnabled(false);
- String os = System.getProperty("os.name");
- if (os.startsWith("Windows"))
- com.sun.java.swing.plaf.windows.WindowsLookAndFeel.setMnemonicHidden(false);
- this.cc = cc;
- restore = addMenuItem("Restore",KeyEvent.VK_R);
- restore.setEnabled(!embed.getValue());
- move = addMenuItem("Move");
- move.setEnabled(false);
- size = addMenuItem("Size");
- size.setEnabled(false);
- minimize = addMenuItem("Minimize", KeyEvent.VK_N);
- minimize.setEnabled(!embed.getValue());
- maximize = addMenuItem("Maximize", KeyEvent.VK_X);
- maximize.setEnabled(!embed.getValue());
- addSeparator();
- exit = addMenuItem("Close Viewer", KeyEvent.VK_C);
- addSeparator();
- fullScreenCheckbox = new JCheckBoxMenuItem("Full Screen");
- fullScreenCheckbox.setMnemonic(KeyEvent.VK_F);
- fullScreenCheckbox.setSelected(fullScreen.getValue());
- fullScreenCheckbox.addActionListener(this);
- fullScreenCheckbox.setEnabled(!embed.getValue());
- add(fullScreenCheckbox);
- addSeparator();
- clipboard = addMenuItem("Clipboard...");
- addSeparator();
- int keyCode = MenuKey.getMenuKeyCode();
- String keyText = KeyEvent.getKeyText(keyCode);
- f8 = addMenuItem("Send "+keyText, keyCode);
- ctrlAltDel = addMenuItem("Send Ctrl-Alt-Del");
- addSeparator();
- refresh = addMenuItem("Refresh Screen", KeyEvent.VK_H);
- addSeparator();
- newConn = addMenuItem("New connection...", KeyEvent.VK_W);
- newConn.setEnabled(!embed.getValue());
- options = addMenuItem("Options...", KeyEvent.VK_O);
- save = addMenuItem("Save connection info as...", KeyEvent.VK_S);
- info = addMenuItem("Connection info...", KeyEvent.VK_I);
- about = addMenuItem("About VncViewer...", KeyEvent.VK_A);
- addSeparator();
- dismiss = addMenuItem("Dismiss menu");
- setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
- }
-
- JMenuItem addMenuItem(String str, int mnemonic) {
- JMenuItem item = new JMenuItem(str, mnemonic);
- item.addActionListener(this);
- add(item);
- return item;
- }
-
- JMenuItem addMenuItem(String str) {
- JMenuItem item = new JMenuItem(str);
- item.addActionListener(this);
- add(item);
- return item;
- }
-
- boolean actionMatch(ActionEvent ev, JMenuItem item) {
- return ev.getActionCommand().equals(item.getActionCommand());
- }
-
- public void actionPerformed(ActionEvent ev) {
- if (actionMatch(ev, exit)) {
- cc.close();
- } else if (actionMatch(ev, fullScreenCheckbox)) {
- if (fullScreenCheckbox.isSelected())
- cc.desktop.fullscreen_on();
- else
- cc.desktop.fullscreen_off();
- } else if (actionMatch(ev, restore)) {
- if (cc.desktop.fullscreen_active())
- cc.desktop.fullscreen_off();
- cc.desktop.setExtendedState(JFrame.NORMAL);
- } else if (actionMatch(ev, minimize)) {
- if (cc.desktop.fullscreen_active())
- cc.desktop.fullscreen_off();
- cc.desktop.setExtendedState(JFrame.ICONIFIED);
- } else if (actionMatch(ev, maximize)) {
- if (cc.desktop.fullscreen_active())
- cc.desktop.fullscreen_off();
- cc.desktop.setExtendedState(JFrame.MAXIMIZED_BOTH);
- } else if (actionMatch(ev, clipboard)) {
- ClipboardDialog.showDialog(cc.desktop);
- } else if (actionMatch(ev, f8)) {
- cc.writeKeyEvent(MenuKey.getMenuKeySym(), true);
- cc.writeKeyEvent(MenuKey.getMenuKeySym(), false);
- } else if (actionMatch(ev, ctrlAltDel)) {
- cc.writeKeyEvent(Keysyms.Control_L, true);
- cc.writeKeyEvent(Keysyms.Alt_L, true);
- cc.writeKeyEvent(Keysyms.Delete, true);
- cc.writeKeyEvent(Keysyms.Delete, false);
- cc.writeKeyEvent(Keysyms.Alt_L, false);
- cc.writeKeyEvent(Keysyms.Control_L, false);
- } else if (actionMatch(ev, refresh)) {
- cc.refresh();
- } else if (actionMatch(ev, newConn)) {
- VncViewer.newViewer();
- } else if (actionMatch(ev, options)) {
- OptionsDialog.showDialog(cc.desktop);
- } else if (actionMatch(ev, save)) {
- String title = "Save the TigerVNC configuration to file";
- File dflt = new File(FileUtils.getVncHomeDir().concat("default.tigervnc"));
- if (!dflt.exists() || !dflt.isFile())
- dflt = new File(FileUtils.getVncHomeDir());
- FileNameExtensionFilter filter =
- new FileNameExtensionFilter("TigerVNC configuration (*.tigervnc)", "tigervnc");
- File f = Dialog.showChooser(title, dflt, this, filter);
- while (f != null && f.exists() && f.isFile()) {
- String msg = f.getAbsolutePath();
- msg = msg.concat(" already exists. Do you want to overwrite?");
- Object[] options = {"Overwrite", "No \u21B5"};
- JOptionPane op =
- new JOptionPane(msg, JOptionPane.QUESTION_MESSAGE,
- JOptionPane.OK_CANCEL_OPTION, null, options, options[1]);
- JDialog dlg = op.createDialog(this, "TigerVNC Viewer");
- dlg.setIconImage(VncViewer.frameIcon);
- dlg.setAlwaysOnTop(true);
- dlg.setVisible(true);
- if (op.getValue() == options[0])
- break;
- else
- f = Dialog.showChooser(title, f, this, filter);
- }
- if (f != null && (!f.exists() || f.canWrite()))
- saveViewerParameters(f.getAbsolutePath(), vncServerName.getValue());
- } else if (actionMatch(ev, info)) {
- cc.showInfo();
- } else if (actionMatch(ev, about)) {
- VncViewer.showAbout(cc.desktop);
- } else if (actionMatch(ev, dismiss)) {
- firePopupMenuCanceled();
- }
- }
-
- public void show(Component invoker, int x, int y) {
- // lightweight components can't show in FullScreen Exclusive mode
- /*
- Window fsw = DesktopWindow.getFullScreenWindow();
- GraphicsDevice gd = null;
- if (fsw != null) {
- gd = fsw.getGraphicsConfiguration().getDevice();
- if (gd.isFullScreenSupported())
- DesktopWindow.setFullScreenWindow(null);
- }
- */
- super.show(invoker, x, y);
- /*
- if (fsw != null && gd.isFullScreenSupported())
- DesktopWindow.setFullScreenWindow(fsw);
- */
- }
-
- CConn cc;
- JMenuItem restore, move, size, minimize, maximize;
- JMenuItem exit, clipboard, ctrlAltDel, refresh;
- JMenuItem newConn, options, save, info, about, dismiss;
- static JMenuItem f8;
- JCheckBoxMenuItem fullScreenCheckbox;
- static LogWriter vlog = new LogWriter("F8Menu");
-}
diff --git a/java/com/tigervnc/vncviewer/KeyMap.java b/java/com/tigervnc/vncviewer/KeyMap.java
new file mode 100644
index 0000000..b307d1d
--- /dev/null
+++ b/java/com/tigervnc/vncviewer/KeyMap.java
@@ -0,0 +1,235 @@
+/* Copyright (C) 2017 Brian P. Hinz
+ *
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+package com.tigervnc.vncviewer;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import javax.swing.*;
+
+import com.tigervnc.rfb.*;
+
+import static java.awt.event.KeyEvent.*;
+import static com.tigervnc.rfb.Keysymdef.*;
+
+public class KeyMap {
+
+ public final static int NoSymbol = 0;
+
+ private static final HashMap<Integer, Character> code_map_java_to_char;
+ static {
+ // Certain KeyStrokes fail to produce a valid character (CTRL+ALT+...
+ // on Windows and Mac almost never does). For these cases, the best
+ // we can try to do is to map to the ASCII symbol from the keyCode.
+ code_map_java_to_char = new HashMap<Integer, Character>();
+ for (int c=32; c<0x7f; c++) {
+ int keyCode = KeyEvent.getExtendedKeyCodeForChar(c);
+ if (keyCode != KeyEvent.VK_UNDEFINED)
+ // Not all ASCII characters have VK_ constants, see vk_to_ascii()
+ code_map_java_to_char.put(keyCode, (char)c);
+ }
+ }
+
+ private static int[][] vkey_map = {
+ /* KEYCODE LOCATION */
+ /* UNKNOWN STANDARD LEFT RIGHT NUMPAD */
+ { VK_BACK_SPACE, NoSymbol, XK_BackSpace, NoSymbol, NoSymbol, NoSymbol },
+ { VK_TAB, NoSymbol, XK_Tab, NoSymbol, NoSymbol, NoSymbol },
+ { VK_CANCEL, NoSymbol, XK_Cancel, NoSymbol, NoSymbol, NoSymbol },
+ { VK_ENTER, NoSymbol, XK_Return, NoSymbol, NoSymbol, XK_KP_Enter },
+ { VK_SHIFT, NoSymbol, XK_Shift_L, XK_Shift_L, XK_Shift_R, NoSymbol },
+ { VK_CONTROL, NoSymbol, XK_Control_L, XK_Control_L, XK_Control_R, NoSymbol },
+ { VK_ALT, NoSymbol, XK_Alt_L, XK_Alt_L, XK_Alt_R, NoSymbol },
+ /* VK_PAUSE left out on purpose because interpretation depends on state of CTRL. See further down. */
+ { VK_CAPS_LOCK, NoSymbol, XK_Caps_Lock, NoSymbol, NoSymbol, NoSymbol },
+ { VK_ESCAPE, NoSymbol, XK_Escape, NoSymbol, NoSymbol, NoSymbol },
+ { VK_END, NoSymbol, XK_End, NoSymbol, NoSymbol, XK_KP_End },
+ { VK_HOME, NoSymbol, XK_Home, NoSymbol, NoSymbol, XK_KP_Home },
+ { VK_LEFT, NoSymbol, XK_Left, NoSymbol, NoSymbol, XK_KP_Left },
+ { VK_UP, NoSymbol, XK_Up, NoSymbol, NoSymbol, XK_KP_Up },
+ { VK_RIGHT, NoSymbol, XK_Right, NoSymbol, NoSymbol, XK_KP_Right },
+ { VK_DOWN, NoSymbol, XK_Down, NoSymbol, NoSymbol, XK_KP_Down },
+ /* VK_PRINTSCREEN left out on purpose because interpretation depends on state of CTRL. See further down. */
+ { VK_PAGE_UP, NoSymbol, XK_Page_Up, NoSymbol, NoSymbol, XK_KP_Page_Up },
+ { VK_PAGE_DOWN, NoSymbol, XK_Page_Down, NoSymbol, NoSymbol, XK_KP_Page_Down },
+ { VK_BEGIN, NoSymbol, XK_Begin, NoSymbol, NoSymbol, XK_KP_Begin },
+ { VK_KP_LEFT, NoSymbol, XK_KP_Left, NoSymbol, NoSymbol, XK_KP_Left },
+ { VK_KP_UP, NoSymbol, XK_KP_Up, NoSymbol, NoSymbol, XK_KP_Up },
+ { VK_KP_RIGHT, NoSymbol, XK_KP_Right, NoSymbol, NoSymbol, XK_KP_Right },
+ { VK_KP_DOWN, NoSymbol, XK_KP_Down, NoSymbol, NoSymbol, XK_KP_Down },
+ { VK_INSERT, NoSymbol, XK_Insert, NoSymbol, NoSymbol, XK_KP_Insert },
+ { VK_DELETE, NoSymbol, XK_Delete, NoSymbol, NoSymbol, XK_KP_Delete },
+ { VK_WINDOWS, NoSymbol, NoSymbol, XK_Super_L, XK_Super_R, NoSymbol },
+ { VK_CONTEXT_MENU, NoSymbol, XK_Menu, NoSymbol, NoSymbol, NoSymbol },
+ { VK_NUMPAD0, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_0 },
+ { VK_NUMPAD1, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_1 },
+ { VK_NUMPAD2, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_2 },
+ { VK_NUMPAD3, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_3 },
+ { VK_NUMPAD4, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_4 },
+ { VK_NUMPAD5, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_5 },
+ { VK_NUMPAD6, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_6 },
+ { VK_NUMPAD7, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_7 },
+ { VK_NUMPAD8, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_8 },
+ { VK_NUMPAD9, NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_KP_9 },
+ { VK_MULTIPLY, NoSymbol, XK_KP_Multiply, NoSymbol, NoSymbol, XK_KP_Multiply },
+ { VK_ADD, NoSymbol, XK_KP_Add, NoSymbol, NoSymbol, XK_KP_Add },
+ { VK_SUBTRACT, NoSymbol, XK_KP_Subtract, NoSymbol, NoSymbol, XK_KP_Subtract },
+ { VK_DIVIDE, NoSymbol, XK_KP_Divide, NoSymbol, NoSymbol, XK_KP_Divide },
+ { VK_SEPARATER, NoSymbol, XK_KP_Separator, NoSymbol, NoSymbol, XK_KP_Separator },
+ { VK_DECIMAL, NoSymbol, XK_KP_Decimal, NoSymbol, NoSymbol, XK_KP_Decimal },
+ { VK_F1, NoSymbol, XK_F1, XK_L1, XK_R1, NoSymbol },
+ { VK_F2, NoSymbol, XK_F2, XK_L2, XK_R2, NoSymbol },
+ { VK_F3, NoSymbol, XK_F3, XK_L3, XK_R3, NoSymbol },
+ { VK_F4, NoSymbol, XK_F4, XK_L4, XK_R4, NoSymbol },
+ { VK_F5, NoSymbol, XK_F5, XK_L5, XK_R5, NoSymbol },
+ { VK_F6, NoSymbol, XK_F6, XK_L6, XK_R6, NoSymbol },
+ { VK_F7, NoSymbol, XK_F7, XK_L7, XK_R7, NoSymbol },
+ { VK_F8, NoSymbol, XK_F8, XK_L8, XK_R8, NoSymbol },
+ { VK_F9, NoSymbol, XK_F9, XK_L9, XK_R9, NoSymbol },
+ { VK_F10, NoSymbol, XK_F10, XK_L10, XK_R10, NoSymbol },
+ { VK_F11, NoSymbol, XK_F11, NoSymbol, XK_R11, NoSymbol },
+ { VK_F12, NoSymbol, XK_F12, NoSymbol, XK_R12, NoSymbol },
+ { VK_F13, NoSymbol, XK_F13, NoSymbol, XK_R13, NoSymbol },
+ { VK_F14, NoSymbol, XK_F14, NoSymbol, XK_R14, NoSymbol },
+ { VK_F15, NoSymbol, XK_F15, NoSymbol, XK_R15, NoSymbol },
+ { VK_F16, NoSymbol, XK_F16, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F17, NoSymbol, XK_F17, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F18, NoSymbol, XK_F18, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F19, NoSymbol, XK_F19, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F20, NoSymbol, XK_F20, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F21, NoSymbol, XK_F21, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F22, NoSymbol, XK_F22, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F23, NoSymbol, XK_F23, NoSymbol, NoSymbol, NoSymbol },
+ { VK_F24, NoSymbol, XK_F24, NoSymbol, NoSymbol, NoSymbol },
+ { VK_NUM_LOCK, NoSymbol, XK_Num_Lock, NoSymbol, NoSymbol, XK_Num_Lock },
+ { VK_SCROLL_LOCK, NoSymbol, XK_Scroll_Lock, NoSymbol, NoSymbol, NoSymbol },
+ { VK_ALT_GRAPH, NoSymbol, XK_ISO_Level3_Shift, NoSymbol, NoSymbol, NoSymbol },
+ { VK_META, NoSymbol, NoSymbol, XK_Meta_L, XK_Meta_R, NoSymbol },
+ { VK_MODECHANGE, NoSymbol, XK_Mode_switch, NoSymbol, NoSymbol, NoSymbol },
+ { VK_CLEAR, NoSymbol, XK_Clear, NoSymbol, NoSymbol, XK_KP_Begin },
+ { VK_AGAIN, NoSymbol, XK_Redo, NoSymbol, NoSymbol, NoSymbol },
+ { VK_UNDO, NoSymbol, XK_Undo, NoSymbol, NoSymbol, NoSymbol },
+ { VK_FIND, NoSymbol, XK_Find, NoSymbol, NoSymbol, NoSymbol },
+ { VK_STOP, NoSymbol, XK_Cancel, NoSymbol, NoSymbol, NoSymbol },
+ { VK_HELP, NoSymbol, XK_Help, NoSymbol, NoSymbol, NoSymbol },
+ { VK_KANJI, NoSymbol, XK_Kanji, NoSymbol, NoSymbol, NoSymbol },
+ { VK_KATAKANA, NoSymbol, XK_Katakana, NoSymbol, NoSymbol, NoSymbol },
+ { VK_HIRAGANA, NoSymbol, XK_Hiragana, NoSymbol, NoSymbol, NoSymbol },
+ { VK_PREVIOUS_CANDIDATE, NoSymbol, XK_PreviousCandidate, NoSymbol, NoSymbol, NoSymbol },
+ { VK_CODE_INPUT, NoSymbol, XK_Codeinput, NoSymbol, NoSymbol, NoSymbol },
+ { VK_JAPANESE_ROMAN, NoSymbol, XK_Romaji, NoSymbol, NoSymbol, NoSymbol },
+ { VK_KANA_LOCK, NoSymbol, XK_Kana_Lock, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_ABOVEDOT, NoSymbol, XK_dead_abovedot, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_ABOVERING, NoSymbol, XK_dead_abovering, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_ACUTE, NoSymbol, XK_dead_acute, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_BREVE, NoSymbol, XK_dead_breve, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_CARON, NoSymbol, XK_dead_caron, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_CEDILLA, NoSymbol, XK_dead_cedilla, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_CIRCUMFLEX, NoSymbol, XK_dead_circumflex, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_DIAERESIS, NoSymbol, XK_dead_diaeresis, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_DOUBLEACUTE, NoSymbol, XK_dead_doubleacute, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_GRAVE, NoSymbol, XK_dead_grave, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_IOTA, NoSymbol, XK_dead_iota, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_MACRON, NoSymbol, XK_dead_macron, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_OGONEK, NoSymbol, XK_dead_ogonek, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_SEMIVOICED_SOUND, NoSymbol, XK_dead_semivoiced_sound, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_TILDE, NoSymbol, XK_dead_tilde, NoSymbol, NoSymbol, NoSymbol },
+ { VK_DEAD_VOICED_SOUND, NoSymbol, XK_dead_voiced_sound, NoSymbol, NoSymbol, NoSymbol },
+ { VK_ALPHANUMERIC, NoSymbol, XK_Eisu_Shift, NoSymbol, NoSymbol, NoSymbol },
+ { VK_ALL_CANDIDATES, NoSymbol, XK_MultipleCandidate, NoSymbol, NoSymbol, NoSymbol },
+ { VK_KANA, NoSymbol, XK_Kana_Shift, NoSymbol, NoSymbol, NoSymbol },
+ { VK_JAPANESE_KATAKANA, NoSymbol, XK_Katakana, NoSymbol, NoSymbol, NoSymbol },
+ { VK_JAPANESE_HIRAGANA, NoSymbol, XK_Hiragana, NoSymbol, NoSymbol, NoSymbol },
+ { VK_COMPOSE, NoSymbol, XK_Multi_key, NoSymbol, NoSymbol, NoSymbol },
+ };
+
+ public static int vkey_to_keysym(KeyEvent ev)
+ {
+ int keyCode = ev.getKeyCode();
+
+ // Start with keys that either don't generate a symbol, or
+ // generate the same symbol as some other key.
+ if (keyCode == KeyEvent.VK_PAUSE)
+ return (ev.isControlDown() ? XK_Break : XK_Pause);
+ else if (keyCode == KeyEvent.VK_PRINTSCREEN)
+ return (ev.isControlDown() ? XK_Sys_Req : XK_Print);
+ else
+ for(int i = 0; i < vkey_map.length; i++)
+ if (keyCode == vkey_map[i][0])
+ return vkey_map[i][ev.getKeyLocation()+1];
+
+ // Unknown special key?
+ if (KeyEvent.getKeyText(keyCode).isEmpty()) {
+ vlog.error("Unknown key code: 0x%04x", keyCode);
+ return NoSymbol;
+ }
+
+ // Pressing Ctrl wreaks havoc with the symbol lookup...
+ int ucs = (int)ev.getKeyChar();
+ if (ev.isControlDown()) {
+ // For CTRL-<letter>, CTRL is sent separately, so just send <letter>.
+ if ((ucs >= 1 && ucs <= 26 && !ev.isShiftDown()) ||
+ // CTRL-{, CTRL-|, CTRL-} also map to ASCII 96-127
+ (ucs >= 27 && ucs <= 29 && ev.isShiftDown()))
+ ucs += 96;
+ // For CTRL-SHIFT-<letter>, send capital <letter> to emulate behavior
+ // of Linux. For CTRL-@, send @. For CTRL-_, send _. For CTRL-^,
+ // send ^.
+ else if (ucs < 32)
+ ucs += 64;
+ // If it's still undefined, map the keyCode to ASCII symbol
+ else if (keyCode >= 0 && keyCode <= 127)
+ if (ucs == CHAR_UNDEFINED || ev.isAltDown())
+ ucs = vk_to_ascii(keyCode, ev.isShiftDown());
+ else if (VncViewer.os.startsWith("mac os x") && ev.isMetaDown())
+ // Alt on OS X behaves more like AltGr on other systems, and to get
+ // sane behaviour we should translate things in that manner for the
+ // remote VNC server. However that means we lose the ability to use
+ // Alt as a shortcut modifier. Do what RealVNC does and hijack the
+ // left command key as an Alt replacement.
+ ucs = vk_to_ascii(keyCode, ev.isShiftDown());
+ }
+
+ // Dead keys are represented by their spacing equivalent
+ // (or something similar depending on the layout)
+ if (Character.getType(ucs) == Character.COMBINING_SPACING_MARK)
+ return Keysym2ucs.ucs2keysym(Keysym2ucs.ucs2combining(ucs));
+
+ if (Character.isDefined(ucs))
+ return Keysym2ucs.ucs2keysym(ucs);
+
+ return NoSymbol;
+ }
+
+ private static int vk_to_ascii(int vk, boolean shift) {
+ char c = 0;
+ if (code_map_java_to_char.containsKey(vk))
+ c = code_map_java_to_char.get(vk);
+ // 0x25 (%) and 0x3F (?) do not have VK_ constants
+ if (vk == VK_5)
+ c = shift ? '%' : c;
+ else if (vk == VK_SLASH)
+ c = shift ? '?' : c;
+ if (Character.isLetter(c))
+ c = shift ? Character.toUpperCase(c) : Character.toLowerCase(c);
+ return (int)c;
+ }
+
+ static LogWriter vlog = new LogWriter("KeyMap");
+}
diff --git a/java/com/tigervnc/vncviewer/MenuKey.java b/java/com/tigervnc/vncviewer/MenuKey.java
index 071c004..3fd6345 100644
--- a/java/com/tigervnc/vncviewer/MenuKey.java
+++ b/java/com/tigervnc/vncviewer/MenuKey.java
@@ -1,6 +1,6 @@
/* Copyright 2011 Martin Koegler <mkoegler@auto.tuwien.ac.at>
* Copyright 2011 Pierre Ossman <ossman@cendio.se> for Cendio AB
- * Copyright 2012 Brian P. Hinz
+ * Copyright 2012-2017 Brian P. Hinz
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -24,42 +24,47 @@
import com.tigervnc.rfb.*;
+import static java.awt.event.KeyEvent.*;
+import static com.tigervnc.rfb.Keysymdef.*;
+
public class MenuKey
{
static class MenuKeySymbol {
- public MenuKeySymbol(String name_, int keycode_, int keysym_) {
+ public MenuKeySymbol(String name_, int javacode_,
+ int keycode_, int keysym_) {
name = name_;
+ javacode = javacode_;
keycode = keycode_;
keysym = keysym_;
}
String name;
+ int javacode;
int keycode;
int keysym;
}
private static final MenuKeySymbol[] menuSymbols = {
- new MenuKeySymbol("F1", KeyEvent.VK_F1, Keysyms.F1),
- new MenuKeySymbol("F2", KeyEvent.VK_F2, Keysyms.F2),
- new MenuKeySymbol("F3", KeyEvent.VK_F3, Keysyms.F3),
- new MenuKeySymbol("F4", KeyEvent.VK_F4, Keysyms.F4),
- new MenuKeySymbol("F5", KeyEvent.VK_F5, Keysyms.F5),
- new MenuKeySymbol("F6", KeyEvent.VK_F6, Keysyms.F6),
- new MenuKeySymbol("F7", KeyEvent.VK_F7, Keysyms.F7),
- new MenuKeySymbol("F8", KeyEvent.VK_F8, Keysyms.F8),
- new MenuKeySymbol("F9", KeyEvent.VK_F9, Keysyms.F9),
- new MenuKeySymbol("F10", KeyEvent.VK_F10, Keysyms.F10),
- new MenuKeySymbol("F11", KeyEvent.VK_F11, Keysyms.F11),
- new MenuKeySymbol("F12", KeyEvent.VK_F12, Keysyms.F12),
- new MenuKeySymbol("Pause", KeyEvent.VK_PAUSE, Keysyms.Pause),
- new MenuKeySymbol("Print", KeyEvent.VK_PRINTSCREEN, Keysyms.Print),
- new MenuKeySymbol("Scroll_Lock", KeyEvent.VK_SCROLL_LOCK,
- Keysyms.Scroll_Lock),
- new MenuKeySymbol("Escape", KeyEvent.VK_ESCAPE, Keysyms.Escape),
- new MenuKeySymbol("Insert", KeyEvent.VK_INSERT, Keysyms.Insert),
- new MenuKeySymbol("Delete", KeyEvent.VK_DELETE, Keysyms.Delete),
- new MenuKeySymbol("Home", KeyEvent.VK_HOME, Keysyms.Home),
- new MenuKeySymbol("Page_Up", KeyEvent.VK_PAGE_UP, Keysyms.Page_Up),
- new MenuKeySymbol("Page_Down", KeyEvent.VK_PAGE_DOWN, Keysyms.Page_Down)
+ new MenuKeySymbol("F1", VK_F1, 0x3b, XK_F1),
+ new MenuKeySymbol("F2", VK_F2, 0x3c, XK_F2),
+ new MenuKeySymbol("F3", VK_F3, 0x3d, XK_F3),
+ new MenuKeySymbol("F4", VK_F4, 0x3e, XK_F4),
+ new MenuKeySymbol("F5", VK_F5, 0x3f, XK_F5),
+ new MenuKeySymbol("F6", VK_F6, 0x40, XK_F6),
+ new MenuKeySymbol("F7", VK_F7, 0x41, XK_F7),
+ new MenuKeySymbol("F8", VK_F8, 0x42, XK_F8),
+ new MenuKeySymbol("F9", VK_F9, 0x43, XK_F9),
+ new MenuKeySymbol("F10", VK_F10, 0x44, XK_F10),
+ new MenuKeySymbol("F11", VK_F11, 0x57, XK_F11),
+ new MenuKeySymbol("F12", VK_F12, 0x58, XK_F12),
+ new MenuKeySymbol("Pause", VK_PAUSE, 0xc6, XK_Pause),
+ new MenuKeySymbol("Scroll_Lock", VK_SCROLL_LOCK,
+ 0x46, XK_Scroll_Lock),
+ new MenuKeySymbol("Escape", VK_ESCAPE, 0x01, XK_Escape),
+ new MenuKeySymbol("Insert", VK_INSERT, 0xd2, XK_Insert),
+ new MenuKeySymbol("Delete", VK_DELETE, 0xd3, XK_Delete),
+ new MenuKeySymbol("Home", VK_HOME, 0xc7, XK_Home),
+ new MenuKeySymbol("Page_Up", VK_PAGE_UP, 0xc9, XK_Page_Up),
+ new MenuKeySymbol("Page_Down", VK_PAGE_DOWN, 0xd1, XK_Page_Down)
};
static int getMenuKeySymbolCount() {
@@ -87,8 +92,21 @@
return s;
}
+ static int getMenuKeyJavaCode() {
+ int menuKeyCode = VK_F8;
+
+ @SuppressWarnings({"static"})
+ String menuKeyStr =
+ Configuration.global().getParam("menuKey").getValueStr();
+ for(int i = 0; i < getMenuKeySymbolCount(); i++)
+ if (menuSymbols[i].name.equals(menuKeyStr))
+ menuKeyCode = menuSymbols[i].javacode;
+
+ return menuKeyCode;
+ }
+
static int getMenuKeyCode() {
- int menuKeyCode = KeyEvent.VK_F8;
+ int menuKeyCode = VK_F8;
@SuppressWarnings({"static"})
String menuKeyStr =
@@ -101,7 +119,7 @@
}
static int getMenuKeySym() {
- int menuKeySym = Keysyms.F8;
+ int menuKeySym = XK_F8;
@SuppressWarnings({"static"})
String menuKeyStr =
diff --git a/java/com/tigervnc/vncviewer/ServerDialog.java b/java/com/tigervnc/vncviewer/ServerDialog.java
index 001e231..99b0f7a 100644
--- a/java/com/tigervnc/vncviewer/ServerDialog.java
+++ b/java/com/tigervnc/vncviewer/ServerDialog.java
@@ -269,7 +269,7 @@
}
private void handleAbout() {
- VncViewer.showAbout(this);
+ VncViewer.about_vncviewer(this);
}
private void handleCancel() {
diff --git a/java/com/tigervnc/vncviewer/Viewport.java b/java/com/tigervnc/vncviewer/Viewport.java
index 62b027f..72d6160 100644
--- a/java/com/tigervnc/vncviewer/Viewport.java
+++ b/java/com/tigervnc/vncviewer/Viewport.java
@@ -31,16 +31,11 @@
package com.tigervnc.vncviewer;
import java.awt.*;
-import java.awt.Color;
-import java.awt.color.ColorSpace;
import java.awt.event.*;
import java.awt.geom.AffineTransform;
import java.awt.image.*;
-import java.awt.datatransfer.DataFlavor;
-import java.awt.datatransfer.Transferable;
-import java.awt.datatransfer.Clipboard;
-import java.io.BufferedReader;
import java.nio.*;
+import java.util.*;
import javax.swing.*;
import javax.imageio.*;
@@ -48,46 +43,76 @@
import com.tigervnc.rfb.*;
import com.tigervnc.rfb.Cursor;
+import com.tigervnc.rfb.Exception;
import com.tigervnc.rfb.Point;
+import static java.awt.event.KeyEvent.*;
import static com.tigervnc.vncviewer.Parameters.*;
+import static com.tigervnc.rfb.Keysymdef.*;
-class Viewport extends JPanel implements MouseListener,
- MouseMotionListener, MouseWheelListener, KeyListener {
+class Viewport extends JPanel implements ActionListener {
static LogWriter vlog = new LogWriter("Viewport");
+ enum ID { EXIT, FULLSCREEN, MINIMIZE, RESIZE, NEWVIEWER,
+ CTRL, ALT, MENUKEY, CTRLALTDEL, CLIPBOARD,
+ REFRESH, OPTIONS, INFO, ABOUT, DISMISS }
+
+ enum MENU { INACTIVE, TOGGLE, VALUE, RADIO,
+ INVISIBLE, SUBMENU_POINTER, SUBMENU, DIVIDER }
+
public Viewport(int w, int h, PixelFormat serverPF, CConn cc_)
{
cc = cc_;
- setScaledSize(cc.cp.width, cc.cp.height);
+ setScaledSize(w, h);
frameBuffer = createFramebuffer(serverPF, w, h);
assert(frameBuffer != null);
setBackground(Color.BLACK);
cc.setFramebuffer(frameBuffer);
+
+ contextMenu = new JPopupMenu();
+
OptionsDialog.addCallback("handleOptions", this);
- addMouseListener(this);
- addMouseWheelListener(this);
- addMouseMotionListener(this);
- addKeyListener(this);
+ addMouseListener(new MouseAdapter() {
+ public void mouseClicked(MouseEvent e) { }
+ public void mouseEntered(MouseEvent e) { handle(e); }
+ public void mouseExited(MouseEvent e) { handle(e); }
+ public void mouseReleased(MouseEvent e) { handle(e); }
+ public void mousePressed(MouseEvent e) { handle(e); }
+ });
+ addMouseWheelListener(new MouseAdapter() {
+ public void mouseWheelMoved(MouseWheelEvent e) { handle(e); }
+ });
+ addMouseMotionListener(new MouseMotionAdapter() {
+ public void mouseDragged(MouseEvent e) { handle(e); }
+ public void mouseMoved(MouseEvent e) { handle(e); }
+ });
+ addKeyListener(new KeyAdapter() {
+ public void keyTyped(KeyEvent e) { }
+ public void keyPressed(KeyEvent e) { handleSystemEvent(e); }
+ public void keyReleased(KeyEvent e) { handleSystemEvent(e); }
+ });
addFocusListener(new FocusAdapter() {
public void focusGained(FocusEvent e) {
ClipboardDialog.clientCutText();
}
public void focusLost(FocusEvent e) {
- cc.releaseDownKeys();
+ releaseDownKeys();
}
});
+
setFocusTraversalKeysEnabled(false);
setFocusable(true);
+ setMenuKey();
+
// Send a fake pointer event so that the server will stop rendering
// a server-side cursor. Ideally we'd like to send the actual pointer
// position, but we can't really tell when the window manager is done
// placing us so we don't have a good time for that.
- cc.writer().pointerEvent(new Point(w/2, h/2), 0);
+ handlePointerEvent(new Point(w/2, h/2), 0);
}
// Most efficient format (from Viewport's point of view)
@@ -127,6 +152,9 @@
{
int i;
+ if (cursor != null)
+ cursor.flush();
+
for (i = 0; i < width*height; i++)
if (data[i*4 + 3] != 0) break;
@@ -148,7 +176,6 @@
new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB_PRE);
cursor.setRGB(0, 0, width, height, buffer.array(), 0, width);
cursorHotspot = hotspot;
-
}
}
@@ -158,35 +185,32 @@
int x = (int)Math.floor((float)cursorHotspot.x * scaleRatioX);
int y = (int)Math.floor((float)cursorHotspot.y * scaleRatioY);
- java.awt.Cursor softCursor;
-
Dimension cs = tk.getBestCursorSize(cw, ch);
if (cs.width != cw && cs.height != ch) {
cw = Math.min(cw, cs.width);
ch = Math.min(ch, cs.height);
x = (int)Math.min(x, Math.max(cs.width - 1, 0));
y = (int)Math.min(y, Math.max(cs.height - 1, 0));
- BufferedImage scaledImage =
- new BufferedImage(cs.width, cs.height, BufferedImage.TYPE_INT_ARGB);
- Graphics2D g2 = scaledImage.createGraphics();
- g2.setRenderingHint(RenderingHints.KEY_RENDERING,
- RenderingHints.VALUE_RENDER_QUALITY);
- g2.drawImage(cursor,
- 0, 0, cw, ch,
- 0, 0, cursor.getWidth(), cursor.getHeight(), null);
+ BufferedImage tmp =
+ new BufferedImage(cs.width, cs.height, BufferedImage.TYPE_INT_ARGB_PRE);
+ Graphics2D g2 = tmp.createGraphics();
+ g2.drawImage(cursor, 0, 0, cw, ch, 0, 0, width, height, null);
g2.dispose();
- java.awt.Point hs = new java.awt.Point(x, y);
- softCursor = tk.createCustomCursor(scaledImage, hs, "softCursor");
- scaledImage.flush();
- } else {
- java.awt.Point hs = new java.awt.Point(x, y);
- softCursor = tk.createCustomCursor(cursor, hs, "softCursor");
+ cursor = tmp;
}
- cursor.flush();
+ setCursor(cursor, x, y);
+ }
+ private void setCursor(Image img, int x, int y)
+ {
+ java.awt.Point hotspot;
+ java.awt.Cursor softCursor;
+ String name = "rfb cursor";
+
+ hotspot = new java.awt.Point(x, y);
+ softCursor = tk.createCustomCursor(img, hotspot, name);
setCursor(softCursor);
-
}
public void resize(int x, int y, int w, int h) {
@@ -200,6 +224,54 @@
setScaledSize(w, h);
}
+ public int handle(MouseEvent e)
+ {
+ int buttonMask, wheelMask;
+ switch (e.getID()) {
+ case MouseEvent.MOUSE_ENTERED:
+ if (cursor != null)
+ setCursor(cursor, cursorHotspot.x, cursorHotspot.y);
+ if (embed.getValue())
+ requestFocus();
+ return 1;
+ case MouseEvent.MOUSE_EXITED:
+ setCursor(java.awt.Cursor.getDefaultCursor());
+ return 1;
+ case MouseEvent.MOUSE_PRESSED:
+ case MouseEvent.MOUSE_RELEASED:
+ case MouseEvent.MOUSE_DRAGGED:
+ case MouseEvent.MOUSE_MOVED:
+ case MouseEvent.MOUSE_WHEEL:
+ buttonMask = 0;
+ if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) != 0)
+ buttonMask |= 1;
+ if ((e.getModifiersEx() & MouseEvent.BUTTON2_DOWN_MASK) != 0)
+ buttonMask |= 2;
+ if ((e.getModifiersEx() & MouseEvent.BUTTON3_DOWN_MASK) != 0)
+ buttonMask |= 4;
+
+ if (e.getID() == MouseEvent.MOUSE_WHEEL) {
+ wheelMask = 0;
+ int clicks = ((MouseWheelEvent)e).getWheelRotation();
+ if (clicks < 0)
+ wheelMask |= e.isShiftDown() ? 32 : 8;
+ else
+ wheelMask |= e.isShiftDown() ? 64 : 16;
+ Point pt = new Point(e.getX(), e.getY());
+ for (int i = 0; i < Math.abs(clicks); i++) {
+ handlePointerEvent(pt, buttonMask|wheelMask);
+ handlePointerEvent(pt, buttonMask);
+ }
+ return 1;
+ }
+
+ handlePointerEvent(new Point(e.getX(), e.getY()), buttonMask);
+ return 1;
+ }
+
+ return -1;
+ }
+
private PlatformPixelBuffer createFramebuffer(PixelFormat pf, int w, int h)
{
PlatformPixelBuffer fb;
@@ -241,116 +313,6 @@
g2.dispose();
}
- // Mouse-Motion callback function
- private void mouseMotionCB(MouseEvent e) {
- if (!viewOnly.getValue() &&
- e.getX() >= 0 && e.getX() <= scaledWidth &&
- e.getY() >= 0 && e.getY() <= scaledHeight)
- cc.writePointerEvent(translateMouseEvent(e));
- }
- public void mouseDragged(MouseEvent e) { mouseMotionCB(e); }
- public void mouseMoved(MouseEvent e) { mouseMotionCB(e); }
-
- // Mouse callback function
- private void mouseCB(MouseEvent e) {
- if (!viewOnly.getValue())
- if ((e.getID() == MouseEvent.MOUSE_RELEASED) ||
- (e.getX() >= 0 && e.getX() <= scaledWidth &&
- e.getY() >= 0 && e.getY() <= scaledHeight))
- cc.writePointerEvent(translateMouseEvent(e));
- }
- public void mouseReleased(MouseEvent e) { mouseCB(e); }
- public void mousePressed(MouseEvent e) { mouseCB(e); }
- public void mouseClicked(MouseEvent e) {}
- public void mouseEntered(MouseEvent e) {
- if (embed.getValue())
- requestFocus();
- }
- public void mouseExited(MouseEvent e) {}
-
- // MouseWheel callback function
- private void mouseWheelCB(MouseWheelEvent e) {
- if (!viewOnly.getValue())
- cc.writeWheelEvent(e);
- }
-
- public void mouseWheelMoved(MouseWheelEvent e) {
- mouseWheelCB(e);
- }
-
- private static final Integer keyEventLock = 0;
-
- // Handle the key-typed event.
- public void keyTyped(KeyEvent e) { }
-
- // Handle the key-released event.
- public void keyReleased(KeyEvent e) {
- synchronized(keyEventLock) {
- cc.writeKeyEvent(e);
- }
- }
-
- // Handle the key-pressed event.
- public void keyPressed(KeyEvent e)
- {
- if (e.getKeyCode() == MenuKey.getMenuKeyCode()) {
- java.awt.Point pt = e.getComponent().getMousePosition();
- if (pt != null) {
- F8Menu menu = new F8Menu(cc);
- menu.show(e.getComponent(), (int)pt.getX(), (int)pt.getY());
- }
- return;
- }
- int ctrlAltShiftMask = Event.SHIFT_MASK | Event.CTRL_MASK | Event.ALT_MASK;
- if ((e.getModifiers() & ctrlAltShiftMask) == ctrlAltShiftMask) {
- switch (e.getKeyCode()) {
- case KeyEvent.VK_A:
- VncViewer.showAbout(this);
- return;
- case KeyEvent.VK_F:
- if (cc.desktop.fullscreen_active())
- cc.desktop.fullscreen_on();
- else
- cc.desktop.fullscreen_off();
- return;
- case KeyEvent.VK_H:
- cc.refresh();
- return;
- case KeyEvent.VK_I:
- cc.showInfo();
- return;
- case KeyEvent.VK_O:
- OptionsDialog.showDialog(this);
- return;
- case KeyEvent.VK_W:
- VncViewer.newViewer();
- return;
- case KeyEvent.VK_LEFT:
- case KeyEvent.VK_RIGHT:
- case KeyEvent.VK_UP:
- case KeyEvent.VK_DOWN:
- return;
- }
- }
- if ((e.getModifiers() & Event.META_MASK) == Event.META_MASK) {
- switch (e.getKeyCode()) {
- case KeyEvent.VK_COMMA:
- case KeyEvent.VK_N:
- case KeyEvent.VK_W:
- case KeyEvent.VK_I:
- case KeyEvent.VK_R:
- case KeyEvent.VK_L:
- case KeyEvent.VK_F:
- case KeyEvent.VK_Z:
- case KeyEvent.VK_T:
- return;
- }
- }
- synchronized(keyEventLock) {
- cc.writeKeyEvent(e);
- }
- }
-
public void setScaledSize(int width, int height)
{
assert(width != 0 && height != 0);
@@ -384,21 +346,417 @@
setSize(new Dimension(scaledWidth, scaledHeight));
}
- private MouseEvent translateMouseEvent(MouseEvent e)
+ private void handlePointerEvent(Point pos, int buttonMask)
{
- if (cc.cp.width != scaledWidth ||
- cc.cp.height != scaledHeight) {
- int sx = (scaleRatioX == 1.00) ?
- e.getX() : (int)Math.floor(e.getX() / scaleRatioX);
- int sy = (scaleRatioY == 1.00) ?
- e.getY() : (int)Math.floor(e.getY() / scaleRatioY);
- e.translatePoint(sx - e.getX(), sy - e.getY());
+ if (!viewOnly.getValue()) {
+ if (buttonMask != lastButtonMask || !pos.equals(lastPointerPos)) {
+ try {
+ if (cc.cp.width != scaledWidth ||
+ cc.cp.height != scaledHeight) {
+ int sx = (scaleRatioX == 1.00) ?
+ pos.x : (int)Math.floor(pos.x / scaleRatioX);
+ int sy = (scaleRatioY == 1.00) ?
+ pos.y : (int)Math.floor(pos.y / scaleRatioY);
+ pos = pos.translate(new Point(sx - pos.x, sy - pos.y));
+ }
+ cc.writer().pointerEvent(pos, buttonMask);
+ } catch (Exception e) {
+ vlog.error("%s", e.getMessage());
+ cc.close();
+ }
+ }
+ lastPointerPos = pos;
+ lastButtonMask = buttonMask;
}
- return e;
+ }
+
+ public void handleKeyPress(int keyCode, int keySym)
+ {
+ // Prevent recursion if the menu wants to send it's own
+ // activation key.
+ if ((menuKeySym != 0) && keySym == menuKeySym && !menuRecursion) {
+ popupContextMenu();
+ return;
+ }
+
+ if (viewOnly.getValue())
+ return;
+
+ if (keyCode == 0) {
+ vlog.error("No key code specified on key press");
+ return;
+ }
+
+ if (VncViewer.os.startsWith("mac os x")) {
+ // Alt on OS X behaves more like AltGr on other systems, and to get
+ // sane behaviour we should translate things in that manner for the
+ // remote VNC server. However that means we lose the ability to use
+ // Alt as a shortcut modifier. Do what RealVNC does and hijack the
+ // left command key as an Alt replacement.
+ switch (keySym) {
+ case XK_Meta_L:
+ keySym = XK_Alt_L;
+ break;
+ case XK_Meta_R:
+ keySym = XK_Super_L;
+ break;
+ case XK_Alt_L:
+ keySym = XK_Mode_switch;
+ break;
+ case XK_Alt_R:
+ keySym = XK_ISO_Level3_Shift;
+ break;
+ }
+ }
+
+ if (VncViewer.os.startsWith("windows")) {
+ // Ugly hack alert!
+ //
+ // Windows doesn't have a proper AltGr, but handles it using fake
+ // Ctrl+Alt. Unfortunately X11 doesn't generally like the combination
+ // Ctrl+Alt+AltGr, which we usually end up with when Xvnc tries to
+ // get everything in the correct state. Cheat and temporarily release
+ // Ctrl and Alt when we send some other symbol.
+ if (downKeySym.containsValue(XK_Control_L) &&
+ downKeySym.containsValue(XK_Alt_R)) {
+ vlog.debug("Faking release of AltGr (Ctrl_L+Alt_R)");
+ try {
+ cc.writer().keyEvent(XK_Control_L, false);
+ cc.writer().keyEvent(XK_Alt_R, false);
+ } catch (Exception e) {
+ vlog.error("%s", e.getMessage());
+ cc.close();
+ }
+ }
+ }
+
+ // Because of the way keyboards work, we cannot expect to have the same
+ // symbol on release as when pressed. This breaks the VNC protocol however,
+ // so we need to keep track of what keysym a key _code_ generated on press
+ // and send the same on release.
+ downKeySym.put(keyCode, keySym);
+
+ vlog.debug("Key pressed: 0x%04x => 0x%04x", keyCode, keySym);
+
+ try {
+ // Fake keycode?
+ if (keyCode > 0xffff)
+ cc.writer().keyEvent(keySym, true);
+ else
+ cc.writer().keyEvent(keySym, true);
+ } catch (Exception e) {
+ vlog.error("%s", e.getMessage());
+ cc.close();
+ }
+
+ if (VncViewer.os.startsWith("windows")) {
+ // Ugly hack continued...
+ if (downKeySym.containsValue(XK_Control_L) &&
+ downKeySym.containsValue(XK_Alt_R)) {
+ vlog.debug("Restoring AltGr state");
+ try {
+ cc.writer().keyEvent(XK_Control_L, true);
+ cc.writer().keyEvent(XK_Alt_R, true);
+ } catch (Exception e) {
+ vlog.error("%s", e.getMessage());
+ cc.close();
+ }
+ }
+ }
+ }
+
+ public void handleKeyRelease(int keyCode)
+ {
+ Integer iter;
+
+ if (viewOnly.getValue())
+ return;
+
+ iter = downKeySym.get(keyCode);
+ if (iter == null) {
+ // These occur somewhat frequently so let's not spam them unless
+ // logging is turned up.
+ vlog.debug("Unexpected release of key code %d", keyCode);
+ return;
+ }
+
+ vlog.debug("Key released: 0x%04x => 0x%04x", keyCode, iter);
+
+ try {
+ if (keyCode > 0xffff)
+ cc.writer().keyEvent(iter, false);
+ else
+ cc.writer().keyEvent(iter, false);
+ } catch (Exception e) {
+ vlog.error("%s", e.getMessage());
+ cc.close();
+ }
+
+ downKeySym.remove(keyCode);
+ }
+
+ private int handleSystemEvent(AWTEvent event)
+ {
+
+ if (event instanceof KeyEvent) {
+ KeyEvent ev = (KeyEvent)event;
+ if (ev.getKeyCode() == 0) {
+ // Not much we can do with this...
+ vlog.debug("Ignoring KeyEvent with unknown Java keycode");
+ return 0;
+ }
+
+ if (ev.getID() == KeyEvent.KEY_PRESSED) {
+ // Generate a fake keycode just for tracking if we can't figure
+ // out the proper one. Java virtual key codes aren't unique
+ // between left/right versions of keys, so we can't use them as
+ // indexes to the downKeySym map. There should not be any key
+ // codes > 0xFFFF so we can use the high nibble to make a unique
+ // pseudo-key code.
+ int keyCode = ev.getKeyCode() | ev.getKeyLocation()<<16;
+
+ // Pressing Ctrl wreaks havoc with the symbol lookup, so turn
+ // that off. But AltGr shows up as Ctrl_L+Alt_R in Windows, so
+ // construct a new KeyEvent that uses a proper AltGraph for the
+ // symbol lookup.
+ if (VncViewer.os.startsWith("windows")) {
+ if (downKeySym.containsValue(XK_Control_L) &&
+ downKeySym.containsValue(XK_Alt_R)) {
+ int mask = ev.getModifiers();
+ mask &= ~CTRL_MASK;
+ mask &= ~ALT_MASK;
+ mask |= ALT_GRAPH_MASK;
+ AWTKeyStroke ks =
+ AWTKeyStroke.getAWTKeyStroke(ev.getKeyCode(), mask);
+ ev = new KeyEvent((JComponent)ev.getSource(), ev.getID(),
+ ev.getWhen(), mask, ev.getKeyCode(),
+ ks.getKeyChar(), ev.getKeyLocation());
+ }
+ }
+
+ int keySym = KeyMap.vkey_to_keysym(ev);
+
+ if (keySym == KeyMap.NoSymbol)
+ vlog.error("No symbol for virtual key 0x%02x", keyCode);
+
+ if (VncViewer.os.startsWith("linux")) {
+ switch (keySym) {
+ // For the first few years, there wasn't a good consensus on what the
+ // Windows keys should be mapped to for X11. So we need to help out a
+ // bit and map all variants to the same key...
+ case XK_Hyper_L:
+ keySym = XK_Super_L;
+ break;
+ case XK_Hyper_R:
+ keySym = XK_Super_R;
+ break;
+ // There has been several variants for Shift-Tab over the years.
+ // RFB states that we should always send a normal tab.
+ case XK_ISO_Left_Tab:
+ keySym = XK_Tab;
+ break;
+ }
+ }
+
+ handleKeyPress(keyCode, keySym);
+
+ if (VncViewer.os.startsWith("mac os x")) {
+ // We don't get any release events for CapsLock, so we have to
+ // send the release right away.
+ if (keySym == XK_Caps_Lock)
+ handleKeyRelease(keyCode);
+ }
+
+ return 1;
+ } else if (ev.getID() == KeyEvent.KEY_RELEASED) {
+ int keyCode = keyCode = ev.getKeyCode() | ev.getKeyLocation()<<16;
+ handleKeyRelease(keyCode);
+ return 1;
+ }
+ }
+
+ return 0;
+ }
+
+ private void initContextMenu()
+ {
+ contextMenu.setLightWeightPopupEnabled(false);
+
+ contextMenu.removeAll();
+
+ menu_add(contextMenu, "Exit viewer", KeyEvent.VK_X,
+ this, ID.EXIT, EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "Full screen", KeyEvent.VK_F, this, ID.FULLSCREEN,
+ window().fullscreen_active() ?
+ EnumSet.of(MENU.TOGGLE, MENU.VALUE) : EnumSet.of(MENU.TOGGLE));
+ menu_add(contextMenu, "Minimize", KeyEvent.VK_Z,
+ this, ID.MINIMIZE, EnumSet.noneOf(MENU.class));
+ menu_add(contextMenu, "Resize window to session", KeyEvent.VK_W,
+ this, ID.RESIZE,
+ window().fullscreen_active() ?
+ EnumSet.of(MENU.INACTIVE, MENU.DIVIDER) : EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "Clipboard viewer...", KeyEvent.VK_UNDEFINED,
+ this, ID.CLIPBOARD, EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "Ctrl", KeyEvent.VK_C,
+ this, ID.CTRL,
+ menuCtrlKey ? EnumSet.of(MENU.TOGGLE, MENU.VALUE) : EnumSet.of(MENU.TOGGLE));
+ menu_add(contextMenu, "Alt", KeyEvent.VK_A,
+ this, ID.ALT,
+ menuAltKey ? EnumSet.of(MENU.TOGGLE, MENU.VALUE) : EnumSet.of(MENU.TOGGLE));
+
+ menu_add(contextMenu, "Send Ctrl-Alt-Del", KeyEvent.VK_D,
+ this, ID.CTRLALTDEL, EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "Refresh screen", KeyEvent.VK_R,
+ this, ID.REFRESH, EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "New connection...", KeyEvent.VK_N,
+ this, ID.NEWVIEWER,
+ embed.getValue() ? EnumSet.of(MENU.INACTIVE, MENU.DIVIDER) : EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "Options...", KeyEvent.VK_O,
+ this, ID.OPTIONS, EnumSet.noneOf(MENU.class));
+ menu_add(contextMenu, "Connection info...", KeyEvent.VK_I,
+ this, ID.INFO, EnumSet.noneOf(MENU.class));
+ menu_add(contextMenu, "About TigerVNC viewer...", KeyEvent.VK_T,
+ this, ID.ABOUT, EnumSet.of(MENU.DIVIDER));
+
+ menu_add(contextMenu, "Dismiss menu", KeyEvent.VK_M,
+ this, ID.DISMISS, EnumSet.noneOf(MENU.class));
+ }
+
+ static void menu_add(JPopupMenu menu, String text,
+ int shortcut, ActionListener cb,
+ ID data, EnumSet<MENU> flags)
+ {
+ JMenuItem item;
+ if (flags.contains(MENU.TOGGLE)) {
+ item = new JCheckBoxMenuItem(text, flags.contains(MENU.VALUE));
+ } else {
+ if (shortcut != 0)
+ item = new JMenuItem(text, shortcut);
+ else
+ item = new JMenuItem(text);
+ }
+ item.setActionCommand(data.toString());
+ item.addActionListener(cb);
+ item.setEnabled(!flags.contains(MENU.INACTIVE));
+ menu.add(item);
+ if (flags.contains(MENU.DIVIDER))
+ menu.addSeparator();
+ }
+
+ void popupContextMenu()
+ {
+ // initialize context menu before display
+ initContextMenu();
+
+ contextMenu.setCursor(java.awt.Cursor.getDefaultCursor());
+
+ contextMenu.show(this, lastPointerPos.x, lastPointerPos.y);
+ }
+
+ public void actionPerformed(ActionEvent ev)
+ {
+ switch(ID.valueOf(ev.getActionCommand())) {
+ case EXIT:
+ cc.close();
+ break;
+ case FULLSCREEN:
+ if (window().fullscreen_active())
+ window().fullscreen_off();
+ else
+ window().fullscreen_on();
+ break;
+ case MINIMIZE:
+ if (window().fullscreen_active())
+ window().fullscreen_off();
+ window().setExtendedState(JFrame.ICONIFIED);
+ break;
+ case RESIZE:
+ if (window().fullscreen_active())
+ break;
+ int dx = window().getInsets().left + window().getInsets().right;
+ int dy = window().getInsets().top + window().getInsets().bottom;
+ window().setSize(getWidth()+dx, getHeight()+dy);
+ break;
+ case CLIPBOARD:
+ ClipboardDialog.showDialog(window());
+ break;
+ case CTRL:
+ if (((JMenuItem)ev.getSource()).isSelected())
+ handleKeyPress(0x1d, XK_Control_L);
+ else
+ handleKeyRelease(0x1d);
+ menuCtrlKey = !menuCtrlKey;
+ break;
+ case ALT:
+ if (((JMenuItem)ev.getSource()).isSelected())
+ handleKeyPress(0x38, XK_Alt_L);
+ else
+ handleKeyRelease(0x38);
+ menuAltKey = !menuAltKey;
+ break;
+ case MENUKEY:
+ menuRecursion = true;
+ handleKeyPress(menuKeyCode, menuKeySym);
+ menuRecursion = false;
+ handleKeyRelease(menuKeyCode);
+ break;
+ case CTRLALTDEL:
+ handleKeyPress(0x1d, XK_Control_L);
+ handleKeyPress(0x38, XK_Alt_L);
+ handleKeyPress(0xd3, XK_Delete);
+
+ handleKeyRelease(0xd3);
+ handleKeyRelease(0x38);
+ handleKeyRelease(0x1d);
+ break;
+ case REFRESH:
+ cc.refreshFramebuffer();
+ break;
+ case NEWVIEWER:
+ VncViewer.newViewer();
+ break;
+ case OPTIONS:
+ OptionsDialog.showDialog(cc.desktop);
+ break;
+ case INFO:
+ Window fullScreenWindow =
+ DesktopWindow.getFullScreenWindow();
+ if (fullScreenWindow != null)
+ DesktopWindow.setFullScreenWindow(null);
+ JOptionPane op = new JOptionPane(cc.connectionInfo(),
+ JOptionPane.PLAIN_MESSAGE,
+ JOptionPane.DEFAULT_OPTION);
+ JDialog dlg = op.createDialog(window(), "VNC connection info");
+ dlg.setIconImage(VncViewer.frameIcon);
+ dlg.setAlwaysOnTop(true);
+ dlg.setVisible(true);
+ if (fullScreenWindow != null)
+ DesktopWindow.setFullScreenWindow(fullScreenWindow);
+ break;
+ case ABOUT:
+ VncViewer.about_vncviewer(cc.desktop);
+ break;
+ case DISMISS:
+ break;
+ }
+ }
+
+ private void setMenuKey()
+ {
+ menuKeyJava = MenuKey.getMenuKeyJavaCode();
+ menuKeyCode = MenuKey.getMenuKeyCode();
+ menuKeySym = MenuKey.getMenuKeySym();
}
public void handleOptions()
{
+ setMenuKey();
/*
setScaledSize(cc.cp.width, cc.cp.height);
if (!oldSize.equals(new Dimension(scaledWidth, scaledHeight))) {
@@ -414,18 +772,48 @@
*/
}
+ public void releaseDownKeys() {
+ while (!downKeySym.isEmpty())
+ handleKeyRelease(downKeySym.keySet().iterator().next());
+ }
+
+ private DesktopWindow window() {
+ return (DesktopWindow)getTopLevelAncestor();
+ }
+ private int x() { return getX(); }
+ private int y() { return getY(); }
+ private int w() { return getWidth(); }
+ private int h() { return getHeight(); }
// access to cc by different threads is specified in CConn
private CConn cc;
// access to the following must be synchronized:
- public PlatformPixelBuffer frameBuffer;
+ private PlatformPixelBuffer frameBuffer;
+
+ Point lastPointerPos = new Point(0, 0);
+ int lastButtonMask = 0;
+
+ private class DownMap extends HashMap<Integer, Integer> {
+ public DownMap(int capacity) {
+ super(capacity);
+ }
+ }
+ DownMap downKeySym = new DownMap(256);
+
+ int menuKeySym;
+ int menuKeyCode, menuKeyJava;
+ JPopupMenu contextMenu;
+ boolean menuRecursion = false;
+
+ boolean menuCtrlKey = false;
+ boolean menuAltKey = false;
static Toolkit tk = Toolkit.getDefaultToolkit();
public int scaledWidth = 0, scaledHeight = 0;
float scaleRatioX, scaleRatioY;
- BufferedImage cursor;
+ static BufferedImage cursor;
Point cursorHotspot = new Point();
}
diff --git a/java/com/tigervnc/vncviewer/VncViewer.java b/java/com/tigervnc/vncviewer/VncViewer.java
index d6a3930..8786c11 100644
--- a/java/com/tigervnc/vncviewer/VncViewer.java
+++ b/java/com/tigervnc/vncviewer/VncViewer.java
@@ -394,7 +394,7 @@
}
public void windowDeactivated(WindowEvent e) {
if (cc != null)
- cc.releaseDownKeys();
+ cc.desktop.viewport.releaseDownKeys();
}
});
}
@@ -412,7 +412,7 @@
}
}
- public static void showAbout(Container parent) {
+ public static void about_vncviewer(Container parent) {
String pkgDate = "";
String pkgTime = "";
try {