Move keyboard handling to separate classes

Encapsulate all the platform specific magic around keyboard in to
specific classes, in order to keep the core code more readable.

14 files changed, 1611 insertions, 1294 deletions

diff --git a/vncviewer/CMakeLists.txt b/vncviewer/CMakeLists.txt
index 143c8fa0..72904b25 100644
--- a/vncviewer/CMakeLists.txt
+++ b/vncviewer/CMakeLists.txt
@@ -18,7 +18,6 @@ add_executable(vncviewer
   PlatformPixelBuffer.cxx
   Viewport.cxx
   parameters.cxx
-  keysym2ucs.c
   touch.cxx
   MonitorIndicesParameter.cxx
   vncviewer.cxx)
@@ -37,17 +36,15 @@ endif()
 
 if(WIN32)
   target_sources(vncviewer PRIVATE Win32TouchHandler.cxx win32.c)
-elseif(APPLE)
-  target_sources(vncviewer PRIVATE cocoa.mm osx_to_qnum.c)
-else()
-  target_sources(vncviewer PRIVATE GestureHandler.cxx XInputTouchHandler.cxx xkb_to_qnum.c)
-endif()
-
-if(WIN32)
+  target_sources(vncviewer PRIVATE KeyboardWin32.cxx keysym2ucs.c)
   target_sources(vncviewer PRIVATE Surface_Win32.cxx)
 elseif(APPLE)
+  target_sources(vncviewer PRIVATE cocoa.mm)
+  target_sources(vncviewer PRIVATE KeyboardMacOS.mm osx_to_qnum.c keysym2ucs.c)
   target_sources(vncviewer PRIVATE Surface_OSX.cxx)
 else()
+  target_sources(vncviewer PRIVATE GestureHandler.cxx XInputTouchHandler.cxx)
+  target_sources(vncviewer PRIVATE KeyboardX11.cxx xkb_to_qnum.c)
   target_sources(vncviewer PRIVATE Surface_X11.cxx)
 endif()
 
diff --git a/vncviewer/Keyboard.h b/vncviewer/Keyboard.h
new file mode 100644
index 00000000..81360252
--- /dev/null
+++ b/vncviewer/Keyboard.h
@@ -0,0 +1,49 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifndef __KEYBOARD_H__
+#define __KEYBOARD_H__
+
+#include <stdint.h>
+
+class KeyboardHandler
+{
+public:
+  virtual void handleKeyPress(int systemKeyCode,
+                              uint32_t keyCode, uint32_t keySym) = 0;
+  virtual void handleKeyRelease(int systemKeyCode) = 0;
+};
+
+class Keyboard
+{
+public:
+  Keyboard(KeyboardHandler* handler_) : handler(handler_) {};
+  virtual ~Keyboard() {};
+
+  virtual bool handleEvent(const void* event) = 0;
+
+  virtual void reset() {};
+
+  virtual unsigned getLEDState() = 0;
+  virtual void setLEDState(unsigned state) = 0;
+
+protected:
+  KeyboardHandler* handler;
+};
+
+#endif
diff --git a/vncviewer/KeyboardMacOS.h b/vncviewer/KeyboardMacOS.h
new file mode 100644
index 00000000..0901664b
--- /dev/null
+++ b/vncviewer/KeyboardMacOS.h
@@ -0,0 +1,60 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifndef __KEYBOARDMACOS_H__
+#define __KEYBOARDMACOS_H__
+
+#include "Keyboard.h"
+
+#ifdef __OBJC__
+@class NSEvent;
+@class NSString;
+#else
+class NSEvent;
+class NSString;
+#endif
+
+class KeyboardMacOS : public Keyboard
+{
+public:
+  KeyboardMacOS(KeyboardHandler* handler);
+  virtual ~KeyboardMacOS();
+
+  bool handleEvent(const void* event) override;
+
+  unsigned getLEDState() override;
+  void setLEDState(unsigned state) override;
+
+  // Special helper on macOS
+  static bool isKeyboardSync(const void* event);
+
+protected:
+  bool isKeyboardEvent(const NSEvent* nsevent);
+  bool isKeyPress(const NSEvent* nsevent);
+  uint32_t translateSystemKeyCode(int systemKeyCode);
+  unsigned getSystemKeyCode(const NSEvent* nsevent);
+
+  NSString* keyTranslate(unsigned keyCode, unsigned modifierFlags);
+  uint32_t translateEventKeysym(const NSEvent* nsevent);
+
+  int openHID(unsigned int* ioc);
+  int getModifierLockState(int modifier, bool* on);
+  int setModifierLockState(int modifier, bool on);
+};
+
+#endif
diff --git a/vncviewer/KeyboardMacOS.mm b/vncviewer/KeyboardMacOS.mm
new file mode 100644
index 00000000..e0a10dc8
--- /dev/null
+++ b/vncviewer/KeyboardMacOS.mm
@@ -0,0 +1,504 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+
+#import <Cocoa/Cocoa.h>
+#import <Carbon/Carbon.h>
+
+#include <IOKit/hidsystem/IOHIDLib.h>
+#include <IOKit/hidsystem/IOHIDParameter.h>
+
+// This wasn't added until 10.12
+#if !defined(MAC_OS_X_VERSION_10_12) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_12
+const int kVK_RightCommand = 0x36;
+#endif
+// And this is still missing
+const int kVK_Menu = 0x6E;
+
+#define XK_LATIN1
+#define XK_MISCELLANY
+#include <rfb/keysymdef.h>
+#include <rfb/XF86keysym.h>
+#include <rfb/LogWriter.h>
+#include <rfb/ledStates.h>
+
+#define NoSymbol 0
+
+#include "i18n.h"
+#include "keysym2ucs.h"
+#include "KeyboardMacOS.h"
+
+extern const unsigned short code_map_osx_to_qnum[];
+extern const unsigned int code_map_osx_to_qnum_len;
+
+static rfb::LogWriter vlog("KeyboardMacOS");
+
+static const int kvk_map[][2] = {
+  { kVK_Return,         XK_Return },
+  { kVK_Tab,            XK_Tab },
+  { kVK_Space,          XK_space },
+  { kVK_Delete,         XK_BackSpace },
+  { kVK_Escape,         XK_Escape },
+  { kVK_RightCommand,   XK_Super_R },
+  { kVK_Command,        XK_Super_L },
+  { kVK_Shift,          XK_Shift_L },
+  { kVK_CapsLock,       XK_Caps_Lock },
+  { kVK_Option,         XK_Alt_L },
+  { kVK_Control,        XK_Control_L },
+  { kVK_RightShift,     XK_Shift_R },
+  { kVK_RightOption,    XK_Alt_R },
+  { kVK_RightControl,   XK_Control_R },
+  { kVK_F17,            XK_F17 },
+  { kVK_VolumeUp,       XF86XK_AudioRaiseVolume },
+  { kVK_VolumeDown,     XF86XK_AudioLowerVolume },
+  { kVK_Mute,           XF86XK_AudioMute },
+  { kVK_F18,            XK_F18 },
+  { kVK_F19,            XK_F19 },
+  { kVK_F20,            XK_F20 },
+  { kVK_F5,             XK_F5 },
+  { kVK_F6,             XK_F6 },
+  { kVK_F7,             XK_F7 },
+  { kVK_F3,             XK_F3 },
+  { kVK_F8,             XK_F8 },
+  { kVK_F9,             XK_F9 },
+  { kVK_F11,            XK_F11 },
+  { kVK_F13,            XK_F13 },
+  { kVK_F16,            XK_F16 },
+  { kVK_F14,            XK_F14 },
+  { kVK_F10,            XK_F10 },
+  { kVK_Menu,           XK_Menu },
+  { kVK_F12,            XK_F12 },
+  { kVK_F15,            XK_F15 },
+  // Should we send Insert here?
+  { kVK_Help,           XK_Help },
+  { kVK_Home,           XK_Home },
+  { kVK_PageUp,         XK_Page_Up },
+  { kVK_ForwardDelete,  XK_Delete },
+  { kVK_F4,             XK_F4 },
+  { kVK_End,            XK_End },
+  { kVK_F2,             XK_F2 },
+  { kVK_PageDown,       XK_Page_Down },
+  { kVK_F1,             XK_F1 },
+  { kVK_LeftArrow,      XK_Left },
+  { kVK_RightArrow,     XK_Right },
+  { kVK_DownArrow,      XK_Down },
+  { kVK_UpArrow,        XK_Up },
+
+  // The OS X headers claim these keys are not layout independent.
+  // Could it be because of the state of the decimal key?
+  /* { kVK_ANSI_KeypadDecimal,     XK_KP_Decimal }, */ // see below
+  { kVK_ANSI_KeypadMultiply,    XK_KP_Multiply },
+  { kVK_ANSI_KeypadPlus,        XK_KP_Add },
+  // OS X doesn't have NumLock, so is this really correct?
+  { kVK_ANSI_KeypadClear,       XK_Num_Lock },
+  { kVK_ANSI_KeypadDivide,      XK_KP_Divide },
+  { kVK_ANSI_KeypadEnter,       XK_KP_Enter },
+  { kVK_ANSI_KeypadMinus,       XK_KP_Subtract },
+  { kVK_ANSI_KeypadEquals,      XK_KP_Equal },
+  { kVK_ANSI_Keypad0,           XK_KP_0 },
+  { kVK_ANSI_Keypad1,           XK_KP_1 },
+  { kVK_ANSI_Keypad2,           XK_KP_2 },
+  { kVK_ANSI_Keypad3,           XK_KP_3 },
+  { kVK_ANSI_Keypad4,           XK_KP_4 },
+  { kVK_ANSI_Keypad5,           XK_KP_5 },
+  { kVK_ANSI_Keypad6,           XK_KP_6 },
+  { kVK_ANSI_Keypad7,           XK_KP_7 },
+  { kVK_ANSI_Keypad8,           XK_KP_8 },
+  { kVK_ANSI_Keypad9,           XK_KP_9 },
+  // Japanese Keyboard Support
+  { kVK_JIS_Eisu,               XK_Eisu_toggle },
+  { kVK_JIS_Kana,               XK_Hiragana_Katakana },
+};
+
+KeyboardMacOS::KeyboardMacOS(KeyboardHandler* handler_)
+  : Keyboard(handler_)
+{
+}
+
+KeyboardMacOS::~KeyboardMacOS()
+{
+}
+
+bool KeyboardMacOS::handleEvent(const void* event)
+{
+  const NSEvent* nsevent = (NSEvent*)event;
+  unsigned systemKeyCode;
+
+  assert(event);
+
+  if (!isKeyboardEvent(nsevent))
+    return false;
+
+  systemKeyCode = getSystemKeyCode(nsevent);
+
+  if (isKeyPress(nsevent)) {
+    uint32_t keyCode;
+    uint32_t keySym;
+
+    keyCode = translateSystemKeyCode(systemKeyCode);
+
+    keySym = translateEventKeysym(nsevent);
+    if (keySym == NoSymbol) {
+      vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
+                 systemKeyCode);
+    }
+
+    handler->handleKeyPress(systemKeyCode, keyCode, keySym);
+
+    // We don't get any release events for CapsLock, so we have to
+    // send the release right away.
+    if (keySym == XK_Caps_Lock)
+      handler->handleKeyRelease(systemKeyCode);
+  } else {
+    handler->handleKeyRelease(systemKeyCode);
+  }
+
+  return true;
+}
+
+unsigned KeyboardMacOS::getLEDState()
+{
+  unsigned state;
+  int ret;
+  bool on;
+
+  state = 0;
+
+  ret = getModifierLockState(kIOHIDCapsLockState, &on);
+  if (ret != 0) {
+    vlog.error(_("Failed to get keyboard LED state: %d"), ret);
+    return rfb::ledUnknown;
+  }
+  if (on)
+    state |= rfb::ledCapsLock;
+
+  ret = getModifierLockState(kIOHIDNumLockState, &on);
+  if (ret != 0) {
+    vlog.error(_("Failed to get keyboard LED state: %d"), ret);
+    return rfb::ledUnknown;
+  }
+  if (on)
+    state |= rfb::ledNumLock;
+
+  // No support for Scroll Lock //
+
+  return state;
+}
+
+void KeyboardMacOS::setLEDState(unsigned state)
+{
+  int ret;
+
+  ret = setModifierLockState(kIOHIDCapsLockState, state & rfb::ledCapsLock);
+  if (ret != 0) {
+    vlog.error(_("Failed to update keyboard LED state: %d"), ret);
+    return;
+  }
+
+  ret = setModifierLockState(kIOHIDNumLockState, state & rfb::ledNumLock);
+  if (ret != 0) {
+    vlog.error(_("Failed to update keyboard LED state: %d"), ret);
+    return;
+  }
+
+  // No support for Scroll Lock //
+}
+
+bool KeyboardMacOS::isKeyboardSync(const void* event)
+{
+  const NSEvent* nsevent = (const NSEvent*)event;
+
+  assert(event);
+
+  // If we get a NSFlagsChanged event with key code 0 then this isn't
+  // an actual keyboard event but rather the system trying to sync up
+  // modifier state after it has stolen input for some reason (e.g.
+  // Cmd+Tab)
+
+  if ([nsevent type] != NSFlagsChanged)
+    return false;
+  if ([nsevent keyCode] != 0)
+    return false;
+
+  return true;
+}
+
+bool KeyboardMacOS::isKeyboardEvent(const NSEvent* nsevent)
+{
+  switch ([nsevent type]) {
+  case NSKeyDown:
+  case NSKeyUp:
+    return true;
+  case NSFlagsChanged:
+    if (isKeyboardSync(nsevent))
+      return false;
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool KeyboardMacOS::isKeyPress(const NSEvent* nsevent)
+{
+  if ([nsevent type] == NSKeyDown)
+    return true;
+
+  if ([nsevent type] == NSFlagsChanged) {
+    UInt32 mask;
+
+    // We don't see any event on release of CapsLock
+    if ([nsevent keyCode] == kVK_CapsLock)
+      return true;
+
+    // These are entirely undocumented, but I cannot find any other way
+    // of differentiating between left and right keys
+    switch ([nsevent keyCode]) {
+    case kVK_RightCommand:
+      mask = 0x0010;
+      break;
+    case kVK_Command:
+      mask = 0x0008;
+      break;
+    case kVK_Shift:
+      mask = 0x0002;
+      break;
+    case kVK_CapsLock:
+      // We don't see any event on release of CapsLock
+      return 1;
+    case kVK_Option:
+      mask = 0x0020;
+      break;
+    case kVK_Control:
+      mask = 0x0001;
+      break;
+    case kVK_RightShift:
+      mask = 0x0004;
+      break;
+    case kVK_RightOption:
+      mask = 0x0040;
+      break;
+    case kVK_RightControl:
+      mask = 0x2000;
+      break;
+    default:
+      return false;
+    }
+
+    if ([nsevent modifierFlags] & mask)
+      return true;
+    else
+      return false;
+  }
+
+  return false;
+}
+
+unsigned KeyboardMacOS::getSystemKeyCode(const NSEvent* nsevent)
+{
+  unsigned keycode;
+
+  keycode = [nsevent keyCode];
+
+  // macOS swaps these two keys for unknown reasons for ISO layouts
+  if (KBGetLayoutType(LMGetKbdType()) == kKeyboardISO) {
+    if (keycode == kVK_ANSI_Grave)
+      return kVK_ISO_Section;
+    if (keycode == kVK_ISO_Section)
+      return kVK_ANSI_Grave;
+  }
+
+  return keycode;
+}
+
+uint32_t KeyboardMacOS::translateSystemKeyCode(int systemKeyCode)
+{
+  if ((unsigned)systemKeyCode >= code_map_osx_to_qnum_len)
+    return 0;
+
+  return code_map_osx_to_qnum[systemKeyCode];
+}
+
+NSString* KeyboardMacOS::keyTranslate(unsigned keyCode,
+                                      unsigned modifierFlags)
+{
+  const UCKeyboardLayout *layout;
+  OSStatus err;
+
+  layout = nullptr;
+
+  TISInputSourceRef keyboard;
+  CFDataRef uchr;
+
+  keyboard = TISCopyCurrentKeyboardLayoutInputSource();
+  uchr = (CFDataRef)TISGetInputSourceProperty(keyboard,
+                                              kTISPropertyUnicodeKeyLayoutData);
+  if (uchr == nullptr)
+    return nil;
+
+  layout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr);
+  if (layout == nullptr)
+    return nil;
+
+  UInt32 dead_state;
+  UniCharCount max_len, actual_len;
+  UniChar string[255];
+
+  dead_state = 0;
+  max_len = sizeof(string)/sizeof(*string);
+
+  modifierFlags = (modifierFlags >> 8) & 0xff;
+
+  err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags,
+                       LMGetKbdType(), 0, &dead_state, max_len, &actual_len,
+                       string);
+  if (err != noErr)
+    return nil;
+
+  // Dead key?
+  if (dead_state != 0) {
+    // We have no fool proof way of asking what dead key this is.
+    // Assume we get a spacing equivalent if we press the
+    // same key again, and try to deduce something from that.
+    err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags,
+                         LMGetKbdType(), 0, &dead_state, max_len, &actual_len,
+                         string);
+    if (err != noErr)
+      return nil;
+  }
+
+  return [NSString stringWithCharacters:string length:actual_len];
+}
+
+uint32_t KeyboardMacOS::translateEventKeysym(const NSEvent* nsevent)
+{
+  UInt16 key_code;
+  size_t i;
+
+  NSString *chars;
+  UInt32 modifiers;
+
+  key_code = [nsevent keyCode];
+
+  // Start with keys that either don't generate a symbol, or
+  // generate the same symbol as some other key.
+  for (i = 0;i < sizeof(kvk_map)/sizeof(kvk_map[0]);i++) {
+    if (key_code == kvk_map[i][0])
+      return kvk_map[i][1];
+  }
+
+  // OS X always sends the same key code for the decimal key on the
+  // num pad, but X11 wants different keysyms depending on if it should
+  // be a comma or full stop.
+  if (key_code == 0x41) {
+    switch ([[nsevent charactersIgnoringModifiers] UTF8String][0]) {
+    case ',':
+      return XK_KP_Separator;
+    case '.':
+      return XK_KP_Decimal;
+    default:
+      return NoSymbol;
+    }
+  }
+
+  // We want a "normal" symbol out of the event, which basically means
+  // we only respect the shift and alt/altgr modifiers. Cocoa can help
+  // us if we only wanted shift, but as we also want alt/altgr, we'll
+  // have to do some lookup ourselves. This matches our behaviour on
+  // other platforms.
+
+  modifiers = 0;
+  if ([nsevent modifierFlags] & NSAlphaShiftKeyMask)
+    modifiers |= alphaLock;
+  if ([nsevent modifierFlags] & NSShiftKeyMask)
+    modifiers |= shiftKey;
+  if ([nsevent modifierFlags] & NSAlternateKeyMask)
+    modifiers |= optionKey;
+
+  chars = keyTranslate(key_code, modifiers);
+  if (chars == nil)
+    return NoSymbol;
+
+  // FIXME: Some dead keys are given as NBSP + combining character
+  if ([chars length] != 1)
+    return NoSymbol;
+
+  // Dead key?
+  if ([[nsevent characters] length] == 0)
+    return ucs2keysym(ucs2combining([chars characterAtIndex:0]));
+
+  return ucs2keysym([chars characterAtIndex:0]);
+}
+
+int KeyboardMacOS::openHID(unsigned int* ioc)
+{
+  kern_return_t ret;
+  io_service_t ios;
+  CFMutableDictionaryRef mdict;
+
+  mdict = IOServiceMatching(kIOHIDSystemClass);
+  ios = IOServiceGetMatchingService(kIOMasterPortDefault,
+                                    (CFDictionaryRef) mdict);
+  if (!ios)
+    return KERN_FAILURE;
+
+  ret = IOServiceOpen(ios, mach_task_self(), kIOHIDParamConnectType, ioc);
+  IOObjectRelease(ios);
+  if (ret != KERN_SUCCESS)
+    return ret;
+
+  return KERN_SUCCESS;
+}
+
+int KeyboardMacOS::getModifierLockState(int modifier, bool* on)
+{
+  kern_return_t ret;
+  io_connect_t ioc;
+
+  ret = openHID(&ioc);
+  if (ret != KERN_SUCCESS)
+    return ret;
+
+  ret = IOHIDGetModifierLockState(ioc, modifier, on);
+  IOServiceClose(ioc);
+  if (ret != KERN_SUCCESS)
+    return ret;
+
+  return KERN_SUCCESS;
+}
+
+int KeyboardMacOS::setModifierLockState(int modifier, bool on)
+{
+  kern_return_t ret;
+  io_connect_t ioc;
+
+  ret = openHID(&ioc);
+  if (ret != KERN_SUCCESS)
+    return ret;
+
+  ret = IOHIDSetModifierLockState(ioc, modifier, on);
+  IOServiceClose(ioc);
+  if (ret != KERN_SUCCESS)
+    return ret;
+
+  return KERN_SUCCESS;
+}
diff --git a/vncviewer/KeyboardWin32.cxx b/vncviewer/KeyboardWin32.cxx
new file mode 100644
index 00000000..ad396485
--- /dev/null
+++ b/vncviewer/KeyboardWin32.cxx
@@ -0,0 +1,639 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <windows.h>
+
+#include <assert.h>
+
+// Missing in at least some versions of MinGW
+#ifndef MAPVK_VK_TO_CHAR
+#define MAPVK_VK_TO_CHAR 2
+#endif
+
+#include <FL/Fl.H>
+
+#define XK_MISCELLANY
+#define XK_XKB_KEYS
+#define XK_KOREAN
+#include <rfb/keysymdef.h>
+#include <rfb/XF86keysym.h>
+#include <rfb/LogWriter.h>
+#include <rfb/ledStates.h>
+
+#define NoSymbol 0
+
+#include "i18n.h"
+#include "keysym2ucs.h"
+#include "KeyboardWin32.h"
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a))
+
+// Used to detect fake input (0xaa is not a real key)
+static const WORD SCAN_FAKE = 0xaa;
+
+static rfb::LogWriter vlog("KeyboardWin32");
+
+// Layout independent keys
+static const UINT vkey_map[][3] = {
+  { VK_CANCEL,              NoSymbol,       XK_Break },
+  { VK_BACK,                XK_BackSpace,   NoSymbol },
+  { VK_TAB,                 XK_Tab,         NoSymbol },
+  { VK_CLEAR,               XK_Clear,       NoSymbol },
+  { VK_RETURN,              XK_Return,      XK_KP_Enter },
+  { VK_SHIFT,               XK_Shift_L,     NoSymbol },
+  { VK_CONTROL,             XK_Control_L,   XK_Control_R },
+  { VK_MENU,                XK_Alt_L,       XK_Alt_R },
+  { VK_PAUSE,               XK_Pause,       NoSymbol },
+  { VK_CAPITAL,             XK_Caps_Lock,   NoSymbol },
+  { VK_ESCAPE,              XK_Escape,      NoSymbol },
+  { VK_CONVERT,             XK_Henkan,      NoSymbol },
+  { VK_NONCONVERT,          XK_Muhenkan,    NoSymbol },
+  { VK_PRIOR,               XK_KP_Prior,    XK_Prior },
+  { VK_NEXT,                XK_KP_Next,     XK_Next },
+  { VK_END,                 XK_KP_End,      XK_End },
+  { VK_HOME,                XK_KP_Home,     XK_Home },
+  { VK_LEFT,                XK_KP_Left,     XK_Left },
+  { VK_UP,                  XK_KP_Up,       XK_Up },
+  { VK_RIGHT,               XK_KP_Right,    XK_Right },
+  { VK_DOWN,                XK_KP_Down,     XK_Down },
+  { VK_SNAPSHOT,            XK_Sys_Req,     XK_Print },
+  { VK_INSERT,              XK_KP_Insert,   XK_Insert },
+  { VK_DELETE,              XK_KP_Delete,   XK_Delete },
+  { VK_LWIN,                NoSymbol,       XK_Super_L },
+  { VK_RWIN,                NoSymbol,       XK_Super_R },
+  { VK_APPS,                NoSymbol,       XK_Menu },
+  { VK_SLEEP,               NoSymbol,       XF86XK_Sleep },
+  { VK_NUMPAD0,             XK_KP_0,        NoSymbol },
+  { VK_NUMPAD1,             XK_KP_1,        NoSymbol },
+  { VK_NUMPAD2,             XK_KP_2,        NoSymbol },
+  { VK_NUMPAD3,             XK_KP_3,        NoSymbol },
+  { VK_NUMPAD4,             XK_KP_4,        NoSymbol },
+  { VK_NUMPAD5,             XK_KP_5,        NoSymbol },
+  { VK_NUMPAD6,             XK_KP_6,        NoSymbol },
+  { VK_NUMPAD7,             XK_KP_7,        NoSymbol },
+  { VK_NUMPAD8,             XK_KP_8,        NoSymbol },
+  { VK_NUMPAD9,             XK_KP_9,        NoSymbol },
+  { VK_MULTIPLY,            XK_KP_Multiply, NoSymbol },
+  { VK_ADD,                 XK_KP_Add,      NoSymbol },
+  { VK_SUBTRACT,            XK_KP_Subtract, NoSymbol },
+  { VK_DIVIDE,              NoSymbol,       XK_KP_Divide },
+  /* VK_SEPARATOR and VK_DECIMAL left out on purpose. See further down. */
+  { VK_F1,                  XK_F1,          NoSymbol },
+  { VK_F2,                  XK_F2,          NoSymbol },
+  { VK_F3,                  XK_F3,          NoSymbol },
+  { VK_F4,                  XK_F4,          NoSymbol },
+  { VK_F5,                  XK_F5,          NoSymbol },
+  { VK_F6,                  XK_F6,          NoSymbol },
+  { VK_F7,                  XK_F7,          NoSymbol },
+  { VK_F8,                  XK_F8,          NoSymbol },
+  { VK_F9,                  XK_F9,          NoSymbol },
+  { VK_F10,                 XK_F10,         NoSymbol },
+  { VK_F11,                 XK_F11,         NoSymbol },
+  { VK_F12,                 XK_F12,         NoSymbol },
+  { VK_F13,                 XK_F13,         NoSymbol },
+  { VK_F14,                 XK_F14,         NoSymbol },
+  { VK_F15,                 XK_F15,         NoSymbol },
+  { VK_F16,                 XK_F16,         NoSymbol },
+  { VK_F17,                 XK_F17,         NoSymbol },
+  { VK_F18,                 XK_F18,         NoSymbol },
+  { VK_F19,                 XK_F19,         NoSymbol },
+  { VK_F20,                 XK_F20,         NoSymbol },
+  { VK_F21,                 XK_F21,         NoSymbol },
+  { VK_F22,                 XK_F22,         NoSymbol },
+  { VK_F23,                 XK_F23,         NoSymbol },
+  { VK_F24,                 XK_F24,         NoSymbol },
+  { VK_NUMLOCK,             NoSymbol,       XK_Num_Lock },
+  { VK_SCROLL,              XK_Scroll_Lock, NoSymbol },
+  { VK_BROWSER_BACK,        NoSymbol,       XF86XK_Back },
+  { VK_BROWSER_FORWARD,     NoSymbol,       XF86XK_Forward },
+  { VK_BROWSER_REFRESH,     NoSymbol,       XF86XK_Refresh },
+  { VK_BROWSER_STOP,        NoSymbol,       XF86XK_Stop },
+  { VK_BROWSER_SEARCH,      NoSymbol,       XF86XK_Search },
+  { VK_BROWSER_FAVORITES,   NoSymbol,       XF86XK_Favorites },
+  { VK_BROWSER_HOME,        NoSymbol,       XF86XK_HomePage },
+  { VK_VOLUME_MUTE,         NoSymbol,       XF86XK_AudioMute },
+  { VK_VOLUME_DOWN,         NoSymbol,       XF86XK_AudioLowerVolume },
+  { VK_VOLUME_UP,           NoSymbol,       XF86XK_AudioRaiseVolume },
+  { VK_MEDIA_NEXT_TRACK,    NoSymbol,       XF86XK_AudioNext },
+  { VK_MEDIA_PREV_TRACK,    NoSymbol,       XF86XK_AudioPrev },
+  { VK_MEDIA_STOP,          NoSymbol,       XF86XK_AudioStop },
+  { VK_MEDIA_PLAY_PAUSE,    NoSymbol,       XF86XK_AudioPlay },
+  { VK_LAUNCH_MAIL,         NoSymbol,       XF86XK_Mail },
+  { VK_LAUNCH_APP2,         NoSymbol,       XF86XK_Calculator },
+};
+
+// Layout dependent keys, but without useful symbols
+
+// Japanese
+static const UINT vkey_map_jp[][3] = {
+  { VK_KANA,                XK_Hiragana_Katakana, NoSymbol },
+  { VK_KANJI,               XK_Kanji,       NoSymbol },
+  { VK_OEM_ATTN,            XK_Eisu_toggle, NoSymbol },
+  { VK_OEM_FINISH,          XK_Katakana,    NoSymbol },
+  { VK_OEM_COPY,            XK_Hiragana,    NoSymbol },
+  // These are really XK_Zenkaku/XK_Hankaku but we have no way of
+  // keeping the client and server in sync
+  { VK_OEM_AUTO,            XK_Zenkaku_Hankaku, NoSymbol },
+  { VK_OEM_ENLW,            XK_Zenkaku_Hankaku, NoSymbol },
+  { VK_OEM_BACKTAB,         XK_Romaji,      NoSymbol },
+  { VK_ATTN,                XK_Romaji,      NoSymbol },
+};
+
+// Korean
+static const UINT vkey_map_ko[][3] = {
+  { VK_HANGUL,              XK_Hangul,      NoSymbol },
+  { VK_HANJA,               XK_Hangul_Hanja, NoSymbol },
+};
+
+KeyboardWin32::KeyboardWin32(KeyboardHandler* handler_)
+  : Keyboard(handler_), cachedHasAltGr(false), currentLayout(nullptr),
+    altGrArmed(false), leftShiftDown(false), rightShiftDown(false)
+{
+}
+
+KeyboardWin32::~KeyboardWin32()
+{
+  reset();
+}
+
+bool KeyboardWin32::handleEvent(const void* event)
+{
+  MSG *msg = (MSG*)event;
+
+  assert(event);
+
+  if ((msg->message == WM_MOUSEMOVE) ||
+      (msg->message == WM_LBUTTONDOWN) ||
+      (msg->message == WM_LBUTTONUP) ||
+      (msg->message == WM_RBUTTONDOWN) ||
+      (msg->message == WM_RBUTTONUP) ||
+      (msg->message == WM_MBUTTONDOWN) ||
+      (msg->message == WM_MBUTTONUP) ||
+      (msg->message == WM_MOUSEWHEEL) ||
+      (msg->message == WM_MOUSEHWHEEL)) {
+    // We can't get a mouse event in the middle of an AltGr sequence, so
+    // abort that detection
+    if (altGrArmed)
+      resolveAltGrDetection(false);
+    return false; // We didn't really consume the mouse event
+  } else if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
+    UINT vKey;
+    bool isExtended;
+    int systemKeyCode, keyCode;
+    uint32_t keySym;
+
+    vKey = msg->wParam;
+    isExtended = (msg->lParam & (1 << 24)) != 0;
+
+    systemKeyCode = ((msg->lParam >> 16) & 0xff);
+
+    // Windows' touch keyboard doesn't set a scan code for the Alt
+    // portion of the AltGr sequence, so we need to help it out
+    if (!isExtended && (systemKeyCode == 0x00) && (vKey == VK_MENU)) {
+      isExtended = true;
+      systemKeyCode = 0x38;
+    }
+
+    // Windows doesn't have a proper AltGr, but handles it using fake
+    // Ctrl+Alt. However the remote end might not be Windows, so we need
+    // to merge those in to a single AltGr event. We detect this case
+    // by seeing the two key events directly after each other with a very
+    // short time between them (<50ms) and supress the Ctrl event.
+    if (altGrArmed) {
+      bool altPressed = isExtended &&
+                        (systemKeyCode == 0x38) &&
+                        (vKey == VK_MENU) &&
+                        ((msg->time - altGrCtrlTime) < 50);
+      resolveAltGrDetection(altPressed);
+    }
+
+    if (systemKeyCode == SCAN_FAKE) {
+      vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey);
+      return true;
+    }
+
+    // Windows sets the scan code to 0x00 for multimedia keys, so we
+    // have to do a reverse lookup based on the vKey.
+    if (systemKeyCode == 0x00) {
+      systemKeyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
+      if (systemKeyCode == 0x00) {
+        if (isExtended)
+          vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
+        else
+          vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
+        return true;
+      }
+    }
+
+    if (systemKeyCode & ~0x7f) {
+      vlog.error(_("Invalid scan code 0x%02x"), (int)systemKeyCode);
+      return true;
+    }
+
+    if (isExtended)
+      systemKeyCode |= 0x80;
+
+    keyCode = translateSystemKeyCode(systemKeyCode);
+
+    keySym = translateVKey(vKey, isExtended);
+    if (keySym == NoSymbol) {
+      if (isExtended)
+        vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
+      else
+        vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
+    }
+
+    // Windows sends the same vKey for both shifts, so we need to look
+    // at the scan code to tell them apart
+    if ((keySym == XK_Shift_L) && (systemKeyCode == 0x36))
+      keySym = XK_Shift_R;
+
+    // AltGr handling (see above)
+    if (hasAltGr()) {
+      if ((systemKeyCode == 0xb8) && (keySym == XK_Alt_R))
+        keySym = XK_ISO_Level3_Shift;
+
+      // Possible start of AltGr sequence?
+      if ((systemKeyCode == 0x1d) && (keySym == XK_Control_L)) {
+        altGrArmed = true;
+        altGrCtrlTime = msg->time;
+        Fl::add_timeout(0.1, handleAltGrTimeout, this);
+        return true;
+      }
+    }
+
+    handler->handleKeyPress(systemKeyCode, keyCode, keySym);
+
+    // We don't get reliable WM_KEYUP for these
+    switch (keySym) {
+    case XK_Zenkaku_Hankaku:
+    case XK_Eisu_toggle:
+    case XK_Katakana:
+    case XK_Hiragana:
+    case XK_Romaji:
+      handler->handleKeyRelease(systemKeyCode);
+    }
+
+    // Shift key tracking, see below
+    if (systemKeyCode == 0x2a)
+        leftShiftDown = true;
+    if (systemKeyCode == 0x36)
+        rightShiftDown = true;
+
+    return true;
+  } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
+    UINT vKey;
+    bool isExtended;
+    int systemKeyCode, keyCode;
+
+    vKey = msg->wParam;
+    isExtended = (msg->lParam & (1 << 24)) != 0;
+
+    systemKeyCode = ((msg->lParam >> 16) & 0xff);
+
+    // Touch keyboard AltGr (see above)
+    if (!isExtended && (systemKeyCode == 0x00) && (vKey == VK_MENU)) {
+      isExtended = true;
+      systemKeyCode = 0x38;
+    }
+
+    // We can't get a release in the middle of an AltGr sequence, so
+    // abort that detection
+    if (altGrArmed)
+      resolveAltGrDetection(false);
+
+    if (systemKeyCode == SCAN_FAKE) {
+      vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey);
+      return 1;
+    }
+
+    if (systemKeyCode == 0x00)
+      systemKeyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
+    if (isExtended)
+      systemKeyCode |= 0x80;
+
+    keyCode = translateSystemKeyCode(systemKeyCode);
+
+    handler->handleKeyRelease(keyCode);
+
+    // Windows has a rather nasty bug where it won't send key release
+    // events for a Shift button if the other Shift is still pressed
+    if ((systemKeyCode == 0x2a) || (systemKeyCode == 0x36)) {
+      if (leftShiftDown)
+        handler->handleKeyRelease(0x2a);
+      if (rightShiftDown)
+        handler->handleKeyRelease(0x36);
+      leftShiftDown = false;
+      rightShiftDown = false;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+void KeyboardWin32::reset()
+{
+  altGrArmed = false;
+  Fl::remove_timeout(handleAltGrTimeout, this);
+
+  leftShiftDown = false;
+  rightShiftDown = false;
+}
+
+unsigned KeyboardWin32::getLEDState()
+{
+  unsigned state;
+
+  state = 0;
+
+  if (GetKeyState(VK_CAPITAL) & 0x1)
+    state |= rfb::ledCapsLock;
+  if (GetKeyState(VK_NUMLOCK) & 0x1)
+    state |= rfb::ledNumLock;
+  if (GetKeyState(VK_SCROLL) & 0x1)
+    state |= rfb::ledScrollLock;
+
+  return state;
+}
+
+void KeyboardWin32::setLEDState(unsigned state)
+{
+  INPUT input[6];
+  UINT count;
+  UINT ret;
+
+  memset(input, 0, sizeof(input));
+  count = 0;
+
+  if (!!(state & rfb::ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
+    input[count].type = input[count+1].type = INPUT_KEYBOARD;
+    input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
+    input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
+    input[count].ki.dwFlags = 0;
+    input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
+    count += 2;
+  }
+
+  if (!!(state & rfb::ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
+    input[count].type = input[count+1].type = INPUT_KEYBOARD;
+    input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
+    input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
+    input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
+    input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
+    count += 2;
+  }
+
+  if (!!(state & rfb::ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
+    input[count].type = input[count+1].type = INPUT_KEYBOARD;
+    input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
+    input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
+    input[count].ki.dwFlags = 0;
+    input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
+    count += 2;
+  }
+
+  if (count == 0)
+    return;
+
+  ret = SendInput(count, input, sizeof(*input));
+  if (ret < count)
+    vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError());
+}
+
+uint32_t KeyboardWin32::translateSystemKeyCode(int systemKeyCode)
+{
+  // Fortunately RFB and Windows use the same scan code set (mostly),
+  // so there is no conversion needed
+  // (as long as we encode the extended keys with the high bit)
+
+  // However Pause sends a code that conflicts with NumLock, so use
+  // the code most RFB implementations use (part of the sequence for
+  // Ctrl+Pause, i.e. Break)
+  if (systemKeyCode == 0x45)
+    return 0xc6;
+
+  // And NumLock incorrectly has the extended bit set
+  if (systemKeyCode == 0xc5)
+    return 0x45;
+
+  // And Alt+PrintScreen (i.e. SysRq) sends a different code than
+  // PrintScreen
+  if (systemKeyCode == 0xb7)
+    return 0x54;
+
+  return systemKeyCode;
+}
+
+uint32_t KeyboardWin32::lookupVKeyMap(unsigned vkey, bool extended,
+                                          const UINT map[][3], size_t size)
+{
+  size_t i;
+
+  for (i = 0;i < size;i++) {
+    if (vkey != map[i][0])
+      continue;
+
+    if (extended)
+      return map[i][2];
+    else
+      return map[i][1];
+  }
+
+  return NoSymbol;
+}
+
+uint32_t KeyboardWin32::translateVKey(unsigned vkey, bool extended)
+{
+  HKL layout;
+  WORD lang, primary_lang;
+
+  BYTE state[256];
+  int ret;
+  WCHAR wstr[10];
+
+  // Start with keys that either don't generate a symbol, or
+  // generate the same symbol as some other key.
+
+  ret = lookupVKeyMap(vkey, extended, vkey_map, ARRAY_SIZE(vkey_map));
+  if (ret != NoSymbol)
+    return ret;
+
+  layout = GetKeyboardLayout(0);
+  lang = LOWORD(layout);
+  primary_lang = PRIMARYLANGID(lang);
+
+  if (primary_lang == LANG_JAPANESE) {
+    ret = lookupVKeyMap(vkey, extended,
+                        vkey_map_jp, ARRAY_SIZE(vkey_map_jp));
+    if (ret != NoSymbol)
+      return ret;
+  }
+
+  if (primary_lang == LANG_KOREAN) {
+    ret = lookupVKeyMap(vkey, extended,
+                        vkey_map_ko, ARRAY_SIZE(vkey_map_ko));
+    if (ret != NoSymbol)
+      return ret;
+  }
+
+  // Windows is not consistent in which virtual key it uses for
+  // the numpad decimal key, and this is not likely to be fixed:
+  // http://blogs.msdn.com/michkap/archive/2006/09/13/752377.aspx
+  //
+  // To get X11 behaviour, we instead look at the text generated
+  // by they key.
+  if ((vkey == VK_DECIMAL) || (vkey == VK_SEPARATOR)) {
+    UINT ch;
+
+    ch = MapVirtualKey(vkey, MAPVK_VK_TO_CHAR);
+    switch (ch) {
+    case ',':
+      return XK_KP_Separator;
+    case '.':
+      return XK_KP_Decimal;
+    default:
+      return NoSymbol;
+    }
+  }
+
+  // MapVirtualKey() doesn't look at modifiers, so it is
+  // insufficient for mapping most keys to a symbol. ToUnicode()
+  // does what we want though. Unfortunately it keeps state, so
+  // we have to be careful around dead characters.
+
+  GetKeyboardState(state);
+
+  // Pressing Ctrl wreaks havoc with the symbol lookup, so turn
+  // that off. But AltGr shows up as Ctrl+Alt in Windows, so keep
+  // Ctrl if Alt is active.
+  if (!(state[VK_LCONTROL] & 0x80) || !(state[VK_RMENU] & 0x80))
+    state[VK_CONTROL] = state[VK_LCONTROL] = state[VK_RCONTROL] = 0;
+
+  // FIXME: Multi character results, like U+0644 U+0627
+  //        on Arabic layout
+  ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0);
+
+  if (ret == 0) {
+    // Most Ctrl+Alt combinations will fail to produce a symbol, so
+    // try it again with Ctrl unconditionally disabled.
+    state[VK_CONTROL] = state[VK_LCONTROL] = state[VK_RCONTROL] = 0;
+    ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0);
+  }
+
+  if (ret == 1)
+    return ucs2keysym(wstr[0]);
+
+  if (ret == -1) {
+    WCHAR dead_char;
+
+    dead_char = wstr[0];
+
+    // Need to clear out the state that the dead key has caused.
+    // This is the recommended method by Microsoft's engineers:
+    // http://blogs.msdn.com/b/michkap/archive/2007/10/27/5717859.aspx
+    do {
+      ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0);
+    } while (ret < 0);
+
+    // Dead keys are represented by their spacing equivalent
+    // (or something similar depending on the layout)
+    return ucs2keysym(ucs2combining(dead_char));
+  }
+
+  return NoSymbol;
+}
+
+bool KeyboardWin32::hasAltGr()
+{
+  BYTE origState[256];
+  BYTE altGrState[256];
+
+  if (currentLayout == GetKeyboardLayout(0))
+    return cachedHasAltGr;
+
+  // Save current keyboard state so we can get things sane again after
+  // we're done
+  if (!GetKeyboardState(origState))
+    return 0;
+
+  // We press Ctrl+Alt (Windows fake AltGr) and then test every key
+  // to see if it produces a printable character. If so then we assume
+  // AltGr is used in the current layout.
+
+  cachedHasAltGr = false;
+
+  memset(altGrState, 0, sizeof(altGrState));
+  altGrState[VK_CONTROL] = 0x80;
+  altGrState[VK_MENU] = 0x80;
+
+  for (UINT vkey = 0;vkey <= 0xff;vkey++) {
+    int ret;
+    WCHAR wstr[10];
+
+    // Need to skip this one as it is a bit magical and will trigger
+    // a false positive
+    if (vkey == VK_PACKET)
+      continue;
+
+    ret = ToUnicode(vkey, 0, altGrState, wstr,
+                    sizeof(wstr)/sizeof(wstr[0]), 0);
+    if (ret == 1) {
+      cachedHasAltGr = true;
+      break;
+    }
+
+    if (ret == -1) {
+      // Dead key, need to clear out state before we proceed
+      do {
+        ret = ToUnicode(vkey, 0, altGrState, wstr,
+                        sizeof(wstr)/sizeof(wstr[0]), 0);
+      } while (ret < 0);
+    }
+  }
+
+  SetKeyboardState(origState);
+
+  currentLayout = GetKeyboardLayout(0);
+
+  return cachedHasAltGr;
+}
+
+void KeyboardWin32::handleAltGrTimeout(void *data)
+{
+  KeyboardWin32 *self = (KeyboardWin32 *)data;
+
+  assert(self);
+
+  self->altGrArmed = false;
+  self->handler->handleKeyPress(0x1d, 0x1d, XK_Control_L);
+}
+
+void KeyboardWin32::resolveAltGrDetection(bool isAltGrSequence)
+{
+  altGrArmed = false;
+  Fl::remove_timeout(handleAltGrTimeout);
+  // when it's not an AltGr sequence we can't supress the Ctrl anymore
+  if (!isAltGrSequence)
+    handler->handleKeyPress(0x1d, 0x1d, XK_Control_L);
+}
diff --git a/vncviewer/KeyboardWin32.h b/vncviewer/KeyboardWin32.h
new file mode 100644
index 00000000..336fe6da
--- /dev/null
+++ b/vncviewer/KeyboardWin32.h
@@ -0,0 +1,58 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifndef __KEYBOARDWIN32_H__
+#define __KEYBOARDWIN32_H__
+
+#include "Keyboard.h"
+
+class KeyboardWin32 : public Keyboard
+{
+public:
+  KeyboardWin32(KeyboardHandler* handler);
+  virtual ~KeyboardWin32();
+
+  bool handleEvent(const void* event) override;
+
+  void reset() override;
+
+  unsigned getLEDState() override;
+  void setLEDState(unsigned state) override;
+
+protected:
+  uint32_t translateSystemKeyCode(int systemKeyCode);
+  uint32_t lookupVKeyMap(unsigned vkey, bool extended,
+                         const UINT map[][3], size_t size);
+  uint32_t translateVKey(unsigned vkey, bool extended);
+
+  bool hasAltGr();
+  static void handleAltGrTimeout(void *data);
+  void resolveAltGrDetection(bool isAltGrSequence);
+
+private:
+  int cachedHasAltGr;
+  HKL currentLayout;
+
+  bool altGrArmed;
+  unsigned int altGrCtrlTime;
+
+  bool leftShiftDown;
+  bool rightShiftDown;
+};
+
+#endif
diff --git a/vncviewer/KeyboardX11.cxx b/vncviewer/KeyboardX11.cxx
new file mode 100644
index 00000000..90a4cedc
--- /dev/null
+++ b/vncviewer/KeyboardX11.cxx
@@ -0,0 +1,219 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <assert.h>
+
+#include <X11/XKBlib.h>
+#include <FL/x.H>
+
+#include <rfb/Exception.h>
+#include <rfb/LogWriter.h>
+#include <rfb/ledStates.h>
+
+#include "i18n.h"
+#include "KeyboardX11.h"
+
+extern const struct _code_map_xkb_to_qnum {
+  const char * from;
+  const unsigned short to;
+} code_map_xkb_to_qnum[];
+extern const unsigned int code_map_xkb_to_qnum_len;
+
+static rfb::LogWriter vlog("KeyboardX11");
+
+KeyboardX11::KeyboardX11(KeyboardHandler* handler_)
+  : Keyboard(handler_)
+{
+  XkbDescPtr xkb;
+  Status status;
+
+  xkb = XkbGetMap(fl_display, 0, XkbUseCoreKbd);
+  if (!xkb)
+    throw rfb::Exception("XkbGetMap");
+
+  status = XkbGetNames(fl_display, XkbKeyNamesMask, xkb);
+  if (status != Success)
+    throw rfb::Exception("XkbGetNames");
+
+  memset(code_map_keycode_to_qnum, 0, sizeof(code_map_keycode_to_qnum));
+  for (KeyCode keycode = xkb->min_key_code;
+       keycode < xkb->max_key_code;
+       keycode++) {
+    const char *keyname = xkb->names->keys[keycode].name;
+    unsigned short rfbcode;
+
+    if (keyname[0] == '\0')
+      continue;
+
+    rfbcode = 0;
+    for (unsigned i = 0;i < code_map_xkb_to_qnum_len;i++) {
+        if (strncmp(code_map_xkb_to_qnum[i].from,
+                    keyname, XkbKeyNameLength) == 0) {
+            rfbcode = code_map_xkb_to_qnum[i].to;
+            break;
+        }
+    }
+    if (rfbcode != 0)
+        code_map_keycode_to_qnum[keycode] = rfbcode;
+    else
+        vlog.debug("No key mapping for key %.4s", keyname);
+  }
+
+  XkbFreeKeyboard(xkb, 0, True);
+}
+
+KeyboardX11::~KeyboardX11()
+{
+}
+
+bool KeyboardX11::handleEvent(const void* event)
+{
+  const XEvent *xevent = (const XEvent*)event;
+
+  assert(event);
+
+  if (xevent->type == KeyPress) {
+    int keycode;
+    char str;
+    KeySym keysym;
+
+    keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
+
+    XLookupString((XKeyEvent*)&xevent->xkey, &str, 1, &keysym, nullptr);
+    if (keysym == NoSymbol) {
+      vlog.error(_("No symbol for key code %d (in the current state)"),
+                 (int)xevent->xkey.keycode);
+    }
+
+    handler->handleKeyPress(xevent->xkey.keycode, keycode, keysym);
+    return true;
+  } else if (xevent->type == KeyRelease) {
+    handler->handleKeyRelease(xevent->xkey.keycode);
+    return true;
+  }
+
+  return false;
+}
+
+unsigned KeyboardX11::getLEDState()
+{
+  unsigned state;
+
+  unsigned int mask;
+
+  Status status;
+  XkbStateRec xkbState;
+
+  status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
+  if (status != Success) {
+    vlog.error(_("Failed to get keyboard LED state: %d"), status);
+    return rfb::ledUnknown;
+  }
+
+  state = 0;
+
+  if (xkbState.locked_mods & LockMask)
+    state |= rfb::ledCapsLock;
+
+  mask = getModifierMask(XK_Num_Lock);
+  if (xkbState.locked_mods & mask)
+    state |= rfb::ledNumLock;
+
+  mask = getModifierMask(XK_Scroll_Lock);
+  if (xkbState.locked_mods & mask)
+    state |= rfb::ledScrollLock;
+
+  return state;
+}
+
+void KeyboardX11::setLEDState(unsigned state)
+{
+  unsigned int affect, values;
+  unsigned int mask;
+
+  Bool ret;
+
+  affect = values = 0;
+
+  affect |= LockMask;
+  if (state & rfb::ledCapsLock)
+    values |= LockMask;
+
+  mask = getModifierMask(XK_Num_Lock);
+  affect |= mask;
+  if (state & rfb::ledNumLock)
+    values |= mask;
+
+  mask = getModifierMask(XK_Scroll_Lock);
+  affect |= mask;
+  if (state & rfb::ledScrollLock)
+    values |= mask;
+
+  ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
+  if (!ret)
+    vlog.error(_("Failed to update keyboard LED state"));
+}
+
+unsigned KeyboardX11::getModifierMask(uint32_t keysym)
+{
+  XkbDescPtr xkb;
+  unsigned int mask, keycode;
+  XkbAction *act;
+
+  mask = 0;
+
+  xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
+  if (xkb == nullptr)
+    return 0;
+
+  for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
+    unsigned int state_out;
+    KeySym ks;
+
+    XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks);
+    if (ks == NoSymbol)
+      continue;
+
+    if (ks == keysym)
+      break;
+  }
+
+  // KeySym not mapped?
+  if (keycode > xkb->max_key_code)
+    goto out;
+
+  act = XkbKeyAction(xkb, keycode, 0);
+  if (act == nullptr)
+    goto out;
+  if (act->type != XkbSA_LockMods)
+    goto out;
+
+  if (act->mods.flags & XkbSA_UseModMapMods)
+    mask = xkb->map->modmap[keycode];
+  else
+    mask = act->mods.mask;
+
+out:
+  XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
+
+  return mask;
+}
diff --git a/vncviewer/KeyboardX11.h b/vncviewer/KeyboardX11.h
new file mode 100644
index 00000000..ba9a88f9
--- /dev/null
+++ b/vncviewer/KeyboardX11.h
@@ -0,0 +1,42 @@
+/* Copyright 2011-2021 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#ifndef __KEYBOARDX11_H__
+#define __KEYBOARDX11_H__
+
+#include "Keyboard.h"
+
+class KeyboardX11 : public Keyboard
+{
+public:
+  KeyboardX11(KeyboardHandler* handler);
+  virtual ~KeyboardX11();
+
+  bool handleEvent(const void* event) override;
+
+  unsigned getLEDState() override;
+  void setLEDState(unsigned state) override;
+
+protected:
+  unsigned getModifierMask(uint32_t keysym);
+
+private:
+  int code_map_keycode_to_qnum[256];
+};
+
+#endif
diff --git a/vncviewer/Viewport.cxx b/vncviewer/Viewport.cxx
index f5bc166d..6a09f407 100644
--- a/vncviewer/Viewport.cxx
+++ b/vncviewer/Viewport.cxx
@@ -1,5 +1,5 @@
 /* Copyright (C) 2002-2005 RealVNC Ltd.  All Rights Reserved.
- * Copyright 2011-2019 Pierre Ossman for Cendio AB
+ * Copyright 2011-2021 Pierre Ossman 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
@@ -33,29 +33,10 @@
 
 // FLTK can pull in the X11 headers on some systems
 #ifndef XK_VoidSymbol
-#define XK_LATIN1
 #define XK_MISCELLANY
-#define XK_XKB_KEYS
 #include <rfb/keysymdef.h>
 #endif
 
-#ifndef XF86XK_ModeLock
-#include <rfb/XF86keysym.h>
-#endif
-
-#if ! (defined(WIN32) || defined(__APPLE__))
-#include <X11/XKBlib.h>
-#endif
-
-#ifndef NoSymbol
-#define NoSymbol 0
-#endif
-
-// Missing in at least some versions of MinGW
-#ifndef MAPVK_VK_TO_VSC
-#define MAPVK_VK_TO_VSC 0
-#endif
-
 #include "fltk/layout.h"
 #include "fltk/util.h"
 #include "Viewport.h"
@@ -64,7 +45,6 @@
 #include "DesktopWindow.h"
 #include "i18n.h"
 #include "parameters.h"
-#include "keysym2ucs.h"
 #include "menukey.h"
 #include "vncviewer.h"
 
@@ -77,28 +57,18 @@
 #include <FL/Fl_Menu_Button.H>
 #include <FL/x.H>
 
-#if !defined(WIN32) && !defined(__APPLE__)
-#include <X11/XKBlib.h>
-extern const struct _code_map_xkb_to_qnum {
-  const char * from;
-  const unsigned short to;
-} code_map_xkb_to_qnum[];
-extern const unsigned int code_map_xkb_to_qnum_len;
-
-static int code_map_keycode_to_qnum[256];
+#if defined(WIN32)
+#include "KeyboardWin32.h"
+#elif defined(__APPLE__)
+#include "KeyboardMacOS.h"
+#else
+#include "KeyboardX11.h"
 #endif
 
 #ifdef __APPLE__
 #include "cocoa.h"
-extern const unsigned short code_map_osx_to_qnum[];
-extern const unsigned int code_map_osx_to_qnum_len;
-#endif
-
-#ifdef WIN32
-#include "win32.h"
 #endif
 
-
 using namespace rfb;
 
 static rfb::LogWriter vlog("Viewport");
@@ -109,11 +79,6 @@ enum { ID_DISCONNECT, ID_FULLSCREEN, ID_MINIMIZE, ID_RESIZE,
        ID_CTRL, ID_ALT, ID_MENUKEY, ID_CTRLALTDEL,
        ID_REFRESH, ID_OPTIONS, ID_INFO, ID_ABOUT };
 
-// Used to detect fake input (0xaa is not a real key)
-#ifdef WIN32
-static const WORD SCAN_FAKE = 0xaa;
-#endif
-
 // Used for fake key presses from the menu
 static const int FAKE_CTRL_KEY_CODE = 0x10001;
 static const int FAKE_ALT_KEY_CODE = 0x10002;
@@ -125,49 +90,16 @@ static const int FAKE_KEY_CODE = 0xffff;
 Viewport::Viewport(int w, int h, const rfb::PixelFormat& /*serverPF*/, CConn* cc_)
   : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(nullptr),
     lastPointerPos(0, 0), lastButtonMask(0),
-#ifdef WIN32
-    altGrArmed(false), leftShiftDown(false), rightShiftDown(false),
-#endif
+    keyboard(nullptr),
     firstLEDState(true), pendingClientClipboard(false),
     menuCtrlKey(false), menuAltKey(false), cursor(nullptr)
 {
-#if !defined(WIN32) && !defined(__APPLE__)
-  XkbDescPtr xkb;
-  Status status;
-
-  xkb = XkbGetMap(fl_display, 0, XkbUseCoreKbd);
-  if (!xkb)
-    throw rfb::Exception("XkbGetMap");
-
-  status = XkbGetNames(fl_display, XkbKeyNamesMask, xkb);
-  if (status != Success)
-    throw rfb::Exception("XkbGetNames");
-
-  memset(code_map_keycode_to_qnum, 0, sizeof(code_map_keycode_to_qnum));
-  for (KeyCode keycode = xkb->min_key_code;
-       keycode < xkb->max_key_code;
-       keycode++) {
-    const char *keyname = xkb->names->keys[keycode].name;
-    unsigned short rfbcode;
-
-    if (keyname[0] == '\0')
-      continue;
-
-    rfbcode = 0;
-    for (unsigned i = 0;i < code_map_xkb_to_qnum_len;i++) {
-        if (strncmp(code_map_xkb_to_qnum[i].from,
-                    keyname, XkbKeyNameLength) == 0) {
-            rfbcode = code_map_xkb_to_qnum[i].to;
-            break;
-        }
-    }
-    if (rfbcode != 0)
-        code_map_keycode_to_qnum[keycode] = rfbcode;
-    else
-        vlog.debug("No key mapping for key %.4s", keyname);
-  }
-
-  XkbFreeKeyboard(xkb, 0, True);
+#if defined(WIN32)
+  keyboard = new KeyboardWin32(this);
+#elif defined(__APPLE__)
+  keyboard = new KeyboardMacOS(this);
+#else
+  keyboard = new KeyboardX11(this);
 #endif
 
   Fl::add_clipboard_notify(handleClipboardChange, this);
@@ -204,9 +136,6 @@ Viewport::~Viewport()
   // Unregister all timeouts in case they get a change tro trigger
   // again later when this object is already gone.
   Fl::remove_timeout(handlePointerTimeout, this);
-#ifdef WIN32
-  Fl::remove_timeout(handleAltGrTimeout, this);
-#endif
 
   Fl::remove_system_handler(handleSystemEvent);
 
@@ -220,6 +149,8 @@ Viewport::~Viewport()
     delete cursor;
   }
 
+  delete keyboard;
+
   // FLTK automatically deletes all child widgets, so we shouldn't touch
   // them ourselves here
 }
@@ -354,90 +285,7 @@ void Viewport::setLEDState(unsigned int ledState)
   if (!hasFocus())
     return;
 
-#if defined(WIN32)
-  INPUT input[6];
-  UINT count;
-  UINT ret;
-
-  memset(input, 0, sizeof(input));
-  count = 0;
-
-  if (!!(ledState & ledCapsLock) != !!(GetKeyState(VK_CAPITAL) & 0x1)) {
-    input[count].type = input[count+1].type = INPUT_KEYBOARD;
-    input[count].ki.wVk = input[count+1].ki.wVk = VK_CAPITAL;
-    input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
-    input[count].ki.dwFlags = 0;
-    input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
-    count += 2;
-  }
-
-  if (!!(ledState & ledNumLock) != !!(GetKeyState(VK_NUMLOCK) & 0x1)) {
-    input[count].type = input[count+1].type = INPUT_KEYBOARD;
-    input[count].ki.wVk = input[count+1].ki.wVk = VK_NUMLOCK;
-    input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
-    input[count].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
-    input[count+1].ki.dwFlags = KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
-    count += 2;
-  }
-
-  if (!!(ledState & ledScrollLock) != !!(GetKeyState(VK_SCROLL) & 0x1)) {
-    input[count].type = input[count+1].type = INPUT_KEYBOARD;
-    input[count].ki.wVk = input[count+1].ki.wVk = VK_SCROLL;
-    input[count].ki.wScan = input[count+1].ki.wScan = SCAN_FAKE;
-    input[count].ki.dwFlags = 0;
-    input[count+1].ki.dwFlags = KEYEVENTF_KEYUP;
-    count += 2;
-  }
-
-  if (count == 0)
-    return;
-
-  ret = SendInput(count, input, sizeof(*input));
-  if (ret < count)
-    vlog.error(_("Failed to update keyboard LED state: %lu"), GetLastError());
-#elif defined(__APPLE__)
-  int ret;
-
-  ret = cocoa_set_caps_lock_state(ledState & ledCapsLock);
-  if (ret != 0) {
-    vlog.error(_("Failed to update keyboard LED state: %d"), ret);
-    return;
-  }
-
-  ret = cocoa_set_num_lock_state(ledState & ledNumLock);
-  if (ret != 0) {
-    vlog.error(_("Failed to update keyboard LED state: %d"), ret);
-    return;
-  }
-
-  // No support for Scroll Lock //
-
-#else
-  unsigned int affect, values;
-  unsigned int mask;
-
-  Bool ret;
-
-  affect = values = 0;
-
-  affect |= LockMask;
-  if (ledState & ledCapsLock)
-    values |= LockMask;
-
-  mask = getModifierMask(XK_Num_Lock);
-  affect |= mask;
-  if (ledState & ledNumLock)
-    values |= mask;
-
-  mask = getModifierMask(XK_Scroll_Lock);
-  affect |= mask;
-  if (ledState & ledScrollLock)
-    values |= mask;
-
-  ret = XkbLockModifiers(fl_display, XkbUseCoreKbd, affect, values);
-  if (!ret)
-    vlog.error(_("Failed to update keyboard LED state"));
-#endif
+  keyboard->setLEDState(ledState);
 }
 
 void Viewport::pushLEDState()
@@ -448,60 +296,13 @@ void Viewport::pushLEDState()
   if (cc->server.ledState() == ledUnknown)
     return;
 
-  ledState = 0;
-
-#if defined(WIN32)
-  if (GetKeyState(VK_CAPITAL) & 0x1)
-    ledState |= ledCapsLock;
-  if (GetKeyState(VK_NUMLOCK) & 0x1)
-    ledState |= ledNumLock;
-  if (GetKeyState(VK_SCROLL) & 0x1)
-    ledState |= ledScrollLock;
-#elif defined(__APPLE__)
-  int ret;
-  bool on;
-
-  ret = cocoa_get_caps_lock_state(&on);
-  if (ret != 0) {
-    vlog.error(_("Failed to get keyboard LED state: %d"), ret);
-    return;
-  }
-  if (on)
-    ledState |= ledCapsLock;
-
-  ret = cocoa_get_num_lock_state(&on);
-  if (ret != 0) {
-    vlog.error(_("Failed to get keyboard LED state: %d"), ret);
+  ledState = keyboard->getLEDState();
+  if (ledState == ledUnknown)
     return;
-  }
-  if (on)
-    ledState |= ledNumLock;
 
+#if defined(__APPLE__)
   // No support for Scroll Lock //
   ledState |= (cc->server.ledState() & ledScrollLock);
-
-#else
-  unsigned int mask;
-
-  Status status;
-  XkbStateRec xkbState;
-
-  status = XkbGetState(fl_display, XkbUseCoreKbd, &xkbState);
-  if (status != Success) {
-    vlog.error(_("Failed to get keyboard LED state: %d"), status);
-    return;
-  }
-
-  if (xkbState.locked_mods & LockMask)
-    ledState |= ledCapsLock;
-
-  mask = getModifierMask(XK_Num_Lock);
-  if (xkbState.locked_mods & mask)
-    ledState |= ledNumLock;
-
-  mask = getModifierMask(XK_Scroll_Lock);
-  if (xkbState.locked_mods & mask)
-    ledState |= ledScrollLock;
 #endif
 
   if ((ledState & ledCapsLock) != (cc->server.ledState() & ledCapsLock)) {
@@ -698,54 +499,6 @@ bool Viewport::hasFocus()
   return focus == this;
 }
 
-#if ! (defined(WIN32) || defined(__APPLE__))
-unsigned int Viewport::getModifierMask(unsigned int keysym)
-{
-  XkbDescPtr xkb;
-  unsigned int mask, keycode;
-  XkbAction *act;
-
-  mask = 0;
-
-  xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
-  if (xkb == nullptr)
-    return 0;
-
-  for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
-    unsigned int state_out;
-    KeySym ks;
-
-    XkbTranslateKeyCode(xkb, keycode, 0, &state_out, &ks);
-    if (ks == NoSymbol)
-      continue;
-
-    if (ks == keysym)
-      break;
-  }
-
-  // KeySym not mapped?
-  if (keycode > xkb->max_key_code)
-    goto out;
-
-  act = XkbKeyAction(xkb, keycode, 0);
-  if (act == nullptr)
-    goto out;
-  if (act->type != XkbSA_LockMods)
-    goto out;
-
-  if (act->mods.flags & XkbSA_UseModMapMods)
-    mask = xkb->map->modmap[keycode];
-  else
-    mask = act->mods.mask;
-
-out:
-  XkbFreeKeyboard(xkb, XkbAllComponentsMask, True);
-
-  return mask;
-}
-#endif
-
-
 void Viewport::handleClipboardChange(int source, void *data)
 {
   Viewport *self = (Viewport *)data;
@@ -835,10 +588,7 @@ void Viewport::resetKeyboard()
     abort_connection_with_unexpected_error(e);
   }
 
-#ifdef WIN32
-  leftShiftDown = false;
-  rightShiftDown = false;
-#endif
+  keyboard->reset();
 }
 
 
@@ -885,294 +635,28 @@ void Viewport::handleKeyRelease(int systemKeyCode)
 int Viewport::handleSystemEvent(void *event, void *data)
 {
   Viewport *self = (Viewport *)data;
+  bool consumed;
 
   assert(self);
 
   if (!self->hasFocus())
     return 0;
 
-  assert(event);
-
-#if defined(WIN32)
-  MSG *msg = (MSG*)event;
-
-  if ((msg->message == WM_MOUSEMOVE) ||
-      (msg->message == WM_LBUTTONDOWN) ||
-      (msg->message == WM_LBUTTONUP) ||
-      (msg->message == WM_RBUTTONDOWN) ||
-      (msg->message == WM_RBUTTONUP) ||
-      (msg->message == WM_MBUTTONDOWN) ||
-      (msg->message == WM_MBUTTONUP) ||
-      (msg->message == WM_MOUSEWHEEL) ||
-      (msg->message == WM_MOUSEHWHEEL)) {
-    // We can't get a mouse event in the middle of an AltGr sequence, so
-    // abort that detection
-    if (self->altGrArmed)
-      self->resolveAltGrDetection(false);
-
-    return 0; // We didn't really consume the mouse event
-  } else if ((msg->message == WM_KEYDOWN) || (msg->message == WM_SYSKEYDOWN)) {
-    UINT vKey;
-    bool isExtended;
-    int keyCode;
-    uint32_t keySym;
-
-    vKey = msg->wParam;
-    isExtended = (msg->lParam & (1 << 24)) != 0;
-
-    keyCode = ((msg->lParam >> 16) & 0xff);
-
-    // Windows' touch keyboard doesn't set a scan code for the Alt
-    // portion of the AltGr sequence, so we need to help it out
-    if (!isExtended && (keyCode == 0x00) && (vKey == VK_MENU)) {
-      isExtended = true;
-      keyCode = 0x38;
-    }
-
-    // Windows doesn't have a proper AltGr, but handles it using fake
-    // Ctrl+Alt. However the remote end might not be Windows, so we need
-    // to merge those in to a single AltGr event. We detect this case
-    // by seeing the two key events directly after each other with a very
-    // short time between them (<50ms) and supress the Ctrl event.
-    if (self->altGrArmed) {
-      bool altPressed = isExtended &&
-                        (keyCode == 0x38) &&
-                        (vKey == VK_MENU) &&
-                        ((msg->time - self->altGrCtrlTime) < 50);
-      self->resolveAltGrDetection(altPressed);
-    }
-
-    if (keyCode == SCAN_FAKE) {
-      vlog.debug("Ignoring fake key press (virtual key 0x%02x)", vKey);
-      return 1;
-    }
-
-    // Windows sets the scan code to 0x00 for multimedia keys, so we
-    // have to do a reverse lookup based on the vKey.
-    if (keyCode == 0x00) {
-      keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
-      if (keyCode == 0x00) {
-        if (isExtended)
-          vlog.error(_("No scan code for extended virtual key 0x%02x"), (int)vKey);
-        else
-          vlog.error(_("No scan code for virtual key 0x%02x"), (int)vKey);
-        return 1;
-      }
-    }
-
-    if (keyCode & ~0x7f) {
-      vlog.error(_("Invalid scan code 0x%02x"), (int)keyCode);
-      return 1;
-    }
-
-    if (isExtended)
-      keyCode |= 0x80;
-
-
-    // Fortunately RFB and Windows use the same scan code set (mostly),
-    // so there is no conversion needed
-    // (as long as we encode the extended keys with the high bit)
-
-    // However Pause sends a code that conflicts with NumLock, so use
-    // the code most RFB implementations use (part of the sequence for
-    // Ctrl+Pause, i.e. Break)
-    if (keyCode == 0x45)
-      keyCode = 0xc6;
-
-    // And NumLock incorrectly has the extended bit set
-    if (keyCode == 0xc5)
-      keyCode = 0x45;
-
-    // And Alt+PrintScreen (i.e. SysRq) sends a different code than
-    // PrintScreen
-    if (keyCode == 0xb7)
-      keyCode = 0x54;
-
-    keySym = win32_vkey_to_keysym(vKey, isExtended);
-    if (keySym == NoSymbol) {
-      if (isExtended)
-        vlog.error(_("No symbol for extended virtual key 0x%02x"), (int)vKey);
-      else
-        vlog.error(_("No symbol for virtual key 0x%02x"), (int)vKey);
-    }
-
-    // Windows sends the same vKey for both shifts, so we need to look
-    // at the scan code to tell them apart
-    if ((keySym == XK_Shift_L) && (keyCode == 0x36))
-      keySym = XK_Shift_R;
-
-    // AltGr handling (see above)
-    if (win32_has_altgr()) {
-      if ((keyCode == 0xb8) && (keySym == XK_Alt_R))
-        keySym = XK_ISO_Level3_Shift;
-
-      // Possible start of AltGr sequence?
-      if ((keyCode == 0x1d) && (keySym == XK_Control_L)) {
-        self->altGrArmed = true;
-        self->altGrCtrlTime = msg->time;
-        Fl::add_timeout(0.1, handleAltGrTimeout, self);
-        return 1;
-      }
-    }
-
-    self->handleKeyPress(keyCode, keyCode, keySym);
-
-    // We don't get reliable WM_KEYUP for these
-    switch (keySym) {
-    case XK_Zenkaku_Hankaku:
-    case XK_Eisu_toggle:
-    case XK_Katakana:
-    case XK_Hiragana:
-    case XK_Romaji:
-      self->handleKeyRelease(keyCode);
-    }
-
-    // Shift key tracking, see below
-    if (keyCode == 0x2a)
-        self->leftShiftDown = true;
-    if (keyCode == 0x36)
-        self->rightShiftDown = true;
-
-    return 1;
-  } else if ((msg->message == WM_KEYUP) || (msg->message == WM_SYSKEYUP)) {
-    UINT vKey;
-    bool isExtended;
-    int keyCode;
-
-    vKey = msg->wParam;
-    isExtended = (msg->lParam & (1 << 24)) != 0;
-
-    keyCode = ((msg->lParam >> 16) & 0xff);
-
-    // Touch keyboard AltGr (see above)
-    if (!isExtended && (keyCode == 0x00) && (vKey == VK_MENU)) {
-      isExtended = true;
-      keyCode = 0x38;
-    }
-
-    // We can't get a release in the middle of an AltGr sequence, so
-    // abort that detection
-    if (self->altGrArmed)
-      self->resolveAltGrDetection(false);
-
-    if (keyCode == SCAN_FAKE) {
-      vlog.debug("Ignoring fake key release (virtual key 0x%02x)", vKey);
-      return 1;
-    }
-
-    if (keyCode == 0x00)
-      keyCode = MapVirtualKey(vKey, MAPVK_VK_TO_VSC);
-    if (isExtended)
-      keyCode |= 0x80;
-    if (keyCode == 0x45)
-      keyCode = 0xc6;
-    if (keyCode == 0xc5)
-      keyCode = 0x45;
-    if (keyCode == 0xb7)
-      keyCode = 0x54;
-
-    self->handleKeyRelease(keyCode);
-
-    // Windows has a rather nasty bug where it won't send key release
-    // events for a Shift button if the other Shift is still pressed
-    if ((keyCode == 0x2a) || (keyCode == 0x36)) {
-      if (self->leftShiftDown)
-        self->handleKeyRelease(0x2a);
-      if (self->rightShiftDown)
-        self->handleKeyRelease(0x36);
-      self->leftShiftDown = false;
-      self->rightShiftDown = false;
-    }
-
-    return 1;
-  }
-#elif defined(__APPLE__)
+#ifdef __APPLE__
   // Special event that means we temporarily lost some input
-  if (cocoa_is_keyboard_sync(event)) {
+  if (KeyboardMacOS::isKeyboardSync(event)) {
     self->resetKeyboard();
     return 1;
   }
+#endif
 
-  if (cocoa_is_keyboard_event(event)) {
-    int systemKeyCode;
-
-    systemKeyCode = cocoa_event_keycode(event);
-
-    if (cocoa_is_key_press(event)) {
-      uint32_t keyCode;
-      uint32_t keySym;
-
-      if ((unsigned)systemKeyCode >= code_map_osx_to_qnum_len)
-        keyCode = 0;
-      else
-        keyCode = code_map_osx_to_qnum[systemKeyCode];
-
-      keySym = cocoa_event_keysym(event);
-      if (keySym == NoSymbol) {
-        vlog.error(_("No symbol for key code 0x%02x (in the current state)"),
-                   (int)keyCode);
-      }
-
-      self->handleKeyPress(systemKeyCode, keyCode, keySym);
-
-      // We don't get any release events for CapsLock, so we have to
-      // send the release right away.
-      if (keySym == XK_Caps_Lock)
-        self->handleKeyRelease(systemKeyCode);
-    } else {
-      self->handleKeyRelease(systemKeyCode);
-    }
-
-    return 1;
-  }
-#else
-  XEvent *xevent = (XEvent*)event;
-
-  if (xevent->type == KeyPress) {
-    int keycode;
-    char str;
-    KeySym keysym;
-
-    keycode = code_map_keycode_to_qnum[xevent->xkey.keycode];
-
-    XLookupString(&xevent->xkey, &str, 1, &keysym, nullptr);
-    if (keysym == NoSymbol) {
-      vlog.error(_("No symbol for key code %d (in the current state)"),
-                 (int)xevent->xkey.keycode);
-    }
-
-    self->handleKeyPress(xevent->xkey.keycode, keycode, keysym);
-    return 1;
-  } else if (xevent->type == KeyRelease) {
-    self->handleKeyRelease(xevent->xkey.keycode);
+  consumed = self->keyboard->handleEvent(event);
+  if (consumed)
     return 1;
-  }
-#endif
 
   return 0;
 }
 
-#ifdef WIN32
-void Viewport::handleAltGrTimeout(void *data)
-{
-  Viewport *self = (Viewport *)data;
-
-  assert(self);
-
-  self->altGrArmed = false;
-  self->handleKeyPress(0x1d, 0x1d, XK_Control_L);
-}
-
-void Viewport::resolveAltGrDetection(bool isAltGrSequence)
-{
-  altGrArmed = false;
-  Fl::remove_timeout(handleAltGrTimeout);
-  // when it's not an AltGr sequence we can't supress the Ctrl anymore
-  if (!isAltGrSequence)
-    handleKeyPress(0x1d, 0x1d, XK_Control_L);
-}
-#endif
-
 // FIXME: gcc confuses ID_DISCONNECT with NULL
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
diff --git a/vncviewer/Viewport.h b/vncviewer/Viewport.h
index 72df22f4..af1eaf2a 100644
--- a/vncviewer/Viewport.h
+++ b/vncviewer/Viewport.h
@@ -1,5 +1,5 @@
 /* Copyright (C) 2002-2005 RealVNC Ltd.  All Rights Reserved.
- * Copyright 2011-2019 Pierre Ossman <ossman@cendio.se> for Cendio AB
+ * Copyright 2011-2021 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
@@ -25,15 +25,18 @@
 #include <FL/Fl_Widget.H>
 
 #include "EmulateMB.h"
+#include "Keyboard.h"
 
 class Fl_Menu_Button;
 class Fl_RGB_Image;
 
 class CConn;
+class Keyboard;
 class PlatformPixelBuffer;
 class Surface;
 
-class Viewport : public Fl_Widget, public EmulateMB {
+class Viewport : public Fl_Widget, protected EmulateMB,
+                 protected KeyboardHandler {
 public:
 
   Viewport(int w, int h, const rfb::PixelFormat& serverPF, CConn* cc_);
@@ -73,8 +76,6 @@ protected:
 private:
   bool hasFocus();
 
-  unsigned int getModifierMask(unsigned int keysym);
-
   static void handleClipboardChange(int source, void *data);
 
   void flushPendingClipboard();
@@ -85,16 +86,11 @@ private:
   void resetKeyboard();
 
   void handleKeyPress(int systemKeyCode,
-                      uint32_t keyCode, uint32_t keySym);
-  void handleKeyRelease(int systemKeyCode);
+                      uint32_t keyCode, uint32_t keySym) override;
+  void handleKeyRelease(int systemKeyCode) override;
 
   static int handleSystemEvent(void *event, void *data);
 
-#ifdef WIN32
-  static void handleAltGrTimeout(void *data);
-  void resolveAltGrDetection(bool isAltGrSequence);
-#endif
-
   void pushLEDState();
 
   void initContextMenu();
@@ -112,13 +108,7 @@ private:
   rfb::Point lastPointerPos;
   uint8_t lastButtonMask;
 
-#ifdef WIN32
-  bool altGrArmed;
-  unsigned int altGrCtrlTime;
-
-  bool leftShiftDown;
-  bool rightShiftDown;
-#endif
+  Keyboard* keyboard;
 
   bool firstLEDState;
 
diff --git a/vncviewer/cocoa.h b/vncviewer/cocoa.h
index 63b2a535..64acefbf 100644
--- a/vncviewer/cocoa.h
+++ b/vncviewer/cocoa.h
@@ -34,18 +34,4 @@ CGColorSpaceRef cocoa_win_color_space(Fl_Window *win);
 bool cocoa_win_is_zoomed(Fl_Window *win);
 void cocoa_win_zoom(Fl_Window *win);
 
-int cocoa_is_keyboard_sync(const void *event);
-int cocoa_is_keyboard_event(const void *event);
-
-int cocoa_is_key_press(const void *event);
-
-int cocoa_event_keycode(const void *event);
-int cocoa_event_keysym(const void *event);
-
-int cocoa_set_caps_lock_state(bool on);
-int cocoa_set_num_lock_state(bool on);
-
-int cocoa_get_caps_lock_state(bool *on);
-int cocoa_get_num_lock_state(bool *on);
-
 #endif
diff --git a/vncviewer/cocoa.mm b/vncviewer/cocoa.mm
index a355b484..1d63b750 100644
--- a/vncviewer/cocoa.mm
+++ b/vncviewer/cocoa.mm
@@ -25,29 +25,9 @@
 #include <FL/x.H>
 
 #import <Cocoa/Cocoa.h>
-#import <Carbon/Carbon.h>
 
-#include <IOKit/hidsystem/IOHIDLib.h>
-#include <IOKit/hidsystem/IOHIDParameter.h>
-
-#define XK_LATIN1
-#define XK_MISCELLANY
-#define XK_XKB_KEYS
-#include <rfb/keysymdef.h>
-#include <rfb/XF86keysym.h>
 #include <rfb/Rect.h>
 
-#include "keysym2ucs.h"
-
-#define NoSymbol 0
-
-// This wasn't added until 10.12
-#if !defined(MAC_OS_X_VERSION_10_12) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_12
-const int kVK_RightCommand = 0x36;
-#endif
-// And this is still missing
-const int kVK_Menu = 0x6E;
-
 static bool captured = false;
 
 int cocoa_get_level(Fl_Window *win)
@@ -179,384 +159,3 @@ void cocoa_win_zoom(Fl_Window *win)
   nsw = (NSWindow*)fl_xid(win);
   [nsw zoom:nsw];
 }
-
-int cocoa_is_keyboard_sync(const void *event)
-{
-  const NSEvent* nsevent = (const NSEvent*)event;
-
-  assert(event);
-
-  // If we get a NSFlagsChanged event with key code 0 then this isn't
-  // an actual keyboard event but rather the system trying to sync up
-  // modifier state after it has stolen input for some reason (e.g.
-  // Cmd+Tab)
-
-  if ([nsevent type] != NSFlagsChanged)
-    return 0;
-  if ([nsevent keyCode] != 0)
-    return 0;
-
-  return 1;
-}
-
-int cocoa_is_keyboard_event(const void *event)
-{
-  NSEvent *nsevent;
-
-  nsevent = (NSEvent*)event;
-
-  switch ([nsevent type]) {
-  case NSKeyDown:
-  case NSKeyUp:
-  case NSFlagsChanged:
-    if (cocoa_is_keyboard_sync(event))
-      return 0;
-    return 1;
-  default:
-    return 0;
-  }
-}
-
-int cocoa_is_key_press(const void *event)
-{
-  NSEvent *nsevent;
-
-  nsevent = (NSEvent*)event;
-
-  if ([nsevent type] == NSKeyDown)
-    return 1;
-
-  if ([nsevent type] == NSFlagsChanged) {
-    UInt32 mask;
-
-    // We don't see any event on release of CapsLock
-    if ([nsevent keyCode] == kVK_CapsLock)
-      return 1;
-
-    // These are entirely undocumented, but I cannot find any other way
-    // of differentiating between left and right keys
-    switch ([nsevent keyCode]) {
-    case kVK_RightCommand:
-      mask = 0x0010;
-      break;
-    case kVK_Command:
-      mask = 0x0008;
-      break;
-    case kVK_Shift:
-      mask = 0x0002;
-      break;
-    case kVK_CapsLock:
-      // We don't see any event on release of CapsLock
-      return 1;
-    case kVK_Option:
-      mask = 0x0020;
-      break;
-    case kVK_Control:
-      mask = 0x0001;
-      break;
-    case kVK_RightShift:
-      mask = 0x0004;
-      break;
-    case kVK_RightOption:
-      mask = 0x0040;
-      break;
-    case kVK_RightControl:
-      mask = 0x2000;
-      break;
-    default:
-      return 0;
-    }
-
-    if ([nsevent modifierFlags] & mask)
-      return 1;
-    else
-      return 0;
-  }
-
-  return 0;
-}
-
-int cocoa_event_keycode(const void *event)
-{
-  NSEvent *nsevent;
-  int keycode;
-
-  nsevent = (NSEvent*)event;
-
-  keycode = [nsevent keyCode];
-
-  // macOS swaps these two keys for unknown reasons for ISO layouts
-  if (KBGetLayoutType(LMGetKbdType()) == kKeyboardISO) {
-    if (keycode == kVK_ANSI_Grave)
-      return kVK_ISO_Section;
-    if (keycode == kVK_ISO_Section)
-      return kVK_ANSI_Grave;
-  }
-
-  return keycode;
-}
-
-static NSString *key_translate(UInt16 keyCode, UInt32 modifierFlags)
-{
-  const UCKeyboardLayout *layout;
-  OSStatus err;
-
-  layout = nullptr;
-
-  TISInputSourceRef keyboard;
-  CFDataRef uchr;
-
-  keyboard = TISCopyCurrentKeyboardLayoutInputSource();
-  uchr = (CFDataRef)TISGetInputSourceProperty(keyboard,
-                                              kTISPropertyUnicodeKeyLayoutData);
-  if (uchr == nullptr)
-    return nil;
-
-  layout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr);
-  if (layout == nullptr)
-    return nil;
-
-  UInt32 dead_state;
-  UniCharCount max_len, actual_len;
-  UniChar string[255];
-
-  dead_state = 0;
-  max_len = sizeof(string)/sizeof(*string);
-
-  modifierFlags = (modifierFlags >> 8) & 0xff;
-
-  err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags,
-                       LMGetKbdType(), 0, &dead_state, max_len, &actual_len,
-                       string);
-  if (err != noErr)
-    return nil;
-
-  // Dead key?
-  if (dead_state != 0) {
-    // We have no fool proof way of asking what dead key this is.
-    // Assume we get a spacing equivalent if we press the
-    // same key again, and try to deduce something from that.
-    err = UCKeyTranslate(layout, keyCode, kUCKeyActionDown, modifierFlags,
-                         LMGetKbdType(), 0, &dead_state, max_len, &actual_len,
-                         string);
-    if (err != noErr)
-      return nil;
-  }
-
-  return [NSString stringWithCharacters:string length:actual_len];
-}
-
-static const int kvk_map[][2] = {
-  { kVK_Return,         XK_Return },
-  { kVK_Tab,            XK_Tab },
-  { kVK_Space,          XK_space },
-  { kVK_Delete,         XK_BackSpace },
-  { kVK_Escape,         XK_Escape },
-  { kVK_RightCommand,   XK_Super_R },
-  { kVK_Command,        XK_Super_L },
-  { kVK_Shift,          XK_Shift_L },
-  { kVK_CapsLock,       XK_Caps_Lock },
-  { kVK_Option,         XK_Alt_L },
-  { kVK_Control,        XK_Control_L },
-  { kVK_RightShift,     XK_Shift_R },
-  { kVK_RightOption,    XK_Alt_R },
-  { kVK_RightControl,   XK_Control_R },
-  { kVK_F17,            XK_F17 },
-  { kVK_VolumeUp,       XF86XK_AudioRaiseVolume },
-  { kVK_VolumeDown,     XF86XK_AudioLowerVolume },
-  { kVK_Mute,           XF86XK_AudioMute },
-  { kVK_F18,            XK_F18 },
-  { kVK_F19,            XK_F19 },
-  { kVK_F20,            XK_F20 },
-  { kVK_F5,             XK_F5 },
-  { kVK_F6,             XK_F6 },
-  { kVK_F7,             XK_F7 },
-  { kVK_F3,             XK_F3 },
-  { kVK_F8,             XK_F8 },
-  { kVK_F9,             XK_F9 },
-  { kVK_F11,            XK_F11 },
-  { kVK_F13,            XK_F13 },
-  { kVK_F16,            XK_F16 },
-  { kVK_F14,            XK_F14 },
-  { kVK_F10,            XK_F10 },
-  { kVK_Menu,           XK_Menu },
-  { kVK_F12,            XK_F12 },
-  { kVK_F15,            XK_F15 },
-  // Should we send Insert here?
-  { kVK_Help,           XK_Help },
-  { kVK_Home,           XK_Home },
-  { kVK_PageUp,         XK_Page_Up },
-  { kVK_ForwardDelete,  XK_Delete },
-  { kVK_F4,             XK_F4 },
-  { kVK_End,            XK_End },
-  { kVK_F2,             XK_F2 },
-  { kVK_PageDown,       XK_Page_Down },
-  { kVK_F1,             XK_F1 },
-  { kVK_LeftArrow,      XK_Left },
-  { kVK_RightArrow,     XK_Right },
-  { kVK_DownArrow,      XK_Down },
-  { kVK_UpArrow,        XK_Up },
-
-  // The OS X headers claim these keys are not layout independent.
-  // Could it be because of the state of the decimal key?
-  /* { kVK_ANSI_KeypadDecimal,     XK_KP_Decimal }, */ // see below
-  { kVK_ANSI_KeypadMultiply,    XK_KP_Multiply },
-  { kVK_ANSI_KeypadPlus,        XK_KP_Add },
-  // OS X doesn't have NumLock, so is this really correct?
-  { kVK_ANSI_KeypadClear,       XK_Num_Lock },
-  { kVK_ANSI_KeypadDivide,      XK_KP_Divide },
-  { kVK_ANSI_KeypadEnter,       XK_KP_Enter },
-  { kVK_ANSI_KeypadMinus,       XK_KP_Subtract },
-  { kVK_ANSI_KeypadEquals,      XK_KP_Equal },
-  { kVK_ANSI_Keypad0,           XK_KP_0 },
-  { kVK_ANSI_Keypad1,           XK_KP_1 },
-  { kVK_ANSI_Keypad2,           XK_KP_2 },
-  { kVK_ANSI_Keypad3,           XK_KP_3 },
-  { kVK_ANSI_Keypad4,           XK_KP_4 },
-  { kVK_ANSI_Keypad5,           XK_KP_5 },
-  { kVK_ANSI_Keypad6,           XK_KP_6 },
-  { kVK_ANSI_Keypad7,           XK_KP_7 },
-  { kVK_ANSI_Keypad8,           XK_KP_8 },
-  { kVK_ANSI_Keypad9,           XK_KP_9 },
-  // Japanese Keyboard Support
-  { kVK_JIS_Eisu,               XK_Eisu_toggle },
-  { kVK_JIS_Kana,               XK_Hiragana_Katakana },
-};
-
-int cocoa_event_keysym(const void *event)
-{
-  NSEvent *nsevent;
-
-  UInt16 key_code;
-  size_t i;
-
-  NSString *chars;
-  UInt32 modifiers;
-
-  nsevent = (NSEvent*)event;
-
-  key_code = [nsevent keyCode];
-
-  // Start with keys that either don't generate a symbol, or
-  // generate the same symbol as some other key.
-  for (i = 0;i < sizeof(kvk_map)/sizeof(kvk_map[0]);i++) {
-    if (key_code == kvk_map[i][0])
-      return kvk_map[i][1];
-  }
-
-  // OS X always sends the same key code for the decimal key on the
-  // num pad, but X11 wants different keysyms depending on if it should
-  // be a comma or full stop.
-  if (key_code == 0x41) {
-    switch ([[nsevent charactersIgnoringModifiers] UTF8String][0]) {
-    case ',':
-      return XK_KP_Separator;
-    case '.':
-      return XK_KP_Decimal;
-    default:
-      return NoSymbol;
-    }
-  }
-
-  // We want a "normal" symbol out of the event, which basically means
-  // we only respect the shift and alt/altgr modifiers. Cocoa can help
-  // us if we only wanted shift, but as we also want alt/altgr, we'll
-  // have to do some lookup ourselves. This matches our behaviour on
-  // other platforms.
-
-  modifiers = 0;
-  if ([nsevent modifierFlags] & NSAlphaShiftKeyMask)
-    modifiers |= alphaLock;
-  if ([nsevent modifierFlags] & NSShiftKeyMask)
-    modifiers |= shiftKey;
-  if ([nsevent modifierFlags] & NSAlternateKeyMask)
-    modifiers |= optionKey;
-
-  chars = key_translate(key_code, modifiers);
-  if (chars == nil)
-    return NoSymbol;
-
-  // FIXME: Some dead keys are given as NBSP + combining character
-  if ([chars length] != 1)
-    return NoSymbol;
-
-  // Dead key?
-  if ([[nsevent characters] length] == 0)
-    return ucs2keysym(ucs2combining([chars characterAtIndex:0]));
-
-  return ucs2keysym([chars characterAtIndex:0]);
-}
-
-static int cocoa_open_hid(io_connect_t *ioc)
-{
-  kern_return_t ret;
-  io_service_t ios;
-  CFMutableDictionaryRef mdict;
-
-  mdict = IOServiceMatching(kIOHIDSystemClass);
-  ios = IOServiceGetMatchingService(kIOMasterPortDefault,
-                                    (CFDictionaryRef) mdict);
-  if (!ios)
-    return KERN_FAILURE;
-
-  ret = IOServiceOpen(ios, mach_task_self(), kIOHIDParamConnectType, ioc);
-  IOObjectRelease(ios);
-  if (ret != KERN_SUCCESS)
-    return ret;
-
-  return KERN_SUCCESS;
-}
-
-static int cocoa_set_modifier_lock_state(int modifier, bool on)
-{
-  kern_return_t ret;
-  io_connect_t ioc;
-
-  ret = cocoa_open_hid(&ioc);
-  if (ret != KERN_SUCCESS)
-    return ret;
-
-  ret = IOHIDSetModifierLockState(ioc, modifier, on);
-  IOServiceClose(ioc);
-  if (ret != KERN_SUCCESS)
-    return ret;
-
-  return KERN_SUCCESS;
-}
-
-static int cocoa_get_modifier_lock_state(int modifier, bool *on)
-{
-  kern_return_t ret;
-  io_connect_t ioc;
-
-  ret = cocoa_open_hid(&ioc);
-  if (ret != KERN_SUCCESS)
-    return ret;
-
-  ret = IOHIDGetModifierLockState(ioc, modifier, on);
-  IOServiceClose(ioc);
-  if (ret != KERN_SUCCESS)
-    return ret;
-
-  return KERN_SUCCESS;
-}
-
-int cocoa_set_caps_lock_state(bool on)
-{
-  return cocoa_set_modifier_lock_state(kIOHIDCapsLockState, on);
-}
-
-int cocoa_set_num_lock_state(bool on)
-{
-  return cocoa_set_modifier_lock_state(kIOHIDNumLockState, on);
-}
-
-int cocoa_get_caps_lock_state(bool *on)
-{
-  return cocoa_get_modifier_lock_state(kIOHIDCapsLockState, on);
-}
-
-int cocoa_get_num_lock_state(bool *on)
-{
-  return cocoa_get_modifier_lock_state(kIOHIDNumLockState, on);
-}
diff --git a/vncviewer/win32.c b/vncviewer/win32.c
index 77366f96..b0a3813c 100644
--- a/vncviewer/win32.c
+++ b/vncviewer/win32.c
@@ -22,25 +22,6 @@
 #endif
 
 #include <windows.h>
-#include <stdio.h>
-
-#define XK_MISCELLANY
-#define XK_XKB_KEYS
-#define XK_KOREAN
-#include <rfb/keysymdef.h>
-#include <rfb/XF86keysym.h>
-
-#include "keysym2ucs.h"
-
-#define NoSymbol 0
-
-// Missing in at least some versions of MinGW
-#ifndef MAPVK_VK_TO_CHAR
-#define MAPVK_VK_TO_CHAR 2
-#endif
-
-int has_altgr;
-HKL current_layout = 0;
 
 static HANDLE thread;
 static DWORD thread_id;
@@ -48,8 +29,6 @@ static DWORD thread_id;
 static HHOOK hook = 0;
 static HWND target_wnd = 0;
 
-#define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a))
-
 static int is_system_hotkey(int vkCode) {
   switch (vkCode) {
   case VK_LWIN:
@@ -140,288 +119,3 @@ void win32_disable_lowlevel_keyboard(HWND hwnd)
   CloseHandle(thread);
   thread = NULL;
 }
-
-// Layout independent keys
-static const UINT vkey_map[][3] = {
-  { VK_CANCEL,              NoSymbol,       XK_Break },
-  { VK_BACK,                XK_BackSpace,   NoSymbol },
-  { VK_TAB,                 XK_Tab,         NoSymbol },
-  { VK_CLEAR,               XK_Clear,       NoSymbol },
-  { VK_RETURN,              XK_Return,      XK_KP_Enter },
-  { VK_SHIFT,               XK_Shift_L,     NoSymbol },
-  { VK_CONTROL,             XK_Control_L,   XK_Control_R },
-  { VK_MENU,                XK_Alt_L,       XK_Alt_R },
-  { VK_PAUSE,               XK_Pause,       NoSymbol },
-  { VK_CAPITAL,             XK_Caps_Lock,   NoSymbol },
-  { VK_ESCAPE,              XK_Escape,      NoSymbol },
-  { VK_CONVERT,             XK_Henkan,      NoSymbol },
-  { VK_NONCONVERT,          XK_Muhenkan,    NoSymbol },
-  { VK_PRIOR,               XK_KP_Prior,    XK_Prior },
-  { VK_NEXT,                XK_KP_Next,     XK_Next },
-  { VK_END,                 XK_KP_End,      XK_End },
-  { VK_HOME,                XK_KP_Home,     XK_Home },
-  { VK_LEFT,                XK_KP_Left,     XK_Left },
-  { VK_UP,                  XK_KP_Up,       XK_Up },
-  { VK_RIGHT,               XK_KP_Right,    XK_Right },
-  { VK_DOWN,                XK_KP_Down,     XK_Down },
-  { VK_SNAPSHOT,            XK_Sys_Req,     XK_Print },
-  { VK_INSERT,              XK_KP_Insert,   XK_Insert },
-  { VK_DELETE,              XK_KP_Delete,   XK_Delete },
-  { VK_LWIN,                NoSymbol,       XK_Super_L },
-  { VK_RWIN,                NoSymbol,       XK_Super_R },
-  { VK_APPS,                NoSymbol,       XK_Menu },
-  { VK_SLEEP,               NoSymbol,       XF86XK_Sleep },
-  { VK_NUMPAD0,             XK_KP_0,        NoSymbol },
-  { VK_NUMPAD1,             XK_KP_1,        NoSymbol },
-  { VK_NUMPAD2,             XK_KP_2,        NoSymbol },
-  { VK_NUMPAD3,             XK_KP_3,        NoSymbol },
-  { VK_NUMPAD4,             XK_KP_4,        NoSymbol },
-  { VK_NUMPAD5,             XK_KP_5,        NoSymbol },
-  { VK_NUMPAD6,             XK_KP_6,        NoSymbol },
-  { VK_NUMPAD7,             XK_KP_7,        NoSymbol },
-  { VK_NUMPAD8,             XK_KP_8,        NoSymbol },
-  { VK_NUMPAD9,             XK_KP_9,        NoSymbol },
-  { VK_MULTIPLY,            XK_KP_Multiply, NoSymbol },
-  { VK_ADD,                 XK_KP_Add,      NoSymbol },
-  { VK_SUBTRACT,            XK_KP_Subtract, NoSymbol },
-  { VK_DIVIDE,              NoSymbol,       XK_KP_Divide },
-  /* VK_SEPARATOR and VK_DECIMAL left out on purpose. See further down. */
-  { VK_F1,                  XK_F1,          NoSymbol },
-  { VK_F2,                  XK_F2,          NoSymbol },
-  { VK_F3,                  XK_F3,          NoSymbol },
-  { VK_F4,                  XK_F4,          NoSymbol },
-  { VK_F5,                  XK_F5,          NoSymbol },
-  { VK_F6,                  XK_F6,          NoSymbol },
-  { VK_F7,                  XK_F7,          NoSymbol },
-  { VK_F8,                  XK_F8,          NoSymbol },
-  { VK_F9,                  XK_F9,          NoSymbol },
-  { VK_F10,                 XK_F10,         NoSymbol },
-  { VK_F11,                 XK_F11,         NoSymbol },
-  { VK_F12,                 XK_F12,         NoSymbol },
-  { VK_F13,                 XK_F13,         NoSymbol },
-  { VK_F14,                 XK_F14,         NoSymbol },
-  { VK_F15,                 XK_F15,         NoSymbol },
-  { VK_F16,                 XK_F16,         NoSymbol },
-  { VK_F17,                 XK_F17,         NoSymbol },
-  { VK_F18,                 XK_F18,         NoSymbol },
-  { VK_F19,                 XK_F19,         NoSymbol },
-  { VK_F20,                 XK_F20,         NoSymbol },
-  { VK_F21,                 XK_F21,         NoSymbol },
-  { VK_F22,                 XK_F22,         NoSymbol },
-  { VK_F23,                 XK_F23,         NoSymbol },
-  { VK_F24,                 XK_F24,         NoSymbol },
-  { VK_NUMLOCK,             NoSymbol,       XK_Num_Lock },
-  { VK_SCROLL,              XK_Scroll_Lock, NoSymbol },
-  { VK_BROWSER_BACK,        NoSymbol,       XF86XK_Back },
-  { VK_BROWSER_FORWARD,     NoSymbol,       XF86XK_Forward },
-  { VK_BROWSER_REFRESH,     NoSymbol,       XF86XK_Refresh },
-  { VK_BROWSER_STOP,        NoSymbol,       XF86XK_Stop },
-  { VK_BROWSER_SEARCH,      NoSymbol,       XF86XK_Search },
-  { VK_BROWSER_FAVORITES,   NoSymbol,       XF86XK_Favorites },
-  { VK_BROWSER_HOME,        NoSymbol,       XF86XK_HomePage },
-  { VK_VOLUME_MUTE,         NoSymbol,       XF86XK_AudioMute },
-  { VK_VOLUME_DOWN,         NoSymbol,       XF86XK_AudioLowerVolume },
-  { VK_VOLUME_UP,           NoSymbol,       XF86XK_AudioRaiseVolume },
-  { VK_MEDIA_NEXT_TRACK,    NoSymbol,       XF86XK_AudioNext },
-  { VK_MEDIA_PREV_TRACK,    NoSymbol,       XF86XK_AudioPrev },
-  { VK_MEDIA_STOP,          NoSymbol,       XF86XK_AudioStop },
-  { VK_MEDIA_PLAY_PAUSE,    NoSymbol,       XF86XK_AudioPlay },
-  { VK_LAUNCH_MAIL,         NoSymbol,       XF86XK_Mail },
-  { VK_LAUNCH_APP2,         NoSymbol,       XF86XK_Calculator },
-};
-
-// Layout dependent keys, but without useful symbols
-
-// Japanese
-static const UINT vkey_map_jp[][3] = {
-  { VK_KANA,                XK_Hiragana_Katakana, NoSymbol },
-  { VK_KANJI,               XK_Kanji,       NoSymbol },
-  { VK_OEM_ATTN,            XK_Eisu_toggle, NoSymbol },
-  { VK_OEM_FINISH,          XK_Katakana,    NoSymbol },
-  { VK_OEM_COPY,            XK_Hiragana,    NoSymbol },
-  // These are really XK_Zenkaku/XK_Hankaku but we have no way of
-  // keeping the client and server in sync
-  { VK_OEM_AUTO,            XK_Zenkaku_Hankaku, NoSymbol },
-  { VK_OEM_ENLW,            XK_Zenkaku_Hankaku, NoSymbol },
-  { VK_OEM_BACKTAB,         XK_Romaji,      NoSymbol },
-  { VK_ATTN,                XK_Romaji,      NoSymbol },
-};
-
-// Korean
-static const UINT vkey_map_ko[][3] = {
-  { VK_HANGUL,              XK_Hangul,      NoSymbol },
-  { VK_HANJA,               XK_Hangul_Hanja, NoSymbol },
-};
-
-static int lookup_vkey_map(UINT vkey, int extended, const UINT map[][3], size_t size)
-{
-  size_t i;
-
-  for (i = 0;i < size;i++) {
-    if (vkey != map[i][0])
-      continue;
-
-    if (extended)
-      return map[i][2];
-    else
-      return map[i][1];
-  }
-
-  return NoSymbol;
-}
-
-int win32_vkey_to_keysym(UINT vkey, int extended)
-{
-  HKL layout;
-  WORD lang, primary_lang;
-
-  BYTE state[256];
-  int ret;
-  WCHAR wstr[10];
-
-  // Start with keys that either don't generate a symbol, or
-  // generate the same symbol as some other key.
-
-  ret = lookup_vkey_map(vkey, extended, vkey_map, ARRAY_SIZE(vkey_map));
-  if (ret != NoSymbol)
-    return ret;
-
-  layout = GetKeyboardLayout(0);
-  lang = LOWORD(layout);
-  primary_lang = PRIMARYLANGID(lang);
-
-  if (primary_lang == LANG_JAPANESE) {
-    ret = lookup_vkey_map(vkey, extended,
-                          vkey_map_jp, ARRAY_SIZE(vkey_map_jp));
-    if (ret != NoSymbol)
-      return ret;
-  }
-
-  if (primary_lang == LANG_KOREAN) {
-    ret = lookup_vkey_map(vkey, extended,
-                          vkey_map_ko, ARRAY_SIZE(vkey_map_ko));
-    if (ret != NoSymbol)
-      return ret;
-  }
-
-  // Windows is not consistent in which virtual key it uses for
-  // the numpad decimal key, and this is not likely to be fixed:
-  // http://blogs.msdn.com/michkap/archive/2006/09/13/752377.aspx
-  //
-  // To get X11 behaviour, we instead look at the text generated
-  // by they key.
-  if ((vkey == VK_DECIMAL) || (vkey == VK_SEPARATOR)) {
-    UINT ch;
-
-    ch = MapVirtualKey(vkey, MAPVK_VK_TO_CHAR);
-    switch (ch) {
-    case ',':
-      return XK_KP_Separator;
-    case '.':
-      return XK_KP_Decimal;
-    default:
-      return NoSymbol;
-    }
-  }
-
-  // MapVirtualKey() doesn't look at modifiers, so it is
-  // insufficient for mapping most keys to a symbol. ToUnicode()
-  // does what we want though. Unfortunately it keeps state, so
-  // we have to be careful around dead characters.
-
-  GetKeyboardState(state);
-
-  // Pressing Ctrl wreaks havoc with the symbol lookup, so turn
-  // that off. But AltGr shows up as Ctrl+Alt in Windows, so keep
-  // Ctrl if Alt is active.
-  if (!(state[VK_LCONTROL] & 0x80) || !(state[VK_RMENU] & 0x80))
-    state[VK_CONTROL] = state[VK_LCONTROL] = state[VK_RCONTROL] = 0;
-
-  // FIXME: Multi character results, like U+0644 U+0627
-  //        on Arabic layout
-  ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0);
-
-  if (ret == 0) {
-    // Most Ctrl+Alt combinations will fail to produce a symbol, so
-    // try it again with Ctrl unconditionally disabled.
-    state[VK_CONTROL] = state[VK_LCONTROL] = state[VK_RCONTROL] = 0;
-    ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0);
-  }
-
-  if (ret == 1)
-    return ucs2keysym(wstr[0]);
-
-  if (ret == -1) {
-    WCHAR dead_char;
-
-    dead_char = wstr[0];
-
-    // Need to clear out the state that the dead key has caused.
-    // This is the recommended method by Microsoft's engineers:
-    // http://blogs.msdn.com/b/michkap/archive/2007/10/27/5717859.aspx
-    do {
-      ret = ToUnicode(vkey, 0, state, wstr, sizeof(wstr)/sizeof(wstr[0]), 0);
-    } while (ret < 0);
-
-    // Dead keys are represented by their spacing equivalent
-    // (or something similar depending on the layout)
-    return ucs2keysym(ucs2combining(dead_char));
-  }
-
-  return NoSymbol;
-}
-
-int win32_has_altgr(void)
-{
-  BYTE orig_state[256];
-  BYTE altgr_state[256];
-
-  if (current_layout == GetKeyboardLayout(0))
-    return has_altgr;
-
-  // Save current keyboard state so we can get things sane again after
-  // we're done
-  if (!GetKeyboardState(orig_state))
-    return 0;
-
-  // We press Ctrl+Alt (Windows fake AltGr) and then test every key
-  // to see if it produces a printable character. If so then we assume
-  // AltGr is used in the current layout.
-
-  has_altgr = 0;
-
-  memset(altgr_state, 0, sizeof(altgr_state));
-  altgr_state[VK_CONTROL] = 0x80;
-  altgr_state[VK_MENU] = 0x80;
-
-  for (UINT vkey = 0;vkey <= 0xff;vkey++) {
-    int ret;
-    WCHAR wstr[10];
-
-    // Need to skip this one as it is a bit magical and will trigger
-    // a false positive
-    if (vkey == VK_PACKET)
-      continue;
-
-    ret = ToUnicode(vkey, 0, altgr_state, wstr,
-                    sizeof(wstr)/sizeof(wstr[0]), 0);
-    if (ret == 1) {
-      has_altgr = 1;
-      break;
-    }
-
-    if (ret == -1) {
-      // Dead key, need to clear out state before we proceed
-      do {
-        ret = ToUnicode(vkey, 0, altgr_state, wstr,
-                        sizeof(wstr)/sizeof(wstr[0]), 0);
-      } while (ret < 0);
-    }
-  }
-
-  SetKeyboardState(orig_state);
-
-  current_layout = GetKeyboardLayout(0);
-
-  return has_altgr;
-}
diff --git a/vncviewer/win32.h b/vncviewer/win32.h
index ebcfccb0..c8168c62 100644
--- a/vncviewer/win32.h
+++ b/vncviewer/win32.h
@@ -29,10 +29,6 @@ extern "C" {
 
 int win32_enable_lowlevel_keyboard(HWND hwnd);
 void win32_disable_lowlevel_keyboard(HWND hwnd);
-
-int win32_vkey_to_keysym(UINT vkey, int extended);
-
-int win32_has_altgr(void);
 };
 
 #endif