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

1339 lines
38 KiB
C++
Raw Blame History

/*
* synergy -- mouse and keyboard sharing utility
* Copyright (C) 2002 Chris Schoeneman
*
* This package is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* found in the file COPYING that should have accompanied this file.
*
* This package is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include "CMSWindowsSecondaryScreen.h"
#include "CMSWindowsScreen.h"
#include "XScreen.h"
#include "CLock.h"
#include "CThread.h"
#include "CFunctionJob.h"
#include "CLog.h"
#include "CArchMiscWindows.h"
#include <cctype>
// these are only defined when WINVER >= 0x0500
#if !defined(SPI_GETMOUSESPEED)
#define SPI_GETMOUSESPEED 112
#endif
#if !defined(SPI_SETMOUSESPEED)
#define SPI_SETMOUSESPEED 113
#endif
// X button stuff
#if !defined(WM_XBUTTONDOWN)
#define WM_XBUTTONDOWN 0x020B
#define WM_XBUTTONUP 0x020C
#define WM_XBUTTONDBLCLK 0x020D
#define WM_NCXBUTTONDOWN 0x00AB
#define WM_NCXBUTTONUP 0x00AC
#define WM_NCXBUTTONDBLCLK 0x00AD
#define MOUSEEVENTF_XDOWN 0x0100
#define MOUSEEVENTF_XUP 0x0200
#define XBUTTON1 0x0001
#define XBUTTON2 0x0002
#endif
// multimedia keys
#if !defined(VK_BROWSER_BACK)
#define VK_BROWSER_BACK 0xA6
#define VK_BROWSER_FORWARD 0xA7
#define VK_BROWSER_REFRESH 0xA8
#define VK_BROWSER_STOP 0xA9
#define VK_BROWSER_SEARCH 0xAA
#define VK_BROWSER_FAVORITES 0xAB
#define VK_BROWSER_HOME 0xAC
#define VK_VOLUME_MUTE 0xAD
#define VK_VOLUME_DOWN 0xAE
#define VK_VOLUME_UP 0xAF
#define VK_MEDIA_NEXT_TRACK 0xB0
#define VK_MEDIA_PREV_TRACK 0xB1
#define VK_MEDIA_STOP 0xB2
#define VK_MEDIA_PLAY_PAUSE 0xB3
#define VK_LAUNCH_MAIL 0xB4
#define VK_LAUNCH_MEDIA_SELECT 0xB5
#define VK_LAUNCH_APP1 0xB6
#define VK_LAUNCH_APP2 0xB7
#endif
//
// CMSWindowsSecondaryScreen
//
// a list of modifier key info
const CMSWindowsSecondaryScreen::CModifierInfo
CMSWindowsSecondaryScreen::s_modifier[] = {
{ KeyModifierShift, VK_LSHIFT, VK_RSHIFT, false },
{ KeyModifierControl, VK_LCONTROL, VK_RCONTROL | 0x100,false },
{ KeyModifierAlt, VK_LMENU, VK_RMENU | 0x100, false },
// note -- no keys for KeyModifierMeta
{ KeyModifierSuper, VK_LWIN | 0x100, VK_RWIN | 0x100, false },
{ KeyModifierCapsLock, VK_CAPITAL, 0, true },
{ KeyModifierNumLock, VK_NUMLOCK | 0x100, 0, true },
{ KeyModifierScrollLock,VK_SCROLL, 0, true }
};
CMSWindowsSecondaryScreen::CMSWindowsSecondaryScreen(
IScreenReceiver* receiver) :
m_is95Family(CArchMiscWindows::isWindows95Family()),
m_window(NULL)
{
m_screen = new CMSWindowsScreen(receiver, this);
}
CMSWindowsSecondaryScreen::~CMSWindowsSecondaryScreen()
{
assert(m_window == NULL);
delete m_screen;
}
CSecondaryScreen::SysKeyID
CMSWindowsSecondaryScreen::getUnhanded(SysKeyID sysKeyID) const
{
switch (sysKeyID) {
case VK_LSHIFT:
case VK_RSHIFT:
return VK_SHIFT;
case VK_LCONTROL:
case VK_RCONTROL:
return VK_CONTROL;
case VK_LMENU:
case VK_RMENU:
return VK_MENU;
default:
return 0;
}
}
CSecondaryScreen::SysKeyID
CMSWindowsSecondaryScreen::getOtherHanded(SysKeyID sysKeyID) const
{
switch (sysKeyID) {
case VK_LSHIFT:
return VK_RSHIFT;
case VK_RSHIFT:
return VK_LSHIFT;
case VK_LCONTROL:
return VK_RCONTROL;
case VK_RCONTROL:
return VK_LCONTROL;
case VK_LMENU:
return VK_RMENU;
case VK_RMENU:
return VK_LMENU;
default:
return 0;
}
}
bool
CMSWindowsSecondaryScreen::isAutoRepeating(SysKeyID) const
{
return true;
}
void
CMSWindowsSecondaryScreen::sync() const
{
m_screen->syncDesktop();
}
IScreen*
CMSWindowsSecondaryScreen::getScreen() const
{
return m_screen;
}
void
CMSWindowsSecondaryScreen::onScreensaver(bool)
{
// ignore
}
bool
CMSWindowsSecondaryScreen::onPreDispatch(const CEvent*)
{
return false;
}
bool
CMSWindowsSecondaryScreen::onEvent(CEvent* event)
{
assert(event != NULL);
const MSG& msg = event->m_msg;
switch (msg.message) {
case WM_ACTIVATEAPP:
if (msg.wParam == FALSE) {
// some other app activated. hide the hider window.
ShowWindow(m_window, SW_HIDE);
}
break;
}
return false;
}
void
CMSWindowsSecondaryScreen::onOneShotTimerExpired(UInt32)
{
// ignore
}
void
CMSWindowsSecondaryScreen::postCreateWindow(HWND window)
{
m_window = window;
// update key state
updateKeys();
// hide cursor if this screen isn't active
if (!isActive()) {
SInt32 x, y;
getScreen()->getCursorCenter(x, y);
showWindow(x, y);
}
}
void
CMSWindowsSecondaryScreen::preDestroyWindow(HWND)
{
// do nothing
}
void
CMSWindowsSecondaryScreen::onAccessibleDesktop()
{
// get the current keyboard state
updateKeys();
}
void
CMSWindowsSecondaryScreen::onPreMainLoop()
{
assert(m_window != NULL);
}
void
CMSWindowsSecondaryScreen::onPreOpen()
{
assert(m_window == NULL);
}
void
CMSWindowsSecondaryScreen::onPreEnter()
{
assert(m_window != NULL);
}
void
CMSWindowsSecondaryScreen::onPreLeave()
{
assert(m_window != NULL);
}
void
CMSWindowsSecondaryScreen::createWindow()
{
// open the desktop and the window
m_window = m_screen->openDesktop();
if (m_window == NULL) {
throw XScreenOpenFailure();
}
}
void
CMSWindowsSecondaryScreen::destroyWindow()
{
// release keys that are logically pressed
releaseKeys();
// close the desktop and the window
m_screen->closeDesktop();
m_window = NULL;
}
void
CMSWindowsSecondaryScreen::showWindow(SInt32 x, SInt32 y)
{
// move hider window under the given position
MoveWindow(m_window, x, y, 1, 1, FALSE);
// raise and show the hider window
ShowWindow(m_window, SW_SHOWNA);
// now warp the mouse
fakeMouseMove(x, y);
}
void
CMSWindowsSecondaryScreen::hideWindow()
{
ShowWindow(m_window, SW_HIDE);
}
CSecondaryScreen::KeyState
CMSWindowsSecondaryScreen::getKeyState(UINT virtualKey) const
{
BYTE sysState = static_cast<BYTE>(GetKeyState(virtualKey));
KeyState state = 0;
if (sysState & 0x01u) {
state |= kToggled;
}
if (sysState & 0x80u) {
state |= kDown;
}
return state;
}
void
CMSWindowsSecondaryScreen::updateKeys(KeyState* keys)
{
// we only care about the modifier key states
keys[VK_LSHIFT] = getKeyState(VK_LSHIFT);
keys[VK_RSHIFT] = getKeyState(VK_RSHIFT);
keys[VK_SHIFT] = getKeyState(VK_SHIFT);
keys[VK_LCONTROL] = getKeyState(VK_LCONTROL);
keys[VK_RCONTROL] = getKeyState(VK_RCONTROL);
keys[VK_CONTROL] = getKeyState(VK_CONTROL);
keys[VK_LMENU] = getKeyState(VK_LMENU);
keys[VK_RMENU] = getKeyState(VK_RMENU);
keys[VK_MENU] = getKeyState(VK_MENU);
keys[VK_LWIN] = getKeyState(VK_LWIN);
keys[VK_RWIN] = getKeyState(VK_RWIN);
keys[VK_APPS] = getKeyState(VK_APPS);
keys[VK_CAPITAL] = getKeyState(VK_CAPITAL);
keys[VK_NUMLOCK] = getKeyState(VK_NUMLOCK);
keys[VK_SCROLL] = getKeyState(VK_SCROLL);
}
KeyModifierMask
CMSWindowsSecondaryScreen::getModifiers() const
{
// update active modifier mask
KeyModifierMask mask = 0;
if (isKeyDown(VK_LSHIFT) || isKeyDown(VK_RSHIFT)) {
mask |= KeyModifierShift;
}
if (isKeyDown(VK_LCONTROL) || isKeyDown(VK_RCONTROL)) {
mask |= KeyModifierControl;
}
if (isKeyDown(VK_LMENU) || isKeyDown(VK_RMENU)) {
mask |= KeyModifierAlt;
}
// note -- no keys for KeyModifierMeta
if (isKeyDown(VK_LWIN) || isKeyDown(VK_RWIN)) {
mask |= KeyModifierSuper;
}
if (isKeyToggled(VK_CAPITAL)) {
mask |= KeyModifierCapsLock;
}
if (isKeyToggled(VK_NUMLOCK)) {
mask |= KeyModifierNumLock;
}
if (isKeyToggled(VK_SCROLL)) {
mask |= KeyModifierScrollLock;
}
// note -- do not save KeyModifierModeSwitch in mask
return mask;
}
// map special KeyID keys to virtual key codes. if the key is an
// extended key then the entry is the virtual key code | 0x100.
// unmapped keys have a 0 entry.
static const UINT g_mapE000[] =
{
/* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x08 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x10 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x18 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x28 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x38 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x48 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x68 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x78 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x88 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x98 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xa0 */ 0, 0, 0, 0,
/* 0xa4 */ 0, 0, VK_BROWSER_BACK|0x100, VK_BROWSER_FORWARD|0x100,
/* 0xa8 */ VK_BROWSER_REFRESH|0x100, VK_BROWSER_STOP|0x100,
/* 0xaa */ VK_BROWSER_SEARCH|0x100, VK_BROWSER_FAVORITES|0x100,
/* 0xac */ VK_BROWSER_HOME|0x100, VK_VOLUME_MUTE|0x100,
/* 0xae */ VK_VOLUME_DOWN|0x100, VK_VOLUME_UP|0x100,
/* 0xb0 */ VK_MEDIA_NEXT_TRACK|0x100, VK_MEDIA_PREV_TRACK|0x100,
/* 0xb2 */ VK_MEDIA_STOP|0x100, VK_MEDIA_PLAY_PAUSE|0x100,
/* 0xb4 */ VK_LAUNCH_MAIL|0x100, VK_LAUNCH_MEDIA_SELECT|0x100,
/* 0xb6 */ VK_LAUNCH_APP1|0x100, VK_LAUNCH_APP2|0x100,
/* 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
};
static const UINT g_mapEE00[] =
{
/* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x08 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x10 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x18 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x20 */ VK_TAB, 0, 0, 0, 0, 0, 0, 0,
/* 0x28 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x38 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x48 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x68 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x78 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x88 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x98 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xa0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xa8 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xb0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xb8 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xc0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xc8 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xd0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xd8 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xe0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xe8 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xf8 */ 0, 0, 0, 0, 0, 0, 0, 0
};
static const UINT g_mapEF00[] =
{
/* 0x00 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x08 */ VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,
/* 0x10 */ 0, 0, 0, VK_PAUSE, VK_SCROLL, 0/*sys-req*/, 0, 0,
/* 0x18 */ 0, 0, 0, VK_ESCAPE, 0, 0, 0, 0,
/* 0x20 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x28 */ 0, 0, 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 */ VK_HOME|0x100, VK_LEFT|0x100, VK_UP|0x100, VK_RIGHT|0x100,
/* 0x54 */ VK_DOWN|0x100, VK_PRIOR|0x100, VK_NEXT|0x100, VK_END|0x100,
/* 0x58 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x60 */ VK_SELECT|0x100, VK_SNAPSHOT|0x100, VK_EXECUTE|0x100, VK_INSERT|0x100,
/* 0x64 */ 0, 0, 0, VK_APPS|0x100,
/* 0x68 */ 0, 0, VK_HELP|0x100, VK_CANCEL|0x100, 0, 0, 0, 0,
/* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0x78 */ 0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK|0x100,
/* 0x80 */ VK_SPACE, 0, 0, 0, 0, 0, 0, 0,
/* 0x88 */ 0, VK_TAB, 0, 0, 0, VK_RETURN|0x100, 0, 0,
/* 0x90 */ 0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP,
/* 0x98 */ VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT,
/* 0x9c */ VK_END, 0, VK_INSERT, VK_DELETE,
/* 0xa0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xa8 */ 0, 0, VK_MULTIPLY, VK_ADD,
/* 0xac */ VK_SEPARATOR, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE|0x100,
/* 0xb0 */ VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3,
/* 0xb4 */ VK_NUMPAD4, VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7,
/* 0xb8 */ VK_NUMPAD8, VK_NUMPAD9, 0, 0, 0, 0, VK_F1, VK_F2,
/* 0xc0 */ VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,
/* 0xc8 */ VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16, VK_F17, VK_F18,
/* 0xd0 */ VK_F19, VK_F20, VK_F21, VK_F22, VK_F23, VK_F24, 0, 0,
/* 0xd8 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xe0 */ 0, VK_LSHIFT, VK_RSHIFT, VK_LCONTROL,
/* 0xe4 */ VK_RCONTROL|0x100, VK_CAPITAL, 0, 0,
/* 0xe8 */ 0, VK_LMENU, VK_RMENU|0x100, VK_LWIN|0x100,
/* 0xec */ VK_RWIN|0x100, 0, 0, 0,
/* 0xf0 */ 0, 0, 0, 0, 0, 0, 0, 0,
/* 0xf8 */ 0, 0, 0, 0, 0, 0, 0, VK_DELETE|0x100
};
DWORD
CMSWindowsSecondaryScreen::mapButton(ButtonID button,
bool press, DWORD* inData) const
{
DWORD dummy;
DWORD* data = (inData != NULL) ? inData : &dummy;
// the system will swap the meaning of left/right for us if
// the user has configured a left-handed mouse but we don't
// want it to swap since we want the handedness of the
// server's mouse. so pre-swap for a left-handed mouse.
if (GetSystemMetrics(SM_SWAPBUTTON)) {
switch (button) {
case kButtonLeft:
button = kButtonRight;
break;
case kButtonRight:
button = kButtonLeft;
break;
}
}
// map button id to button flag and button data
*data = 0;
switch (button) {
case kButtonLeft:
return press ? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_LEFTUP;
case kButtonMiddle:
return press ? MOUSEEVENTF_MIDDLEDOWN : MOUSEEVENTF_MIDDLEUP;
case kButtonRight:
return press ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_RIGHTUP;
case kButtonExtra0 + 0:
*data = XBUTTON1;
return press ? MOUSEEVENTF_XDOWN : MOUSEEVENTF_XUP;
case kButtonExtra0 + 1:
*data = XBUTTON2;
return press ? MOUSEEVENTF_XDOWN : MOUSEEVENTF_XUP;
default:
return 0;
}
}
KeyModifierMask
CMSWindowsSecondaryScreen::mapKey(Keystrokes& keys,
SysKeyID& virtualKey, KeyID id,
KeyModifierMask currentMask,
KeyModifierMask desiredMask, EKeyAction action) const
{
virtualKey = 0;
// check for special keys
if ((id & 0xfffff000) == 0xe000) {
if ((id & 0xff00) == 0xe000) {
virtualKey = g_mapE000[id & 0xff];
}
else if ((id & 0xff00) == 0xee00) {
virtualKey = g_mapEE00[id & 0xff];
}
else if ((id & 0xff00) == 0xef00) {
virtualKey = g_mapEF00[id & 0xff];
}
if (virtualKey == 0) {
LOG((CLOG_DEBUG2 "unknown special key"));
return currentMask;
}
}
// special handling of VK_SNAPSHOT
if ((virtualKey & 0xff) == VK_SNAPSHOT) {
// ignore key repeats on print screen
if (action != kRepeat) {
// get event flags
DWORD flags = 0;
if (isExtendedKey(virtualKey)) {
flags |= KEYEVENTF_EXTENDEDKEY;
}
if (action != kPress) {
flags |= KEYEVENTF_KEYUP;
}
// active window or fullscreen?
BYTE scan = 0;
if ((desiredMask & KeyModifierAlt) == 0) {
scan = 1;
}
// send event
keybd_event(static_cast<BYTE>(virtualKey & 0xff), scan, flags, 0);
}
return currentMask;
}
// handle other special keys
if (virtualKey != 0) {
// compute the final desired modifier mask. special keys use
// the desired modifiers as given except we keep the caps lock,
// num lock, and scroll lock as is.
KeyModifierMask outMask = (currentMask &
(KeyModifierCapsLock |
KeyModifierNumLock |
KeyModifierScrollLock));
outMask |= (desiredMask &
(KeyModifierShift |
KeyModifierControl |
KeyModifierAlt |
KeyModifierMeta |
KeyModifierSuper));
// strip out extended key flag
UINT virtualKey2 = (virtualKey & ~0x100);
// check numeric keypad. note that virtual keys do not distinguish
// between the keypad and non-keypad movement keys. however, the
// virtual keys do distinguish between keypad numbers and operators
// (e.g. add, multiply) and their main keyboard counterparts.
// therefore, we can ignore the num-lock state for movement virtual
// keys but not for numeric keys.
if (virtualKey2 >= VK_NUMPAD0 && virtualKey2 <= VK_DIVIDE) {
// set required shift state based on current numlock state
if ((outMask & KeyModifierNumLock) == 0) {
if ((currentMask & KeyModifierNumLock) == 0) {
LOG((CLOG_DEBUG2 "turn on num lock for keypad key"));
outMask |= KeyModifierNumLock;
}
else {
LOG((CLOG_DEBUG2 "turn on shift for keypad key"));
outMask |= KeyModifierShift;
}
}
}
// check for left tab. that requires the shift key.
if (id == kKeyLeftTab) {
// XXX -- this isn't used; outMask meant instead?
desiredMask |= KeyModifierShift;
}
// now generate the keystrokes and return the resulting modifier mask
LOG((CLOG_DEBUG2 "KeyID 0x%08x to virtual key %d mask 0x%04x", id, virtualKey2, outMask));
return mapToKeystrokes(keys, virtualKey, currentMask, outMask, action);
}
// 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 & 0x0000ffff);
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 currentMask;
}
virtualKey = mapCharacter(keys, multiByte[0],
hkl, currentMask, desiredMask, action);
if (virtualKey != static_cast<UINT>(-1)) {
LOG((CLOG_DEBUG2 "KeyID 0x%08x maps to character %u", id, (unsigned char)multiByte[0]));
if ((MapVirtualKey(virtualKey, 2) & 0x80000000u) != 0) {
// it looks like this character is a dead key but
// MapVirtualKey() will claim it's a dead key even if it's
// not (though i don't think it ever claims it's not when
// it is). we need a backup test to ensure that this is
// really a dead key. we could use ToAscii() for this but
// that keeps state and it's a hassle to restore that state.
// OemKeyScan() appears to do the trick. if the character
// cannot be generated with a single keystroke then it
// returns 0xffffffff.
if (OemKeyScan(multiByte[0]) != 0xffffffffu) {
// character mapped to a dead key but we want the
// character for real so send a space key afterwards.
LOG((CLOG_DEBUG2 "character mapped to dead key"));
Keystroke keystroke;
keystroke.m_sysKeyID = VK_SPACE;
keystroke.m_press = true;
keystroke.m_repeat = false;
keys.push_back(keystroke);
keystroke.m_press = false;
keys.push_back(keystroke);
// ignore the release of this key since we already
// handled it in mapCharacter().
virtualKey = 0;
}
}
return currentMask;
}
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 currentMask;
}
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 currentMask;
}
// 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 currentMask;
}
if (nChars == 2) {
LOG((CLOG_DEBUG2 "KeyID 0x%08x needs dead key %u", id, (unsigned char)multiByte[1]));
mapCharacter(keys, multiByte[1],
hkl, currentMask, desiredMask, action);
}
// process character
LOG((CLOG_DEBUG2 "KeyID 0x%08x maps to character %u", id, (unsigned char)multiByte[0]));
virtualKey = mapCharacter(keys, multiByte[0],
hkl, currentMask, desiredMask, action);
// non-special key cannot modify the modifier mask
return currentMask;
}
KeyModifierMask
CMSWindowsSecondaryScreen::getModifierKeyMask(SysKeyID virtualKey) const
{
switch (virtualKey) {
case VK_CAPITAL:
return KeyModifierCapsLock;
case VK_NUMLOCK:
return KeyModifierNumLock;
case VK_SCROLL:
return KeyModifierScrollLock;
default:
return 0;
}
}
bool
CMSWindowsSecondaryScreen::isModifierActive(SysKeyID virtualKey) const
{
// check if any virtual key for this modifier is down. return false
// for toggle modifiers.
const CModifierInfo* modifier = getModifierInfo(virtualKey);
if (modifier != NULL && !modifier->m_isToggle) {
if (isKeyDown(modifier->m_virtualKey & 0xff) ||
isKeyDown(modifier->m_virtualKey2 & 0xff)) {
return true;
}
}
return false;
}
UINT
CMSWindowsSecondaryScreen::mapCharacter(Keystrokes& keys,
char c, HKL hkl,
KeyModifierMask currentMask,
KeyModifierMask desiredMask, EKeyAction action) const
{
// translate the character into its virtual key and its required
// modifier state.
SHORT virtualKeyAndModifierState = VkKeyScanEx(c, hkl);
// get virtual key
UINT virtualKey = LOBYTE(virtualKeyAndModifierState);
if (LOBYTE(virtualKeyAndModifierState) == 0xff) {
LOG((CLOG_DEBUG2 "cannot map character %d", static_cast<unsigned char>(c)));
return static_cast<UINT>(-1);
}
// get the required modifier state
BYTE modifierState = HIBYTE(virtualKeyAndModifierState);
// compute the final desired modifier mask. this is the
// desired modifier mask except that the system might require
// that certain modifiers be up or down in order to generate
// the character. to start with, we know that we want to keep
// the caps lock, num lock, scroll lock modifiers as is. also,
// the system never requires the meta or super modifiers so we
// can set those however we like.
KeyModifierMask outMask = (currentMask &
(KeyModifierCapsLock |
KeyModifierNumLock |
KeyModifierScrollLock));
outMask |= (desiredMask &
(KeyModifierMeta |
KeyModifierSuper));
// win32 does not permit ctrl and alt used together to
// modify a character because ctrl and alt together mean
// AltGr. if the desired mask has both ctrl and alt then
// strip them both out.
if ((desiredMask & (KeyModifierControl | KeyModifierAlt)) ==
(KeyModifierControl | KeyModifierAlt)) {
desiredMask &= ~(KeyModifierControl | KeyModifierAlt);
}
// strip out the desired shift state. we're forced to use
// a particular shift state to generate the desired character.
outMask &= ~KeyModifierShift;
// use the required modifiers. if AltGr is required then
// modifierState will indicate control and alt.
if ((modifierState & 1) != 0) {
outMask |= KeyModifierShift;
}
if ((modifierState & 2) != 0) {
outMask |= KeyModifierControl;
}
if ((modifierState & 4) != 0) {
outMask |= KeyModifierAlt;
}
// use desired modifiers
if ((desiredMask & KeyModifierControl) != 0) {
outMask |= KeyModifierControl;
}
if ((desiredMask & KeyModifierAlt) != 0) {
outMask |= KeyModifierAlt;
}
// handle combination of caps-lock and shift. if caps-lock is
// off locally then use shift as necessary. if caps-lock is on
// locally then it reverses the meaning of shift for keys that
// are subject to case conversion.
if ((outMask & KeyModifierCapsLock) != 0) {
// there doesn't seem to be a simple way to test if a
// character respects the caps lock key. for normal
// characters it's easy enough but CharLower() and
// CharUpper() don't map dead keys even though they
// do respect caps lock for some unfathomable reason.
// first check the easy way. if that doesn't work
// then see if it's a dead key.
unsigned char uc = static_cast<unsigned char>(c);
if (CharLower((LPTSTR)uc) != CharUpper((LPTSTR)uc) ||
(MapVirtualKey(virtualKey, 2) & 0x80000000lu) != 0) {
LOG((CLOG_DEBUG2 "flip shift"));
outMask ^= 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).
LOG((CLOG_DEBUG2 "character %d to virtual key %d mask 0x%04x", (unsigned char)c, virtualKey, outMask));
mapToKeystrokes(keys, virtualKey, currentMask, outMask, action);
return virtualKey;
}
KeyModifierMask
CMSWindowsSecondaryScreen::mapToKeystrokes(Keystrokes& keys,
UINT virtualKey,
KeyModifierMask currentMask,
KeyModifierMask desiredMask, EKeyAction action) const
{
const CModifierInfo* modifier = getModifierInfo(virtualKey);
// add the key events required to get to the desired modifier state.
// also save the key events required to restore the current state.
// if the key is a modifier key then skip this because modifiers
// should not modify modifiers.
Keystrokes undo;
Keystroke keystroke;
if (desiredMask != currentMask && modifier == NULL) {
const unsigned int s_numModifiers = sizeof(s_modifier) /
sizeof(s_modifier[0]);
for (unsigned int i = 0; i < s_numModifiers; ++i) {
KeyModifierMask bit = s_modifier[i].m_mask;
if ((desiredMask & bit) != (currentMask & bit)) {
if ((desiredMask & bit) != 0) {
// modifier is not active but should be. if the
// modifier is a toggle then toggle it on with a
// press/release, otherwise activate it with a
// press.
keystroke.m_sysKeyID = s_modifier[i].m_virtualKey;
keystroke.m_press = true;
keystroke.m_repeat = false;
keys.push_back(keystroke);
if (s_modifier[i].m_isToggle) {
keystroke.m_press = false;
keys.push_back(keystroke);
undo.push_back(keystroke);
keystroke.m_press = true;
undo.push_back(keystroke);
}
else {
keystroke.m_press = false;
undo.push_back(keystroke);
}
}
else {
// modifier is active but should not be. if the
// modifier is a toggle then toggle it off with a
// press/release, otherwise deactivate it with a
// release. we must check each keycode for the
// modifier if not a toggle.
if (s_modifier[i].m_isToggle) {
keystroke.m_sysKeyID = s_modifier[i].m_virtualKey;
keystroke.m_press = true;
keystroke.m_repeat = false;
keys.push_back(keystroke);
keystroke.m_press = false;
keys.push_back(keystroke);
undo.push_back(keystroke);
keystroke.m_press = true;
undo.push_back(keystroke);
}
else {
UINT key = s_modifier[i].m_virtualKey;
if (isKeyDown(key & 0xff)) {
keystroke.m_sysKeyID = key;
keystroke.m_press = false;
keystroke.m_repeat = false;
keys.push_back(keystroke);
keystroke.m_press = true;
undo.push_back(keystroke);
}
key = s_modifier[i].m_virtualKey2;
if (isKeyDown(key & 0xff)) {
keystroke.m_sysKeyID = key;
keystroke.m_press = false;
keystroke.m_repeat = false;
keys.push_back(keystroke);
keystroke.m_press = true;
undo.push_back(keystroke);
}
}
}
}
}
}
// add the key event
keystroke.m_sysKeyID = virtualKey;
switch (action) {
case kPress:
keystroke.m_press = true;
keystroke.m_repeat = false;
keys.push_back(keystroke);
break;
case kRelease:
keystroke.m_press = false;
keystroke.m_repeat = false;
keys.push_back(keystroke);
break;
case kRepeat:
keystroke.m_press = true;
keystroke.m_repeat = true;
keys.push_back(keystroke);
break;
}
// if this is a dead key press then send a release immediately.
// the dead key may not be processed correctly if its release
// event comes after we release the modifiers.
if (action == kPress &&
(MapVirtualKey(virtualKey, 2) & 0x80000000lu) != 0) {
keystroke.m_press = false;
keys.push_back(keystroke);
}
// add key events to restore the modifier state. apply events in
// the reverse order that they're stored in undo.
while (!undo.empty()) {
keys.push_back(undo.back());
undo.pop_back();
}
// if the key is a modifier key then compute the modifier mask after
// this key is pressed. toggle keys modify the state on release.
// other keys set the modifier bit on press.
KeyModifierMask mask = currentMask;
if (action == kPress) {
if (modifier != NULL && !modifier->m_isToggle) {
mask |= modifier->m_mask;
}
}
LOG((CLOG_DEBUG2 "previous modifiers 0x%04x, final modifiers 0x%04x", currentMask, mask));
return mask;
}
const CMSWindowsSecondaryScreen::CModifierInfo*
CMSWindowsSecondaryScreen::getModifierInfo(UINT virtualKey) const
{
// note if the key is a modifier. strip out extended key flag from
// virtual key before lookup.
switch (virtualKey & 0xffu) {
case VK_SHIFT:
case VK_LSHIFT:
case VK_RSHIFT:
return s_modifier + 0;
case VK_CONTROL:
case VK_LCONTROL:
case VK_RCONTROL:
return s_modifier + 1;
case VK_MENU:
case VK_LMENU:
case VK_RMENU:
return s_modifier + 2;
case VK_LWIN:
case VK_RWIN:
return s_modifier + 3;
case VK_CAPITAL:
return s_modifier + 4;
case VK_NUMLOCK:
return s_modifier + 5;
case VK_SCROLL:
return s_modifier + 6;
default:
return NULL;
}
}
CSecondaryScreen::SysKeyID
CMSWindowsSecondaryScreen::getToggleSysKey(KeyID keyID) const
{
switch (keyID) {
case kKeyNumLock:
return VK_NUMLOCK | 0x100;
case kKeyCapsLock:
return VK_CAPITAL;
case kKeyScrollLock:
return VK_SCROLL;
default:
return 0;
}
}
UINT
CMSWindowsSecondaryScreen::virtualKeyToScanCode(UINT& virtualKey) const
{
// try mapping given virtual key
UINT code = MapVirtualKey(virtualKey & 0xff, 0);
if (code != 0) {
return code;
}
// no dice. if the virtual key distinguishes between left/right
// then try the one that doesn't distinguish sides. windows (or
// keyboard drivers) are inconsistent in their treatment of these
// virtual keys. the following behaviors have been observed:
//
// win2k (gateway desktop):
// MapVirtualKey(vk, 0):
// VK_SHIFT == VK_LSHIFT != VK_RSHIFT
// VK_CONTROL == VK_LCONTROL == VK_RCONTROL
// VK_MENU == VK_LMENU == VK_RMENU
// MapVirtualKey(sc, 3):
// VK_LSHIFT and VK_RSHIFT mapped independently
// VK_LCONTROL is mapped but not VK_RCONTROL
// VK_LMENU is mapped but not VK_RMENU
//
// 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)
switch (virtualKey & 0xff) {
case VK_LSHIFT:
case VK_RSHIFT:
virtualKey = VK_SHIFT;
return MapVirtualKey(VK_SHIFT, 0);
case VK_LCONTROL:
case VK_RCONTROL:
virtualKey = VK_CONTROL;
return MapVirtualKey(VK_CONTROL, 0);
case VK_LMENU:
case VK_RMENU:
virtualKey = VK_MENU;
return MapVirtualKey(VK_MENU, 0);
default:
return 0;
}
}
bool
CMSWindowsSecondaryScreen::isExtendedKey(UINT virtualKey) const
{
// see if we've already encoded the extended flag
if ((virtualKey & 0x100) != 0) {
return true;
}
// check known virtual keys
switch (virtualKey & 0xffu) {
case VK_NUMLOCK:
case VK_RCONTROL:
case VK_RMENU:
case VK_LWIN:
case VK_RWIN:
case VK_APPS:
return true;
default:
return false;
}
}
void
CMSWindowsSecondaryScreen::fakeKeyEvent(UINT virtualKey, bool press) const
{
DWORD flags = 0;
if (isExtendedKey(virtualKey)) {
flags |= KEYEVENTF_EXTENDEDKEY;
}
if (!press) {
flags |= KEYEVENTF_KEYUP;
}
const UINT code = virtualKeyToScanCode(virtualKey);
keybd_event(static_cast<BYTE>(virtualKey & 0xff),
static_cast<BYTE>(code), flags, 0);
}
void
CMSWindowsSecondaryScreen::fakeMouseButton(ButtonID button, bool press) const
{
// map button id to button flag
DWORD data;
DWORD flags = mapButton(button, press, &data);
// send event
if (flags != 0) {
mouse_event(flags, 0, 0, data, 0);
}
}
void
CMSWindowsSecondaryScreen::fakeMouseMove(SInt32 x, SInt32 y) const
{
// motion is simple (i.e. it's on the primary monitor) if there
// is only one monitor.
bool simple = !m_screen->isMultimon();
if (!simple) {
// also simple if motion is within the primary monitor
simple = (x >= 0 && x < GetSystemMetrics(SM_CXSCREEN) &&
y >= 0 && y < GetSystemMetrics(SM_CYSCREEN));
}
// move the mouse directly to target position if motion is simple
if (simple) {
// when using absolute positioning with mouse_event(),
// the normalized device coordinates range over only
// the primary screen.
SInt32 w = GetSystemMetrics(SM_CXSCREEN);
SInt32 h = GetSystemMetrics(SM_CYSCREEN);
mouse_event(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
(DWORD)((65536.0 * x) / w),
(DWORD)((65536.0 * y) / h),
0, 0);
}
// windows 98 (and Me?) is broken. you cannot set the absolute
// position of the mouse except on the primary monitor but you
// can do relative moves onto any monitor. this is, in microsoft's
// words, "by design." apparently the designers of windows 2000
// we're a little less lazy and did it right.
//
// microsoft recommends in Q193003 to absolute position the cursor
// somewhere on the primary monitor then relative move to the
// desired location. this doesn't work for us because when the
// user drags a scrollbar, a window, etc. it causes the dragged
// item to jump back a forth between the position on the primary
// monitor and the desired position. while it always ends up in
// the right place, the effect is disconcerting.
//
// instead we'll get the cursor's current position and do just a
// relative move from there to the desired position. relative
// moves are subject to cursor acceleration which we don't want.
// so we disable acceleration, do the relative move, then restore
// acceleration. there's a slight chance we'll end up in the
// wrong place if the user moves the cursor using this system's
// mouse while simultaneously moving the mouse on the server
// system. that defeats the purpose of synergy so we'll assume
// that won't happen. even if it does, the next mouse move will
// correct the position.
else {
// save mouse speed & acceleration
int oldSpeed[4];
bool accelChanged =
SystemParametersInfo(SPI_GETMOUSE,0, oldSpeed, 0) &&
SystemParametersInfo(SPI_GETMOUSESPEED, 0, oldSpeed + 3, 0);
// use 1:1 motion
if (accelChanged) {
int newSpeed[4] = { 0, 0, 0, 1 };
accelChanged =
SystemParametersInfo(SPI_SETMOUSE, 0, newSpeed, 0) ||
SystemParametersInfo(SPI_SETMOUSESPEED, 0, newSpeed + 3, 0);
}
// get current mouse position
POINT pos;
GetCursorPos(&pos);
// move relative to mouse position
mouse_event(MOUSEEVENTF_MOVE, x - pos.x, y - pos.y, 0, 0);
// restore mouse speed & acceleration
if (accelChanged) {
SystemParametersInfo(SPI_SETMOUSE, 0, oldSpeed, 0);
SystemParametersInfo(SPI_SETMOUSESPEED, 0, oldSpeed + 3, 0);
}
}
}
void
CMSWindowsSecondaryScreen::fakeMouseWheel(SInt32 delta)
{
mouse_event(MOUSEEVENTF_WHEEL, 0, 0, delta, 0);
}
UINT
CMSWindowsSecondaryScreen::getCodePageFromLangID(LANGID langid) const
{
// construct a locale id from the language id
LCID lcid = MAKELCID(langid, SORT_DEFAULT);
// get the ANSI code page for this locale
char data[6];
if (GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, data, 6) == 0) {
// can't get code page
LOG((CLOG_DEBUG1 "can't find code page for langid 0x%04x", langid));
return CP_ACP;
}
// convert stringified code page into a number
UINT codePage = static_cast<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;
}
bool
CMSWindowsSecondaryScreen::synthesizeCtrlAltDel(EKeyAction action)
{
// ignore except for key press
if (action != kPress) {
return true;
}
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, we
// 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(
&CMSWindowsSecondaryScreen::ctrlAltDelThread));
cad.wait();
}
else {
Keystrokes keys;
UINT virtualKey;
KeyID key = kKeyDelete;
KeyModifierMask mask = KeyModifierControl | KeyModifierAlt;
// get the sequence of keys to simulate ctrl+alt+del
mapKey(keys, virtualKey, key, mask, kPress);
if (!keys.empty()) {
// generate key events
doKeystrokes(keys, 1);
}
}
return true;
}
void
CMSWindowsSecondaryScreen::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()));
}
}
Reference in New Issue View Git Blame Copy Permalink