Fixed win32 config saving, keyboard mapping, and AltGr bugs.

Made extensive changes to the launcher to provide more control over setting up auto-start and it now saves configuration to the user's documents directory if auto-starting at login and saves to the system directory if auto-starting at boot. Replaced MapVirtualKey() with table lookup to work around that function's lack of support for extended keyboard scan codes. Added first cut at support for AltGr.
2026-07-27 08:40:41 +08:00 · 2002-09-02 17:30:04 +00:00
parent c95e991aeb
commit a729e33cfb
23 changed files with 1455 additions and 1052 deletions
--- a/lib/client/CClient.cpp
+++ b/lib/client/CClient.cpp
@@ -511,7 +511,7 @@ CClient::runServer()
 		for (;;) {
 			try {
 				// allow connect this much time to succeed
-				CTimerThread timer(m_camp ? -1.0 : 30.0);
+				CTimerThread timer(15.0);

 				// create socket and attempt to connect to server
 				log((CLOG_DEBUG1 "connecting to server"));
@@ -532,7 +532,7 @@ CClient::runServer()
 				}

 				// we're camping.  wait a bit before retrying
-				CThread::sleep(5.0);
+				CThread::sleep(15.0);
 			}
 		}

--- a/lib/client/CMSWindowsSecondaryScreen.cpp
+++ b/lib/client/CMSWindowsSecondaryScreen.cpp
@@ -459,6 +459,7 @@ CMSWindowsSecondaryScreen::updateKeys()
 	if ((m_keys[VK_SCROLL] & 0x01) != 0) {
 		m_mask |= KeyModifierScrollLock;
 	}
+	// note -- do not save KeyModifierModeSwitch in m_mask
 	log((CLOG_DEBUG2 "modifiers on update: 0x%04x", m_mask));
 }

@@ -634,6 +635,11 @@ CMSWindowsSecondaryScreen::mapKey(Keystrokes& keys, UINT& virtualKey,
 								KeyModifierAlt |
 								KeyModifierMeta));

+	// set control and alt if mode shift (AltGr) is requested
+	if ((mask & KeyModifierModeSwitch) != 0) {
+		outMask |= KeyModifierControl | KeyModifierAlt;
+	}
+
 	// extract extended key flag
 	const bool isExtended = ((virtualKey & 0x100) != 0);
 	virtualKey           &= ~0x100;
--- a/lib/platform/CUnixPlatform.cpp
+++ b/lib/platform/CUnixPlatform.cpp
@@ -38,14 +38,15 @@ CUnixPlatform::~CUnixPlatform()
 }

 bool
-CUnixPlatform::installDaemon(const char*, const char*, const char*, const char*)
+CUnixPlatform::installDaemon(const char*, const char*,
+				const char*, const char*, bool)
 {
 	// daemons don't require special installation
 	return true;
 }

 CUnixPlatform::EResult
-CUnixPlatform::uninstallDaemon(const char*)
+CUnixPlatform::uninstallDaemon(const char*, bool)
 {
 	// daemons don't require special installation
 	return kSuccess;
@@ -106,6 +107,18 @@ CUnixPlatform::installDaemonLogger(const char* name)
 	CLog::setOutputter(&CUnixPlatform::deamonLogger);
 }

+bool
+CUnixPlatform::canInstallDaemon(const char*, bool) const
+{
+	return false;
+}
+
+bool
+CUnixPlatform::isDaemonInstalled(const char*, bool) const
+{
+	return false;
+}
+
 const char*
 CUnixPlatform::getBasename(const char* pathname) const
 {
--- a/lib/platform/CUnixPlatform.h
+++ b/lib/platform/CUnixPlatform.h
@@ -27,10 +27,15 @@ public:
 	virtual bool		installDaemon(const char* name,
 							const char* description,
 							const char* pathname,
-							const char* commandLine);
-	virtual EResult		uninstallDaemon(const char* name);
+							const char* commandLine,
+							bool allUsers);
+	virtual EResult		uninstallDaemon(const char* name, bool allUsers);
 	virtual int			daemonize(const char* name, DaemonFunc);
 	virtual void		installDaemonLogger(const char* name);
+	virtual bool		canInstallDaemon(const char* name,
+							bool allUsers) const;
+	virtual bool		isDaemonInstalled(const char* name,
+							bool allUsers) const;
 	virtual const char*	getBasename(const char* pathname) const;
 	virtual CString		getUserDirectory() const;
 	virtual CString		getSystemDirectory() const;
--- a/lib/platform/CWin32Platform.cpp
+++ b/lib/platform/CWin32Platform.cpp
@@ -94,14 +94,16 @@ CWin32Platform::setStatusError(SERVICE_STATUS_HANDLE handle, DWORD error)

 bool
 CWin32Platform::installDaemon(const char* name, const char* description,
-				const char* pathname, const char* commandLine)
+				const char* pathname, const char* commandLine, bool allUsers)
 {
-	// windows 95 family services
-	if (isWindows95Family()) {
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || isWindows95Family()) {
 		// open registry
-		HKEY key = open95ServicesKey();
+		HKEY key = isWindows95Family() ? open95ServicesKey() :
+										openUserStartupKey();
 		if (key == NULL) {
-			log((CLOG_ERR "cannot open RunServices registry key", GetLastError()));
+			log((CLOG_ERR "cannot open registry key", GetLastError()));
 			return false;
 		}

@@ -152,6 +154,8 @@ CWin32Platform::installDaemon(const char* name, const char* description,
 			CloseServiceHandle(mgr);
 		}
 		else {
+// FIXME -- handle ERROR_SERVICE_EXISTS
+
 			log((CLOG_ERR "CreateService failed with %d", GetLastError()));
 			CloseServiceHandle(mgr);
 			return false;
@@ -162,7 +166,7 @@ CWin32Platform::installDaemon(const char* name, const char* description,
 		key      = openKey(key, name);
 		if (key == NULL) {
 			// can't open key
-			uninstallDaemon(name);
+			uninstallDaemon(name, allUsers);
 			return false;
 		}

@@ -173,7 +177,7 @@ CWin32Platform::installDaemon(const char* name, const char* description,
 		key = openKey(key, "Parameters");
 		if (key == NULL) {
 			// can't open key
-			uninstallDaemon(name);
+			uninstallDaemon(name, allUsers);
 			return false;
 		}
 		setValue(key, "CommandLine", commandLine);
@@ -186,14 +190,16 @@ CWin32Platform::installDaemon(const char* name, const char* description,
 }

 IPlatform::EResult
-CWin32Platform::uninstallDaemon(const char* name)
+CWin32Platform::uninstallDaemon(const char* name, bool allUsers)
 {
-	// windows 95 family services
-	if (isWindows95Family()) {
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || isWindows95Family()) {
 		// open registry
-		HKEY key = open95ServicesKey();
+		HKEY key = isWindows95Family() ? open95ServicesKey() :
+										openUserStartupKey();
 		if (key == NULL) {
-			log((CLOG_ERR "cannot open RunServices registry key", GetLastError()));
+			log((CLOG_ERR "cannot open registry key", GetLastError()));
 			return kAlready;
 		}

@@ -334,6 +340,91 @@ CWin32Platform::installDaemonLogger(const char* name)
 	}
 }

+bool
+CWin32Platform::canInstallDaemon(const char* name, bool allUsers) const
+{
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || isWindows95Family()) {
+		// check if we can open the registry key
+		HKEY key = isWindows95Family() ? open95ServicesKey() :
+										openUserStartupKey();
+		closeKey(key);
+		return (key != NULL);
+	}
+
+	// windows NT family services
+	else {
+		// check if we can open service manager for write
+		SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_WRITE);
+		if (mgr == NULL) {
+			return false;
+		}
+		CloseServiceHandle(mgr);
+
+		// check if we can open the registry key for this service
+		HKEY key = openNTServicesKey();
+		key      = openKey(key, name);
+		key      = openKey(key, "Parameters");
+		closeKey(key);
+
+		return (key != NULL);
+	}
+}
+
+bool
+CWin32Platform::isDaemonInstalled(const char* name, bool allUsers) const
+{
+	// if not for all users then use the user's autostart registry.
+	// key.  if windows 95 family then use windows 95 services key.
+	if (!allUsers || isWindows95Family()) {
+		// check if we can open the registry key
+		HKEY key = isWindows95Family() ? open95ServicesKey() :
+										openUserStartupKey();
+		if (key == NULL) {
+			return false;
+		}
+
+		// check for entry
+		const bool installed = !readValueString(key, name).empty();
+
+		// clean up
+		closeKey(key);
+
+		return installed;
+	}
+
+	// windows NT family services
+	else {
+		// check parameters for this service
+		HKEY key = openNTServicesKey();
+		key      = openKey(key, name);
+		key      = openKey(key, "Parameters");
+		if (key != NULL) {
+			const bool installed = !readValueString(key, "CommandLine").empty();
+			closeKey(key);
+			if (!installed) {
+				return false;
+			}
+		}
+
+		// open service manager
+		SC_HANDLE mgr = OpenSCManager(NULL, NULL, GENERIC_READ);
+		if (mgr == NULL) {
+			return false;
+		}
+
+		// open the service
+		SC_HANDLE service = OpenService(mgr, name, GENERIC_READ);
+
+		// clean up
+		CloseServiceHandle(service);
+		CloseServiceHandle(mgr);
+
+		return (service != NULL);
+	}
+}
+
 const char*
 CWin32Platform::getBasename(const char* pathname) const
 {
@@ -436,6 +527,11 @@ CWin32Platform::addPathComponent(const CString& prefix,
 HKEY
 CWin32Platform::openKey(HKEY key, const char* keyName)
 {
+	// ignore if parent is NULL
+	if (key == NULL) {
+		return NULL;
+	}
+
 	// open next key
 	HKEY newKey;
 	LONG result = RegOpenKeyEx(key, keyName, 0,
@@ -555,6 +651,21 @@ CWin32Platform::open95ServicesKey()
 	return openKey(HKEY_LOCAL_MACHINE, s_keyNames);
 }

+HKEY
+CWin32Platform::openUserStartupKey()
+{
+	static const char* s_keyNames[] = {
+		_T("Software"),
+		_T("Microsoft"),
+		_T("Windows"),
+		_T("CurrentVersion"),
+		_T("Run"),
+		NULL
+	};
+
+	return openKey(HKEY_CURRENT_USER, s_keyNames);
+}
+
 int
 CWin32Platform::runDaemon(RunFunc run, StopFunc stop)
 {
--- a/lib/platform/CWin32Platform.h
+++ b/lib/platform/CWin32Platform.h
@@ -71,10 +71,15 @@ public:
 	virtual bool		installDaemon(const char* name,
 							const char* description,
 							const char* pathname,
-							const char* commandLine);
-	virtual EResult		uninstallDaemon(const char* name);
+							const char* commandLine,
+							bool allUsers);
+	virtual EResult		uninstallDaemon(const char* name, bool allUsers);
 	virtual int			daemonize(const char* name, DaemonFunc);
 	virtual void		installDaemonLogger(const char* name);
+	virtual bool		canInstallDaemon(const char* name,
+							bool allUsers) const;
+	virtual bool		isDaemonInstalled(const char* name,
+							bool allUsers) const;
 	virtual const char*	getBasename(const char* pathname) const;
 	virtual CString		getUserDirectory() const;
 	virtual CString		getSystemDirectory() const;
@@ -93,6 +98,7 @@ private:
 	static CString		readValueString(HKEY, const char* name);
 	static HKEY			openNTServicesKey();
 	static HKEY			open95ServicesKey();
+	static HKEY			openUserStartupKey();

 	void				serviceMain(DWORD, LPTSTR*);
 	static void WINAPI	serviceMainEntry(DWORD, LPTSTR*);
--- a/lib/platform/IPlatform.h
+++ b/lib/platform/IPlatform.h
@@ -43,18 +43,22 @@ public:
 	system and \c description is a short human readable description of
 	the daemon.  \c pathname is the path to the daemon executable.
 	\c commandLine should \b not include the name of program as the
-	first argument.
+	first argument.  If \c allUsers is true then the daemon will be
+	installed to start at boot time, otherwise it will be installed to
+	start when the current user logs in.
 	*/
 	// FIXME -- throw on error?  will get better error messages that way.
 	virtual bool		installDaemon(const char* name,
 							const char* description,
 							const char* pathname,
-							const char* commandLine) = 0;
+							const char* commandLine,
+							bool allUsers) = 0;
+
 	//! Uninstall daemon
 	/*!
 	Uninstall a daemon.
 	*/
-	virtual EResult		uninstallDaemon(const char* name) = 0;
+	virtual EResult		uninstallDaemon(const char* name, bool allUsers) = 0;

 	//! Daemonize the process
 	/*!
@@ -91,6 +95,24 @@ public:
 	//! @name accessors
 	//@{

+	//! Check if user has permission to install the daemon
+	/*!
+	Returns true iff the caller has permission to install or
+	uninstall the daemon.  Note that even if this method returns
+	true it's possible that installing/uninstalling the service
+	may still fail.  This method ignores whether or not the
+	service is already installed.
+	*/
+	virtual bool		canInstallDaemon(const char* name,
+							bool allUsers) const = 0;
+
+	//! Check if the daemon is installed
+	/*!
+	Returns true iff the daemon is installed.
+	*/
+	virtual bool		isDaemonInstalled(const char* name,
+							bool allUsers) const = 0;
+
 	//! Extract base name
 	/*!
 	Find the base name in the given \c pathname.
--- a/lib/server/CMSWindowsPrimaryScreen.cpp
+++ b/lib/server/CMSWindowsPrimaryScreen.cpp
@@ -614,264 +614,266 @@ CMSWindowsPrimaryScreen::ignore() const
 	return (m_mark != m_markReceived);
 }

-static const KeyID		g_virtualKey[] =
+// map virtual keys to synergy key enumeration.  use extended keyboard
+// bit to distinguish some keys.
+static const KeyID		g_virtualKey[][2] =
 {
-	/* 0x00 */ kKeyNone,		// reserved
-	/* 0x01 */ kKeyNone,		// VK_LBUTTON
-	/* 0x02 */ kKeyNone,		// VK_RBUTTON
-	/* 0x03 */ kKeyBreak,		// VK_CANCEL
-	/* 0x04 */ kKeyNone,		// VK_MBUTTON
-	/* 0x05 */ kKeyNone,		// undefined
-	/* 0x06 */ kKeyNone,		// undefined
-	/* 0x07 */ kKeyNone,		// undefined
-	/* 0x08 */ kKeyBackSpace,	// VK_BACK
-	/* 0x09 */ kKeyTab,			// VK_TAB
-	/* 0x0a */ kKeyNone,		// undefined
-	/* 0x0b */ kKeyNone,		// undefined
-	/* 0x0c */ kKeyClear,		// VK_CLEAR
-	/* 0x0d */ kKeyReturn,		// VK_RETURN
-	/* 0x0e */ kKeyNone,		// undefined
-	/* 0x0f */ kKeyNone,		// undefined
-	/* 0x10 */ kKeyShift_L,		// VK_SHIFT
-	/* 0x11 */ kKeyControl_L,	// VK_CONTROL
-	/* 0x12 */ kKeyAlt_L,		// VK_MENU
-	/* 0x13 */ kKeyPause,		// VK_PAUSE
-	/* 0x14 */ kKeyCapsLock,	// VK_CAPITAL
-	/* 0x15 */ kKeyNone,		// VK_KANA			
-	/* 0x16 */ kKeyNone,		// VK_HANGUL		
-	/* 0x17 */ kKeyNone,		// VK_JUNJA			
-	/* 0x18 */ kKeyNone,		// VK_FINAL			
-	/* 0x19 */ kKeyNone,		// VK_KANJI			
-	/* 0x1a */ kKeyNone,		// undefined
-	/* 0x1b */ kKeyEscape,		// VK_ESCAPE
-	/* 0x1c */ kKeyNone,		// VK_CONVERT		
-	/* 0x1d */ kKeyNone,		// VK_NONCONVERT	
-	/* 0x1e */ kKeyNone,		// VK_ACCEPT		
-	/* 0x1f */ kKeyNone,		// VK_MODECHANGE	
-	/* 0x20 */ 0x0020,			// VK_SPACE
-	/* 0x21 */ kKeyPageUp,		// VK_PRIOR
-	/* 0x22 */ kKeyPageDown,	// VK_NEXT
-	/* 0x23 */ kKeyEnd,			// VK_END
-	/* 0x24 */ kKeyHome,		// VK_HOME
-	/* 0x25 */ kKeyLeft,		// VK_LEFT
-	/* 0x26 */ kKeyUp,			// VK_UP
-	/* 0x27 */ kKeyRight,		// VK_RIGHT
-	/* 0x28 */ kKeyDown,		// VK_DOWN
-	/* 0x29 */ kKeySelect,		// VK_SELECT
-	/* 0x2a */ kKeyNone,		// VK_PRINT
-	/* 0x2b */ kKeyExecute,		// VK_EXECUTE
-	/* 0x2c */ kKeyPrint,		// VK_SNAPSHOT
-	/* 0x2d */ kKeyInsert,		// VK_INSERT
-	/* 0x2e */ kKeyDelete,		// VK_DELETE
-	/* 0x2f */ kKeyHelp,		// VK_HELP
-	/* 0x30 */ kKeyNone,		// VK_0
-	/* 0x31 */ kKeyNone,		// VK_1
-	/* 0x32 */ kKeyNone,		// VK_2
-	/* 0x33 */ kKeyNone,		// VK_3
-	/* 0x34 */ kKeyNone,		// VK_4
-	/* 0x35 */ kKeyNone,		// VK_5
-	/* 0x36 */ kKeyNone,		// VK_6
-	/* 0x37 */ kKeyNone,		// VK_7
-	/* 0x38 */ kKeyNone,		// VK_8
-	/* 0x39 */ kKeyNone,		// VK_9
-	/* 0x3a */ kKeyNone,		// undefined
-	/* 0x3b */ kKeyNone,		// undefined
-	/* 0x3c */ kKeyNone,		// undefined
-	/* 0x3d */ kKeyNone,		// undefined
-	/* 0x3e */ kKeyNone,		// undefined
-	/* 0x3f */ kKeyNone,		// undefined
-	/* 0x40 */ kKeyNone,		// undefined
-	/* 0x41 */ kKeyNone,		// VK_A
-	/* 0x42 */ kKeyNone,		// VK_B
-	/* 0x43 */ kKeyNone,		// VK_C
-	/* 0x44 */ kKeyNone,		// VK_D
-	/* 0x45 */ kKeyNone,		// VK_E
-	/* 0x46 */ kKeyNone,		// VK_F
-	/* 0x47 */ kKeyNone,		// VK_G
-	/* 0x48 */ kKeyNone,		// VK_H
-	/* 0x49 */ kKeyNone,		// VK_I
-	/* 0x4a */ kKeyNone,		// VK_J
-	/* 0x4b */ kKeyNone,		// VK_K
-	/* 0x4c */ kKeyNone,		// VK_L
-	/* 0x4d */ kKeyNone,		// VK_M
-	/* 0x4e */ kKeyNone,		// VK_N
-	/* 0x4f */ kKeyNone,		// VK_O
-	/* 0x50 */ kKeyNone,		// VK_P
-	/* 0x51 */ kKeyNone,		// VK_Q
-	/* 0x52 */ kKeyNone,		// VK_R
-	/* 0x53 */ kKeyNone,		// VK_S
-	/* 0x54 */ kKeyNone,		// VK_T
-	/* 0x55 */ kKeyNone,		// VK_U
-	/* 0x56 */ kKeyNone,		// VK_V
-	/* 0x57 */ kKeyNone,		// VK_W
-	/* 0x58 */ kKeyNone,		// VK_X
-	/* 0x59 */ kKeyNone,		// VK_Y
-	/* 0x5a */ kKeyNone,		// VK_Z
-	/* 0x5b */ kKeyMeta_L,		// VK_LWIN
-	/* 0x5c */ kKeyMeta_R,		// VK_RWIN
-	/* 0x5d */ kKeyMenu,		// VK_APPS
-	/* 0x5e */ kKeyNone,		// undefined
-	/* 0x5f */ kKeyNone,		// undefined
-	/* 0x60 */ kKeyKP_0,		// VK_NUMPAD0
-	/* 0x61 */ kKeyKP_1,		// VK_NUMPAD1
-	/* 0x62 */ kKeyKP_2,		// VK_NUMPAD2
-	/* 0x63 */ kKeyKP_3,		// VK_NUMPAD3
-	/* 0x64 */ kKeyKP_4,		// VK_NUMPAD4
-	/* 0x65 */ kKeyKP_5,		// VK_NUMPAD5
-	/* 0x66 */ kKeyKP_6,		// VK_NUMPAD6
-	/* 0x67 */ kKeyKP_7,		// VK_NUMPAD7
-	/* 0x68 */ kKeyKP_8,		// VK_NUMPAD8
-	/* 0x69 */ kKeyKP_9,		// VK_NUMPAD9
-	/* 0x6a */ kKeyKP_Multiply,	// VK_MULTIPLY
-	/* 0x6b */ kKeyKP_Add,		// VK_ADD
-	/* 0x6c */ kKeyKP_Separator,// VK_SEPARATOR
-	/* 0x6d */ kKeyKP_Subtract,	// VK_SUBTRACT
-	/* 0x6e */ kKeyKP_Decimal,	// VK_DECIMAL
-	/* 0x6f */ kKeyKP_Divide,	// VK_DIVIDE
-	/* 0x70 */ kKeyF1,			// VK_F1
-	/* 0x71 */ kKeyF2,			// VK_F2
-	/* 0x72 */ kKeyF3,			// VK_F3
-	/* 0x73 */ kKeyF4,			// VK_F4
-	/* 0x74 */ kKeyF5,			// VK_F5
-	/* 0x75 */ kKeyF6,			// VK_F6
-	/* 0x76 */ kKeyF7,			// VK_F7
-	/* 0x77 */ kKeyF8,			// VK_F8
-	/* 0x78 */ kKeyF9,			// VK_F9
-	/* 0x79 */ kKeyF10,			// VK_F10
-	/* 0x7a */ kKeyF11,			// VK_F11
-	/* 0x7b */ kKeyF12,			// VK_F12
-	/* 0x7c */ kKeyF13,			// VK_F13
-	/* 0x7d */ kKeyF14,			// VK_F14
-	/* 0x7e */ kKeyF15,			// VK_F15
-	/* 0x7f */ kKeyF16,			// VK_F16
-	/* 0x80 */ kKeyF17,			// VK_F17
-	/* 0x81 */ kKeyF18,			// VK_F18
-	/* 0x82 */ kKeyF19,			// VK_F19
-	/* 0x83 */ kKeyF20,			// VK_F20
-	/* 0x84 */ kKeyF21,			// VK_F21
-	/* 0x85 */ kKeyF22,			// VK_F22
-	/* 0x86 */ kKeyF23,			// VK_F23
-	/* 0x87 */ kKeyF24,			// VK_F24
-	/* 0x88 */ kKeyNone,		// unassigned
-	/* 0x89 */ kKeyNone,		// unassigned
-	/* 0x8a */ kKeyNone,		// unassigned
-	/* 0x8b */ kKeyNone,		// unassigned
-	/* 0x8c */ kKeyNone,		// unassigned
-	/* 0x8d */ kKeyNone,		// unassigned
-	/* 0x8e */ kKeyNone,		// unassigned
-	/* 0x8f */ kKeyNone,		// unassigned
-	/* 0x90 */ kKeyNumLock,		// VK_NUMLOCK
-	/* 0x91 */ kKeyScrollLock,	// VK_SCROLL
-	/* 0x92 */ kKeyNone,		// unassigned
-	/* 0x93 */ kKeyNone,		// unassigned
-	/* 0x94 */ kKeyNone,		// unassigned
-	/* 0x95 */ kKeyNone,		// unassigned
-	/* 0x96 */ kKeyNone,		// unassigned
-	/* 0x97 */ kKeyNone,		// unassigned
-	/* 0x98 */ kKeyNone,		// unassigned
-	/* 0x99 */ kKeyNone,		// unassigned
-	/* 0x9a */ kKeyNone,		// unassigned
-	/* 0x9b */ kKeyNone,		// unassigned
-	/* 0x9c */ kKeyNone,		// unassigned
-	/* 0x9d */ kKeyNone,		// unassigned
-	/* 0x9e */ kKeyNone,		// unassigned
-	/* 0x9f */ kKeyNone,		// unassigned
-	/* 0xa0 */ kKeyShift_L,		// VK_LSHIFT
-	/* 0xa1 */ kKeyShift_R,		// VK_RSHIFT
-	/* 0xa2 */ kKeyControl_L,	// VK_LCONTROL
-	/* 0xa3 */ kKeyControl_R,	// VK_RCONTROL
-	/* 0xa4 */ kKeyAlt_L,		// VK_LMENU
-	/* 0xa5 */ kKeyAlt_R,		// VK_RMENU
-	/* 0xa6 */ kKeyNone,		// unassigned
-	/* 0xa7 */ kKeyNone,		// unassigned
-	/* 0xa8 */ kKeyNone,		// unassigned
-	/* 0xa9 */ kKeyNone,		// unassigned
-	/* 0xaa */ kKeyNone,		// unassigned
-	/* 0xab */ kKeyNone,		// unassigned
-	/* 0xac */ kKeyNone,		// unassigned
-	/* 0xad */ kKeyNone,		// unassigned
-	/* 0xae */ kKeyNone,		// unassigned
-	/* 0xaf */ kKeyNone,		// unassigned
-	/* 0xb0 */ kKeyNone,		// unassigned
-	/* 0xb1 */ kKeyNone,		// unassigned
-	/* 0xb2 */ kKeyNone,		// unassigned
-	/* 0xb3 */ kKeyNone,		// unassigned
-	/* 0xb4 */ kKeyNone,		// unassigned
-	/* 0xb5 */ kKeyNone,		// unassigned
-	/* 0xb6 */ kKeyNone,		// unassigned
-	/* 0xb7 */ kKeyNone,		// unassigned
-	/* 0xb8 */ kKeyNone,		// unassigned
-	/* 0xb9 */ kKeyNone,		// unassigned
-	/* 0xba */ kKeyNone,		// OEM specific
-	/* 0xbb */ kKeyNone,		// OEM specific
-	/* 0xbc */ kKeyNone,		// OEM specific
-	/* 0xbd */ kKeyNone,		// OEM specific
-	/* 0xbe */ kKeyNone,		// OEM specific
-	/* 0xbf */ kKeyNone,		// OEM specific
-	/* 0xc0 */ kKeyNone,		// OEM specific
-	/* 0xc1 */ kKeyNone,		// unassigned
-	/* 0xc2 */ kKeyNone,		// unassigned
-	/* 0xc3 */ kKeyNone,		// unassigned
-	/* 0xc4 */ kKeyNone,		// unassigned
-	/* 0xc5 */ kKeyNone,		// unassigned
-	/* 0xc6 */ kKeyNone,		// unassigned
-	/* 0xc7 */ kKeyNone,		// unassigned
-	/* 0xc8 */ kKeyNone,		// unassigned
-	/* 0xc9 */ kKeyNone,		// unassigned
-	/* 0xca */ kKeyNone,		// unassigned
-	/* 0xcb */ kKeyNone,		// unassigned
-	/* 0xcc */ kKeyNone,		// unassigned
-	/* 0xcd */ kKeyNone,		// unassigned
-	/* 0xce */ kKeyNone,		// unassigned
-	/* 0xcf */ kKeyNone,		// unassigned
-	/* 0xd0 */ kKeyNone,		// unassigned
-	/* 0xd1 */ kKeyNone,		// unassigned
-	/* 0xd2 */ kKeyNone,		// unassigned
-	/* 0xd3 */ kKeyNone,		// unassigned
-	/* 0xd4 */ kKeyNone,		// unassigned
-	/* 0xd5 */ kKeyNone,		// unassigned
-	/* 0xd6 */ kKeyNone,		// unassigned
-	/* 0xd7 */ kKeyNone,		// unassigned
-	/* 0xd8 */ kKeyNone,		// unassigned
-	/* 0xd9 */ kKeyNone,		// unassigned
-	/* 0xda */ kKeyNone,		// unassigned
-	/* 0xdb */ kKeyNone,		// OEM specific
-	/* 0xdc */ kKeyNone,		// OEM specific
-	/* 0xdd */ kKeyNone,		// OEM specific
-	/* 0xde */ kKeyNone,		// OEM specific
-	/* 0xdf */ kKeyNone,		// OEM specific
-	/* 0xe0 */ kKeyNone,		// OEM specific
-	/* 0xe1 */ kKeyNone,		// OEM specific
-	/* 0xe2 */ kKeyNone,		// OEM specific
-	/* 0xe3 */ kKeyNone,		// OEM specific
-	/* 0xe4 */ kKeyNone,		// OEM specific
-	/* 0xe5 */ kKeyNone,		// unassigned
-	/* 0xe6 */ kKeyNone,		// OEM specific
-	/* 0xe7 */ kKeyNone,		// unassigned
-	/* 0xe8 */ kKeyNone,		// unassigned
-	/* 0xe9 */ kKeyNone,		// OEM specific
-	/* 0xea */ kKeyNone,		// OEM specific
-	/* 0xeb */ kKeyNone,		// OEM specific
-	/* 0xec */ kKeyNone,		// OEM specific
-	/* 0xed */ kKeyNone,		// OEM specific
-	/* 0xee */ kKeyNone,		// OEM specific
-	/* 0xef */ kKeyNone,		// OEM specific
-	/* 0xf0 */ kKeyNone,		// OEM specific
-	/* 0xf1 */ kKeyNone,		// OEM specific
-	/* 0xf2 */ kKeyNone,		// OEM specific
-	/* 0xf3 */ kKeyNone,		// OEM specific
-	/* 0xf4 */ kKeyNone,		// OEM specific
-	/* 0xf5 */ kKeyNone,		// OEM specific
-	/* 0xf6 */ kKeyNone,		// VK_ATTN			
-	/* 0xf7 */ kKeyNone,		// VK_CRSEL			
-	/* 0xf8 */ kKeyNone,		// VK_EXSEL			
-	/* 0xf9 */ kKeyNone,		// VK_EREOF			
-	/* 0xfa */ kKeyNone,		// VK_PLAY			
-	/* 0xfb */ kKeyNone,		// VK_ZOOM			
-	/* 0xfc */ kKeyNone,		// reserved
-	/* 0xfd */ kKeyNone,		// VK_PA1			
-	/* 0xfe */ kKeyNone,		// VK_OEM_CLEAR		
-	/* 0xff */ kKeyNone			// reserved
+	/* 0x00 */ kKeyNone,		kKeyNone,		// reserved
+	/* 0x01 */ kKeyNone,		kKeyNone,		// VK_LBUTTON
+	/* 0x02 */ kKeyNone,		kKeyNone,		// VK_RBUTTON
+	/* 0x03 */ kKeyNone,		kKeyBreak,		// VK_CANCEL
+	/* 0x04 */ kKeyNone,		kKeyNone,		// VK_MBUTTON
+	/* 0x05 */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x06 */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x07 */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x08 */ kKeyBackSpace,	kKeyNone,		// VK_BACK
+	/* 0x09 */ kKeyTab,			kKeyNone,		// VK_TAB
+	/* 0x0a */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x0b */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x0c */ kKeyClear,		kKeyClear,		// VK_CLEAR
+	/* 0x0d */ kKeyReturn,		kKeyKP_Enter,	// VK_RETURN
+	/* 0x0e */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x0f */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x10 */ kKeyShift_L,		kKeyShift_R,	// VK_SHIFT
+	/* 0x11 */ kKeyControl_L,	kKeyControl_R,	// VK_CONTROL
+	/* 0x12 */ kKeyAlt_L,		kKeyAlt_R,		// VK_MENU
+	/* 0x13 */ kKeyPause,		kKeyNone,		// VK_PAUSE
+	/* 0x14 */ kKeyCapsLock,	kKeyNone,		// VK_CAPITAL
+	/* 0x15 */ kKeyNone,		kKeyNone,		// VK_KANA			
+	/* 0x16 */ kKeyNone,		kKeyNone,		// VK_HANGUL		
+	/* 0x17 */ kKeyNone,		kKeyNone,		// VK_JUNJA			
+	/* 0x18 */ kKeyNone,		kKeyNone,		// VK_FINAL			
+	/* 0x19 */ kKeyNone,		kKeyNone,		// VK_KANJI			
+	/* 0x1a */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x1b */ kKeyEscape,		kKeyNone,		// VK_ESCAPE
+	/* 0x1c */ kKeyNone,		kKeyNone,		// VK_CONVERT		
+	/* 0x1d */ kKeyNone,		kKeyNone,		// VK_NONCONVERT	
+	/* 0x1e */ kKeyNone,		kKeyNone,		// VK_ACCEPT		
+	/* 0x1f */ kKeyNone,		kKeyNone,		// VK_MODECHANGE	
+	/* 0x20 */ 0x0020,			kKeyNone,		// VK_SPACE
+	/* 0x21 */ kKeyKP_PageUp,	kKeyPageUp,		// VK_PRIOR
+	/* 0x22 */ kKeyKP_PageDown,	kKeyPageDown,	// VK_NEXT
+	/* 0x23 */ kKeyKP_End,		kKeyEnd,		// VK_END
+	/* 0x24 */ kKeyKP_Home,		kKeyHome,		// VK_HOME
+	/* 0x25 */ kKeyKP_Left,		kKeyLeft,		// VK_LEFT
+	/* 0x26 */ kKeyKP_Up,		kKeyUp,			// VK_UP
+	/* 0x27 */ kKeyKP_Right,	kKeyRight,		// VK_RIGHT
+	/* 0x28 */ kKeyKP_Down,		kKeyDown,		// VK_DOWN
+	/* 0x29 */ kKeySelect,		kKeySelect,		// VK_SELECT
+	/* 0x2a */ kKeyNone,		kKeyNone,		// VK_PRINT
+	/* 0x2b */ kKeyExecute,		kKeyExecute,	// VK_EXECUTE
+	/* 0x2c */ kKeyPrint,		kKeyPrint,		// VK_SNAPSHOT
+	/* 0x2d */ kKeyKP_Insert,	kKeyInsert,		// VK_INSERT
+	/* 0x2e */ kKeyKP_Delete,	kKeyDelete,		// VK_DELETE
+	/* 0x2f */ kKeyHelp,		kKeyHelp,		// VK_HELP
+	/* 0x30 */ kKeyNone,		kKeyNone,		// VK_0
+	/* 0x31 */ kKeyNone,		kKeyNone,		// VK_1
+	/* 0x32 */ kKeyNone,		kKeyNone,		// VK_2
+	/* 0x33 */ kKeyNone,		kKeyNone,		// VK_3
+	/* 0x34 */ kKeyNone,		kKeyNone,		// VK_4
+	/* 0x35 */ kKeyNone,		kKeyNone,		// VK_5
+	/* 0x36 */ kKeyNone,		kKeyNone,		// VK_6
+	/* 0x37 */ kKeyNone,		kKeyNone,		// VK_7
+	/* 0x38 */ kKeyNone,		kKeyNone,		// VK_8
+	/* 0x39 */ kKeyNone,		kKeyNone,		// VK_9
+	/* 0x3a */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x3b */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x3c */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x3d */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x3e */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x3f */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x40 */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x41 */ kKeyNone,		kKeyNone,		// VK_A
+	/* 0x42 */ kKeyNone,		kKeyNone,		// VK_B
+	/* 0x43 */ kKeyNone,		kKeyNone,		// VK_C
+	/* 0x44 */ kKeyNone,		kKeyNone,		// VK_D
+	/* 0x45 */ kKeyNone,		kKeyNone,		// VK_E
+	/* 0x46 */ kKeyNone,		kKeyNone,		// VK_F
+	/* 0x47 */ kKeyNone,		kKeyNone,		// VK_G
+	/* 0x48 */ kKeyNone,		kKeyNone,		// VK_H
+	/* 0x49 */ kKeyNone,		kKeyNone,		// VK_I
+	/* 0x4a */ kKeyNone,		kKeyNone,		// VK_J
+	/* 0x4b */ kKeyNone,		kKeyNone,		// VK_K
+	/* 0x4c */ kKeyNone,		kKeyNone,		// VK_L
+	/* 0x4d */ kKeyNone,		kKeyNone,		// VK_M
+	/* 0x4e */ kKeyNone,		kKeyNone,		// VK_N
+	/* 0x4f */ kKeyNone,		kKeyNone,		// VK_O
+	/* 0x50 */ kKeyNone,		kKeyNone,		// VK_P
+	/* 0x51 */ kKeyNone,		kKeyNone,		// VK_Q
+	/* 0x52 */ kKeyNone,		kKeyNone,		// VK_R
+	/* 0x53 */ kKeyNone,		kKeyNone,		// VK_S
+	/* 0x54 */ kKeyNone,		kKeyNone,		// VK_T
+	/* 0x55 */ kKeyNone,		kKeyNone,		// VK_U
+	/* 0x56 */ kKeyNone,		kKeyNone,		// VK_V
+	/* 0x57 */ kKeyNone,		kKeyNone,		// VK_W
+	/* 0x58 */ kKeyNone,		kKeyNone,		// VK_X
+	/* 0x59 */ kKeyNone,		kKeyNone,		// VK_Y
+	/* 0x5a */ kKeyNone,		kKeyNone,		// VK_Z
+	/* 0x5b */ kKeyNone,		kKeyMeta_L,		// VK_LWIN
+	/* 0x5c */ kKeyNone,		kKeyMeta_R,		// VK_RWIN
+	/* 0x5d */ kKeyMenu,		kKeyMenu,		// VK_APPS
+	/* 0x5e */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x5f */ kKeyNone,		kKeyNone,		// undefined
+	/* 0x60 */ kKeyKP_0,		kKeyNone,		// VK_NUMPAD0
+	/* 0x61 */ kKeyKP_1,		kKeyNone,		// VK_NUMPAD1
+	/* 0x62 */ kKeyKP_2,		kKeyNone,		// VK_NUMPAD2
+	/* 0x63 */ kKeyKP_3,		kKeyNone,		// VK_NUMPAD3
+	/* 0x64 */ kKeyKP_4,		kKeyNone,		// VK_NUMPAD4
+	/* 0x65 */ kKeyKP_5,		kKeyNone,		// VK_NUMPAD5
+	/* 0x66 */ kKeyKP_6,		kKeyNone,		// VK_NUMPAD6
+	/* 0x67 */ kKeyKP_7,		kKeyNone,		// VK_NUMPAD7
+	/* 0x68 */ kKeyKP_8,		kKeyNone,		// VK_NUMPAD8
+	/* 0x69 */ kKeyKP_9,		kKeyNone,		// VK_NUMPAD9
+	/* 0x6a */ kKeyKP_Multiply,	kKeyNone,		// VK_MULTIPLY
+	/* 0x6b */ kKeyKP_Add,		kKeyNone,		// VK_ADD
+	/* 0x6c */ kKeyKP_Separator,kKeyKP_Separator,// VK_SEPARATOR
+	/* 0x6d */ kKeyKP_Subtract,	kKeyNone,		// VK_SUBTRACT
+	/* 0x6e */ kKeyKP_Decimal,	kKeyNone,		// VK_DECIMAL
+	/* 0x6f */ kKeyNone,		kKeyKP_Divide,	// VK_DIVIDE
+	/* 0x70 */ kKeyF1,			kKeyNone,		// VK_F1
+	/* 0x71 */ kKeyF2,			kKeyNone,		// VK_F2
+	/* 0x72 */ kKeyF3,			kKeyNone,		// VK_F3
+	/* 0x73 */ kKeyF4,			kKeyNone,		// VK_F4
+	/* 0x74 */ kKeyF5,			kKeyNone,		// VK_F5
+	/* 0x75 */ kKeyF6,			kKeyNone,		// VK_F6
+	/* 0x76 */ kKeyF7,			kKeyNone,		// VK_F7
+	/* 0x77 */ kKeyF8,			kKeyNone,		// VK_F8
+	/* 0x78 */ kKeyF9,			kKeyNone,		// VK_F9
+	/* 0x79 */ kKeyF10,			kKeyNone,		// VK_F10
+	/* 0x7a */ kKeyF11,			kKeyNone,		// VK_F11
+	/* 0x7b */ kKeyF12,			kKeyNone,		// VK_F12
+	/* 0x7c */ kKeyF13,			kKeyF13,		// VK_F13
+	/* 0x7d */ kKeyF14,			kKeyF14,		// VK_F14
+	/* 0x7e */ kKeyF15,			kKeyF15,		// VK_F15
+	/* 0x7f */ kKeyF16,			kKeyF16,		// VK_F16
+	/* 0x80 */ kKeyF17,			kKeyF17,		// VK_F17
+	/* 0x81 */ kKeyF18,			kKeyF18,		// VK_F18
+	/* 0x82 */ kKeyF19,			kKeyF19,		// VK_F19
+	/* 0x83 */ kKeyF20,			kKeyF20,		// VK_F20
+	/* 0x84 */ kKeyF21,			kKeyF21,		// VK_F21
+	/* 0x85 */ kKeyF22,			kKeyF22,		// VK_F22
+	/* 0x86 */ kKeyF23,			kKeyF23,		// VK_F23
+	/* 0x87 */ kKeyF24,			kKeyF24,		// VK_F24
+	/* 0x88 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x89 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x8a */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x8b */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x8c */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x8d */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x8e */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x8f */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x90 */ kKeyNumLock,		kKeyNumLock,	// VK_NUMLOCK
+	/* 0x91 */ kKeyScrollLock,	kKeyNone,		// VK_SCROLL
+	/* 0x92 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x93 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x94 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x95 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x96 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x97 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x98 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x99 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x9a */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x9b */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x9c */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x9d */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x9e */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0x9f */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xa0 */ kKeyShift_L,		kKeyShift_L,	// VK_LSHIFT
+	/* 0xa1 */ kKeyShift_R,		kKeyShift_R,	// VK_RSHIFT
+	/* 0xa2 */ kKeyControl_L,	kKeyControl_L,	// VK_LCONTROL
+	/* 0xa3 */ kKeyControl_R,	kKeyControl_R,	// VK_RCONTROL
+	/* 0xa4 */ kKeyAlt_L,		kKeyAlt_L,		// VK_LMENU
+	/* 0xa5 */ kKeyAlt_R,		kKeyAlt_R,		// VK_RMENU
+	/* 0xa6 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xa7 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xa8 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xa9 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xaa */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xab */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xac */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xad */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xae */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xaf */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb0 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb1 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb2 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb3 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb4 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb5 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb6 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb7 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb8 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xb9 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xba */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xbb */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xbc */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xbd */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xbe */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xbf */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xc0 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xc1 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc2 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc3 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc4 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc5 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc6 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc7 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc8 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xc9 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xca */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xcb */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xcc */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xcd */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xce */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xcf */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd0 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd1 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd2 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd3 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd4 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd5 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd6 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd7 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd8 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xd9 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xda */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xdb */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xdc */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xdd */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xde */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xdf */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe0 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe1 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe2 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe3 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe4 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe5 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xe6 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xe7 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xe8 */ kKeyNone,		kKeyNone,		// unassigned
+	/* 0xe9 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xea */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xeb */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xec */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xed */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xee */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xef */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf0 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf1 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf2 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf3 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf4 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf5 */ kKeyNone,		kKeyNone,		// OEM specific
+	/* 0xf6 */ kKeyNone,		kKeyNone,		// VK_ATTN			
+	/* 0xf7 */ kKeyNone,		kKeyNone,		// VK_CRSEL			
+	/* 0xf8 */ kKeyNone,		kKeyNone,		// VK_EXSEL			
+	/* 0xf9 */ kKeyNone,		kKeyNone,		// VK_EREOF			
+	/* 0xfa */ kKeyNone,		kKeyNone,		// VK_PLAY			
+	/* 0xfb */ kKeyNone,		kKeyNone,		// VK_ZOOM			
+	/* 0xfc */ kKeyNone,		kKeyNone,		// reserved
+	/* 0xfd */ kKeyNone,		kKeyNone,		// VK_PA1			
+	/* 0xfe */ kKeyNone,		kKeyNone,		// VK_OEM_CLEAR		
+	/* 0xff */ kKeyNone,		kKeyNone		// reserved
 };

 KeyID
@@ -918,68 +920,22 @@ CMSWindowsPrimaryScreen::mapKey(
 	if ((m_keys[VK_SCROLL] & 0x01) != 0) {
 		mask |= KeyModifierScrollLock;
 	}
+	if ((mask & (KeyModifierControl | KeyModifierAlt)) ==
+				(KeyModifierControl | KeyModifierAlt)) {
+		// ctrl+alt => AltGr on windows
+		mask |= KeyModifierModeSwitch;
+		mask &= ~(KeyModifierControl | KeyModifierAlt);
+	}
 	*maskOut = mask;
 	log((CLOG_DEBUG2 "key in vk=%d info=0x%08x mask=0x%04x", vkCode, info, mask));

-	// get the scan code
-	UINT scanCode = static_cast<UINT>((info & 0xff0000) >> 16);
-
-	// convert virtual key to one that distinguishes between left and
-	// right for keys that have left/right versions.  known scan codes
-	// that don't have left/right versions are passed through unchanged.
-	// unknown scan codes return 0.
-	UINT vkCode2 = MapVirtualKey(scanCode, 3);
-
-	// work around bug Q72583 (bad num pad conversion in MapVirtualKey())
-	if (vkCode >= VK_NUMPAD0 && vkCode <= VK_DIVIDE) {
-		vkCode2 = vkCode;
-	}
-
-	// MapVirtualKey() appears to map VK_LWIN, VK_RWIN, VK_APPS to
-	// some other meaningless virtual key.  work around that bug.
-	else if (vkCode >= VK_LWIN && vkCode <= VK_APPS) {
-		vkCode2 = vkCode;
-	}
-
-	// if the original vkCode is VK_SNAPSHOT then use it.  oddly enough,
-	// some keyboards use the same scan code for keypad multiply and
-	// print screen.  the difference is that the latter has the extended
-	// key flag set.  but MapVirtualKey() doesn't seem capable of using
-	// that flag.
-	else if (vkCode == VK_SNAPSHOT) {
-		vkCode2 = vkCode;
-	}
-
-	// if MapVirtualKey failed then use original virtual key
-	else if (vkCode2 == 0) {
-		vkCode2 = vkCode;
-	}
-
-	// sadly, win32 will not distinguish between the left and right
-	// control and alt keys using the above function.  however, we
-	// can check for those:  if bit 24 of info is set then the key
-	// is a "extended" key, such as the right control and right alt
-	// keys.
-	if ((info & 0x1000000) != 0) {
-		switch (vkCode2) {
-		case VK_CONTROL:
-		case VK_LCONTROL:
-			vkCode2 = VK_RCONTROL;
-			break;
-
-		case VK_MENU:
-		case VK_LMENU:
-			vkCode2 = VK_RMENU;
-			break;
-		}
-	}
-
-	// use left/right distinguishing virtual key
-	vkCode = vkCode2;
-	log((CLOG_DEBUG1 "key vk=%d scan=%d", vkCode, scanCode));
+	// get the scan code and the extended keyboard flag
+	UINT scanCode = static_cast<UINT>((info & 0x00ff0000u) >> 16);
+	int extended  = ((info & 0x01000000) == 0) ? 0 : 1;
+	log((CLOG_DEBUG1 "key vk=%d ext=%d scan=%d", vkCode, extended, scanCode));

 	// handle some keys via table lookup
-	KeyID id = g_virtualKey[vkCode];
+	KeyID id = g_virtualKey[vkCode][extended];
 	if (id != kKeyNone) {
 		return id;
 	}
@@ -989,17 +945,19 @@ CMSWindowsPrimaryScreen::mapKey(
 		return kKeyMultiKey;
 	}

-	// ToAscii() maps ctrl+letter to the corresponding control code
-	// and ctrl+backspace to delete.  if we've got a control code or
-	// delete then do ToAscii() again but without the control state.
-	// ToAscii() interprets the control modifier state which we don't
-	// want.  so save the control state then clear it.
-	BYTE lControl       = m_keys[VK_LCONTROL];
-	BYTE rControl       = m_keys[VK_RCONTROL];
-	BYTE control        = m_keys[VK_CONTROL];
-	m_keys[VK_LCONTROL] = 0;
-	m_keys[VK_RCONTROL] = 0;
-	m_keys[VK_CONTROL]  = 0;
+	// save the control state then clear it.  ToAscii() maps ctrl+letter
+	// to the corresponding control code and ctrl+backspace to delete.
+	// we don't want that translation so we clear the control modifier
+	// state.  however, if we want to simulate AltGr (which is ctrl+alt)
+	// then we must not clear it.
+	BYTE lControl = m_keys[VK_LCONTROL];
+	BYTE rControl = m_keys[VK_RCONTROL];
+	BYTE control  = m_keys[VK_CONTROL];
+	if ((mask & KeyModifierModeSwitch) == 0) {
+		m_keys[VK_LCONTROL] = 0;
+		m_keys[VK_RCONTROL] = 0;
+		m_keys[VK_CONTROL]  = 0;
+	}

 	// convert to ascii
 	// FIXME -- support unicode
@@ -1092,18 +1050,18 @@ CMSWindowsPrimaryScreen::updateKeys()

 	// we only care about the modifier key states.  other keys and the
 	// mouse buttons should be up.
-	m_keys[VK_LSHIFT]   = static_cast<BYTE>(GetKeyState(VK_LSHIFT));
-	m_keys[VK_RSHIFT]   = static_cast<BYTE>(GetKeyState(VK_RSHIFT));
-	m_keys[VK_SHIFT]    = static_cast<BYTE>(GetKeyState(VK_SHIFT));
-	m_keys[VK_LCONTROL] = static_cast<BYTE>(GetKeyState(VK_LCONTROL));
-	m_keys[VK_RCONTROL] = static_cast<BYTE>(GetKeyState(VK_RCONTROL));
-	m_keys[VK_CONTROL]  = static_cast<BYTE>(GetKeyState(VK_CONTROL));
-	m_keys[VK_LMENU]    = static_cast<BYTE>(GetKeyState(VK_LMENU));
-	m_keys[VK_RMENU]    = static_cast<BYTE>(GetKeyState(VK_RMENU));
-	m_keys[VK_MENU]     = static_cast<BYTE>(GetKeyState(VK_MENU));
-	m_keys[VK_LWIN]     = static_cast<BYTE>(GetKeyState(VK_LWIN));
-	m_keys[VK_RWIN]     = static_cast<BYTE>(GetKeyState(VK_RWIN));
-	m_keys[VK_APPS]     = static_cast<BYTE>(GetKeyState(VK_APPS));
+	m_keys[VK_LSHIFT]   = static_cast<BYTE>(GetKeyState(VK_LSHIFT) & 0x80);
+	m_keys[VK_RSHIFT]   = static_cast<BYTE>(GetKeyState(VK_RSHIFT) & 0x80);
+	m_keys[VK_SHIFT]    = static_cast<BYTE>(GetKeyState(VK_SHIFT) & 0x80);
+	m_keys[VK_LCONTROL] = static_cast<BYTE>(GetKeyState(VK_LCONTROL) & 0x80);
+	m_keys[VK_RCONTROL] = static_cast<BYTE>(GetKeyState(VK_RCONTROL) & 0x80);
+	m_keys[VK_CONTROL]  = static_cast<BYTE>(GetKeyState(VK_CONTROL) & 0x80);
+	m_keys[VK_LMENU]    = static_cast<BYTE>(GetKeyState(VK_LMENU) & 0x80);
+	m_keys[VK_RMENU]    = static_cast<BYTE>(GetKeyState(VK_RMENU) & 0x80);
+	m_keys[VK_MENU]     = static_cast<BYTE>(GetKeyState(VK_MENU) & 0x80);
+	m_keys[VK_LWIN]     = static_cast<BYTE>(GetKeyState(VK_LWIN) & 0x80);
+	m_keys[VK_RWIN]     = static_cast<BYTE>(GetKeyState(VK_RWIN) & 0x80);
+	m_keys[VK_APPS]     = static_cast<BYTE>(GetKeyState(VK_APPS) & 0x80);
 	m_keys[VK_CAPITAL]  = static_cast<BYTE>(GetKeyState(VK_CAPITAL));
 	m_keys[VK_NUMLOCK]  = static_cast<BYTE>(GetKeyState(VK_NUMLOCK));
 	m_keys[VK_SCROLL]   = static_cast<BYTE>(GetKeyState(VK_SCROLL));