/* * synergy -- mouse and keyboard sharing utility * Copyright (C) 2003 Chris Schoeneman * * This package is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * found in the file COPYING that should have accompanied this file. * * This package 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. */ #include "CMSWindowsKeyState.h" #include "CMSWindowsDesks.h" #include "CThread.h" #include "CFunctionJob.h" #include "CLog.h" #include "CStringUtil.h" #include "CArchMiscWindows.h" // extended mouse buttons #if !defined(VK_XBUTTON1) #define VK_XBUTTON1 0x05 #define VK_XBUTTON2 0x06 #endif // multimedia keys #if !defined(VK_BROWSER_BACK) #define VK_BROWSER_BACK 0xA6 #define VK_BROWSER_FORWARD 0xA7 #define VK_BROWSER_REFRESH 0xA8 #define VK_BROWSER_STOP 0xA9 #define VK_BROWSER_SEARCH 0xAA #define VK_BROWSER_FAVORITES 0xAB #define VK_BROWSER_HOME 0xAC #define VK_VOLUME_MUTE 0xAD #define VK_VOLUME_DOWN 0xAE #define VK_VOLUME_UP 0xAF #define VK_MEDIA_NEXT_TRACK 0xB0 #define VK_MEDIA_PREV_TRACK 0xB1 #define VK_MEDIA_STOP 0xB2 #define VK_MEDIA_PLAY_PAUSE 0xB3 #define VK_LAUNCH_MAIL 0xB4 #define VK_LAUNCH_MEDIA_SELECT 0xB5 #define VK_LAUNCH_APP1 0xB6 #define VK_LAUNCH_APP2 0xB7 #endif // // CMSWindowsKeyState // const char* CMSWindowsKeyState::s_vkToName[] = { "vk 0x00", "Left Button", "Right Button", "VK_CANCEL", "Middle Button", "vk 0x05", "vk 0x06", "vk 0x07", "VK_BACK", "VK_TAB", "vk 0x0a", "vk 0x0b", "VK_CLEAR", "VK_RETURN", "vk 0x0e", "vk 0x0f", "VK_SHIFT", "VK_CONTROL", "VK_MENU", "VK_PAUSE", "VK_CAPITAL", "VK_KANA", "vk 0x16", "VK_JUNJA", "VK_FINAL", "VK_KANJI", "vk 0x1a", "VK_ESCAPE", "VK_CONVERT", "VK_NONCONVERT", "VK_ACCEPT", "VK_MODECHANGE", "VK_SPACE", "VK_PRIOR", "VK_NEXT", "VK_END", "VK_HOME", "VK_LEFT", "VK_UP", "VK_RIGHT", "VK_DOWN", "VK_SELECT", "VK_PRINT", "VK_EXECUTE", "VK_SNAPSHOT", "VK_INSERT", "VK_DELETE", "VK_HELP", "VK_0", "VK_1", "VK_2", "VK_3", "VK_4", "VK_5", "VK_6", "VK_7", "VK_8", "VK_9", "vk 0x3a", "vk 0x3b", "vk 0x3c", "vk 0x3d", "vk 0x3e", "vk 0x3f", "vk 0x40", "VK_A", "VK_B", "VK_C", "VK_D", "VK_E", "VK_F", "VK_G", "VK_H", "VK_I", "VK_J", "VK_K", "VK_L", "VK_M", "VK_N", "VK_O", "VK_P", "VK_Q", "VK_R", "VK_S", "VK_T", "VK_U", "VK_V", "VK_W", "VK_X", "VK_Y", "VK_Z", "VK_LWIN", "VK_RWIN", "VK_APPS", "vk 0x5e", "vk 0x5f", "VK_NUMPAD0", "VK_NUMPAD1", "VK_NUMPAD2", "VK_NUMPAD3", "VK_NUMPAD4", "VK_NUMPAD5", "VK_NUMPAD6", "VK_NUMPAD7", "VK_NUMPAD8", "VK_NUMPAD9", "VK_MULTIPLY", "VK_ADD", "VK_SEPARATOR", "VK_SUBTRACT", "VK_DECIMAL", "VK_DIVIDE", "VK_F1", "VK_F2", "VK_F3", "VK_F4", "VK_F5", "VK_F6", "VK_F7", "VK_F8", "VK_F9", "VK_F10", "VK_F11", "VK_F12", "VK_F13", "VK_F14", "VK_F15", "VK_F16", "VK_F17", "VK_F18", "VK_F19", "VK_F20", "VK_F21", "VK_F22", "VK_F23", "VK_F24", "vk 0x88", "vk 0x89", "vk 0x8a", "vk 0x8b", "vk 0x8c", "vk 0x8d", "vk 0x8e", "vk 0x8f", "VK_NUMLOCK", "VK_SCROLL", "vk 0x92", "vk 0x93", "vk 0x94", "vk 0x95", "vk 0x96", "vk 0x97", "vk 0x98", "vk 0x99", "vk 0x9a", "vk 0x9b", "vk 0x9c", "vk 0x9d", "vk 0x9e", "vk 0x9f", "VK_LSHIFT", "VK_RSHIFT", "VK_LCONTROL", "VK_RCONTROL", "VK_LMENU", "VK_RMENU", "VK_BROWSER_BACK", "VK_BROWSER_FORWARD", "VK_BROWSER_REFRESH", "VK_BROWSER_STOP", "VK_BROWSER_SEARCH", "VK_BROWSER_FAVORITES", "VK_BROWSER_HOME", "VK_VOLUME_MUTE", "VK_VOLUME_DOWN", "VK_VOLUME_UP", "VK_MEDIA_NEXT_TRACK", "VK_MEDIA_PREV_TRACK", "VK_MEDIA_STOP", "VK_MEDIA_PLAY_PAUSE", "VK_LAUNCH_MAIL", "VK_LAUNCH_MEDIA_SELECT", "VK_LAUNCH_APP1", "VK_LAUNCH_APP2", "vk 0xb8", "vk 0xb9", "vk 0xba", "vk 0xbb", "vk 0xbc", "vk 0xbd", "vk 0xbe", "vk 0xbf", "vk 0xc0", "vk 0xc1", "vk 0xc2", "vk 0xc3", "vk 0xc4", "vk 0xc5", "vk 0xc6", "vk 0xc7", "vk 0xc8", "vk 0xc9", "vk 0xca", "vk 0xcb", "vk 0xcc", "vk 0xcd", "vk 0xce", "vk 0xcf", "vk 0xd0", "vk 0xd1", "vk 0xd2", "vk 0xd3", "vk 0xd4", "vk 0xd5", "vk 0xd6", "vk 0xd7", "vk 0xd8", "vk 0xd9", "vk 0xda", "vk 0xdb", "vk 0xdc", "vk 0xdd", "vk 0xde", "vk 0xdf", "vk 0xe0", "vk 0xe1", "vk 0xe2", "vk 0xe3", "vk 0xe4", "VK_PROCESSKEY", "vk 0xe6", "vk 0xe7", "vk 0xe8", "vk 0xe9", "vk 0xea", "vk 0xeb", "vk 0xec", "vk 0xed", "vk 0xee", "vk 0xef", "vk 0xf0", "vk 0xf1", "vk 0xf2", "vk 0xf3", "vk 0xf4", "vk 0xf5", "VK_ATTN", "VK_CRSEL", "VK_EXSEL", "VK_EREOF", "VK_PLAY", "VK_ZOOM", "VK_NONAME", "VK_PA1", "VK_OEM_CLEAR", "vk 0xff" }; // map virtual keys to synergy key enumeration const KeyID CMSWindowsKeyState::s_virtualKey[][2] = { /* 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 */ kKeyZenkaku, 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 */ kKeyNone, 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, kKeySuper_L, // VK_LWIN /* 0x5c */ kKeyNone, kKeySuper_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, kKeyWWWBack, // VK_BROWSER_BACK /* 0xa7 */ kKeyNone, kKeyWWWForward, // VK_BROWSER_FORWARD /* 0xa8 */ kKeyNone, kKeyWWWRefresh, // VK_BROWSER_REFRESH /* 0xa9 */ kKeyNone, kKeyWWWStop, // VK_BROWSER_STOP /* 0xaa */ kKeyNone, kKeyWWWSearch, // VK_BROWSER_SEARCH /* 0xab */ kKeyNone, kKeyWWWFavorites, // VK_BROWSER_FAVORITES /* 0xac */ kKeyNone, kKeyWWWHome, // VK_BROWSER_HOME /* 0xad */ kKeyNone, kKeyAudioMute, // VK_VOLUME_MUTE /* 0xae */ kKeyNone, kKeyAudioDown, // VK_VOLUME_DOWN /* 0xaf */ kKeyNone, kKeyAudioUp, // VK_VOLUME_UP /* 0xb0 */ kKeyNone, kKeyAudioNext, // VK_MEDIA_NEXT_TRACK /* 0xb1 */ kKeyNone, kKeyAudioPrev, // VK_MEDIA_PREV_TRACK /* 0xb2 */ kKeyNone, kKeyAudioStop, // VK_MEDIA_STOP /* 0xb3 */ kKeyNone, kKeyAudioPlay, // VK_MEDIA_PLAY_PAUSE /* 0xb4 */ kKeyNone, kKeyAppMail, // VK_LAUNCH_MAIL /* 0xb5 */ kKeyNone, kKeyAppMedia, // VK_LAUNCH_MEDIA_SELECT /* 0xb6 */ kKeyNone, kKeyAppUser1, // VK_LAUNCH_APP1 /* 0xb7 */ kKeyNone, kKeyAppUser2, // VK_LAUNCH_APP2 /* 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 }; // map special KeyID keys to virtual key codes const UINT CMSWindowsKeyState::s_mapE000[] = { /* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x08 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x18 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x28 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x38 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x48 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x68 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x78 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x88 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x98 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 */ 0, 0, 0, 0, /* 0xa4 */ 0, 0, VK_BROWSER_BACK, VK_BROWSER_FORWARD, /* 0xa8 */ VK_BROWSER_REFRESH, VK_BROWSER_STOP, /* 0xaa */ VK_BROWSER_SEARCH, VK_BROWSER_FAVORITES, /* 0xac */ VK_BROWSER_HOME, VK_VOLUME_MUTE, /* 0xae */ VK_VOLUME_DOWN, VK_VOLUME_UP, /* 0xb0 */ VK_MEDIA_NEXT_TRACK, VK_MEDIA_PREV_TRACK, /* 0xb2 */ VK_MEDIA_STOP, VK_MEDIA_PLAY_PAUSE, /* 0xb4 */ VK_LAUNCH_MAIL, VK_LAUNCH_MEDIA_SELECT, /* 0xb6 */ VK_LAUNCH_APP1, VK_LAUNCH_APP2, /* 0xb8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf8 */ 0, 0, 0, 0, 0, 0, 0, 0 }; const UINT CMSWindowsKeyState::s_mapEE00[] = { /* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x08 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x18 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */ VK_TAB, 0, 0, 0, 0, 0, 0, 0, /* 0x28 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x38 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x48 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x68 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x78 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x88 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x98 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xb8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xc8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xd8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf8 */ 0, 0, 0, 0, 0, 0, 0, 0 }; /* in g_mapEF00, 0xac is VK_DECIMAL not VK_SEPARATOR because win32 * doesn't seem to use VK_SEPARATOR but instead maps VK_DECIMAL to * the same meaning. */ const UINT CMSWindowsKeyState::s_mapEF00[] = { /* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x08 */ VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0, /* 0x10 */ 0, 0, 0, VK_PAUSE, VK_SCROLL, 0/*sys-req*/, 0, 0, /* 0x18 */ 0, 0, 0, VK_ESCAPE, 0, 0, 0, 0, /* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x28 */ 0, 0, VK_KANJI, 0, 0, 0, 0, 0, /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x38 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x48 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */ VK_HOME, VK_LEFT, VK_UP, VK_RIGHT, /* 0x54 */ VK_DOWN, VK_PRIOR, VK_NEXT, VK_END, /* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 */ VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, /* 0x64 */ 0, 0, 0, VK_APPS, /* 0x68 */ 0, 0, VK_HELP, VK_CANCEL, 0, 0, 0, 0, /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0x78 */ 0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK, /* 0x80 */ VK_SPACE, 0, 0, 0, 0, 0, 0, 0, /* 0x88 */ 0, VK_TAB, 0, 0, 0, VK_RETURN, 0, 0, /* 0x90 */ 0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP, /* 0x98 */ VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT, /* 0x9c */ VK_END, 0, VK_INSERT, VK_DELETE, /* 0xa0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xa8 */ 0, 0, VK_MULTIPLY, VK_ADD, /* 0xac */ VK_DECIMAL, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE, /* 0xb0 */ VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, /* 0xb4 */ VK_NUMPAD4, VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, /* 0xb8 */ VK_NUMPAD8, VK_NUMPAD9, 0, 0, 0, 0, VK_F1, VK_F2, /* 0xc0 */ VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10, /* 0xc8 */ VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16, VK_F17, VK_F18, /* 0xd0 */ VK_F19, VK_F20, VK_F21, VK_F22, VK_F23, VK_F24, 0, 0, /* 0xd8 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xe0 */ 0, VK_LSHIFT, VK_RSHIFT, VK_LCONTROL, /* 0xe4 */ VK_RCONTROL, VK_CAPITAL, 0, 0, /* 0xe8 */ 0, VK_LMENU, VK_RMENU, VK_LWIN, /* 0xec */ VK_RWIN, 0, 0, 0, /* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0, /* 0xf8 */ 0, 0, 0, 0, 0, 0, 0, VK_DELETE }; CMSWindowsKeyState::CMSWindowsKeyState(CMSWindowsDesks* desks) : m_is95Family(CArchMiscWindows::isWindows95Family()), m_desks(desks), m_keyLayout(GetKeyboardLayout(0)) { } CMSWindowsKeyState::~CMSWindowsKeyState() { // do nothing } void CMSWindowsKeyState::setKeyLayout(HKL keyLayout) { m_keyLayout = keyLayout; } void CMSWindowsKeyState::fixKey(void* target, UINT virtualKey) { // check if virtualKey is up but we think it's down. if so then // synthesize a key release for it. // // we use GetAsyncKeyState() to check the state of the keys even // though we might not be in sync with that yet. KeyButton button = m_virtKeyToScanCode[virtualKey]; if (isKeyDown(button) && (GetAsyncKeyState(virtualKey) & 0x8000) == 0) { // compute appropriate parameters for fake event LPARAM lParam = 0xc0000000 | ((LPARAM)button << 16); // process as if it were a key up KeyModifierMask mask; KeyID key = mapKeyFromEvent(virtualKey, lParam, &mask); LOG((CLOG_DEBUG1 "event: fake key release key=%d mask=0x%04x button=0x%04x", key, mask, button)); CKeyState::sendKeyEvent(target, false, false, key, mask, 1, button); CKeyState::setKeyDown(button, false); } } KeyID CMSWindowsKeyState::mapKeyFromEvent(WPARAM charAndVirtKey, LPARAM info, KeyModifierMask* maskOut) const { // note: known microsoft bugs // Q72583 -- MapVirtualKey() maps keypad keys incorrectly // 95,98: num pad vk code -> invalid scan code // 95,98,NT4: num pad scan code -> bad vk code except // SEPARATOR, MULTIPLY, SUBTRACT, ADD // extract character and virtual key char c = (char)((charAndVirtKey & 0xff00u) >> 8); UINT vkCode = (charAndVirtKey & 0xffu); // handle some keys via table lookup int extended = ((info >> 24) & 1); KeyID id = s_virtualKey[vkCode][extended]; // check if not in table; map character to key id if (id == kKeyNone && c != 0) { if ((c & 0x80u) == 0) { // ASCII id = static_cast(c) & 0xffu; } else { // character is not really ASCII. instead it's some // character in the current ANSI code page. try to // convert that to a Unicode character. if we fail // then use the single byte character as is. char src = c; wchar_t unicode; if (MultiByteToWideChar(CP_THREAD_ACP, MB_PRECOMPOSED, &src, 1, &unicode, 1) > 0) { id = static_cast(unicode); } else { id = static_cast(c) & 0xffu; } } } // set mask KeyModifierMask activeMask = getActiveModifiers(); bool needAltGr = false; if (id != kKeyNone && c != 0) { // note if key requires AltGr. VkKeyScan() can have a problem // with some characters. there are two problems in particular. // first, typing a dead key then pressing space will cause // VkKeyScan() to return 0xffff. second, certain characters // may map to multiple virtual keys and we might get the wrong // one. if that happens then we might not get the right // modifier mask. AltGr+9 on the french keyboard layout (^) // has this problem. in the first case, we'll assume AltGr is // required (only because it solves the problems we've seen // so far). in the second, we'll use whatever the keyboard // state says. WORD virtualKeyAndModifierState = VkKeyScanEx(c, m_keyLayout); if (virtualKeyAndModifierState == 0xffff) { // there is no mapping. assume AltGr. LOG((CLOG_DEBUG1 "no VkKeyScan() mapping")); needAltGr = true; } else if (LOBYTE(virtualKeyAndModifierState) != vkCode) { // we didn't get the key that was actually pressed LOG((CLOG_DEBUG1 "VkKeyScan() mismatch")); if ((activeMask & (KeyModifierControl | KeyModifierAlt)) == (KeyModifierControl | KeyModifierAlt)) { needAltGr = true; } } else { BYTE modifierState = HIBYTE(virtualKeyAndModifierState); if ((modifierState & 6) == 6) { // key requires ctrl and alt == AltGr needAltGr = true; } } } // map modifier key if (maskOut != NULL) { if (needAltGr) { activeMask |= KeyModifierModeSwitch; activeMask &= ~(KeyModifierControl | KeyModifierAlt); } else { activeMask &= ~KeyModifierModeSwitch; } *maskOut = activeMask; } return id; } KeyButton CMSWindowsKeyState::virtualKeyToButton(UINT virtualKey) const { return m_virtKeyToScanCode[virtualKey & 0xffu]; } void CMSWindowsKeyState::setKeyDown(KeyButton button, bool down) { CKeyState::setKeyDown(button, down); // special case: we detect ctrl+alt+del being pressed on some // systems but we don't detect the release of those keys. so // if ctrl, alt, and del are down then mark them up. if (down && isKeyDown(m_virtKeyToScanCode[VK_DELETE])) { KeyModifierMask mask = getActiveModifiers(); if ((mask & (KeyModifierControl | KeyModifierAlt)) == (KeyModifierControl | KeyModifierAlt)) { CKeyState::setKeyDown(m_virtKeyToScanCode[VK_LCONTROL], false); CKeyState::setKeyDown(m_virtKeyToScanCode[VK_RCONTROL], false); CKeyState::setKeyDown(m_virtKeyToScanCode[VK_LMENU], false); CKeyState::setKeyDown(m_virtKeyToScanCode[VK_RMENU], false); CKeyState::setKeyDown(m_virtKeyToScanCode[VK_DELETE], false); } } } void CMSWindowsKeyState::sendKeyEvent(void* target, bool press, bool isAutoRepeat, KeyID key, KeyModifierMask mask, SInt32 count, KeyButton button) { if (press || isAutoRepeat) { // if AltGr required for this key then make sure // the ctrl and alt keys are *not* down on the // client. windows simulates AltGr with ctrl and // alt for some inexplicable reason and clients // will get confused if they see mode switch and // ctrl and alt. we'll also need to put ctrl and // alt back the way they were after we simulate // the key. bool ctrlL = isKeyDown(m_virtKeyToScanCode[VK_LCONTROL]); bool ctrlR = isKeyDown(m_virtKeyToScanCode[VK_RCONTROL]); bool altL = isKeyDown(m_virtKeyToScanCode[VK_LMENU]); bool altR = isKeyDown(m_virtKeyToScanCode[VK_RMENU]); if ((mask & KeyModifierModeSwitch) != 0) { KeyModifierMask mask2 = (mask & ~(KeyModifierControl | KeyModifierAlt | KeyModifierModeSwitch)); if (ctrlL) { CKeyState::sendKeyEvent(target, false, false, kKeyControl_L, mask2, 1, m_virtKeyToScanCode[VK_LCONTROL]); } if (ctrlR) { CKeyState::sendKeyEvent(target, false, false, kKeyControl_R, mask2, 1, m_virtKeyToScanCode[VK_RCONTROL]); } if (altL) { CKeyState::sendKeyEvent(target, false, false, kKeyAlt_L, mask2, 1, m_virtKeyToScanCode[VK_LMENU]); } if (altR) { CKeyState::sendKeyEvent(target, false, false, kKeyAlt_R, mask2, 1, m_virtKeyToScanCode[VK_RMENU]); } } // send key if (press) { CKeyState::sendKeyEvent(target, true, false, key, mask, 1, button); if (count > 0) { --count; } } if (count >= 1) { CKeyState::sendKeyEvent(target, true, true, key, mask, count, button); } // restore ctrl and alt state if ((mask & KeyModifierModeSwitch) != 0) { KeyModifierMask mask2 = (mask & ~(KeyModifierControl | KeyModifierAlt | KeyModifierModeSwitch)); if (ctrlL) { CKeyState::sendKeyEvent(target, true, false, kKeyControl_L, mask2, 1, m_virtKeyToScanCode[VK_LCONTROL]); mask2 |= KeyModifierControl; } if (ctrlR) { CKeyState::sendKeyEvent(target, true, false, kKeyControl_R, mask2, 1, m_virtKeyToScanCode[VK_RCONTROL]); mask2 |= KeyModifierControl; } if (altL) { CKeyState::sendKeyEvent(target, true, false, kKeyAlt_L, mask2, 1, m_virtKeyToScanCode[VK_LMENU]); mask2 |= KeyModifierAlt; } if (altR) { CKeyState::sendKeyEvent(target, true, false, kKeyAlt_R, mask2, 1, m_virtKeyToScanCode[VK_RMENU]); mask2 |= KeyModifierAlt; } } } else { // key release. if the key isn't down according to // our table then we never got the key press event // for it. if it's not a modifier key then we'll // synthesize the press first. only do this on // the windows 95 family, which eats certain special // keys like alt+tab, ctrl+esc, etc. if (m_is95Family && isKeyDown(button)) { switch (m_scanCodeToVirtKey[button]) { case VK_LSHIFT: case VK_RSHIFT: case VK_SHIFT: case VK_LCONTROL: case VK_RCONTROL: case VK_CONTROL: case VK_LMENU: case VK_RMENU: case VK_MENU: case VK_CAPITAL: case VK_NUMLOCK: case VK_SCROLL: case VK_LWIN: case VK_RWIN: break; default: CKeyState::sendKeyEvent(target, true, false, key, mask, 1, button); break; } } // do key up CKeyState::sendKeyEvent(target, false, false, key, mask, 1, button); } } bool CMSWindowsKeyState::fakeCtrlAltDel() { if (!m_is95Family) { // to fake ctrl+alt+del on the NT family we broadcast a suitable // hotkey to all windows on the winlogon desktop. however, the // current thread must be on that desktop to do the broadcast // and we can't switch just any thread because some own windows // or hooks. so start a new thread to do the real work. CThread cad(new CFunctionJob(&CMSWindowsKeyState::ctrlAltDelThread)); cad.wait(); } else { // simulate ctrl+alt+del fakeKeyDown(kKeyDelete, KeyModifierControl | KeyModifierAlt, m_virtKeyToScanCode[VK_DELETE]); } return true; } void CMSWindowsKeyState::ctrlAltDelThread(void*) { // get the Winlogon desktop at whatever privilege we can HDESK desk = OpenDesktop("Winlogon", 0, FALSE, MAXIMUM_ALLOWED); if (desk != NULL) { if (SetThreadDesktop(desk)) { PostMessage(HWND_BROADCAST, WM_HOTKEY, 0, MAKELPARAM(MOD_CONTROL | MOD_ALT, VK_DELETE)); } else { LOG((CLOG_DEBUG "can't switch to Winlogon desk: %d", GetLastError())); } CloseDesktop(desk); } else { LOG((CLOG_DEBUG "can't open Winlogon desk: %d", GetLastError())); } } const char* CMSWindowsKeyState::getKeyName(KeyButton button) const { char keyName[100]; char keyName2[100]; CMSWindowsKeyState* self = const_cast(this); if (GetKeyNameText(button << 16, keyName, sizeof(keyName)) != 0) { // get the extended name of the key if button is not extended // or vice versa. if the names are different then report both. button ^= 0x100u; if (GetKeyNameText(button << 16, keyName2, sizeof(keyName2)) != 0 && strcmp(keyName, keyName2) != 0) { self->m_keyName = CStringUtil::print("%s or %s", keyName, keyName2); } else { self->m_keyName = keyName; } } else if (m_scanCodeToVirtKey[button] != 0) { self->m_keyName = s_vkToName[m_scanCodeToVirtKey[button]]; } else { self->m_keyName = CStringUtil::print("scan code 0x%03x", button); } return m_keyName.c_str(); } void CMSWindowsKeyState::doUpdateKeys() { // clear scan code to/from virtual key mapping memset(m_scanCodeToVirtKey, 0, sizeof(m_scanCodeToVirtKey)); memset(m_virtKeyToScanCode, 0, sizeof(m_virtKeyToScanCode)); // add modifiers. note that ModeSwitch is mapped to VK_RMENU and // that it's mapped *before* the Alt modifier. we must map it so // KeyModifierModeSwitch mask can be converted to keystrokes. it // must be mapped before the Alt modifier so that the Alt modifier // takes precedence when mapping keystrokes to modifier masks. // // we have to explicitly set the extended key flag for some // modifiers because the win32 API is inadequate. KeyButtons keys; keys.push_back((KeyButton)(MapVirtualKey(VK_RMENU, 0) | 0x100)); addModifier(KeyModifierModeSwitch, keys); keys.clear(); keys.push_back((KeyButton)MapVirtualKey(VK_LSHIFT, 0)); keys.push_back((KeyButton)(MapVirtualKey(VK_RSHIFT, 0) | 0x100)); addModifier(KeyModifierShift, keys); keys.clear(); keys.push_back((KeyButton)MapVirtualKey(VK_LCONTROL, 0)); keys.push_back((KeyButton)(MapVirtualKey(VK_RCONTROL, 0) | 0x100)); addModifier(KeyModifierControl, keys); keys.clear(); keys.push_back((KeyButton)MapVirtualKey(VK_LMENU, 0)); keys.push_back((KeyButton)(MapVirtualKey(VK_RMENU, 0) | 0x100)); addModifier(KeyModifierAlt, keys); keys.clear(); keys.push_back((KeyButton)(MapVirtualKey(VK_LWIN, 0) | 0x100)); keys.push_back((KeyButton)(MapVirtualKey(VK_RWIN, 0) | 0x100)); addModifier(KeyModifierSuper, keys); keys.clear(); keys.push_back((KeyButton)MapVirtualKey(VK_CAPITAL, 0)); addModifier(KeyModifierCapsLock, keys); keys.clear(); keys.push_back((KeyButton)(MapVirtualKey(VK_NUMLOCK, 0) | 0x100)); addModifier(KeyModifierNumLock, keys); keys.clear(); keys.push_back((KeyButton)MapVirtualKey(VK_SCROLL, 0)); addModifier(KeyModifierScrollLock, keys); /* FIXME -- potential problem here on win me // win me (sony vaio laptop): // MapVirtualKey(vk, 0): // VK_SHIFT mapped; VK_LSHIFT, VK_RSHIFT not mapped // VK_CONTROL mapped; VK_LCONTROL, VK_RCONTROL not mapped // VK_MENU mapped; VK_LMENU, VK_RMENU not mapped // MapVirtualKey(sc, 3): // all scan codes unmapped (function apparently unimplemented) */ BYTE keyState[256]; GetKeyboardState(keyState); for (UINT i = 1; i < 256; ++i) { // skip mouse button virtual keys switch (i) { case VK_LBUTTON: case VK_RBUTTON: case VK_MBUTTON: case VK_XBUTTON1: case VK_XBUTTON2: continue; default: break; } // map to a scancode and back to a virtual key UINT scancode = MapVirtualKey(i, 0); UINT virtKey = MapVirtualKey(scancode, 3); if (virtKey == 0) { // assume MapVirtualKey(xxx, 3) is unimplemented virtKey = i; } else if (scancode == 0) { // the VK_PAUSE virtual key doesn't map properly if (i == VK_PAUSE) { // i hope this works on all keyboards scancode = 0x45; virtKey = i; } else { continue; } } // we need some adjustments due to inadequacies in the API. // the API provides no means to query the keyboard by scan // code that i can see. so we're doing it by virtual key. // but a single virtual key can map to multiple physical // keys. for example, VK_HOME maps to NumPad 7 and to the // (extended key) Home key. this means we can never tell // which of the two keys is pressed. // // this is a problem if a key is down when this method is // called. if the extended key is down we'll record the // non-extended key as being down. when the extended key // goes up, we'll record that correctly and leave the // non-extended key as being down. to deal with that we // always re-check the keyboard state if we think we're // locked to a screen because a key is down. the re-check // should clear it up. // // the win32 functions that take scan codes are: // // if the mapped virtual key doesn't match the starting // point then there's a really good chance that that virtual // key is mapped to an extended key. however, this is not // the case for modifiers that don't distinguish between left // and right. also VK_NUMLOCK gets mapped to a non-extended // key but it should be. if (virtKey != i || i == VK_NUMLOCK) { if (i != VK_SHIFT && i != VK_CONTROL && i != VK_MENU) { scancode |= 0x100; } } // okay, now we have the scan code for the virtual key. m_scanCodeToVirtKey[scancode] = i; m_virtKeyToScanCode[i] = (KeyButton)scancode; // save the key state if ((keyState[i] & 0x80) != 0) { setKeyDown((KeyButton)scancode, true); } // toggle state applies to all keys but we only want it for // the modifier keys with corresponding lights. if ((keyState[i] & 0x01) != 0) { switch (i) { case VK_CAPITAL: setToggled(KeyModifierCapsLock); break; case VK_NUMLOCK: setToggled(KeyModifierNumLock); break; case VK_SCROLL: setToggled(KeyModifierScrollLock); break; } } } } void CMSWindowsKeyState::doFakeKeyEvent(KeyButton button, bool press, bool isAutoRepeat) { UINT vk = m_scanCodeToVirtKey[button]; m_desks->fakeKeyEvent(button, vk, press, isAutoRepeat); } KeyButton CMSWindowsKeyState::mapKey(Keystrokes& keys, KeyID id, KeyModifierMask mask, bool isAutoRepeat) const { UINT virtualKey = 0; // check for special keys if ((id & 0xfffff000u) == 0xe000u) { if ((id & 0xff00u) == 0xe000u) { virtualKey = s_mapE000[id & 0xffu]; } else if ((id & 0xff00) == 0xee00) { virtualKey = s_mapEE00[id & 0xffu]; } else if ((id & 0xff00) == 0xef00) { virtualKey = s_mapEF00[id & 0xffu]; } if (virtualKey == 0) { LOG((CLOG_DEBUG2 "unknown special key")); return 0; } } // special handling of VK_SNAPSHOT if (virtualKey == VK_SNAPSHOT) { // ignore key repeats on print screen if (!isAutoRepeat) { // active window (with alt) or fullscreen (without alt)? BYTE scan = 0; if ((mask & KeyModifierAlt) != 0) { scan = 1; } // send events keybd_event(VK_SNAPSHOT, scan, 0, 0); keybd_event(VK_SNAPSHOT, scan, KEYEVENTF_KEYUP, 0); } return 0; } // handle other special keys if (virtualKey != 0) { // compute required modifiers KeyModifierMask requiredMask = 0; KeyModifierMask outMask = 0; // check numeric keypad. note that virtual keys do not distinguish // between the keypad and non-keypad movement keys. however, the // virtual keys do distinguish between keypad numbers and operators // (e.g. add, multiply) and their main keyboard counterparts. // therefore, we can ignore the num-lock state for movement virtual // keys but not for numeric keys. if (virtualKey >= VK_NUMPAD0 && virtualKey <= VK_DIVIDE) { requiredMask |= KeyModifierNumLock; if ((getActiveModifiers() & KeyModifierNumLock) != 0) { LOG((CLOG_DEBUG2 "turn on num lock for keypad key")); outMask |= KeyModifierNumLock; } } // check for left tab. that requires the shift key. if (id == kKeyLeftTab) { requiredMask |= KeyModifierShift; outMask |= KeyModifierShift; } // now generate the keystrokes and return the resulting modifier mask KeyButton scanCode = m_virtKeyToScanCode[virtualKey]; LOG((CLOG_DEBUG2 "KeyID 0x%08x to virtual key %d scan code 0x%04x mask 0x%04x", id, virtualKey, scanCode, outMask)); return mapToKeystrokes(keys, scanCode, outMask, requiredMask, isAutoRepeat); } // determine the thread that'll receive this event // FIXME -- we can't be sure we'll get the right thread here HWND targetWindow = GetForegroundWindow(); DWORD targetThread = GetWindowThreadProcessId(targetWindow, NULL); // figure out the code page for the target thread. i'm just // guessing here. get the target thread's keyboard layout, // extract the language id from that, and choose the code page // based on that language. HKL hkl = GetKeyboardLayout(targetThread); LANGID langID = static_cast(LOWORD(hkl)); UINT codePage = getCodePageFromLangID(langID); LOG((CLOG_DEBUG2 "using code page %d and language id 0x%04x for thread 0x%08x", codePage, langID, targetThread)); // regular characters are complicated by dead keys. it may not be // possible to generate a desired character directly. we may need // to generate a dead key first then some other character. the // app receiving the events will compose these two characters into // a single precomposed character. // // as best as i can tell this is the simplest way to convert a // character into its uncomposed version. along the way we'll // discover if the key cannot be handled at all. we convert // from wide char to multibyte, then from multibyte to wide char // forcing conversion to composite characters, then from wide // char back to multibyte without making precomposed characters. // // after the first conversion to multibyte we see if we can map // the key. if so then we don't bother trying to decompose dead // keys. BOOL error; char multiByte[2 * MB_LEN_MAX]; wchar_t unicode[2]; unicode[0] = static_cast(id & 0x0000ffffu); int nChars = WideCharToMultiByte(codePage, WC_COMPOSITECHECK | WC_DEFAULTCHAR, unicode, 1, multiByte, sizeof(multiByte), NULL, &error); if (nChars == 0 || error) { LOG((CLOG_DEBUG2 "KeyID 0x%08x not in code page", id)); return 0; } KeyButton button = mapCharacter(keys, multiByte[0], hkl, isAutoRepeat); if (button != 0) { LOG((CLOG_DEBUG2 "KeyID 0x%08x maps to character %u", id, (unsigned char)multiByte[0])); if (isDeadChar(multiByte[0], hkl, false)) { // character mapped to a dead key but we want the // character for real so send a space key afterwards. LOG((CLOG_DEBUG2 "character mapped to dead key")); Keystroke keystroke; keystroke.m_key = m_virtKeyToScanCode[VK_SPACE]; keystroke.m_press = true; keystroke.m_repeat = false; keys.push_back(keystroke); keystroke.m_press = false; keys.push_back(keystroke); // ignore the release of this key since we already // handled it. button = 0; } return button; } nChars = MultiByteToWideChar(codePage, MB_COMPOSITE | MB_ERR_INVALID_CHARS, multiByte, nChars, unicode, 2); if (nChars == 0) { LOG((CLOG_DEBUG2 "KeyID 0x%08x mb->wc mapping failed", id)); return 0; } nChars = WideCharToMultiByte(codePage, 0, unicode, nChars, multiByte, sizeof(multiByte), NULL, &error); if (nChars == 0 || error) { LOG((CLOG_DEBUG2 "KeyID 0x%08x wc->mb mapping failed", id)); return 0; } // we expect one or two characters in multiByte. if there are two // then the *second* is a dead key. process the dead key if there. // FIXME -- we assume each character is one byte here if (nChars > 2) { LOG((CLOG_DEBUG2 "multibyte characters not supported for character 0x%04x", id)); return 0; } if (nChars == 2) { LOG((CLOG_DEBUG2 "KeyID 0x%08x needs dead key %u", id, (unsigned char)multiByte[1])); mapCharacter(keys, multiByte[1], hkl, isAutoRepeat); } // process character LOG((CLOG_DEBUG2 "KeyID 0x%08x maps to character %u", id, (unsigned char)multiByte[0])); return mapCharacter(keys, multiByte[0], hkl, isAutoRepeat); } UINT CMSWindowsKeyState::getCodePageFromLangID(LANGID langid) const { // construct a locale id from the language id LCID lcid = MAKELCID(langid, SORT_DEFAULT); // get the ANSI code page for this locale char data[6]; if (GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, data, 6) == 0) { // can't get code page LOG((CLOG_DEBUG1 "can't find code page for langid 0x%04x", langid)); return CP_ACP; } // convert stringified code page into a number UINT codePage = static_cast(atoi(data)); if (codePage == 0) { // parse failed LOG((CLOG_DEBUG1 "can't parse code page %s for langid 0x%04x", data, langid)); return CP_ACP; } return codePage; } KeyButton CMSWindowsKeyState::mapCharacter(Keystrokes& keys, char c, HKL hkl, bool isAutoRepeat) const { KeyModifierMask activeMask = getActiveModifiers(); // translate the character into its virtual key and its required // modifier state. SHORT virtualKeyAndModifierState = VkKeyScanEx(c, hkl); // get virtual key UINT virtualKey = LOBYTE(virtualKeyAndModifierState); if (virtualKey == 0xffu) { LOG((CLOG_DEBUG2 "cannot map character %d", static_cast(c))); return 0; } // get the required modifier state BYTE modifierState = HIBYTE(virtualKeyAndModifierState); // see what modifiers are needed. we only check for shift and // AltGr. we must always match the desired shift state but only // the desired AltGr state if AltGr is required. AltGr is actually // ctrl + alt so we can't require that ctrl and alt not be pressed // otherwise users couldn't do, say, ctrl+z. // // the space character (ascii 32) is special in that it's unaffected // by shift and should match our stored shift state. KeyModifierMask desiredMask = 0; KeyModifierMask requiredMask = KeyModifierShift; if (c == 32) { desiredMask |= (activeMask & KeyModifierShift); } else if ((modifierState & 0x01u) == 1) { desiredMask |= KeyModifierShift; } if ((modifierState & 0x06u) == 6) { // add ctrl and alt, which must be matched. match alt via // mode-switch, which uses the right alt key rather than // the left. windows doesn't care which alt key so long // as ctrl is also down but some apps do their own mapping // and they do care. Emacs and PuTTY, for example. desiredMask |= KeyModifierControl | KeyModifierModeSwitch; requiredMask |= KeyModifierControl | KeyModifierModeSwitch; } // handle combination of caps-lock and shift. if caps-lock is // off locally then use shift as necessary. if caps-lock is on // locally then it reverses the meaning of shift for keys that // are subject to case conversion. if ((activeMask & KeyModifierCapsLock) != 0) { // there doesn't seem to be a simple way to test if a // character respects the caps lock key. for normal // characters it's easy enough but CharLower() and // CharUpper() don't map dead keys even though they // do respect caps lock for some unfathomable reason. // first check the easy way. if that doesn't work // then see if it's a dead key. unsigned char uc = static_cast(c); if (CharLower((LPTSTR)uc) != CharUpper((LPTSTR)uc) || (MapVirtualKeyEx(virtualKey, 2, hkl) & 0x80000000lu) != 0) { LOG((CLOG_DEBUG2 "flip shift")); desiredMask ^= KeyModifierShift; } } // now generate the keystrokes. ignore the resulting modifier // mask since it can't have changed (because we don't call this // method for modifier keys). KeyButton scanCode = m_virtKeyToScanCode[virtualKey]; LOG((CLOG_DEBUG2 "character %d to virtual key %d scan code 0x%04x mask 0x%08x", (unsigned char)c, virtualKey, scanCode, desiredMask)); return mapToKeystrokes(keys, scanCode, desiredMask, requiredMask, isAutoRepeat); } KeyButton CMSWindowsKeyState::mapToKeystrokes(Keystrokes& keys, KeyButton button, KeyModifierMask desiredMask, KeyModifierMask requiredMask, bool isAutoRepeat) const { // adjust the modifiers to match the desired modifiers Keystrokes undo; if (!adjustModifiers(keys, undo, desiredMask, requiredMask)) { LOG((CLOG_DEBUG2 "failed to adjust modifiers")); keys.clear(); return 0; } // add the key event Keystroke keystroke; keystroke.m_key = button; keystroke.m_press = true; keystroke.m_repeat = isAutoRepeat; keys.push_back(keystroke); // put undo keystrokes at end of keystrokes in reverse order while (!undo.empty()) { keys.push_back(undo.back()); undo.pop_back(); } return button; } bool CMSWindowsKeyState::adjustModifiers(Keystrokes& keys, Keystrokes& undo, KeyModifierMask desiredMask, KeyModifierMask requiredMask) const { // for each modifier in requiredMask make sure the current state // of that modifier matches the bit in desiredMask. for (KeyModifierMask mask = 1u; requiredMask != 0; mask <<= 1) { if ((mask & requiredMask) != 0) { bool active = ((desiredMask & mask) != 0); if (!mapModifier(keys, undo, mask, active)) { return false; } requiredMask ^= mask; } } return true; } int CMSWindowsKeyState::toAscii(TCHAR c, HKL hkl, bool menu, WORD* chars) const { // ignore bogus character if (c == 0) { return 0; } // translate the character into its virtual key and its required // modifier state. SHORT virtualKeyAndModifierState = VkKeyScanEx(c, hkl); // get virtual key BYTE virtualKey = LOBYTE(virtualKeyAndModifierState); if (virtualKey == 0xffu) { return 0; } // get the required modifier state BYTE modifierState = HIBYTE(virtualKeyAndModifierState); // set shift state required to generate key BYTE keys[256]; memset(keys, 0, sizeof(keys)); if (modifierState & 0x01u) { keys[VK_SHIFT] = 0x80u; } if (modifierState & 0x02u) { keys[VK_CONTROL] = 0x80u; } if (modifierState & 0x04u) { keys[VK_MENU] = 0x80u; } // get the scan code for the key UINT scanCode = MapVirtualKeyEx(virtualKey, 0, hkl); // discard characters if chars is NULL WORD dummy; if (chars == NULL) { chars = &dummy; } // put it back return ToAsciiEx(virtualKey, scanCode, keys, chars, menu ? 1 : 0, hkl); } bool CMSWindowsKeyState::isDeadChar(TCHAR c, HKL hkl, bool menu) const { // first clear out ToAsciiEx()'s internal buffer by sending it // a space. WORD ascii; int old = toAscii(' ', hkl, 0, &ascii); // now pass the character of interest WORD dummy; bool isDead = (toAscii(c, hkl, menu, &dummy) < 0); // clear out internal buffer again toAscii(' ', hkl, 0, &dummy); // put old dead key back if there was one if (old == 1 && ascii != ' ') { toAscii(static_cast(ascii & 0xffu), hkl, menu, &dummy); } return isDead; }