static __inline void process_key_pressed(uint64_t timestamp, KBDLLHOOKSTRUCT *kbhook) {
// Check and setup modifiers.
if (kbhook->vkCode == VK_LSHIFT) { set_modifier_mask(MASK_SHIFT_L); }
else if (kbhook->vkCode == VK_RSHIFT) { set_modifier_mask(MASK_SHIFT_R); }
else if (kbhook->vkCode == VK_LCONTROL) { set_modifier_mask(MASK_CTRL_L); }
else if (kbhook->vkCode == VK_RCONTROL) { set_modifier_mask(MASK_CTRL_R); }
else if (kbhook->vkCode == VK_LMENU) { set_modifier_mask(MASK_ALT_L); }
else if (kbhook->vkCode == VK_RMENU) { set_modifier_mask(MASK_ALT_R); }
else if (kbhook->vkCode == VK_LWIN) { set_modifier_mask(MASK_META_L); }
else if (kbhook->vkCode == VK_RWIN) { set_modifier_mask(MASK_META_R); }
// Populate key pressed event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_KEY_PRESSED;
event.mask = get_modifiers();
event.data.keyboard.keycode = keycode_to_scancode(kbhook->vkCode);
event.data.keyboard.rawcode = kbhook->vkCode;
event.data.keyboard.keychar = CHAR_UNDEFINED;
logger(LOG_LEVEL_INFO, "%s [%u]: Key %#X pressed. (%#X)\n",
__FUNCTION__, __LINE__, event.data.keyboard.keycode, event.data.keyboard.rawcode);
if (wants_to_hook_event(EVENT_KEY_PRESSED)){
// Populate key pressed event.
dispatch_event(&event);
}
if (!wants_to_hook_event(EVENT_KEY_TYPED))
return;
// If the pressed event was not consumed...
if (event.reserved ^ 0x01) {
// Buffer for unicode typed chars. No more than 2 needed.
WCHAR buffer[2]; // = { WCH_NONE };
// If the pressed event was not consumed and a unicode char exists...
SIZE_T count = keycode_to_unicode(kbhook->vkCode, buffer, sizeof(buffer));
for (unsigned int i = 0; i < count; i++) {
// Populate key typed event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_KEY_TYPED;
event.mask = get_modifiers();
event.data.keyboard.keycode = keycode_to_scancode(kbhook->vkCode);
event.data.keyboard.rawcode = kbhook->vkCode;
event.data.keyboard.keychar = buffer[i];
logger(LOG_LEVEL_INFO, "%s [%u]: Key %#X typed. (%lc)\n",
__FUNCTION__, __LINE__, event.data.keyboard.keycode, (wint_t) event.data.keyboard.keychar);
// Fire key typed event.
dispatch_event(&event);
}
}
}
void initialize_modifiers() {
current_modifiers = 0x0000;
if (GetKeyState(VK_LSHIFT) < 0) { set_modifier_mask(MASK_SHIFT_L); }
if (GetKeyState(VK_RSHIFT) < 0) { set_modifier_mask(MASK_SHIFT_R); }
if (GetKeyState(VK_LCONTROL) < 0) { set_modifier_mask(MASK_CTRL_L); }
if (GetKeyState(VK_RCONTROL) < 0) { set_modifier_mask(MASK_CTRL_R); }
if (GetKeyState(VK_LMENU) < 0) { set_modifier_mask(MASK_ALT_L); }
if (GetKeyState(VK_RMENU) < 0) { set_modifier_mask(MASK_ALT_R); }
if (GetKeyState(VK_LWIN) < 0) { set_modifier_mask(MASK_META_L); }
if (GetKeyState(VK_RWIN) < 0) { set_modifier_mask(MASK_META_R); }
}
// Initialize the modifier lock masks.
static void initialize_locks() {
#ifdef USE_XKBCOMMON
if (xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS)) {
set_modifier_mask(MASK_CAPS_LOCK);
}
else {
unset_modifier_mask(MASK_CAPS_LOCK);
}
if (xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM)) {
set_modifier_mask(MASK_NUM_LOCK);
}
else {
unset_modifier_mask(MASK_NUM_LOCK);
}
if (xkb_state_led_name_is_active(state, XKB_LED_NAME_SCROLL)) {
set_modifier_mask(MASK_SCROLL_LOCK);
}
else {
unset_modifier_mask(MASK_SCROLL_LOCK);
}
#else
unsigned int led_mask = 0x00;
if (XkbGetIndicatorState(hook->ctrl.display, XkbUseCoreKbd, &led_mask) == Success) {
if (led_mask & 0x01) {
set_modifier_mask(MASK_CAPS_LOCK);
}
else {
unset_modifier_mask(MASK_CAPS_LOCK);
}
if (led_mask & 0x02) {
set_modifier_mask(MASK_NUM_LOCK);
}
else {
unset_modifier_mask(MASK_NUM_LOCK);
}
if (led_mask & 0x04) {
set_modifier_mask(MASK_SCROLL_LOCK);
}
else {
unset_modifier_mask(MASK_SCROLL_LOCK);
}
}
else {
logger(LOG_LEVEL_WARN, "%s [%u]: XkbGetIndicatorState failed to get current led mask!\n",
__FUNCTION__, __LINE__);
}
#endif
}
LRESULT CALLBACK mouse_hook_event_proc(int nCode, WPARAM wParam, LPARAM lParam) {
// Calculate Unix epoch from native time source.
uint64_t timestamp = get_event_timestamp();
MSLLHOOKSTRUCT *mshook = (MSLLHOOKSTRUCT *) lParam;
switch (wParam) {
case WM_LBUTTONDOWN:
set_modifier_mask(MASK_BUTTON1);
process_button_pressed(timestamp, mshook, MOUSE_BUTTON1);
break;
case WM_RBUTTONDOWN:
set_modifier_mask(MASK_BUTTON2);
process_button_pressed(timestamp, mshook, MOUSE_BUTTON2);
break;
case WM_MBUTTONDOWN:
set_modifier_mask(MASK_BUTTON3);
process_button_pressed(timestamp, mshook, MOUSE_BUTTON3);
break;
case WM_XBUTTONDOWN:
case WM_NCXBUTTONDOWN:
if (HIWORD(mshook->mouseData) == XBUTTON1) {
set_modifier_mask(MASK_BUTTON4);
process_button_pressed(timestamp, mshook, MOUSE_BUTTON4);
}
else if (HIWORD(mshook->mouseData) == XBUTTON2) {
set_modifier_mask(MASK_BUTTON5);
process_button_pressed(timestamp, mshook, MOUSE_BUTTON5);
}
else {
// Extra mouse buttons.
uint16_t button = HIWORD(mshook->mouseData);
// Add support for mouse 4 & 5.
if (button == 4) {
set_modifier_mask(MOUSE_BUTTON4);
}
else if (button == 5) {
set_modifier_mask(MOUSE_BUTTON5);
}
process_button_pressed(timestamp, mshook, button);
}
break;
case WM_LBUTTONUP:
unset_modifier_mask(MASK_BUTTON1);
process_button_released(timestamp, mshook, MOUSE_BUTTON1);
break;
case WM_RBUTTONUP:
unset_modifier_mask(MASK_BUTTON2);
process_button_released(timestamp, mshook, MOUSE_BUTTON2);
break;
case WM_MBUTTONUP:
unset_modifier_mask(MASK_BUTTON3);
process_button_released(timestamp, mshook, MOUSE_BUTTON3);
break;
case WM_XBUTTONUP:
case WM_NCXBUTTONUP:
if (HIWORD(mshook->mouseData) == XBUTTON1) {
unset_modifier_mask(MASK_BUTTON4);
process_button_released(timestamp, mshook, MOUSE_BUTTON4);
}
else if (HIWORD(mshook->mouseData) == XBUTTON2) {
unset_modifier_mask(MASK_BUTTON5);
process_button_released(timestamp, mshook, MOUSE_BUTTON5);
}
else {
// Extra mouse buttons.
uint16_t button = HIWORD(mshook->mouseData);
// Add support for mouse 4 & 5.
if (button == 4) {
unset_modifier_mask(MOUSE_BUTTON4);
}
else if (button == 5) {
unset_modifier_mask(MOUSE_BUTTON5);
}
process_button_released(timestamp, mshook, MOUSE_BUTTON5);
}
break;
case WM_MOUSEMOVE:
process_mouse_moved(timestamp, mshook);
break;
case WM_MOUSEWHEEL:
process_mouse_wheel(timestamp, mshook);
break;
/* For horizontal scroll wheel support.
* NOTE Windows >= Vista
* case 0x020E:
case WM_MOUSEHWHEEL:
process_mouse_wheel(timestamp, mshook);
break;
*/
default:
// In theory this *should* never execute.
logger(LOG_LEVEL_WARN, "%s [%u]: Unhandled Windows mouse event! (%#X)\n",
__FUNCTION__, __LINE__, (unsigned int) wParam);
break;
}
LRESULT hook_result = -1;
if (nCode < 0 || event.reserved ^ 0x01) {
hook_result = CallNextHookEx(mouse_event_hhook, nCode, wParam, lParam);
}
else {
logger(LOG_LEVEL_DEBUG, "%s [%u]: Consuming the current event. (%li)\n",
__FUNCTION__, __LINE__, (long) hook_result);
}
return hook_result;
}
// Initialize the modifier mask to the current modifiers.
static void initialize_modifiers() {
current_modifiers = 0x0000;
// NOTE We are checking the high order bit, so it will be < 0 for a singed short.
if (GetKeyState(VK_LSHIFT) < 0) { set_modifier_mask(MASK_SHIFT_L); }
if (GetKeyState(VK_RSHIFT) < 0) { set_modifier_mask(MASK_SHIFT_R); }
if (GetKeyState(VK_LCONTROL) < 0) { set_modifier_mask(MASK_CTRL_L); }
if (GetKeyState(VK_RCONTROL) < 0) { set_modifier_mask(MASK_CTRL_R); }
if (GetKeyState(VK_LMENU) < 0) { set_modifier_mask(MASK_ALT_L); }
if (GetKeyState(VK_RMENU) < 0) { set_modifier_mask(MASK_ALT_R); }
if (GetKeyState(VK_LWIN) < 0) { set_modifier_mask(MASK_META_L); }
if (GetKeyState(VK_RWIN) < 0) { set_modifier_mask(MASK_META_R); }
if (GetKeyState(VK_LBUTTON) < 0) { set_modifier_mask(MASK_BUTTON1); }
if (GetKeyState(VK_RBUTTON) < 0) { set_modifier_mask(MASK_BUTTON2); }
if (GetKeyState(VK_MBUTTON) < 0) { set_modifier_mask(MASK_BUTTON3); }
if (GetKeyState(VK_XBUTTON1) < 0) { set_modifier_mask(MASK_BUTTON4); }
if (GetKeyState(VK_XBUTTON2) < 0) { set_modifier_mask(MASK_BUTTON5); }
if (GetKeyState(VK_NUMLOCK) < 0) { set_modifier_mask(MASK_NUM_LOCK); }
if (GetKeyState(VK_CAPITAL) < 0) { set_modifier_mask(MASK_CAPS_LOCK); }
if (GetKeyState(VK_SCROLL) < 0) { set_modifier_mask(MASK_SCROLL_LOCK); }
}
void hook_event_proc(XPointer closeure, XRecordInterceptData *recorded_data) {
uint64_t timestamp = (uint64_t) recorded_data->server_time;
if (recorded_data->category == XRecordStartOfData) {
// Populate the hook start event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_HOOK_ENABLED;
event.mask = 0x00;
// Fire the hook start event.
dispatch_event(&event);
}
else if (recorded_data->category == XRecordEndOfData) {
// Populate the hook stop event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_HOOK_DISABLED;
event.mask = 0x00;
// Fire the hook stop event.
dispatch_event(&event);
}
else if (recorded_data->category == XRecordFromServer || recorded_data->category == XRecordFromClient) {
// Get XRecord data.
XRecordDatum *data = (XRecordDatum *) recorded_data->data;
if (data->type == KeyPress) {
// The X11 KeyCode associated with this event.
KeyCode keycode = (KeyCode) data->event.u.u.detail;
KeySym keysym = 0x00;
#if defined(USE_XKBCOMMON)
if (state != NULL) {
keysym = xkb_state_key_get_one_sym(state, keycode);
}
#else
keysym = keycode_to_keysym(keycode, data->event.u.keyButtonPointer.state);
#endif
unsigned short int scancode = keycode_to_scancode(keycode);
// TODO If you have a better suggestion for this ugly, let me know.
if (scancode == VC_SHIFT_L) { set_modifier_mask(MASK_SHIFT_L); }
else if (scancode == VC_SHIFT_R) { set_modifier_mask(MASK_SHIFT_R); }
else if (scancode == VC_CONTROL_L) { set_modifier_mask(MASK_CTRL_L); }
else if (scancode == VC_CONTROL_R) { set_modifier_mask(MASK_CTRL_R); }
else if (scancode == VC_ALT_L) { set_modifier_mask(MASK_ALT_L); }
else if (scancode == VC_ALT_R) { set_modifier_mask(MASK_ALT_R); }
else if (scancode == VC_META_L) { set_modifier_mask(MASK_META_L); }
else if (scancode == VC_META_R) { set_modifier_mask(MASK_META_R); }
xkb_state_update_key(state, keycode, XKB_KEY_DOWN);
initialize_locks();
if ((get_modifiers() & MASK_NUM_LOCK) == 0) {
switch (scancode) {
case VC_KP_SEPARATOR:
case VC_KP_1:
case VC_KP_2:
case VC_KP_3:
case VC_KP_4:
case VC_KP_5:
case VC_KP_6:
case VC_KP_7:
case VC_KP_8:
case VC_KP_0:
case VC_KP_9:
scancode |= 0xEE00;
break;
}
}
// Populate key pressed event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_KEY_PRESSED;
event.mask = get_modifiers();
event.data.keyboard.keycode = scancode;
event.data.keyboard.rawcode = keysym;
event.data.keyboard.keychar = CHAR_UNDEFINED;
logger(LOG_LEVEL_INFO, "%s [%u]: Key %#X pressed. (%#X)\n",
__FUNCTION__, __LINE__, event.data.keyboard.keycode, event.data.keyboard.rawcode);
// Fire key pressed event.
dispatch_event(&event);
// If the pressed event was not consumed...
if (event.reserved ^ 0x01) {
uint16_t buffer[2];
size_t count = 0;
// Check to make sure the key is printable.
#ifdef USE_XKBCOMMON
if (state != NULL) {
count = keycode_to_unicode(state, keycode, buffer, sizeof(buffer) / sizeof(uint16_t));
}
#else
count = keysym_to_unicode(keysym, buffer, sizeof(buffer) / sizeof(uint16_t));
#endif
for (unsigned int i = 0; i < count; i++) {
// Populate key typed event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_KEY_TYPED;
event.mask = get_modifiers();
event.data.keyboard.keycode = VC_UNDEFINED;
event.data.keyboard.rawcode = keysym;
event.data.keyboard.keychar = buffer[i];
logger(LOG_LEVEL_INFO, "%s [%u]: Key %#X typed. (%lc)\n",
__FUNCTION__, __LINE__, event.data.keyboard.keycode, (uint16_t) event.data.keyboard.keychar);
// Fire key typed event.
dispatch_event(&event);
}
}
}
else if (data->type == KeyRelease) {
// The X11 KeyCode associated with this event.
KeyCode keycode = (KeyCode) data->event.u.u.detail;
KeySym keysym = 0x00;
#ifdef USE_XKBCOMMON
if (state != NULL) {
keysym = xkb_state_key_get_one_sym(state, keycode);
}
#else
keysym = keycode_to_keysym(keycode, data->event.u.keyButtonPointer.state);
#endif
unsigned short int scancode = keycode_to_scancode(keycode);
// TODO If you have a better suggestion for this ugly, let me know.
if (scancode == VC_SHIFT_L) { unset_modifier_mask(MASK_SHIFT_L); }
else if (scancode == VC_SHIFT_R) { unset_modifier_mask(MASK_SHIFT_R); }
else if (scancode == VC_CONTROL_L) { unset_modifier_mask(MASK_CTRL_L); }
else if (scancode == VC_CONTROL_R) { unset_modifier_mask(MASK_CTRL_R); }
else if (scancode == VC_ALT_L) { unset_modifier_mask(MASK_ALT_L); }
else if (scancode == VC_ALT_R) { unset_modifier_mask(MASK_ALT_R); }
else if (scancode == VC_META_L) { unset_modifier_mask(MASK_META_L); }
else if (scancode == VC_META_R) { unset_modifier_mask(MASK_META_R); }
xkb_state_update_key(state, keycode, XKB_KEY_UP);
initialize_locks();
if ((get_modifiers() & MASK_NUM_LOCK) == 0) {
switch (scancode) {
case VC_KP_SEPARATOR:
case VC_KP_1:
case VC_KP_2:
case VC_KP_3:
case VC_KP_4:
case VC_KP_5:
case VC_KP_6:
case VC_KP_7:
case VC_KP_8:
case VC_KP_0:
case VC_KP_9:
scancode |= 0xEE00;
break;
}
}
// Populate key released event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_KEY_RELEASED;
event.mask = get_modifiers();
event.data.keyboard.keycode = scancode;
event.data.keyboard.rawcode = keysym;
event.data.keyboard.keychar = CHAR_UNDEFINED;
logger(LOG_LEVEL_INFO, "%s [%u]: Key %#X released. (%#X)\n",
__FUNCTION__, __LINE__, event.data.keyboard.keycode, event.data.keyboard.rawcode);
// Fire key released event.
dispatch_event(&event);
}
else if (data->type == ButtonPress) {
// X11 handles wheel events as button events.
if (data->event.u.u.detail == WheelUp || data->event.u.u.detail == WheelDown
|| data->event.u.u.detail == WheelLeft || data->event.u.u.detail == WheelRight) {
// Reset the click count and previous button.
hook->input.mouse.click.count = 1;
hook->input.mouse.click.button = MOUSE_NOBUTTON;
/* Scroll wheel release events.
* Scroll type: WHEEL_UNIT_SCROLL
* Scroll amount: 3 unit increments per notch
* Units to scroll: 3 unit increments
* Vertical unit increment: 15 pixels
*/
// Populate mouse wheel event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_MOUSE_WHEEL;
event.mask = get_modifiers();
event.data.wheel.clicks = hook->input.mouse.click.count;
event.data.wheel.x = data->event.u.keyButtonPointer.rootX;
event.data.wheel.y = data->event.u.keyButtonPointer.rootY;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t count;
screen_data *screens = hook_create_screen_info(&count);
if (count > 1) {
event.data.wheel.x -= screens[0].x;
event.data.wheel.y -= screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
/* X11 does not have an API call for acquiring the mouse scroll type. This
* maybe part of the XInput2 (XI2) extention but I will wont know until it
* is available on my platform. For the time being we will just use the
* unit scroll value.
*/
event.data.wheel.type = WHEEL_UNIT_SCROLL;
/* Some scroll wheel properties are available via the new XInput2 (XI2)
* extension. Unfortunately the extension is not available on my
* development platform at this time. For the time being we will just
* use the Windows default value of 3.
*/
event.data.wheel.amount = 3;
if (data->event.u.u.detail == WheelUp || data->event.u.u.detail == WheelLeft) {
// Wheel Rotated Up and Away.
event.data.wheel.rotation = -1;
}
else { // data->event.u.u.detail == WheelDown
// Wheel Rotated Down and Towards.
event.data.wheel.rotation = 1;
}
if (data->event.u.u.detail == WheelUp || data->event.u.u.detail == WheelDown) {
// Wheel Rotated Up or Down.
event.data.wheel.direction = WHEEL_VERTICAL_DIRECTION;
}
else { // data->event.u.u.detail == WheelLeft || data->event.u.u.detail == WheelRight
// Wheel Rotated Left or Right.
event.data.wheel.direction = WHEEL_HORIZONTAL_DIRECTION;
}
logger(LOG_LEVEL_INFO, "%s [%u]: Mouse wheel type %u, rotated %i units in the %u direction at %u, %u.\n",
__FUNCTION__, __LINE__, event.data.wheel.type,
event.data.wheel.amount * event.data.wheel.rotation,
event.data.wheel.direction,
event.data.wheel.x, event.data.wheel.y);
// Fire mouse wheel event.
dispatch_event(&event);
}
else {
/* This information is all static for X11, its up to the WM to
* decide how to interpret the wheel events.
*/
uint16_t button = MOUSE_NOBUTTON;
switch (data->event.u.u.detail) {
// FIXME This should use a lookup table to handle button remapping.
case Button1:
button = MOUSE_BUTTON1;
set_modifier_mask(MASK_BUTTON1);
break;
case Button2:
button = MOUSE_BUTTON2;
set_modifier_mask(MASK_BUTTON2);
break;
case Button3:
button = MOUSE_BUTTON3;
set_modifier_mask(MASK_BUTTON3);
break;
case XButton1:
button = MOUSE_BUTTON4;
set_modifier_mask(MASK_BUTTON5);
break;
case XButton2:
button = MOUSE_BUTTON5;
set_modifier_mask(MASK_BUTTON5);
break;
default:
// Do not set modifier masks past button MASK_BUTTON5.
break;
}
// Track the number of clicks, the button must match the previous button.
if (button == hook->input.mouse.click.button && (long int) (timestamp - hook->input.mouse.click.time) <= hook_get_multi_click_time()) {
if (hook->input.mouse.click.count < USHRT_MAX) {
hook->input.mouse.click.count++;
}
else {
logger(LOG_LEVEL_WARN, "%s [%u]: Click count overflow detected!\n",
__FUNCTION__, __LINE__);
}
}
else {
// Reset the click count.
hook->input.mouse.click.count = 1;
// Set the previous button.
hook->input.mouse.click.button = button;
}
// Save this events time to calculate the hook->input.mouse.click.count.
hook->input.mouse.click.time = timestamp;
// Populate mouse pressed event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_MOUSE_PRESSED;
event.mask = get_modifiers();
event.data.mouse.button = button;
event.data.mouse.clicks = hook->input.mouse.click.count;
event.data.mouse.x = data->event.u.keyButtonPointer.rootX;
event.data.mouse.y = data->event.u.keyButtonPointer.rootY;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t count;
screen_data *screens = hook_create_screen_info(&count);
if (count > 1) {
event.data.mouse.x -= screens[0].x;
event.data.mouse.y -= screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
logger(LOG_LEVEL_INFO, "%s [%u]: Button %u pressed %u time(s). (%u, %u)\n",
__FUNCTION__, __LINE__, event.data.mouse.button, event.data.mouse.clicks,
event.data.mouse.x, event.data.mouse.y);
// Fire mouse pressed event.
dispatch_event(&event);
}
}
else if (data->type == ButtonRelease) {
// X11 handles wheel events as button events.
if (data->event.u.u.detail != WheelUp && data->event.u.u.detail != WheelDown) {
/* This information is all static for X11, its up to the WM to
* decide how to interpret the wheel events.
*/
uint16_t button = MOUSE_NOBUTTON;
switch (data->event.u.u.detail) {
// FIXME This should use a lookup table to handle button remapping.
case Button1:
button = MOUSE_BUTTON1;
unset_modifier_mask(MASK_BUTTON1);
break;
case Button2:
button = MOUSE_BUTTON2;
unset_modifier_mask(MASK_BUTTON2);
break;
case Button3:
button = MOUSE_BUTTON3;
unset_modifier_mask(MASK_BUTTON3);
break;
case XButton1:
button = MOUSE_BUTTON4;
unset_modifier_mask(MASK_BUTTON5);
break;
case XButton2:
button = MOUSE_BUTTON5;
unset_modifier_mask(MASK_BUTTON5);
break;
default:
// Do not set modifier masks past button MASK_BUTTON5.
break;
}
// Populate mouse released event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_MOUSE_RELEASED;
event.mask = get_modifiers();
event.data.mouse.button = button;
event.data.mouse.clicks = hook->input.mouse.click.count;
event.data.mouse.x = data->event.u.keyButtonPointer.rootX;
event.data.mouse.y = data->event.u.keyButtonPointer.rootY;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t count;
screen_data *screens = hook_create_screen_info(&count);
if (count > 1) {
event.data.mouse.x -= screens[0].x;
event.data.mouse.y -= screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
logger(LOG_LEVEL_INFO, "%s [%u]: Button %u released %u time(s). (%u, %u)\n",
__FUNCTION__, __LINE__, event.data.mouse.button,
event.data.mouse.clicks,
event.data.mouse.x, event.data.mouse.y);
// Fire mouse released event.
dispatch_event(&event);
// If the pressed event was not consumed...
if (event.reserved ^ 0x01 && hook->input.mouse.is_dragged != true) {
// Populate mouse clicked event.
event.time = timestamp;
event.reserved = 0x00;
event.type = EVENT_MOUSE_CLICKED;
event.mask = get_modifiers();
event.data.mouse.button = button;
event.data.mouse.clicks = hook->input.mouse.click.count;
event.data.mouse.x = data->event.u.keyButtonPointer.rootX;
event.data.mouse.y = data->event.u.keyButtonPointer.rootY;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t count;
screen_data *screens = hook_create_screen_info(&count);
if (count > 1) {
event.data.mouse.x -= screens[0].x;
event.data.mouse.y -= screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
logger(LOG_LEVEL_INFO, "%s [%u]: Button %u clicked %u time(s). (%u, %u)\n",
__FUNCTION__, __LINE__, event.data.mouse.button,
event.data.mouse.clicks,
event.data.mouse.x, event.data.mouse.y);
// Fire mouse clicked event.
dispatch_event(&event);
}
// Reset the number of clicks.
if (button == hook->input.mouse.click.button && (long int) (event.time - hook->input.mouse.click.time) > hook_get_multi_click_time()) {
// Reset the click count.
hook->input.mouse.click.count = 0;
}
}
}
else if (data->type == MotionNotify) {
// Reset the click count.
if (hook->input.mouse.click.count != 0 && (long int) (timestamp - hook->input.mouse.click.time) > hook_get_multi_click_time()) {
hook->input.mouse.click.count = 0;
}
// Populate mouse move event.
event.time = timestamp;
event.reserved = 0x00;
event.mask = get_modifiers();
// Check the upper half of virtual modifiers for non-zero
// values and set the mouse dragged flag.
hook->input.mouse.is_dragged = (event.mask >> 8 > 0);
if (hook->input.mouse.is_dragged) {
// Create Mouse Dragged event.
event.type = EVENT_MOUSE_DRAGGED;
}
else {
// Create a Mouse Moved event.
event.type = EVENT_MOUSE_MOVED;
}
event.data.mouse.button = MOUSE_NOBUTTON;
event.data.mouse.clicks = hook->input.mouse.click.count;
event.data.mouse.x = data->event.u.keyButtonPointer.rootX;
event.data.mouse.y = data->event.u.keyButtonPointer.rootY;
#if defined(USE_XINERAMA) || defined(USE_XRANDR)
uint8_t count;
screen_data *screens = hook_create_screen_info(&count);
if (count > 1) {
event.data.mouse.x -= screens[0].x;
event.data.mouse.y -= screens[0].y;
}
if (screens != NULL) {
free(screens);
}
#endif
logger(LOG_LEVEL_INFO, "%s [%u]: Mouse %s to %i, %i. (%#X)\n",
__FUNCTION__, __LINE__, hook->input.mouse.is_dragged ? "dragged" : "moved",
event.data.mouse.x, event.data.mouse.y, event.mask);
// Fire mouse move event.
dispatch_event(&event);
}
else {
// Initialize the modifier mask to the current modifiers.
static void initialize_modifiers() {
hook->input.mask = 0x0000;
KeyCode keycode;
char keymap[32];
XQueryKeymap(hook->ctrl.display, keymap);
Window unused_win;
int unused_int;
unsigned int mask;
if (XQueryPointer(hook->ctrl.display, DefaultRootWindow(hook->ctrl.display), &unused_win, &unused_win, &unused_int, &unused_int, &unused_int, &unused_int, &mask)) {
if (mask & ShiftMask) {
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Shift_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_SHIFT_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Shift_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_SHIFT_R); }
}
if (mask & ControlMask) {
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Control_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_CTRL_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Control_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_CTRL_R); }
}
if (mask & Mod1Mask) {
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Alt_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_ALT_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Alt_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_ALT_R); }
}
if (mask & Mod4Mask) {
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Super_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_META_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Super_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_META_R); }
}
if (mask & Button1Mask) { set_modifier_mask(MASK_BUTTON1); }
if (mask & Button2Mask) { set_modifier_mask(MASK_BUTTON2); }
if (mask & Button3Mask) { set_modifier_mask(MASK_BUTTON3); }
if (mask & Button4Mask) { set_modifier_mask(MASK_BUTTON4); }
if (mask & Button5Mask) { set_modifier_mask(MASK_BUTTON5); }
}
else {
logger(LOG_LEVEL_WARN, "%s [%u]: XQueryPointer failed to get current modifiers!\n",
__FUNCTION__, __LINE__);
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Shift_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_SHIFT_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Shift_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_SHIFT_R); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Control_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_CTRL_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Control_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_CTRL_R); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Alt_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_ALT_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Alt_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_ALT_R); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Super_L);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_META_L); }
keycode = XKeysymToKeycode(hook->ctrl.display, XK_Super_R);
if (keymap[keycode / 8] & (1 << (keycode % 8))) { set_modifier_mask(MASK_META_R); }
}
initialize_locks();
}
