397 lines
13 KiB
Plaintext
397 lines
13 KiB
Plaintext
#import "InputHandler.h"
|
|
#import "Permissions.h"
|
|
#import <Cocoa/Cocoa.h>
|
|
#import <Carbon/Carbon.h>
|
|
#include <unistd.h> // for usleep
|
|
|
|
InputHandler::InputHandler()
|
|
: m_lastMousePos(CGPointZero)
|
|
{
|
|
// atomic members are initialized in class declaration
|
|
}
|
|
|
|
InputHandler::~InputHandler()
|
|
{
|
|
}
|
|
|
|
bool InputHandler::init()
|
|
{
|
|
m_hasPermission = Permissions::checkAccessibility();
|
|
if (!m_hasPermission) {
|
|
NSLog(@"InputHandler: Accessibility permission not granted");
|
|
// Request permission (shows system dialog)
|
|
Permissions::requestAccessibility();
|
|
}
|
|
return m_hasPermission;
|
|
}
|
|
|
|
void InputHandler::handleInputEvent(const MSG64_MAC* msg)
|
|
{
|
|
if (!m_hasPermission) {
|
|
// Re-check permission
|
|
m_hasPermission = Permissions::checkAccessibility();
|
|
if (!m_hasPermission) {
|
|
if (!m_warningLogged) {
|
|
NSLog(@"InputHandler: Cannot handle input - no accessibility permission");
|
|
m_warningLogged = true;
|
|
}
|
|
return;
|
|
}
|
|
m_warningLogged = false;
|
|
}
|
|
|
|
uint32_t message = (uint32_t)msg->message;
|
|
// Extract coordinates from lParam (MAKELPARAM format: low=x, high=y)
|
|
int x = (int)(msg->lParam & 0xFFFF);
|
|
int y = (int)((msg->lParam >> 16) & 0xFFFF);
|
|
|
|
switch (message) {
|
|
// Mouse movement
|
|
case WM_MOUSEMOVE:
|
|
handleMouseMove(x, y);
|
|
break;
|
|
|
|
// Left button
|
|
case WM_LBUTTONDOWN:
|
|
handleMouseButton(kCGMouseButtonLeft, true, x, y);
|
|
break;
|
|
case WM_LBUTTONUP:
|
|
handleMouseButton(kCGMouseButtonLeft, false, x, y);
|
|
break;
|
|
case WM_LBUTTONDBLCLK:
|
|
handleMouseDoubleClick(kCGMouseButtonLeft, x, y);
|
|
break;
|
|
|
|
// Right button
|
|
case WM_RBUTTONDOWN:
|
|
handleMouseButton(kCGMouseButtonRight, true, x, y);
|
|
break;
|
|
case WM_RBUTTONUP:
|
|
handleMouseButton(kCGMouseButtonRight, false, x, y);
|
|
break;
|
|
case WM_RBUTTONDBLCLK:
|
|
handleMouseDoubleClick(kCGMouseButtonRight, x, y);
|
|
break;
|
|
|
|
// Middle button
|
|
case WM_MBUTTONDOWN:
|
|
handleMouseButton(kCGMouseButtonCenter, true, x, y);
|
|
break;
|
|
case WM_MBUTTONUP:
|
|
handleMouseButton(kCGMouseButtonCenter, false, x, y);
|
|
break;
|
|
case WM_MBUTTONDBLCLK:
|
|
handleMouseDoubleClick(kCGMouseButtonCenter, x, y);
|
|
break;
|
|
|
|
// Mouse wheel
|
|
case WM_MOUSEWHEEL: {
|
|
short delta = GET_WHEEL_DELTA_WPARAM(msg->wParam);
|
|
handleMouseWheel(delta);
|
|
break;
|
|
}
|
|
|
|
// Keyboard
|
|
case WM_KEYDOWN:
|
|
case WM_SYSKEYDOWN:
|
|
handleKeyEvent((uint32_t)msg->wParam, true);
|
|
break;
|
|
|
|
case WM_KEYUP:
|
|
case WM_SYSKEYUP:
|
|
handleKeyEvent((uint32_t)msg->wParam, false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void InputHandler::handleMouseMove(int x, int y)
|
|
{
|
|
CGPoint point = CGPointMake(x, y);
|
|
m_lastMousePos = point;
|
|
|
|
CGEventType eventType = kCGEventMouseMoved;
|
|
CGMouseButton button = kCGMouseButtonLeft;
|
|
|
|
// If button is held, use drag event
|
|
if (m_leftButtonDown) {
|
|
eventType = kCGEventLeftMouseDragged;
|
|
button = kCGMouseButtonLeft;
|
|
} else if (m_rightButtonDown) {
|
|
eventType = kCGEventRightMouseDragged;
|
|
button = kCGMouseButtonRight;
|
|
} else if (m_middleButtonDown) {
|
|
eventType = kCGEventOtherMouseDragged;
|
|
button = kCGMouseButtonCenter;
|
|
}
|
|
|
|
CGEventRef event = CGEventCreateMouseEvent(NULL, eventType, point, button);
|
|
if (event) {
|
|
CGEventPost(kCGHIDEventTap, event);
|
|
CFRelease(event);
|
|
}
|
|
}
|
|
|
|
void InputHandler::handleMouseButton(CGMouseButton button, bool down, int x, int y)
|
|
{
|
|
CGPoint point = CGPointMake(x, y);
|
|
m_lastMousePos = point;
|
|
|
|
CGEventType eventType;
|
|
|
|
switch (button) {
|
|
case kCGMouseButtonLeft:
|
|
eventType = down ? kCGEventLeftMouseDown : kCGEventLeftMouseUp;
|
|
m_leftButtonDown = down;
|
|
break;
|
|
case kCGMouseButtonRight:
|
|
eventType = down ? kCGEventRightMouseDown : kCGEventRightMouseUp;
|
|
m_rightButtonDown = down;
|
|
break;
|
|
case kCGMouseButtonCenter:
|
|
default:
|
|
eventType = down ? kCGEventOtherMouseDown : kCGEventOtherMouseUp;
|
|
m_middleButtonDown = down;
|
|
break;
|
|
}
|
|
|
|
CGEventRef event = CGEventCreateMouseEvent(NULL, eventType, point, button);
|
|
if (event) {
|
|
// clickState=1 for all single clicks
|
|
CGEventSetIntegerValueField(event, kCGMouseEventClickState, 1);
|
|
CGEventPost(kCGHIDEventTap, event);
|
|
CFRelease(event);
|
|
}
|
|
}
|
|
|
|
void InputHandler::handleMouseDoubleClick(CGMouseButton button, int x, int y)
|
|
{
|
|
// WM_LBUTTONDBLCLK represents the second click of a double-click.
|
|
// The first click was already sent via WM_LBUTTONDOWN/WM_LBUTTONUP.
|
|
//
|
|
// We send complete down(2) + up(2) here because:
|
|
// - Web client: dblclick fires AFTER mouseup, no subsequent WM_LBUTTONUP
|
|
// - MFC client: WM_LBUTTONUP follows, but extra up(1) is harmless
|
|
|
|
CGPoint point = CGPointMake(x, y);
|
|
m_lastMousePos = point;
|
|
|
|
CGEventType downType, upType;
|
|
|
|
switch (button) {
|
|
case kCGMouseButtonLeft:
|
|
downType = kCGEventLeftMouseDown;
|
|
upType = kCGEventLeftMouseUp;
|
|
break;
|
|
case kCGMouseButtonRight:
|
|
downType = kCGEventRightMouseDown;
|
|
upType = kCGEventRightMouseUp;
|
|
break;
|
|
case kCGMouseButtonCenter:
|
|
default:
|
|
downType = kCGEventOtherMouseDown;
|
|
upType = kCGEventOtherMouseUp;
|
|
break;
|
|
}
|
|
|
|
// Send second click: down(2) + up(2)
|
|
CGEventRef down = CGEventCreateMouseEvent(NULL, downType, point, button);
|
|
CGEventRef up = CGEventCreateMouseEvent(NULL, upType, point, button);
|
|
|
|
if (down) {
|
|
CGEventSetIntegerValueField(down, kCGMouseEventClickState, 2);
|
|
CGEventPost(kCGHIDEventTap, down);
|
|
CFRelease(down);
|
|
}
|
|
|
|
if (up) {
|
|
CGEventSetIntegerValueField(up, kCGMouseEventClickState, 2);
|
|
CGEventPost(kCGHIDEventTap, up);
|
|
CFRelease(up);
|
|
}
|
|
|
|
// Note: For MFC client, an extra WM_LBUTTONUP will follow (sending up(1)),
|
|
// but this is harmless since mouse is already up.
|
|
}
|
|
|
|
void InputHandler::handleMouseWheel(int delta)
|
|
{
|
|
// Convert Windows wheel delta (120 = one notch) to macOS pixel units
|
|
// Using pixel units provides smoother scrolling than line units
|
|
// Windows: 120 = one standard notch
|
|
// macOS: approximately 10 pixels per notch feels natural
|
|
int32_t scrollAmount = (delta * 10) / 120;
|
|
|
|
// Use pixel units for smoother scrolling experience
|
|
CGEventRef event = CGEventCreateScrollWheelEvent(
|
|
NULL,
|
|
kCGScrollEventUnitPixel,
|
|
1,
|
|
scrollAmount
|
|
);
|
|
if (event) {
|
|
CGEventPost(kCGHIDEventTap, event);
|
|
CFRelease(event);
|
|
}
|
|
}
|
|
|
|
void InputHandler::handleKeyEvent(uint32_t vkCode, bool down)
|
|
{
|
|
CGKeyCode keyCode = vkToMacKeyCode(vkCode);
|
|
if (keyCode == 0xFF) {
|
|
return; // Unknown key
|
|
}
|
|
|
|
// Update modifier flags based on key
|
|
CGEventFlags flag = 0;
|
|
switch (keyCode) {
|
|
case kVK_Shift:
|
|
case kVK_RightShift:
|
|
flag = kCGEventFlagMaskShift;
|
|
break;
|
|
case kVK_Control:
|
|
case kVK_RightControl:
|
|
flag = kCGEventFlagMaskControl;
|
|
break;
|
|
case kVK_Option:
|
|
case kVK_RightOption:
|
|
flag = kCGEventFlagMaskAlternate;
|
|
break;
|
|
case kVK_Command:
|
|
case kVK_RightCommand:
|
|
flag = kCGEventFlagMaskCommand;
|
|
break;
|
|
case kVK_CapsLock:
|
|
flag = kCGEventFlagMaskAlphaShift;
|
|
break;
|
|
}
|
|
|
|
if (flag) {
|
|
CGEventFlags current = m_modifierFlags.load();
|
|
if (down) {
|
|
m_modifierFlags.store(current | flag);
|
|
} else {
|
|
m_modifierFlags.store(current & ~flag);
|
|
}
|
|
}
|
|
|
|
CGEventRef event = CGEventCreateKeyboardEvent(NULL, keyCode, down);
|
|
if (event) {
|
|
// Set current modifier flags to ensure proper key combinations
|
|
CGEventSetFlags(event, m_modifierFlags.load());
|
|
CGEventPost(kCGHIDEventTap, event);
|
|
CFRelease(event);
|
|
}
|
|
}
|
|
|
|
// Convert Windows VK code to macOS key code
|
|
// Reference: Carbon/HIToolbox/Events.h
|
|
CGKeyCode InputHandler::vkToMacKeyCode(uint32_t vk)
|
|
{
|
|
// Letters A-Z (VK 0x41-0x5A)
|
|
if (vk >= 0x41 && vk <= 0x5A) {
|
|
// macOS key codes for A-Z are not sequential
|
|
static const CGKeyCode letterKeys[] = {
|
|
kVK_ANSI_A, kVK_ANSI_B, kVK_ANSI_C, kVK_ANSI_D, kVK_ANSI_E,
|
|
kVK_ANSI_F, kVK_ANSI_G, kVK_ANSI_H, kVK_ANSI_I, kVK_ANSI_J,
|
|
kVK_ANSI_K, kVK_ANSI_L, kVK_ANSI_M, kVK_ANSI_N, kVK_ANSI_O,
|
|
kVK_ANSI_P, kVK_ANSI_Q, kVK_ANSI_R, kVK_ANSI_S, kVK_ANSI_T,
|
|
kVK_ANSI_U, kVK_ANSI_V, kVK_ANSI_W, kVK_ANSI_X, kVK_ANSI_Y,
|
|
kVK_ANSI_Z
|
|
};
|
|
return letterKeys[vk - 0x41];
|
|
}
|
|
|
|
// Numbers 0-9 (VK 0x30-0x39)
|
|
if (vk >= 0x30 && vk <= 0x39) {
|
|
static const CGKeyCode numberKeys[] = {
|
|
kVK_ANSI_0, kVK_ANSI_1, kVK_ANSI_2, kVK_ANSI_3, kVK_ANSI_4,
|
|
kVK_ANSI_5, kVK_ANSI_6, kVK_ANSI_7, kVK_ANSI_8, kVK_ANSI_9
|
|
};
|
|
return numberKeys[vk - 0x30];
|
|
}
|
|
|
|
// Numpad 0-9 (VK 0x60-0x69)
|
|
if (vk >= 0x60 && vk <= 0x69) {
|
|
static const CGKeyCode numpadKeys[] = {
|
|
kVK_ANSI_Keypad0, kVK_ANSI_Keypad1, kVK_ANSI_Keypad2,
|
|
kVK_ANSI_Keypad3, kVK_ANSI_Keypad4, kVK_ANSI_Keypad5,
|
|
kVK_ANSI_Keypad6, kVK_ANSI_Keypad7, kVK_ANSI_Keypad8,
|
|
kVK_ANSI_Keypad9
|
|
};
|
|
return numpadKeys[vk - 0x60];
|
|
}
|
|
|
|
// F1-F12 (VK 0x70-0x7B)
|
|
if (vk >= 0x70 && vk <= 0x7B) {
|
|
static const CGKeyCode fKeys[] = {
|
|
kVK_F1, kVK_F2, kVK_F3, kVK_F4, kVK_F5, kVK_F6,
|
|
kVK_F7, kVK_F8, kVK_F9, kVK_F10, kVK_F11, kVK_F12
|
|
};
|
|
return fKeys[vk - 0x70];
|
|
}
|
|
|
|
// Special keys
|
|
switch (vk) {
|
|
case 0x08: return kVK_Delete; // VK_BACK (Backspace)
|
|
case 0x09: return kVK_Tab; // VK_TAB
|
|
case 0x0D: return kVK_Return; // VK_RETURN
|
|
case 0x10: return kVK_Shift; // VK_SHIFT
|
|
case 0x11: return kVK_Control; // VK_CONTROL
|
|
case 0x12: return kVK_Option; // VK_MENU (Alt -> Option)
|
|
case 0x13: return kVK_F15; // VK_PAUSE (no direct equivalent)
|
|
case 0x14: return kVK_CapsLock; // VK_CAPITAL
|
|
case 0x1B: return kVK_Escape; // VK_ESCAPE
|
|
case 0x20: return kVK_Space; // VK_SPACE
|
|
case 0x21: return kVK_PageUp; // VK_PRIOR
|
|
case 0x22: return kVK_PageDown; // VK_NEXT
|
|
case 0x23: return kVK_End; // VK_END
|
|
case 0x24: return kVK_Home; // VK_HOME
|
|
case 0x25: return kVK_LeftArrow; // VK_LEFT
|
|
case 0x26: return kVK_UpArrow; // VK_UP
|
|
case 0x27: return kVK_RightArrow; // VK_RIGHT
|
|
case 0x28: return kVK_DownArrow; // VK_DOWN
|
|
case 0x2C: return kVK_F13; // VK_SNAPSHOT (PrintScreen)
|
|
case 0x2D: return kVK_Help; // VK_INSERT (Help on Mac)
|
|
case 0x2E: return kVK_ForwardDelete; // VK_DELETE
|
|
|
|
// Windows keys -> Command
|
|
case 0x5B: return kVK_Command; // VK_LWIN
|
|
case 0x5C: return kVK_RightCommand; // VK_RWIN
|
|
|
|
// Numpad operators
|
|
case 0x6A: return kVK_ANSI_KeypadMultiply; // VK_MULTIPLY
|
|
case 0x6B: return kVK_ANSI_KeypadPlus; // VK_ADD
|
|
case 0x6D: return kVK_ANSI_KeypadMinus; // VK_SUBTRACT
|
|
case 0x6E: return kVK_ANSI_KeypadDecimal; // VK_DECIMAL
|
|
case 0x6F: return kVK_ANSI_KeypadDivide; // VK_DIVIDE
|
|
|
|
// Lock keys
|
|
case 0x90: return kVK_ANSI_KeypadClear; // VK_NUMLOCK (Clear on Mac)
|
|
case 0x91: return kVK_F14; // VK_SCROLL
|
|
|
|
// Shift variants
|
|
case 0xA0: return kVK_Shift; // VK_LSHIFT
|
|
case 0xA1: return kVK_RightShift; // VK_RSHIFT
|
|
case 0xA2: return kVK_Control; // VK_LCONTROL
|
|
case 0xA3: return kVK_RightControl; // VK_RCONTROL
|
|
case 0xA4: return kVK_Option; // VK_LMENU
|
|
case 0xA5: return kVK_RightOption; // VK_RMENU
|
|
|
|
// OEM keys (US keyboard layout)
|
|
case 0xBA: return kVK_ANSI_Semicolon; // VK_OEM_1 (;:)
|
|
case 0xBB: return kVK_ANSI_Equal; // VK_OEM_PLUS (=+)
|
|
case 0xBC: return kVK_ANSI_Comma; // VK_OEM_COMMA (,<)
|
|
case 0xBD: return kVK_ANSI_Minus; // VK_OEM_MINUS (-_)
|
|
case 0xBE: return kVK_ANSI_Period; // VK_OEM_PERIOD (.>)
|
|
case 0xBF: return kVK_ANSI_Slash; // VK_OEM_2 (/?)
|
|
case 0xC0: return kVK_ANSI_Grave; // VK_OEM_3 (`~)
|
|
case 0xDB: return kVK_ANSI_LeftBracket; // VK_OEM_4 ([{)
|
|
case 0xDC: return kVK_ANSI_Backslash; // VK_OEM_5 (\|)
|
|
case 0xDD: return kVK_ANSI_RightBracket; // VK_OEM_6 (]})
|
|
case 0xDE: return kVK_ANSI_Quote; // VK_OEM_7 ('")
|
|
|
|
default:
|
|
return 0xFF; // Unknown key
|
|
}
|
|
}
|