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 {