rayelliott
/
barrier
mirror of https://github.com/debauchee/barrier.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
barrier/lib/platform/CMSWindowsKeyState.cpp

1603 lines
49 KiB
C++
Raw Normal View History

Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/*
* 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.
*/
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
#include "CMSWindowsKeyState.h"
#include "CMSWindowsDesks.h"
#include "CThread.h"
#include "CFunctionJob.h"
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
#include "CLog.h"
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
#include "CStringUtil.h"
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
#include "CArchMiscWindows.h"
// extended mouse buttons
#if !defined(VK_XBUTTON1)
#define VK_XBUTTON1 0x05
#define VK_XBUTTON2 0x06
#endif
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
// 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
//
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// CMSWindowsKeyState
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
//
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
const char* CMSWindowsKeyState::s_vkToName[] =
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
"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
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
const KeyID CMSWindowsKeyState::s_virtualKey[][2] =
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
/* 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
Merged changes from 1.0 branch, including Japanese keyboard support (thanks to Kazuhide Takahashi).
2003-09-28 11:58:38 +00:00
/* 0x19 */ kKeyZenkaku, kKeyNone, // VK_KANJI
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 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
};
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
// map special KeyID keys to virtual key codes
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
const UINT CMSWindowsKeyState::s_mapE000[] =
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
/* 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,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 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,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 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
};
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
const UINT CMSWindowsKeyState::s_mapEE00[] =
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
/* 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
};
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
/* 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. */
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
const UINT CMSWindowsKeyState::s_mapEF00[] =
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
/* 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,
Merged changes from 1.0 branch, including Japanese keyboard support (thanks to Kazuhide Takahashi).
2003-09-28 11:58:38 +00:00
/* 0x28 */ 0, 0, VK_KANJI, 0, 0, 0, 0, 0,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 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,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 0x50 */ VK_HOME, VK_LEFT, VK_UP, VK_RIGHT,
/* 0x54 */ VK_DOWN, VK_PRIOR, VK_NEXT, VK_END,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 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,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 0x78 */ 0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 0x80 */ VK_SPACE, 0, 0, 0, 0, 0, 0, 0,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 0x88 */ 0, VK_TAB, 0, 0, 0, VK_RETURN, 0, 0,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 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,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 0xac */ VK_DECIMAL, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 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,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 0xe4 */ VK_RCONTROL, VK_CAPITAL, 0, 0,
/* 0xe8 */ 0, VK_LMENU, VK_RMENU, VK_LWIN,
/* 0xec */ VK_RWIN, 0, 0, 0,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
/* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0,
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 0xf8 */ 0, 0, 0, 0, 0, 0, 0, VK_DELETE
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
};
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::CMSWindowsKeyState(CMSWindowsDesks* desks) :
m_is95Family(CArchMiscWindows::isWindows95Family()),
m_desks(desks),
m_keyLayout(GetKeyboardLayout(0))
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
}
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::~CMSWindowsKeyState()
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
// do nothing
}
void
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
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
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// 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<KeyID>(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<KeyID>(unicode);
}
else {
id = static_cast<KeyID>(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];
}
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
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<CMSWindowsKeyState*>(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()
{
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
// clear scan code to/from virtual key mapping
memset(m_scanCodeToVirtKey, 0, sizeof(m_scanCodeToVirtKey));
memset(m_virtKeyToScanCode, 0, sizeof(m_virtKeyToScanCode));
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// 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);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
/* 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)
*/
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
BYTE keyState[256];
GetKeyboardState(keyState);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
for (UINT i = 1; i < 256; ++i) {
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// skip mouse button virtual keys
switch (i) {
case VK_LBUTTON:
case VK_RBUTTON:
case VK_MBUTTON:
case VK_XBUTTON1:
case VK_XBUTTON2:
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
continue;
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
default:
break;
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
}
// map to a scancode and back to a virtual key
UINT scancode = MapVirtualKey(i, 0);
UINT virtKey = MapVirtualKey(scancode, 3);
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
if (virtKey == 0) {
// assume MapVirtualKey(xxx, 3) is unimplemented
virtKey = i;
}
else if (scancode == 0) {
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
// 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;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
}
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
// we need some adjustments due to inadequacies in the API.
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// 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:
//
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
// 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;
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// save the key state
if ((keyState[i] & 0x80) != 0) {
setKeyDown((KeyButton)scancode, true);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
}
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
// toggle state applies to all keys but we only want it for
// the modifier keys with corresponding lights.
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
if ((keyState[i] & 0x01) != 0) {
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
switch (i) {
case VK_CAPITAL:
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
setToggled(KeyModifierCapsLock);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
break;
case VK_NUMLOCK:
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
setToggled(KeyModifierNumLock);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
break;
case VK_SCROLL:
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
setToggled(KeyModifierScrollLock);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
break;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
}
}
}
void
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::doFakeKeyEvent(KeyButton button,
bool press, bool isAutoRepeat)
Win32 fixes. Fixed slightly off cursor positioning when using absolute mouse_event(). Improved keyboard handling: now using keyboard layout of last foreground window when leaving server so users can meaningfully choose the locale, moved dead key handling into hook library so there should be no more race conditions involving the keyboard dead key buffer, simplified keyboard and cursor handling by using a full screen transparent window when not using low level hooks, fixed error in restoring buffered dead key when checking for dead keys. This hopefully fixes all known keyboard bugs on win32.
2004-03-08 20:53:32 +00:00
{
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
UINT vk = m_scanCodeToVirtKey[button];
m_desks->fakeKeyEvent(button, vk, press, isAutoRepeat);
Win32 fixes. Fixed slightly off cursor positioning when using absolute mouse_event(). Improved keyboard handling: now using keyboard layout of last foreground window when leaving server so users can meaningfully choose the locale, moved dead key handling into hook library so there should be no more race conditions involving the keyboard dead key buffer, simplified keyboard and cursor handling by using a full screen transparent window when not using low level hooks, fixed error in restoring buffered dead key when checking for dead keys. This hopefully fixes all known keyboard bugs on win32.
2004-03-08 20:53:32 +00:00
}
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
KeyButton
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::mapKey(Keystrokes& keys, KeyID id,
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
KeyModifierMask mask, bool isAutoRepeat) const
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
UINT virtualKey = 0;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
// 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"));
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
return 0;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
}
// special handling of VK_SNAPSHOT
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
if (virtualKey == VK_SNAPSHOT) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
// ignore key repeats on print screen
if (!isAutoRepeat) {
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
// active window (with alt) or fullscreen (without alt)?
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
BYTE scan = 0;
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
if ((mask & KeyModifierAlt) != 0) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
scan = 1;
}
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
// send events
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
keybd_event(VK_SNAPSHOT, scan, 0, 0);
keybd_event(VK_SNAPSHOT, scan, KEYEVENTF_KEYUP, 0);
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
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.
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
if (virtualKey >= VK_NUMPAD0 && virtualKey <= VK_DIVIDE) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
requiredMask |= KeyModifierNumLock;
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
if ((getActiveModifiers() & KeyModifierNumLock) != 0) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
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
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
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));
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
return mapToKeystrokes(keys, scanCode,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
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<LANGID>(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<wchar_t>(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;
}
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
KeyButton button = mapCharacter(keys, multiByte[0], hkl, isAutoRepeat);
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
if (button != 0) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
LOG((CLOG_DEBUG2 "KeyID 0x%08x maps to character %u", id, (unsigned char)multiByte[0]));
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
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"));
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
Keystroke keystroke;
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
keystroke.m_key = m_virtKeyToScanCode[VK_SPACE];
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
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.
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
button = 0;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
return button;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
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]));
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
mapCharacter(keys, multiByte[1], hkl, isAutoRepeat);
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
// process character
LOG((CLOG_DEBUG2 "KeyID 0x%08x maps to character %u", id, (unsigned char)multiByte[0]));
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
return mapCharacter(keys, multiByte[0], hkl, isAutoRepeat);
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
UINT
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::getCodePageFromLangID(LANGID langid) const
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
// 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<UINT>(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
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::mapCharacter(Keystrokes& keys,
char c, HKL hkl, bool isAutoRepeat) const
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
{
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
KeyModifierMask activeMask = getActiveModifiers();
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
// translate the character into its virtual key and its required
// modifier state.
SHORT virtualKeyAndModifierState = VkKeyScanEx(c, hkl);
// get virtual key
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
UINT virtualKey = LOBYTE(virtualKeyAndModifierState);
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
if (virtualKey == 0xffu) {
LOG((CLOG_DEBUG2 "cannot map character %d", static_cast<unsigned char>(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
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
// otherwise users couldn't do, say, ctrl+z.
//
// the space character (ascii 32) is special in that it's unaffected
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
// by shift and should match our stored shift state.
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
KeyModifierMask desiredMask = 0;
KeyModifierMask requiredMask = KeyModifierShift;
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
if (c == 32) {
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
desiredMask |= (activeMask & KeyModifierShift);
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
}
else if ((modifierState & 0x01u) == 1) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
desiredMask |= KeyModifierShift;
}
if ((modifierState & 0x06u) == 6) {
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
// 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;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
// 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.
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
if ((activeMask & KeyModifierCapsLock) != 0) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
// 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<unsigned char>(c);
if (CharLower((LPTSTR)uc) != CharUpper((LPTSTR)uc) ||
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
(MapVirtualKeyEx(virtualKey, 2, hkl) & 0x80000000lu) != 0) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
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).
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
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));
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
return mapToKeystrokes(keys, scanCode,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
desiredMask, requiredMask, isAutoRepeat);
}
KeyButton
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::mapToKeystrokes(Keystrokes& keys, KeyButton button,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
KeyModifierMask desiredMask, KeyModifierMask requiredMask,
bool isAutoRepeat) const
{
// adjust the modifiers to match the desired modifiers
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
Keystrokes undo;
if (!adjustModifiers(keys, undo, desiredMask, requiredMask)) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
LOG((CLOG_DEBUG2 "failed to adjust modifiers"));
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
keys.clear();
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
return 0;
}
// add the key event
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
Keystroke keystroke;
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
keystroke.m_key = button;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
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();
}
Updated keyboard handling on win32. Still needs some work to avoid shadowing key state in multiple places. Also got locked to screen and reported key appeared to be wrong.
2004-03-17 20:59:25 +00:00
return button;
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
}
bool
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::adjustModifiers(Keystrokes& keys,
Keystrokes& undo,
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
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);
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
if (!mapModifier(keys, undo, mask, active)) {
Merged primary and secondary screens into one class.
2003-09-02 22:05:47 +00:00
return false;
}
requiredMask ^= mask;
}
}
return true;
}
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
int
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::toAscii(TCHAR c, HKL hkl, bool menu, WORD* chars) const
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
{
// 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
Converted win32 to new keyboard state tracking design. Also changed locking to screen so that keys no longer count (only mouse buttons and scroll lock toggled on). This is to deal with the unreliability of key event reporting which can leave us locked to a screen with no key physically pressed. The result of this is that clients get key repeats and releases without the corresponding key press. CKeyState handles this by discarding repeat/release events on keys it hasn't seen go down. Also made a few other minor fixes to win32 keyboard handling.
2004-03-26 20:59:26 +00:00
CMSWindowsKeyState::isDeadChar(TCHAR c, HKL hkl, bool menu) const
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
{
// 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
Win32 fixes. Fixed slightly off cursor positioning when using absolute mouse_event(). Improved keyboard handling: now using keyboard layout of last foreground window when leaving server so users can meaningfully choose the locale, moved dead key handling into hook library so there should be no more race conditions involving the keyboard dead key buffer, simplified keyboard and cursor handling by using a full screen transparent window when not using low level hooks, fixed error in restoring buffered dead key when checking for dead keys. This hopefully fixes all known keyboard bugs on win32.
2004-03-08 20:53:32 +00:00
if (old == 1 && ascii != ' ') {
Fixed potential failure to use synergy's keyboard layout when using low-level keyboard hooks, fixed handling of the global keyboard layout dead key buffer, fixed identification of dead keys, fixed synthesis of AltGr (now using right-alt instead of left-alt), now using VK_DECIMAL for Separator key, fixed bug where an unmappable key was treated as virtual key 0xff, and added support for shift-space (shift was being discarded). Also fixed failure to hide cursor when leaving primary screen and added support for handling PrintScreen key.
2003-09-06 23:17:41 +00:00
toAscii(static_cast<TCHAR>(ascii & 0xffu), hkl, menu, &dummy);
}
return isDead;
}