fdo-mirrors/libinput
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libinput/libinput.git synced 2026-05-07 03:48:06 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Switch the fallback and touchpad backends to use struct evdev_event

Browse source 
These two use enough shared functions that they cannot be switched
separatly.

Part-of: <https://gitlab.freedesktop.org/libinput/libinput/-/merge_requests/1215>
This commit is contained in:
Peter Hutterer 2025-06-05 13:53:55 +10:00
parent 41e988c99e
commit 4be243d0e7
12 changed files with 347 additions and 294 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
src/evdev-debounce.c
View file

@ -173,12 +173,12 @@ debounce_notify_button(struct fallback_dispatch *fallback,
enum libinput_button_state state) enum libinput_button_state state)
{ {
struct evdev_device *device = fallback->device; struct evdev_device *device = fallback->device;
unsigned int code = fallback->debounce.button_code; evdev_usage_t usage = fallback->debounce.button_usage;
uint64_t time = fallback->debounce.button_time; uint64_t time = fallback->debounce.button_time;
code = evdev_to_left_handed(device, code); usage = evdev_to_left_handed(device, usage);
fallback_notify_physical_button(fallback, device, time, code, state); fallback_notify_physical_button(fallback, device, time, usage, state);
} }
static void static void
@ -484,16 +484,17 @@ void
fallback_debounce_handle_state(struct fallback_dispatch *dispatch, fallback_debounce_handle_state(struct fallback_dispatch *dispatch,
uint64_t time) uint64_t time)
{ {
unsigned int changed[16] = {0}; /* event codes of changed buttons */ evdev_usage_t changed[16] = {0}; /* usage of changed buttons */
size_t nchanged = 0; size_t nchanged = 0;
bool flushed = false; bool flushed = false;
for (unsigned int code = 0; code <= KEY_MAX; code++) { for (uint32_t u = EVDEV_KEY_RESERVED; u <= EVDEV_KEY_MAX; u++) {
if (get_key_type(code) != KEY_TYPE_BUTTON) evdev_usage_t usage = evdev_usage_from_uint32_t(u);
if (get_key_type(usage) != KEY_TYPE_BUTTON)
continue; continue;
if (hw_key_has_changed(dispatch, code)) if (hw_key_has_changed(dispatch, usage))
changed[nchanged++] = code; changed[nchanged++] = usage;
/* If you manage to press more than 16 buttons in the same /* If you manage to press more than 16 buttons in the same
* frame, we just quietly ignore the rest of them */ * frame, we just quietly ignore the rest of them */
@ -504,7 +505,7 @@ fallback_debounce_handle_state(struct fallback_dispatch *dispatch,
/* If we have more than one button this frame or a different button, /* If we have more than one button this frame or a different button,
* flush the state machine with otherbutton */ * flush the state machine with otherbutton */
if (nchanged > 1 || if (nchanged > 1 ||
changed[0] != dispatch->debounce.button_code) { evdev_usage_cmp(changed[0], dispatch->debounce.button_usage) != 0) {
debounce_handle_event(dispatch, debounce_handle_event(dispatch,
DEBOUNCE_EVENT_OTHERBUTTON, DEBOUNCE_EVENT_OTHERBUTTON,
time); time);
@ -530,7 +531,7 @@ fallback_debounce_handle_state(struct fallback_dispatch *dispatch,
flushed = false; flushed = false;
} }
dispatch->debounce.button_code = changed[i]; dispatch->debounce.button_usage = changed[i];
debounce_handle_event(dispatch, debounce_handle_event(dispatch,
is_down ? is_down ?
DEBOUNCE_EVENT_PRESS : DEBOUNCE_EVENT_PRESS :

158
src/evdev-fallback.c
View file

@ -35,16 +35,16 @@ static void
fallback_keyboard_notify_key(struct fallback_dispatch *dispatch, fallback_keyboard_notify_key(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
uint64_t time, uint64_t time,
int key, evdev_usage_t usage,
enum libinput_key_state state) enum libinput_key_state state)
{ {
int down_count; int down_count;
down_count = evdev_update_key_down_count(device, key, state); down_count = evdev_update_key_down_count(device, usage, state);
if ((state == LIBINPUT_KEY_STATE_PRESSED && down_count == 1) || if ((state == LIBINPUT_KEY_STATE_PRESSED && down_count == 1) ||
(state == LIBINPUT_KEY_STATE_RELEASED && down_count == 0)) (state == LIBINPUT_KEY_STATE_RELEASED && down_count == 0))
keyboard_notify_key(&device->base, time, key, state); keyboard_notify_key(&device->base, time, evdev_usage_code(usage), state);
} }
static void static void
@ -65,7 +65,7 @@ void
fallback_notify_physical_button(struct fallback_dispatch *dispatch, fallback_notify_physical_button(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
uint64_t time, uint64_t time,
int button, evdev_usage_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
evdev_pointer_notify_physical_button(device, time, button, state); evdev_pointer_notify_physical_button(device, time, button, state);
@ -466,7 +466,7 @@ fallback_process_touch_button(struct fallback_dispatch *dispatch,
static inline void static inline void
fallback_process_key(struct fallback_dispatch *dispatch, fallback_process_key(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, uint64_t time) struct evdev_event *e, uint64_t time)
{ {
enum key_type type; enum key_type type;
@ -474,7 +474,7 @@ fallback_process_key(struct fallback_dispatch *dispatch,
if (e->value == 2) if (e->value == 2)
return; return;
if (e->code == BTN_TOUCH) { if (evdev_usage_eq(e->usage, EVDEV_BTN_TOUCH)) {
if (!device->is_mt) if (!device->is_mt)
fallback_process_touch_button(dispatch, fallback_process_touch_button(dispatch,
device, device,
@ -483,7 +483,7 @@ fallback_process_key(struct fallback_dispatch *dispatch,
return; return;
} }
type = get_key_type(e->code); type = get_key_type(e->usage);
/* Ignore key release events from the kernel for keys that libinput /* Ignore key release events from the kernel for keys that libinput
* never got a pressed event for or key presses for keys that we * never got a pressed event for or key presses for keys that we
@ -493,15 +493,15 @@ fallback_process_key(struct fallback_dispatch *dispatch,
break; break;
case KEY_TYPE_KEY: case KEY_TYPE_KEY:
case KEY_TYPE_BUTTON: case KEY_TYPE_BUTTON:
if ((e->value && hw_is_key_down(dispatch, e->code)) || if ((e->value && hw_is_key_down(dispatch, e->usage)) ||
(e->value == 0 && !hw_is_key_down(dispatch, e->code))) (e->value == 0 && !hw_is_key_down(dispatch, e->usage)))
return; return;
dispatch->pending_event |= EVDEV_KEY; dispatch->pending_event |= EVDEV_KEY;
break; break;
} }
hw_set_key_down(dispatch, e->code, e->value); hw_set_key_down(dispatch, e->usage, e->value);
switch (type) { switch (type) {
case KEY_TYPE_NONE: case KEY_TYPE_NONE:
@ -511,7 +511,7 @@ fallback_process_key(struct fallback_dispatch *dispatch,
dispatch, dispatch,
device, device,
time, time,
e->code, e->usage,
e->value ? LIBINPUT_KEY_STATE_PRESSED : e->value ? LIBINPUT_KEY_STATE_PRESSED :
LIBINPUT_KEY_STATE_RELEASED); LIBINPUT_KEY_STATE_RELEASED);
break; break;
@ -523,12 +523,13 @@ fallback_process_key(struct fallback_dispatch *dispatch,
static void static void
fallback_process_touch(struct fallback_dispatch *dispatch, fallback_process_touch(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
struct mt_slot *slot = &dispatch->mt.slots[dispatch->mt.slot]; struct mt_slot *slot = &dispatch->mt.slots[dispatch->mt.slot];
if (e->code == ABS_MT_SLOT) { switch (evdev_usage_enum(e->usage)) {
case EVDEV_ABS_MT_SLOT:
if ((size_t)e->value >= dispatch->mt.slots_len) { if ((size_t)e->value >= dispatch->mt.slots_len) {
evdev_log_bug_libinput(device, evdev_log_bug_libinput(device,
"exceeded slot count (%d of max %zd)\n", "exceeded slot count (%d of max %zd)\n",
@ -538,10 +539,7 @@ fallback_process_touch(struct fallback_dispatch *dispatch,
} }
dispatch->mt.slot = e->value; dispatch->mt.slot = e->value;
return; return;
} case EVDEV_ABS_MT_TRACKING_ID:
switch (e->code) {
case ABS_MT_TRACKING_ID:
if (e->value >= 0) { if (e->value >= 0) {
dispatch->pending_event |= EVDEV_ABSOLUTE_MT; dispatch->pending_event |= EVDEV_ABSOLUTE_MT;
slot->state = SLOT_STATE_BEGIN; slot->state = SLOT_STATE_BEGIN;
@ -568,19 +566,19 @@ fallback_process_touch(struct fallback_dispatch *dispatch,
} }
slot->dirty = true; slot->dirty = true;
break; break;
case ABS_MT_POSITION_X: case EVDEV_ABS_MT_POSITION_X:
evdev_device_check_abs_axis_range(device, e->code, e->value); evdev_device_check_abs_axis_range(device, e->usage, e->value);
dispatch->mt.slots[dispatch->mt.slot].point.x = e->value; dispatch->mt.slots[dispatch->mt.slot].point.x = e->value;
dispatch->pending_event |= EVDEV_ABSOLUTE_MT; dispatch->pending_event |= EVDEV_ABSOLUTE_MT;
slot->dirty = true; slot->dirty = true;
break; break;
case ABS_MT_POSITION_Y: case EVDEV_ABS_MT_POSITION_Y:
evdev_device_check_abs_axis_range(device, e->code, e->value); evdev_device_check_abs_axis_range(device, e->usage, e->value);
dispatch->mt.slots[dispatch->mt.slot].point.y = e->value; dispatch->mt.slots[dispatch->mt.slot].point.y = e->value;
dispatch->pending_event |= EVDEV_ABSOLUTE_MT; dispatch->pending_event |= EVDEV_ABSOLUTE_MT;
slot->dirty = true; slot->dirty = true;
break; break;
case ABS_MT_TOOL_TYPE: case EVDEV_ABS_MT_TOOL_TYPE:
/* The transitions matter - we (may) need to send a touch /* The transitions matter - we (may) need to send a touch
* cancel event if we just switched to a palm touch. And the * cancel event if we just switched to a palm touch. And the
* kernel may switch back to finger but we keep the touch as * kernel may switch back to finger but we keep the touch as
@ -600,25 +598,29 @@ fallback_process_touch(struct fallback_dispatch *dispatch,
dispatch->pending_event |= EVDEV_ABSOLUTE_MT; dispatch->pending_event |= EVDEV_ABSOLUTE_MT;
slot->dirty = true; slot->dirty = true;
break; break;
default:
break;
} }
} }
static inline void static inline void
fallback_process_absolute_motion(struct fallback_dispatch *dispatch, fallback_process_absolute_motion(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e) struct evdev_event *e)
{ {
switch (e->code) { switch (evdev_usage_enum(e->usage)) {
case ABS_X: case EVDEV_ABS_X:
evdev_device_check_abs_axis_range(device, e->code, e->value); evdev_device_check_abs_axis_range(device, e->usage, e->value);
dispatch->abs.point.x = e->value; dispatch->abs.point.x = e->value;
dispatch->pending_event |= EVDEV_ABSOLUTE_MOTION; dispatch->pending_event |= EVDEV_ABSOLUTE_MOTION;
break; break;
case ABS_Y: case EVDEV_ABS_Y:
evdev_device_check_abs_axis_range(device, e->code, e->value); evdev_device_check_abs_axis_range(device, e->usage, e->value);
dispatch->abs.point.y = e->value; dispatch->abs.point.y = e->value;
dispatch->pending_event |= EVDEV_ABSOLUTE_MOTION; dispatch->pending_event |= EVDEV_ABSOLUTE_MOTION;
break; break;
default:
break;
} }
} }
@ -701,7 +703,7 @@ fallback_lid_toggle_keyboard_listeners(struct fallback_dispatch *dispatch,
static inline void static inline void
fallback_process_switch(struct fallback_dispatch *dispatch, fallback_process_switch(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
enum libinput_switch_state state; enum libinput_switch_state state;
@ -709,8 +711,8 @@ fallback_process_switch(struct fallback_dispatch *dispatch,
/* TODO: this should to move to handle_state */ /* TODO: this should to move to handle_state */
switch (e->code) { switch (evdev_usage_enum(e->usage)) {
case SW_LID: case EVDEV_SW_LID:
is_closed = !!e->value; is_closed = !!e->value;
fallback_lid_toggle_keyboard_listeners(dispatch, is_closed); fallback_lid_toggle_keyboard_listeners(dispatch, is_closed);
@ -721,7 +723,7 @@ fallback_process_switch(struct fallback_dispatch *dispatch,
dispatch->lid.is_closed = is_closed; dispatch->lid.is_closed = is_closed;
fallback_lid_notify_toggle(dispatch, device, time); fallback_lid_notify_toggle(dispatch, device, time);
break; break;
case SW_TABLET_MODE: case EVDEV_SW_TABLET_MODE:
if (dispatch->tablet_mode.sw.state == e->value) if (dispatch->tablet_mode.sw.state == e->value)
return; return;
@ -735,42 +737,51 @@ fallback_process_switch(struct fallback_dispatch *dispatch,
LIBINPUT_SWITCH_TABLET_MODE, LIBINPUT_SWITCH_TABLET_MODE,
state); state);
break; break;
default:
break;
} }
} }
static inline bool static inline bool
fallback_reject_relative(struct evdev_device *device, fallback_reject_relative(struct evdev_device *device,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
if ((e->code == REL_X || e->code == REL_Y) && switch (evdev_usage_enum(e->usage)) {
(device->seat_caps & EVDEV_DEVICE_POINTER) == 0) { case EVDEV_REL_X:
evdev_log_bug_libinput_ratelimit(device, case EVDEV_REL_Y:
&device->nonpointer_rel_limit, if ((device->seat_caps & EVDEV_DEVICE_POINTER) == 0) {
"REL_X/Y from a non-pointer device\n"); evdev_log_bug_libinput_ratelimit(device,
return true; &device->nonpointer_rel_limit,
"REL_X/Y from a non-pointer device\n");
return true;
}
break;
default:
break;
} }
return false; return false;
} }
static inline void static inline void
fallback_process_relative(struct fallback_dispatch *dispatch, fallback_process_relative(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, uint64_t time) struct evdev_event *e, uint64_t time)
{ {
if (fallback_reject_relative(device, e, time)) if (fallback_reject_relative(device, e, time))
return; return;
switch (e->code) { switch (evdev_usage_enum(e->usage)) {
case REL_X: case EVDEV_REL_X:
dispatch->rel.x += e->value; dispatch->rel.x += e->value;
dispatch->pending_event |= EVDEV_RELATIVE_MOTION; dispatch->pending_event |= EVDEV_RELATIVE_MOTION;
break; break;
case REL_Y: case EVDEV_REL_Y:
dispatch->rel.y += e->value; dispatch->rel.y += e->value;
dispatch->pending_event |= EVDEV_RELATIVE_MOTION; dispatch->pending_event |= EVDEV_RELATIVE_MOTION;
break; break;
default:
break;
} }
fallback_wheel_process_relative(dispatch, device, e, time); fallback_wheel_process_relative(dispatch, device, e, time);
@ -779,7 +790,7 @@ fallback_process_relative(struct fallback_dispatch *dispatch,
static inline void static inline void
fallback_process_absolute(struct fallback_dispatch *dispatch, fallback_process_absolute(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
if (device->is_mt) { if (device->is_mt) {
@ -793,11 +804,13 @@ static inline bool
fallback_any_button_down(struct fallback_dispatch *dispatch, fallback_any_button_down(struct fallback_dispatch *dispatch,
struct evdev_device *device) struct evdev_device *device)
{ {
unsigned int button; uint32_t button;
for (button = EVDEV_BTN_LEFT; button < EVDEV_BTN_JOYSTICK; button++) {
for (button = BTN_LEFT; button < BTN_JOYSTICK; button++) { evdev_usage_t usage = evdev_usage_from_uint32_t(button);
if (libevdev_has_event_code(device->evdev, EV_KEY, button) && if (libevdev_has_event_code(device->evdev,
hw_is_key_down(dispatch, button)) EV_KEY,
evdev_usage_code(usage)) &&
hw_is_key_down(dispatch, usage))
return true; return true;
} }
return false; return false;
@ -942,11 +955,12 @@ fallback_handle_state(struct fallback_dispatch *dispatch,
/* Buttons and keys */ /* Buttons and keys */
if (dispatch->pending_event & EVDEV_KEY) { if (dispatch->pending_event & EVDEV_KEY) {
bool want_debounce = false; bool want_debounce = false;
for (unsigned int code = 0; code <= KEY_MAX; code++) { for (uint32_t u = EVDEV_KEY_RESERVED; u <= EVDEV_KEY_MAX; u++) {
if (!hw_key_has_changed(dispatch, code)) evdev_usage_t usage = evdev_usage_from_uint32_t(u);
if (!hw_key_has_changed(dispatch, usage))
continue; continue;
if (get_key_type(code) == KEY_TYPE_BUTTON) { if (get_key_type(usage) == KEY_TYPE_BUTTON) {
want_debounce = true; want_debounce = true;
break; break;
} }
@ -964,12 +978,14 @@ fallback_handle_state(struct fallback_dispatch *dispatch,
static void static void
fallback_interface_process(struct evdev_dispatch *evdev_dispatch, fallback_interface_process(struct evdev_dispatch *evdev_dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *event, struct input_event *input_event,
uint64_t time) uint64_t time)
{ {
struct fallback_dispatch *dispatch = fallback_dispatch(evdev_dispatch); struct fallback_dispatch *dispatch = fallback_dispatch(evdev_dispatch);
static bool warned = false; static bool warned = false;
struct evdev_event event = evdev_event_from_input_event(input_event, NULL);
if (dispatch->arbitration.in_arbitration) { if (dispatch->arbitration.in_arbitration) {
if (!warned) { if (!warned) {
evdev_log_debug(device, "dropping events due to touch arbitration\n"); evdev_log_debug(device, "dropping events due to touch arbitration\n");
@ -980,18 +996,19 @@ fallback_interface_process(struct evdev_dispatch *evdev_dispatch,
warned = false; warned = false;
switch (event->type) { uint16_t type = evdev_event_type(&event);
switch (type) {
case EV_REL: case EV_REL:
fallback_process_relative(dispatch, device, event, time); fallback_process_relative(dispatch, device, &event, time);
break; break;
case EV_ABS: case EV_ABS:
fallback_process_absolute(dispatch, device, event, time); fallback_process_absolute(dispatch, device, &event, time);
break; break;
case EV_KEY: case EV_KEY:
fallback_process_key(dispatch, device, event, time); fallback_process_key(dispatch, device, &event, time);
break; break;
case EV_SW: case EV_SW:
fallback_process_switch(dispatch, device, event, time); fallback_process_switch(dispatch, device, &event, time);
break; break;
case EV_SYN: case EV_SYN:
fallback_handle_state(dispatch, device, time); fallback_handle_state(dispatch, device, time);
@ -1038,10 +1055,9 @@ release_pressed_keys(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
uint64_t time) uint64_t time)
{ {
int code; for (uint32_t u = EVDEV_KEY_RESERVED; u <= EVDEV_KEY_MAX; u++) {
evdev_usage_t usage = evdev_usage_from_uint32_t(u);
for (code = 0; code < KEY_CNT; code++) { int count = get_key_down_count(device, usage);
int count = get_key_down_count(device, code);
if (count == 0) if (count == 0)
continue; continue;
@ -1049,11 +1065,11 @@ release_pressed_keys(struct fallback_dispatch *dispatch,
if (count > 1) { if (count > 1) {
evdev_log_bug_libinput(device, evdev_log_bug_libinput(device,
"key %d is down %d times.\n", "key %d is down %d times.\n",
code, u,
count); count);
} }
switch (get_key_type(code)) { switch (get_key_type(usage)) {
case KEY_TYPE_NONE: case KEY_TYPE_NONE:
break; break;
case KEY_TYPE_KEY: case KEY_TYPE_KEY:
@ -1061,7 +1077,7 @@ release_pressed_keys(struct fallback_dispatch *dispatch,
dispatch, dispatch,
device, device,
time, time,
code, usage,
LIBINPUT_KEY_STATE_RELEASED); LIBINPUT_KEY_STATE_RELEASED);
break; break;
case KEY_TYPE_BUTTON: case KEY_TYPE_BUTTON:
@ -1073,16 +1089,16 @@ release_pressed_keys(struct fallback_dispatch *dispatch,
evdev_pointer_notify_button( evdev_pointer_notify_button(
device, device,
time, time,
code, usage,
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
break; break;
} }
count = get_key_down_count(device, code); count = get_key_down_count(device, usage);
if (count != 0) { if (count != 0) {
evdev_log_bug_libinput(device, evdev_log_bug_libinput(device,
"releasing key %d failed.\n", "releasing key %d failed.\n",
code); evdev_usage_enum(usage));
break; break;
} }
} }
@ -1457,7 +1473,7 @@ fallback_change_scroll_method(struct evdev_device *device)
struct fallback_dispatch *dispatch = fallback_dispatch(device->dispatch); struct fallback_dispatch *dispatch = fallback_dispatch(device->dispatch);
if (device->scroll.want_method == device->scroll.method && if (device->scroll.want_method == device->scroll.method &&
device->scroll.want_button == device->scroll.button && evdev_usage_cmp(device->scroll.want_button, device->scroll.button) == 0 &&
device->scroll.want_lock_enabled == device->scroll.lock_enabled) device->scroll.want_lock_enabled == device->scroll.lock_enabled)
return; return;
@ -1683,7 +1699,7 @@ fallback_dispatch_create(struct libinput_device *libinput_device)
evdev_init_left_handed(device, evdev_init_left_handed(device,
fallback_change_to_left_handed); fallback_change_to_left_handed);
if (device->scroll.want_button) if (evdev_usage_enum(device->scroll.want_button))
evdev_init_button_scroll(device, evdev_init_button_scroll(device,
fallback_change_scroll_method); fallback_change_scroll_method);

71
src/evdev-fallback.h
View file

@ -30,6 +30,7 @@
#define EVDEV_FALLBACK_H #define EVDEV_FALLBACK_H
#include "evdev.h" #include "evdev.h"
#include "util-input-event.h"
enum debounce_state { enum debounce_state {
DEBOUNCE_STATE_IS_UP = 100, DEBOUNCE_STATE_IS_UP = 100,
@ -142,7 +143,7 @@ struct fallback_dispatch {
enum evdev_event_type pending_event; enum evdev_event_type pending_event;
struct { struct {
unsigned int button_code; evdev_usage_t button_usage;
uint64_t button_time; uint64_t button_time;
struct libinput_timer timer; struct libinput_timer timer;
struct libinput_timer timer_short; struct libinput_timer timer_short;
@ -190,49 +191,59 @@ enum key_type {
}; };
static inline enum key_type static inline enum key_type
get_key_type(uint16_t code) get_key_type(evdev_usage_t evdev_usage)
{ {
switch (code) { switch (evdev_usage_enum(evdev_usage)) {
case BTN_TOOL_PEN: case EVDEV_BTN_TOOL_PEN:
case BTN_TOOL_RUBBER: case EVDEV_BTN_TOOL_RUBBER:
case BTN_TOOL_BRUSH: case EVDEV_BTN_TOOL_BRUSH:
case BTN_TOOL_PENCIL: case EVDEV_BTN_TOOL_PENCIL:
case BTN_TOOL_AIRBRUSH: case EVDEV_BTN_TOOL_AIRBRUSH:
case BTN_TOOL_MOUSE: case EVDEV_BTN_TOOL_MOUSE:
case BTN_TOOL_LENS: case EVDEV_BTN_TOOL_LENS:
case BTN_TOOL_QUINTTAP: case EVDEV_BTN_TOOL_QUINTTAP:
case BTN_TOOL_DOUBLETAP: case EVDEV_BTN_TOOL_DOUBLETAP:
case BTN_TOOL_TRIPLETAP: case EVDEV_BTN_TOOL_TRIPLETAP:
case BTN_TOOL_QUADTAP: case EVDEV_BTN_TOOL_QUADTAP:
case BTN_TOOL_FINGER: case EVDEV_BTN_TOOL_FINGER:
case BTN_TOUCH: case EVDEV_BTN_TOUCH:
return KEY_TYPE_NONE; return KEY_TYPE_NONE;
default:
break;
} }
if (code >= KEY_ESC && code <= KEY_MICMUTE) enum evdev_usage usage = evdev_usage_enum(evdev_usage);
if (usage >= EVDEV_KEY_ESC && usage <= EVDEV_KEY_MICMUTE)
return KEY_TYPE_KEY; return KEY_TYPE_KEY;
if (code >= BTN_MISC && code <= BTN_GEAR_UP) if (usage >= EVDEV_BTN_MISC && usage <= EVDEV_BTN_GEAR_UP)
return KEY_TYPE_BUTTON; return KEY_TYPE_BUTTON;
if (code >= KEY_OK && code <= KEY_LIGHTS_TOGGLE) if (usage >= EVDEV_KEY_OK && usage <= EVDEV_KEY_LIGHTS_TOGGLE)
return KEY_TYPE_KEY; return KEY_TYPE_KEY;
if (code >= BTN_DPAD_UP && code <= BTN_DPAD_RIGHT) if (usage >= EVDEV_BTN_DPAD_UP && usage <= EVDEV_BTN_DPAD_RIGHT)
return KEY_TYPE_BUTTON; return KEY_TYPE_BUTTON;
if (code >= KEY_ALS_TOGGLE && code < BTN_TRIGGER_HAPPY) if (usage >= EVDEV_KEY_ALS_TOGGLE && usage < EVDEV_BTN_TRIGGER_HAPPY)
return KEY_TYPE_KEY; return KEY_TYPE_KEY;
if (code >= BTN_TRIGGER_HAPPY && code <= BTN_TRIGGER_HAPPY40) if (usage >= EVDEV_BTN_TRIGGER_HAPPY && usage <= EVDEV_BTN_TRIGGER_HAPPY40)
return KEY_TYPE_BUTTON; return KEY_TYPE_BUTTON;
return KEY_TYPE_NONE; return KEY_TYPE_NONE;
} }
static inline void static inline void
hw_set_key_down(struct fallback_dispatch *dispatch, int code, int pressed) hw_set_key_down(struct fallback_dispatch *dispatch, evdev_usage_t usage, int pressed)
{ {
assert(evdev_usage_type(usage) == EV_KEY);
unsigned int code = evdev_usage_code(usage);
long_set_bit_state(dispatch->hw_key_mask, code, pressed); long_set_bit_state(dispatch->hw_key_mask, code, pressed);
} }
static inline bool static inline bool
hw_key_has_changed(struct fallback_dispatch *dispatch, int code) hw_key_has_changed(struct fallback_dispatch *dispatch, evdev_usage_t usage)
{ {
assert(evdev_usage_type(usage) == EV_KEY);
unsigned int code = evdev_usage_code(usage);
return long_bit_is_set(dispatch->hw_key_mask, code) != return long_bit_is_set(dispatch->hw_key_mask, code) !=
long_bit_is_set(dispatch->last_hw_key_mask, code); long_bit_is_set(dispatch->last_hw_key_mask, code);
} }
@ -250,14 +261,18 @@ hw_key_update_last_state(struct fallback_dispatch *dispatch)
} }
static inline bool static inline bool
hw_is_key_down(struct fallback_dispatch *dispatch, int code) hw_is_key_down(struct fallback_dispatch *dispatch, evdev_usage_t usage)
{ {
assert(evdev_usage_type(usage) == EV_KEY);
unsigned int code = evdev_usage_code(usage);
return long_bit_is_set(dispatch->hw_key_mask, code); return long_bit_is_set(dispatch->hw_key_mask, code);
} }
static inline int static inline int
get_key_down_count(struct evdev_device *device, int code) get_key_down_count(struct evdev_device *device, evdev_usage_t usage)
{ {
assert(evdev_usage_type(usage) == EV_KEY);
unsigned int code = evdev_usage_code(usage);
return device->key_count[code]; return device->key_count[code];
} }
@ -268,7 +283,7 @@ void
fallback_notify_physical_button(struct fallback_dispatch *dispatch, fallback_notify_physical_button(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
uint64_t time, uint64_t time,
int button, evdev_usage_t button,
enum libinput_button_state state); enum libinput_button_state state);
void void
@ -278,7 +293,7 @@ fallback_init_wheel(struct fallback_dispatch *dispatch,
void void
fallback_wheel_process_relative(struct fallback_dispatch *dispatch, fallback_wheel_process_relative(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, uint64_t time); struct evdev_event *e, uint64_t time);
void void
fallback_wheel_handle_state(struct fallback_dispatch *dispatch, fallback_wheel_handle_state(struct fallback_dispatch *dispatch,

49
src/evdev-middle-button.c
View file

@ -129,7 +129,7 @@ middlebutton_set_state(struct evdev_device *device,
static void static void
middlebutton_post_event(struct evdev_device *device, middlebutton_post_event(struct evdev_device *device,
uint64_t now, uint64_t now,
int button, evdev_usage_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
evdev_pointer_notify_button(device, evdev_pointer_notify_button(device,
@ -175,13 +175,13 @@ evdev_middlebutton_ldown_handle_event(struct evdev_device *device,
break; break;
case MIDDLEBUTTON_EVENT_R_DOWN: case MIDDLEBUTTON_EVENT_R_DOWN:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time); middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time);
break; break;
case MIDDLEBUTTON_EVENT_OTHER: case MIDDLEBUTTON_EVENT_OTHER:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, middlebutton_set_state(device,
MIDDLEBUTTON_PASSTHROUGH, MIDDLEBUTTON_PASSTHROUGH,
@ -193,17 +193,17 @@ evdev_middlebutton_ldown_handle_event(struct evdev_device *device,
case MIDDLEBUTTON_EVENT_L_UP: case MIDDLEBUTTON_EVENT_L_UP:
middlebutton_post_event(device, middlebutton_post_event(device,
device->middlebutton.first_event_time, device->middlebutton.first_event_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
middlebutton_set_state(device, MIDDLEBUTTON_IDLE, time); middlebutton_set_state(device, MIDDLEBUTTON_IDLE, time);
break; break;
case MIDDLEBUTTON_EVENT_TIMEOUT: case MIDDLEBUTTON_EVENT_TIMEOUT:
middlebutton_post_event(device, middlebutton_post_event(device,
device->middlebutton.first_event_time, device->middlebutton.first_event_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, middlebutton_set_state(device,
MIDDLEBUTTON_PASSTHROUGH, MIDDLEBUTTON_PASSTHROUGH,
@ -225,7 +225,7 @@ evdev_middlebutton_rdown_handle_event(struct evdev_device *device,
switch (event) { switch (event) {
case MIDDLEBUTTON_EVENT_L_DOWN: case MIDDLEBUTTON_EVENT_L_DOWN:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time); middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time);
break; break;
@ -235,7 +235,7 @@ evdev_middlebutton_rdown_handle_event(struct evdev_device *device,
case MIDDLEBUTTON_EVENT_OTHER: case MIDDLEBUTTON_EVENT_OTHER:
middlebutton_post_event(device, middlebutton_post_event(device,
device->middlebutton.first_event_time, device->middlebutton.first_event_time,
BTN_RIGHT, evdev_usage_from(EVDEV_BTN_RIGHT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, middlebutton_set_state(device,
MIDDLEBUTTON_PASSTHROUGH, MIDDLEBUTTON_PASSTHROUGH,
@ -244,10 +244,10 @@ evdev_middlebutton_rdown_handle_event(struct evdev_device *device,
case MIDDLEBUTTON_EVENT_R_UP: case MIDDLEBUTTON_EVENT_R_UP:
middlebutton_post_event(device, middlebutton_post_event(device,
device->middlebutton.first_event_time, device->middlebutton.first_event_time,
BTN_RIGHT, evdev_usage_from(EVDEV_BTN_RIGHT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_RIGHT, evdev_usage_from(EVDEV_BTN_RIGHT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
middlebutton_set_state(device, MIDDLEBUTTON_IDLE, time); middlebutton_set_state(device, MIDDLEBUTTON_IDLE, time);
break; break;
@ -257,7 +257,7 @@ evdev_middlebutton_rdown_handle_event(struct evdev_device *device,
case MIDDLEBUTTON_EVENT_TIMEOUT: case MIDDLEBUTTON_EVENT_TIMEOUT:
middlebutton_post_event(device, middlebutton_post_event(device,
device->middlebutton.first_event_time, device->middlebutton.first_event_time,
BTN_RIGHT, evdev_usage_from(EVDEV_BTN_RIGHT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, middlebutton_set_state(device,
MIDDLEBUTTON_PASSTHROUGH, MIDDLEBUTTON_PASSTHROUGH,
@ -283,13 +283,13 @@ evdev_middlebutton_middle_handle_event(struct evdev_device *device,
break; break;
case MIDDLEBUTTON_EVENT_OTHER: case MIDDLEBUTTON_EVENT_OTHER:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
middlebutton_set_state(device, MIDDLEBUTTON_IGNORE_LR, time); middlebutton_set_state(device, MIDDLEBUTTON_IGNORE_LR, time);
return 0; return 0;
case MIDDLEBUTTON_EVENT_R_UP: case MIDDLEBUTTON_EVENT_R_UP:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
middlebutton_set_state(device, middlebutton_set_state(device,
MIDDLEBUTTON_LEFT_UP_PENDING, MIDDLEBUTTON_LEFT_UP_PENDING,
@ -297,7 +297,7 @@ evdev_middlebutton_middle_handle_event(struct evdev_device *device,
break; break;
case MIDDLEBUTTON_EVENT_L_UP: case MIDDLEBUTTON_EVENT_L_UP:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
middlebutton_set_state(device, middlebutton_set_state(device,
MIDDLEBUTTON_RIGHT_UP_PENDING, MIDDLEBUTTON_RIGHT_UP_PENDING,
@ -325,7 +325,7 @@ evdev_middlebutton_lup_pending_handle_event(struct evdev_device *device,
break; break;
case MIDDLEBUTTON_EVENT_R_DOWN: case MIDDLEBUTTON_EVENT_R_DOWN:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time); middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time);
break; break;
@ -357,7 +357,7 @@ evdev_middlebutton_rup_pending_handle_event(struct evdev_device *device,
switch (event) { switch (event) {
case MIDDLEBUTTON_EVENT_L_DOWN: case MIDDLEBUTTON_EVENT_L_DOWN:
middlebutton_post_event(device, time, middlebutton_post_event(device, time,
BTN_MIDDLE, evdev_usage_from(EVDEV_BTN_MIDDLE),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time); middlebutton_set_state(device, MIDDLEBUTTON_MIDDLE, time);
break; break;
@ -577,26 +577,26 @@ evdev_middlebutton_apply_config(struct evdev_device *device)
bool bool
evdev_middlebutton_filter_button(struct evdev_device *device, evdev_middlebutton_filter_button(struct evdev_device *device,
uint64_t time, uint64_t time,
int button, evdev_usage_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
enum evdev_middlebutton_event event; enum evdev_middlebutton_event event;
bool is_press = state == LIBINPUT_BUTTON_STATE_PRESSED; bool is_press = state == LIBINPUT_BUTTON_STATE_PRESSED;
int rc; int rc;
unsigned int btnbit = (button - BTN_LEFT); unsigned int btnbit = (evdev_usage_enum(button) - EVDEV_BTN_LEFT);
uint32_t old_mask = 0; uint32_t old_mask = 0;
if (!device->middlebutton.enabled) if (!device->middlebutton.enabled)
return false; return false;
switch (button) { switch (evdev_usage_enum(button)) {
case BTN_LEFT: case EVDEV_BTN_LEFT:
if (is_press) if (is_press)
event = MIDDLEBUTTON_EVENT_L_DOWN; event = MIDDLEBUTTON_EVENT_L_DOWN;
else else
event = MIDDLEBUTTON_EVENT_L_UP; event = MIDDLEBUTTON_EVENT_L_UP;
break; break;
case BTN_RIGHT: case EVDEV_BTN_RIGHT:
if (is_press) if (is_press)
event = MIDDLEBUTTON_EVENT_R_DOWN; event = MIDDLEBUTTON_EVENT_R_DOWN;
else else
@ -605,18 +605,17 @@ evdev_middlebutton_filter_button(struct evdev_device *device,
/* BTN_MIDDLE counts as "other" and resets middle button /* BTN_MIDDLE counts as "other" and resets middle button
* emulation */ * emulation */
case BTN_MIDDLE: case EVDEV_BTN_MIDDLE:
default: default:
event = MIDDLEBUTTON_EVENT_OTHER; event = MIDDLEBUTTON_EVENT_OTHER;
break; break;
} }
if (button < BTN_LEFT || if (evdev_usage_lt(button, EVDEV_BTN_LEFT) ||
btnbit >= sizeof(device->middlebutton.button_mask) * 8) { btnbit >= sizeof(device->middlebutton.button_mask) * 8) {
evdev_log_bug_libinput(device, evdev_log_bug_libinput(device,
"Button mask too small for %s\n", "Button mask too small for %s\n",
libevdev_event_code_get_name(EV_KEY, evdev_usage_code_name(button));
button));
return true; return true;
} }

52
src/evdev-mt-touchpad-buttons.c
View file

@ -589,16 +589,16 @@ tp_button_handle_timeout(uint64_t now, void *data)
void void
tp_process_button(struct tp_dispatch *tp, tp_process_button(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
uint32_t mask = bit(e->code - BTN_LEFT); uint32_t mask = bit(evdev_usage_enum(e->usage) - EVDEV_BTN_LEFT);
/* Ignore other buttons on clickpads */ /* Ignore other buttons on clickpads */
if (tp->buttons.is_clickpad && e->code != BTN_LEFT) { if (tp->buttons.is_clickpad && evdev_usage_ne(e->usage, EVDEV_BTN_LEFT)) {
evdev_log_bug_kernel(tp->device, evdev_log_bug_kernel(tp->device,
"received %s button event on a clickpad\n", "received %s button event on a clickpad\n",
libevdev_event_code_get_name(EV_KEY, e->code)); evdev_event_get_code_name(e));
return; return;
} }
@ -1079,20 +1079,21 @@ tp_post_physical_buttons(struct tp_dispatch *tp, uint64_t time)
current = tp->buttons.state; current = tp->buttons.state;
old = tp->buttons.old_state; old = tp->buttons.old_state;
button = BTN_LEFT; button = EVDEV_BTN_LEFT;
while (current || old) { while (current || old) {
enum libinput_button_state state; enum libinput_button_state state;
if ((current & 0x1) ^ (old & 0x1)) { if ((current & 0x1) ^ (old & 0x1)) {
uint32_t b; evdev_usage_t b;
if (!!(current & 0x1)) if (!!(current & 0x1))
state = LIBINPUT_BUTTON_STATE_PRESSED; state = LIBINPUT_BUTTON_STATE_PRESSED;
else else
state = LIBINPUT_BUTTON_STATE_RELEASED; state = LIBINPUT_BUTTON_STATE_RELEASED;
b = evdev_to_left_handed(tp->device, button); b = evdev_to_left_handed(tp->device,
evdev_usage_from_uint32_t(button));
evdev_pointer_notify_physical_button(tp->device, evdev_pointer_notify_physical_button(tp->device,
time, time,
b, b,
@ -1162,7 +1163,7 @@ out:
return within_distance; return within_distance;
} }
static uint32_t static evdev_usage_t
tp_clickfinger_set_button(struct tp_dispatch *tp) tp_clickfinger_set_button(struct tp_dispatch *tp)
{ {
uint32_t button; uint32_t button;
@ -1170,9 +1171,9 @@ tp_clickfinger_set_button(struct tp_dispatch *tp)
struct tp_touch *t; struct tp_touch *t;
struct tp_touch *first = NULL, struct tp_touch *first = NULL,
*second = NULL; *second = NULL;
int32_t button_map[2][3] = { uint32_t button_map[2][3] = {
{ BTN_LEFT, BTN_RIGHT, BTN_MIDDLE }, { EVDEV_BTN_LEFT, EVDEV_BTN_RIGHT, EVDEV_BTN_MIDDLE },
{ BTN_LEFT, BTN_MIDDLE, BTN_RIGHT }, { EVDEV_BTN_LEFT, EVDEV_BTN_MIDDLE, EVDEV_BTN_RIGHT },
}; };
tp_for_each_touch(tp, t) { tp_for_each_touch(tp, t) {
@ -1209,19 +1210,21 @@ out:
switch (nfingers) { switch (nfingers) {
case 1: case 1:
case 2: case 2:
case 3: button = button_map[tp->buttons.map][nfingers-1]; break; case 3:
button = button_map[tp->buttons.map][nfingers-1];
break;
default: default:
button = 0; button = 0;
break; break;
} }
return button; return evdev_usage_from_uint32_t(button);
} }
static int static int
tp_notify_clickpadbutton(struct tp_dispatch *tp, tp_notify_clickpadbutton(struct tp_dispatch *tp,
uint64_t time, uint64_t time,
uint32_t button, evdev_usage_t button,
uint32_t is_topbutton, uint32_t is_topbutton,
enum libinput_button_state state) enum libinput_button_state state)
{ {
@ -1233,7 +1236,7 @@ tp_notify_clickpadbutton(struct tp_dispatch *tp,
int value; int value;
value = (state == LIBINPUT_BUTTON_STATE_PRESSED) ? 1 : 0; value = (state == LIBINPUT_BUTTON_STATE_PRESSED) ? 1 : 0;
event = input_event_init(time, EV_KEY, button, value); event = input_event_init(time, EV_KEY, evdev_usage_code(button), value);
syn_report = input_event_init(time, EV_SYN, SYN_REPORT, 0); syn_report = input_event_init(time, EV_SYN, SYN_REPORT, 0);
dispatch->interface->process(dispatch, dispatch->interface->process(dispatch,
tp->buttons.trackpoint, tp->buttons.trackpoint,
@ -1263,7 +1266,7 @@ tp_notify_clickpadbutton(struct tp_dispatch *tp,
button = tp_clickfinger_set_button(tp); button = tp_clickfinger_set_button(tp);
tp->buttons.active = button; tp->buttons.active = button;
if (!button) if (evdev_usage_eq(button, 0))
return 0; return 0;
} }
@ -1274,7 +1277,8 @@ tp_notify_clickpadbutton(struct tp_dispatch *tp,
static int static int
tp_post_clickpadbutton_buttons(struct tp_dispatch *tp, uint64_t time) tp_post_clickpadbutton_buttons(struct tp_dispatch *tp, uint64_t time)
{ {
uint32_t current, old, button, is_top; uint32_t current, old, is_top;
evdev_usage_t button = evdev_usage_from_uint32_t(0);
enum libinput_button_state state; enum libinput_button_state state;
enum { AREA = 0x01, LEFT = 0x02, MIDDLE = 0x04, RIGHT = 0x08 }; enum { AREA = 0x01, LEFT = 0x02, MIDDLE = 0x04, RIGHT = 0x08 };
bool want_left_handed = true; bool want_left_handed = true;
@ -1339,15 +1343,15 @@ tp_post_clickpadbutton_buttons(struct tp_dispatch *tp, uint64_t time)
if ((tp->device->middlebutton.enabled || is_top) && if ((tp->device->middlebutton.enabled || is_top) &&
(area & LEFT) && (area & RIGHT)) { (area & LEFT) && (area & RIGHT)) {
button = BTN_MIDDLE; button = evdev_usage_from(EVDEV_BTN_MIDDLE);
} else if (area & MIDDLE) { } else if (area & MIDDLE) {
button = BTN_MIDDLE; button = evdev_usage_from(EVDEV_BTN_MIDDLE);
} else if (area & RIGHT) { } else if (area & RIGHT) {
button = BTN_RIGHT; button = evdev_usage_from(EVDEV_BTN_RIGHT);
} else if (area & LEFT) { } else if (area & LEFT) {
button = BTN_LEFT; button = evdev_usage_from(EVDEV_BTN_LEFT);
} else { /* main or no area (for clickfinger) is always BTN_LEFT */ } else { /* main or no area (for clickfinger) is always BTN_LEFT */
button = BTN_LEFT; button = evdev_usage_from(EVDEV_BTN_LEFT);
want_left_handed = false; want_left_handed = false;
} }
@ -1363,14 +1367,14 @@ tp_post_clickpadbutton_buttons(struct tp_dispatch *tp, uint64_t time)
} else { } else {
button = tp->buttons.active; button = tp->buttons.active;
is_top = tp->buttons.active_is_topbutton; is_top = tp->buttons.active_is_topbutton;
tp->buttons.active = 0; tp->buttons.active = evdev_usage_from_uint32_t(0);
tp->buttons.active_is_topbutton = 0; tp->buttons.active_is_topbutton = 0;
state = LIBINPUT_BUTTON_STATE_RELEASED; state = LIBINPUT_BUTTON_STATE_RELEASED;
} }
tp->buttons.click_pending = false; tp->buttons.click_pending = false;
if (button) if (evdev_usage_ne(button, 0))
return tp_notify_clickpadbutton(tp, return tp_notify_clickpadbutton(tp,
time, time,
button, button,

12
src/evdev-mt-touchpad-gestures.c
View file

@ -1030,7 +1030,7 @@ tp_gesture_handle_event_on_state_3fg_drag(struct tp_dispatch *tp,
/* If the gesture is cancelled we release the button immediately */ /* If the gesture is cancelled we release the button immediately */
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
tp->gesture.drag_3fg_release_time, tp->gesture.drag_3fg_release_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
tp->gesture.state = GESTURE_STATE_NONE; tp->gesture.state = GESTURE_STATE_NONE;
break; break;
@ -1044,7 +1044,7 @@ tp_gesture_handle_event_on_state_3fg_drag(struct tp_dispatch *tp,
if (tp->gesture.finger_count_pending < 2) { if (tp->gesture.finger_count_pending < 2) {
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
tp->gesture.drag_3fg_release_time, tp->gesture.drag_3fg_release_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
tp->gesture.state = GESTURE_STATE_NONE; tp->gesture.state = GESTURE_STATE_NONE;
} }
@ -1082,7 +1082,7 @@ tp_gesture_handle_event_on_state_3fg_drag_released(struct tp_dispatch *tp,
libinput_timer_cancel(&tp->gesture.finger_count_switch_timer); libinput_timer_cancel(&tp->gesture.finger_count_switch_timer);
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
tp->gesture.drag_3fg_release_time, tp->gesture.drag_3fg_release_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
tp->gesture.state = GESTURE_STATE_NONE; tp->gesture.state = GESTURE_STATE_NONE;
break; break;
@ -1100,7 +1100,7 @@ tp_gesture_handle_event_on_state_3fg_drag_released(struct tp_dispatch *tp,
libinput_timer_cancel(&tp->gesture.drag_3fg_timer); libinput_timer_cancel(&tp->gesture.drag_3fg_timer);
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
tp->gesture.drag_3fg_release_time, tp->gesture.drag_3fg_release_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
tp->gesture.state = GESTURE_STATE_POINTER_MOTION; tp->gesture.state = GESTURE_STATE_POINTER_MOTION;
break; break;
@ -1114,7 +1114,7 @@ tp_gesture_handle_event_on_state_3fg_drag_released(struct tp_dispatch *tp,
libinput_timer_cancel(&tp->gesture.drag_3fg_timer); libinput_timer_cancel(&tp->gesture.drag_3fg_timer);
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
tp->gesture.drag_3fg_release_time, tp->gesture.drag_3fg_release_time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_RELEASED); LIBINPUT_BUTTON_STATE_RELEASED);
tp->gesture.state = GESTURE_STATE_SCROLL_START; tp->gesture.state = GESTURE_STATE_SCROLL_START;
break; break;
@ -1709,7 +1709,7 @@ tp_gesture_handle_state_3fg_drag_start(struct tp_dispatch *tp, uint64_t time)
{ {
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
time, time,
BTN_LEFT, evdev_usage_from(EVDEV_BTN_LEFT),
LIBINPUT_BUTTON_STATE_PRESSED); LIBINPUT_BUTTON_STATE_PRESSED);
/* FIXME: immediately send a motion event? */ /* FIXME: immediately send a motion event? */
tp->gesture.state = GESTURE_STATE_3FG_DRAG; tp->gesture.state = GESTURE_STATE_3FG_DRAG;

8
src/evdev-mt-touchpad-tap.c
View file

@ -126,9 +126,9 @@ tp_tap_notify(struct tp_dispatch *tp,
enum libinput_button_state state) enum libinput_button_state state)
{ {
int32_t button; int32_t button;
int32_t button_map[2][3] = { uint32_t button_map[2][3] = {
{ BTN_LEFT, BTN_RIGHT, BTN_MIDDLE }, { EVDEV_BTN_LEFT, EVDEV_BTN_RIGHT, EVDEV_BTN_MIDDLE },
{ BTN_LEFT, BTN_MIDDLE, BTN_RIGHT }, { EVDEV_BTN_LEFT, EVDEV_BTN_MIDDLE, EVDEV_BTN_RIGHT },
}; };
assert(tp->tap.map < ARRAY_LENGTH(button_map)); assert(tp->tap.map < ARRAY_LENGTH(button_map));
@ -147,7 +147,7 @@ tp_tap_notify(struct tp_dispatch *tp,
evdev_pointer_notify_button(tp->device, evdev_pointer_notify_button(tp->device,
time, time,
button, evdev_usage_from_uint32_t(button),
state); state);
} }

162
src/evdev-mt-touchpad.c
View file

@ -290,29 +290,29 @@ tp_fake_finger_is_touching(struct tp_dispatch *tp)
static inline void static inline void
tp_fake_finger_set(struct tp_dispatch *tp, tp_fake_finger_set(struct tp_dispatch *tp,
unsigned int code, evdev_usage_t usage,
bool is_press) bool is_press)
{ {
unsigned int shift; unsigned int shift;
switch (code) { switch (evdev_usage_enum(usage)) {
case BTN_TOUCH: case EVDEV_BTN_TOUCH:
if (!is_press) if (!is_press)
tp->fake_touches &= ~FAKE_FINGER_OVERFLOW; tp->fake_touches &= ~FAKE_FINGER_OVERFLOW;
shift = 0; shift = 0;
break; break;
case BTN_TOOL_FINGER: case EVDEV_BTN_TOOL_FINGER:
shift = 1; shift = 1;
break; break;
case BTN_TOOL_DOUBLETAP: case EVDEV_BTN_TOOL_DOUBLETAP:
case BTN_TOOL_TRIPLETAP: case EVDEV_BTN_TOOL_TRIPLETAP:
case BTN_TOOL_QUADTAP: case EVDEV_BTN_TOOL_QUADTAP:
shift = code - BTN_TOOL_DOUBLETAP + 2; shift = evdev_usage_enum(usage) - EVDEV_BTN_TOOL_DOUBLETAP + 2;
break; break;
/* when QUINTTAP is released we're either switching to 6 fingers /* when QUINTTAP is released we're either switching to 6 fingers
(flag stays in place until BTN_TOUCH is released) or (flag stays in place until BTN_TOUCH is released) or
one of DOUBLE/TRIPLE/QUADTAP (will clear the flag on press) */ one of DOUBLE/TRIPLE/QUADTAP (will clear the flag on press) */
case BTN_TOOL_QUINTTAP: case EVDEV_BTN_TOOL_QUINTTAP:
if (is_press) if (is_press)
tp->fake_touches |= FAKE_FINGER_OVERFLOW; tp->fake_touches |= FAKE_FINGER_OVERFLOW;
return; return;
@ -493,20 +493,20 @@ tp_get_delta(struct tp_touch *t)
} }
static inline int32_t static inline int32_t
rotated(struct tp_dispatch *tp, unsigned int code, int value) rotated(struct tp_dispatch *tp, evdev_usage_t usage, int value)
{ {
const struct input_absinfo *absinfo; const struct input_absinfo *absinfo;
if (!tp->left_handed.rotate) if (!tp->left_handed.rotate)
return value; return value;
switch (code) { switch (evdev_usage_enum(usage)) {
case ABS_X: case EVDEV_ABS_X:
case ABS_MT_POSITION_X: case EVDEV_ABS_MT_POSITION_X:
absinfo = tp->device->abs.absinfo_x; absinfo = tp->device->abs.absinfo_x;
break; break;
case ABS_Y: case EVDEV_ABS_Y:
case ABS_MT_POSITION_Y: case EVDEV_ABS_MT_POSITION_Y:
absinfo = tp->device->abs.absinfo_y; absinfo = tp->device->abs.absinfo_y;
break; break;
default: default:
@ -517,32 +517,32 @@ rotated(struct tp_dispatch *tp, unsigned int code, int value)
static void static void
tp_process_absolute(struct tp_dispatch *tp, tp_process_absolute(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
struct tp_touch *t = tp_current_touch(tp); struct tp_touch *t = tp_current_touch(tp);
switch(e->code) { switch (evdev_usage_enum(e->usage)) {
case ABS_MT_POSITION_X: case EVDEV_ABS_MT_POSITION_X:
evdev_device_check_abs_axis_range(tp->device, evdev_device_check_abs_axis_range(tp->device,
e->code, e->usage,
e->value); e->value);
t->point.x = rotated(tp, e->code, e->value); t->point.x = rotated(tp, e->usage, e->value);
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_MOTION; tp->queued |= TOUCHPAD_EVENT_MOTION;
break; break;
case ABS_MT_POSITION_Y: case EVDEV_ABS_MT_POSITION_Y:
evdev_device_check_abs_axis_range(tp->device, evdev_device_check_abs_axis_range(tp->device,
e->code, e->usage,
e->value); e->value);
t->point.y = rotated(tp, e->code, e->value); t->point.y = rotated(tp, e->usage, e->value);
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_MOTION; tp->queued |= TOUCHPAD_EVENT_MOTION;
break; break;
case ABS_MT_SLOT: case EVDEV_ABS_MT_SLOT:
tp->slot = e->value; tp->slot = e->value;
break; break;
case ABS_MT_TRACKING_ID: case EVDEV_ABS_MT_TRACKING_ID:
if (e->value != -1) { if (e->value != -1) {
tp->nactive_slots += 1; tp->nactive_slots += 1;
tp_new_touch(tp, t, time); tp_new_touch(tp, t, time);
@ -551,58 +551,62 @@ tp_process_absolute(struct tp_dispatch *tp,
tp_end_sequence(tp, t, time); tp_end_sequence(tp, t, time);
} }
break; break;
case ABS_MT_PRESSURE: case EVDEV_ABS_MT_PRESSURE:
t->pressure = e->value; t->pressure = e->value;
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_OTHERAXIS; tp->queued |= TOUCHPAD_EVENT_OTHERAXIS;
break; break;
case ABS_MT_TOOL_TYPE: case EVDEV_ABS_MT_TOOL_TYPE:
t->is_tool_palm = e->value == MT_TOOL_PALM; t->is_tool_palm = e->value == MT_TOOL_PALM;
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_OTHERAXIS; tp->queued |= TOUCHPAD_EVENT_OTHERAXIS;
break; break;
case ABS_MT_TOUCH_MAJOR: case EVDEV_ABS_MT_TOUCH_MAJOR:
t->major = e->value; t->major = e->value;
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_OTHERAXIS; tp->queued |= TOUCHPAD_EVENT_OTHERAXIS;
break; break;
case ABS_MT_TOUCH_MINOR: case EVDEV_ABS_MT_TOUCH_MINOR:
t->minor = e->value; t->minor = e->value;
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_OTHERAXIS; tp->queued |= TOUCHPAD_EVENT_OTHERAXIS;
break; break;
default:
break;
} }
} }
static void static void
tp_process_absolute_st(struct tp_dispatch *tp, tp_process_absolute_st(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
struct tp_touch *t = tp_current_touch(tp); struct tp_touch *t = tp_current_touch(tp);
switch(e->code) { switch (evdev_usage_enum(e->usage)) {
case ABS_X: case EVDEV_ABS_X:
evdev_device_check_abs_axis_range(tp->device, evdev_device_check_abs_axis_range(tp->device,
e->code, e->usage,
e->value); e->value);
t->point.x = rotated(tp, e->code, e->value); t->point.x = rotated(tp, e->usage, e->value);
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_MOTION; tp->queued |= TOUCHPAD_EVENT_MOTION;
break; break;
case ABS_Y: case EVDEV_ABS_Y:
evdev_device_check_abs_axis_range(tp->device, evdev_device_check_abs_axis_range(tp->device,
e->code, e->usage,
e->value); e->value);
t->point.y = rotated(tp, e->code, e->value); t->point.y = rotated(tp, e->usage, e->value);
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_MOTION; tp->queued |= TOUCHPAD_EVENT_MOTION;
break; break;
case ABS_PRESSURE: case EVDEV_ABS_PRESSURE:
t->pressure = e->value; t->pressure = e->value;
t->dirty = true; t->dirty = true;
tp->queued |= TOUCHPAD_EVENT_OTHERAXIS; tp->queued |= TOUCHPAD_EVENT_OTHERAXIS;
break; break;
default:
break;
} }
} }
@ -709,7 +713,7 @@ tp_process_fake_touches(struct tp_dispatch *tp,
static void static void
tp_process_trackpoint_button(struct tp_dispatch *tp, tp_process_trackpoint_button(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
struct evdev_dispatch *dispatch; struct evdev_dispatch *dispatch;
@ -727,18 +731,18 @@ tp_process_trackpoint_button(struct tp_dispatch *tp,
dispatch = tp->buttons.trackpoint->dispatch; dispatch = tp->buttons.trackpoint->dispatch;
event = *e; event = evdev_event_to_input_event(e, time);
syn_report.input_event_sec = e->input_event_sec; syn_report.input_event_sec = event.input_event_sec;
syn_report.input_event_usec = e->input_event_usec; syn_report.input_event_usec = event.input_event_usec;
switch (event.code) { switch (evdev_usage_enum(e->usage)) {
case BTN_0: case EVDEV_BTN_0:
event.code = BTN_LEFT; event.code = BTN_LEFT;
break; break;
case BTN_1: case EVDEV_BTN_1:
event.code = BTN_RIGHT; event.code = BTN_RIGHT;
break; break;
case BTN_2: case EVDEV_BTN_2:
event.code = BTN_MIDDLE; event.code = BTN_MIDDLE;
break; break;
default: default:
@ -755,41 +759,43 @@ tp_process_trackpoint_button(struct tp_dispatch *tp,
static void static void
tp_process_key(struct tp_dispatch *tp, tp_process_key(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
/* ignore kernel key repeat */ /* ignore kernel key repeat */
if (e->value == 2) if (e->value == 2)
return; return;
switch (e->code) { switch (evdev_usage_enum(e->usage)) {
case BTN_LEFT: case EVDEV_BTN_LEFT:
case BTN_MIDDLE: case EVDEV_BTN_MIDDLE:
case BTN_RIGHT: case EVDEV_BTN_RIGHT:
tp_process_button(tp, e, time); tp_process_button(tp, e, time);
break; break;
case BTN_TOUCH: case EVDEV_BTN_TOUCH:
case BTN_TOOL_FINGER: case EVDEV_BTN_TOOL_FINGER:
case BTN_TOOL_DOUBLETAP: case EVDEV_BTN_TOOL_DOUBLETAP:
case BTN_TOOL_TRIPLETAP: case EVDEV_BTN_TOOL_TRIPLETAP:
case BTN_TOOL_QUADTAP: case EVDEV_BTN_TOOL_QUADTAP:
case BTN_TOOL_QUINTTAP: case EVDEV_BTN_TOOL_QUINTTAP:
tp_fake_finger_set(tp, e->code, !!e->value); tp_fake_finger_set(tp, e->usage, !!e->value);
break; break;
case BTN_0: case EVDEV_BTN_0:
case BTN_1: case EVDEV_BTN_1:
case BTN_2: case EVDEV_BTN_2:
tp_process_trackpoint_button(tp, e, time); tp_process_trackpoint_button(tp, e, time);
break; break;
default:
break;
} }
} }
static void static void
tp_process_msc(struct tp_dispatch *tp, tp_process_msc(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
if (e->code != MSC_TIMESTAMP) if (evdev_usage_eq(e->usage, EVDEV_MSC_TIMESTAMP))
return; return;
tp->quirks.msc_timestamp.now = e->value; tp->quirks.msc_timestamp.now = e->value;
@ -1939,23 +1945,25 @@ tp_debug_touch_state(struct tp_dispatch *tp,
static void static void
tp_interface_process(struct evdev_dispatch *dispatch, tp_interface_process(struct evdev_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, struct input_event *input_event,
uint64_t time) uint64_t time)
{ {
struct tp_dispatch *tp = tp_dispatch(dispatch); struct tp_dispatch *tp = tp_dispatch(dispatch);
struct evdev_event e = evdev_event_from_input_event(input_event, NULL);
switch (e->type) { uint16_t type = evdev_event_type(&e);
switch (type) {
case EV_ABS: case EV_ABS:
if (tp->has_mt) if (tp->has_mt)
tp_process_absolute(tp, e, time); tp_process_absolute(tp, &e, time);
else else
tp_process_absolute_st(tp, e, time); tp_process_absolute_st(tp, &e, time);
break; break;
case EV_KEY: case EV_KEY:
tp_process_key(tp, e, time); tp_process_key(tp, &e, time);
break; break;
case EV_MSC: case EV_MSC:
tp_process_msc(tp, e, time); tp_process_msc(tp, &e, time);
break; break;
case EV_SYN: case EV_SYN:
tp_handle_state(tp, time); tp_handle_state(tp, time);
@ -2643,8 +2651,8 @@ tp_interface_device_removed(struct evdev_device *device,
if (removed_device == tp->buttons.trackpoint) { if (removed_device == tp->buttons.trackpoint) {
/* Clear any pending releases for the trackpoint */ /* Clear any pending releases for the trackpoint */
if (tp->buttons.active && tp->buttons.active_is_topbutton) { if (evdev_usage_ne(tp->buttons.active, 0) && tp->buttons.active_is_topbutton) {
tp->buttons.active = 0; tp->buttons.active = evdev_usage_from_uint32_t(0);
tp->buttons.active_is_topbutton = false; tp->buttons.active_is_topbutton = false;
} }
if (tp->palm.monitor_trackpoint) if (tp->palm.monitor_trackpoint)
@ -2964,7 +2972,7 @@ tp_init_slots(struct tp_dispatch *tp,
* performed. * performed.
*/ */
if (libevdev_get_event_value(device->evdev, EV_KEY, BTN_TOOL_FINGER)) if (libevdev_get_event_value(device->evdev, EV_KEY, BTN_TOOL_FINGER))
tp_fake_finger_set(tp, BTN_TOOL_FINGER, 1); tp_fake_finger_set(tp, evdev_usage_from(EVDEV_BTN_TOOL_FINGER), true);
return true; return true;
} }

4
src/evdev-mt-touchpad.h
View file

@ -384,7 +384,7 @@ struct tp_dispatch {
double x_scale_coeff; double x_scale_coeff;
double y_scale_coeff; double y_scale_coeff;
} motion_dist; /* for pinned touches */ } motion_dist; /* for pinned touches */
unsigned int active; /* currently active button, for release event */ evdev_usage_t active; /* currently active button, for release event */
bool active_is_topbutton; /* is active a top button? */ bool active_is_topbutton; /* is active a top button? */
/* Only used for clickpads. The software button areas are /* Only used for clickpads. The software button areas are
@ -664,7 +664,7 @@ tp_remove_buttons(struct tp_dispatch *tp);
void void
tp_process_button(struct tp_dispatch *tp, tp_process_button(struct tp_dispatch *tp,
const struct input_event *e, const struct evdev_event *e,
uint64_t time); uint64_t time);
void void

26
src/evdev-wheel.c
View file

@ -307,18 +307,20 @@ wheel_handle_state_scrolling(struct fallback_dispatch *dispatch,
static void static void
wheel_handle_direction_change(struct fallback_dispatch *dispatch, wheel_handle_direction_change(struct fallback_dispatch *dispatch,
struct input_event *e, struct evdev_event *e,
uint64_t time) uint64_t time)
{ {
enum wheel_direction new_dir = WHEEL_DIR_UNKNOW; enum wheel_direction new_dir = WHEEL_DIR_UNKNOW;
switch (e->code) { switch (evdev_usage_enum(e->usage)) {
case REL_WHEEL_HI_RES: case EVDEV_REL_WHEEL_HI_RES:
new_dir = (e->value > 0) ? WHEEL_DIR_VPOS : WHEEL_DIR_VNEG; new_dir = (e->value > 0) ? WHEEL_DIR_VPOS : WHEEL_DIR_VNEG;
break; break;
case REL_HWHEEL_HI_RES: case EVDEV_REL_HWHEEL_HI_RES:
new_dir = (e->value > 0) ? WHEEL_DIR_HPOS : WHEEL_DIR_HNEG; new_dir = (e->value > 0) ? WHEEL_DIR_HPOS : WHEEL_DIR_HNEG;
break; break;
default:
return;
} }
if (new_dir != WHEEL_DIR_UNKNOW && new_dir != dispatch->wheel.dir) { if (new_dir != WHEEL_DIR_UNKNOW && new_dir != dispatch->wheel.dir) {
@ -332,7 +334,7 @@ wheel_handle_direction_change(struct fallback_dispatch *dispatch,
static void static void
fallback_rotate_wheel(struct fallback_dispatch *dispatch, fallback_rotate_wheel(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e) struct evdev_event *e)
{ {
/* Special case: if we're upside down (-ish), /* Special case: if we're upside down (-ish),
* swap the direction of the wheels so that user-down * swap the direction of the wheels so that user-down
@ -347,10 +349,10 @@ fallback_rotate_wheel(struct fallback_dispatch *dispatch,
void void
fallback_wheel_process_relative(struct fallback_dispatch *dispatch, fallback_wheel_process_relative(struct fallback_dispatch *dispatch,
struct evdev_device *device, struct evdev_device *device,
struct input_event *e, uint64_t time) struct evdev_event *e, uint64_t time)
{ {
switch (e->code) { switch (evdev_usage_enum(e->usage)) {
case REL_WHEEL: case EVDEV_REL_WHEEL:
fallback_rotate_wheel(dispatch, device, e); fallback_rotate_wheel(dispatch, device, e);
dispatch->wheel.lo_res.y += e->value; dispatch->wheel.lo_res.y += e->value;
if (dispatch->wheel.emulate_hi_res_wheel) if (dispatch->wheel.emulate_hi_res_wheel)
@ -358,7 +360,7 @@ fallback_wheel_process_relative(struct fallback_dispatch *dispatch,
dispatch->pending_event |= EVDEV_WHEEL; dispatch->pending_event |= EVDEV_WHEEL;
wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time); wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time);
break; break;
case REL_HWHEEL: case EVDEV_REL_HWHEEL:
fallback_rotate_wheel(dispatch, device, e); fallback_rotate_wheel(dispatch, device, e);
dispatch->wheel.lo_res.x += e->value; dispatch->wheel.lo_res.x += e->value;
if (dispatch->wheel.emulate_hi_res_wheel) if (dispatch->wheel.emulate_hi_res_wheel)
@ -366,7 +368,7 @@ fallback_wheel_process_relative(struct fallback_dispatch *dispatch,
dispatch->pending_event |= EVDEV_WHEEL; dispatch->pending_event |= EVDEV_WHEEL;
wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time); wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time);
break; break;
case REL_WHEEL_HI_RES: case EVDEV_REL_WHEEL_HI_RES:
fallback_rotate_wheel(dispatch, device, e); fallback_rotate_wheel(dispatch, device, e);
dispatch->wheel.hi_res.y += e->value; dispatch->wheel.hi_res.y += e->value;
dispatch->wheel.hi_res_event_received = true; dispatch->wheel.hi_res_event_received = true;
@ -374,7 +376,7 @@ fallback_wheel_process_relative(struct fallback_dispatch *dispatch,
wheel_handle_direction_change(dispatch, e, time); wheel_handle_direction_change(dispatch, e, time);
wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time); wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time);
break; break;
case REL_HWHEEL_HI_RES: case EVDEV_REL_HWHEEL_HI_RES:
fallback_rotate_wheel(dispatch, device, e); fallback_rotate_wheel(dispatch, device, e);
dispatch->wheel.hi_res.x += e->value; dispatch->wheel.hi_res.x += e->value;
dispatch->wheel.hi_res_event_received = true; dispatch->wheel.hi_res_event_received = true;
@ -382,6 +384,8 @@ fallback_wheel_process_relative(struct fallback_dispatch *dispatch,
wheel_handle_direction_change(dispatch, e, time); wheel_handle_direction_change(dispatch, e, time);
wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time); wheel_handle_event(dispatch, WHEEL_EVENT_SCROLL, time);
break; break;
default:
break;
} }
} }

39
src/evdev.c
View file

@ -129,11 +129,13 @@ parse_udev_flag(struct evdev_device *device,
int int
evdev_update_key_down_count(struct evdev_device *device, evdev_update_key_down_count(struct evdev_device *device,
int code, evdev_usage_t usage,
int pressed) int pressed)
{ {
int key_count = 0; int key_count = 0;
assert(code >= 0 && code < KEY_CNT); assert(evdev_usage_ge(usage, EVDEV_KEY_RESERVED) && evdev_usage_le(usage, EVDEV_KEY_MAX));
unsigned int code = evdev_usage_code(usage);
if (pressed) { if (pressed) {
key_count = ++device->key_count[code]; key_count = ++device->key_count[code];
@ -142,8 +144,9 @@ evdev_update_key_down_count(struct evdev_device *device,
key_count = --device->key_count[code]; key_count = --device->key_count[code];
} else { } else {
evdev_log_bug_libinput(device, evdev_log_bug_libinput(device,
"releasing key %s with count %d\n", "releasing key %s (%#x) with count %d\n",
libevdev_event_code_get_name(EV_KEY, code), libevdev_event_code_get_name(EV_KEY, code),
evdev_usage_as_uint32_t(usage),
device->key_count[code]); device->key_count[code]);
} }
} }
@ -171,7 +174,7 @@ evdev_device_switch_get_state(struct evdev_device *device,
void void
evdev_pointer_notify_physical_button(struct evdev_device *device, evdev_pointer_notify_physical_button(struct evdev_device *device,
uint64_t time, uint64_t time,
int button, evdev_usage_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
if (evdev_middlebutton_filter_button(device, if (evdev_middlebutton_filter_button(device,
@ -182,23 +185,25 @@ evdev_pointer_notify_physical_button(struct evdev_device *device,
evdev_pointer_notify_button(device, evdev_pointer_notify_button(device,
time, time,
(unsigned int)button, button,
state); state);
} }
static void static void
evdev_pointer_post_button(struct evdev_device *device, evdev_pointer_post_button(struct evdev_device *device,
uint64_t time, uint64_t time,
unsigned int button, evdev_usage_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
int down_count; int down_count;
down_count = evdev_update_key_down_count(device, button, state); down_count = evdev_update_key_down_count(device,
button,
state);
if ((state == LIBINPUT_BUTTON_STATE_PRESSED && down_count == 1) || if ((state == LIBINPUT_BUTTON_STATE_PRESSED && down_count == 1) ||
(state == LIBINPUT_BUTTON_STATE_RELEASED && down_count == 0)) { (state == LIBINPUT_BUTTON_STATE_RELEASED && down_count == 0)) {
pointer_notify_button(&device->base, time, button, state); pointer_notify_button(&device->base, time, evdev_usage_code(button), state);
if (state == LIBINPUT_BUTTON_STATE_RELEASED) { if (state == LIBINPUT_BUTTON_STATE_RELEASED) {
if (device->left_handed.change_to_enabled) if (device->left_handed.change_to_enabled)
@ -251,7 +256,7 @@ evdev_button_scroll_button(struct evdev_device *device,
} }
if (is_press) { if (is_press) {
if (device->scroll.button < BTN_MOUSE + 5) { if (evdev_usage_lt(device->scroll.button, EVDEV_BTN_LEFT + 5)) {
/* For mouse buttons 1-5 (0x110 to 0x114) we apply a timeout before scrolling /* For mouse buttons 1-5 (0x110 to 0x114) we apply a timeout before scrolling
* since the button could also be used for regular clicking. */ * since the button could also be used for regular clicking. */
enum timer_flags flags = TIMER_FLAG_NONE; enum timer_flags flags = TIMER_FLAG_NONE;
@ -266,8 +271,8 @@ evdev_button_scroll_button(struct evdev_device *device,
* for a negative timer to be set. * for a negative timer to be set.
*/ */
if (device->middlebutton.enabled && if (device->middlebutton.enabled &&
(device->scroll.button == BTN_LEFT || (evdev_usage_eq(device->scroll.button, EVDEV_BTN_LEFT) ||
device->scroll.button == BTN_RIGHT)) { evdev_usage_eq(device->scroll.button, EVDEV_BTN_RIGHT))) {
flags = TIMER_FLAG_ALLOW_NEGATIVE; flags = TIMER_FLAG_ALLOW_NEGATIVE;
} }
@ -318,11 +323,11 @@ evdev_button_scroll_button(struct evdev_device *device,
void void
evdev_pointer_notify_button(struct evdev_device *device, evdev_pointer_notify_button(struct evdev_device *device,
uint64_t time, uint64_t time,
unsigned int button, evdev_usage_t button,
enum libinput_button_state state) enum libinput_button_state state)
{ {
if (device->scroll.method == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN && if (device->scroll.method == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN &&
button == device->scroll.button) { evdev_usage_cmp(button, device->scroll.button) == 0) {
evdev_button_scroll_button(device, time, state); evdev_button_scroll_button(device, time, state);
return; return;
} }
@ -790,7 +795,7 @@ evdev_scroll_set_button(struct libinput_device *device,
{ {
struct evdev_device *evdev = evdev_device(device); struct evdev_device *evdev = evdev_device(device);
evdev->scroll.want_button = button; evdev->scroll.want_button = evdev_usage_from_code(EV_KEY, button);
evdev->scroll.change_scroll_method(evdev); evdev->scroll.change_scroll_method(evdev);
return LIBINPUT_CONFIG_STATUS_SUCCESS; return LIBINPUT_CONFIG_STATUS_SUCCESS;
@ -803,7 +808,7 @@ evdev_scroll_get_button(struct libinput_device *device)
/* return the wanted configuration, even if it hasn't taken /* return the wanted configuration, even if it hasn't taken
* effect yet! */ * effect yet! */
return evdev->scroll.want_button; return evdev_usage_code(evdev->scroll.want_button);
} }
static uint32_t static uint32_t
@ -902,7 +907,7 @@ evdev_init_button_scroll(struct evdev_device *device,
device->base.config.scroll_method = &device->scroll.config; device->base.config.scroll_method = &device->scroll.config;
device->scroll.method = evdev_scroll_get_default_method((struct libinput_device *)device); device->scroll.method = evdev_scroll_get_default_method((struct libinput_device *)device);
device->scroll.want_method = device->scroll.method; device->scroll.want_method = device->scroll.method;
device->scroll.button = evdev_scroll_get_default_button((struct libinput_device *)device); device->scroll.button = evdev_usage_from_code(EV_KEY, evdev_scroll_get_default_button((struct libinput_device *)device));
device->scroll.want_button = device->scroll.button; device->scroll.want_button = device->scroll.button;
device->scroll.change_scroll_method = change_scroll_method; device->scroll.change_scroll_method = change_scroll_method;
} }
@ -2149,7 +2154,7 @@ evdev_configure_device(struct evdev_device *device)
/* want button scrolling config option */ /* want button scrolling config option */
if (libevdev_has_event_code(evdev, EV_REL, REL_X) || if (libevdev_has_event_code(evdev, EV_REL, REL_X) ||
libevdev_has_event_code(evdev, EV_REL, REL_Y)) libevdev_has_event_code(evdev, EV_REL, REL_Y))
device->scroll.want_button = 1; device->scroll.want_button = evdev_usage_from_code(EV_KEY, 1);
} }
if (udev_tags & EVDEV_UDEV_TAG_KEYBOARD) { if (udev_tags & EVDEV_UDEV_TAG_KEYBOARD) {

39
src/evdev.h
View file

@ -37,6 +37,7 @@
#include "timer.h" #include "timer.h"
#include "filter.h" #include "filter.h"
#include "quirks.h" #include "quirks.h"
#include "evdev-frame.h"
#include "util-input-event.h" #include "util-input-event.h"
/* The fake resolution value for abs devices without resolution */ /* The fake resolution value for abs devices without resolution */
@ -212,13 +213,13 @@ struct evdev_device {
struct libinput_device_config_scroll_method config; struct libinput_device_config_scroll_method config;
/* Currently enabled method, button */ /* Currently enabled method, button */
enum libinput_config_scroll_method method; enum libinput_config_scroll_method method;
uint32_t button; evdev_usage_t button;
uint64_t button_down_time; uint64_t button_down_time;
/* set during device init, used at runtime to delay changes /* set during device init, used at runtime to delay changes
* until all buttons are up */ * until all buttons are up */
enum libinput_config_scroll_method want_method; enum libinput_config_scroll_method want_method;
uint32_t want_button; evdev_usage_t want_button;
/* Checks if buttons are down and commits the setting */ /* Checks if buttons are down and commits the setting */
void (*change_scroll_method)(struct evdev_device *device); void (*change_scroll_method)(struct evdev_device *device);
enum evdev_button_scroll_state button_scroll_state; enum evdev_button_scroll_state button_scroll_state;
@ -569,12 +570,12 @@ evdev_notify_resumed_device(struct evdev_device *device);
void void
evdev_pointer_notify_button(struct evdev_device *device, evdev_pointer_notify_button(struct evdev_device *device,
uint64_t time, uint64_t time,
unsigned int button, evdev_usage_t button,
enum libinput_button_state state); enum libinput_button_state state);
void void
evdev_pointer_notify_physical_button(struct evdev_device *device, evdev_pointer_notify_physical_button(struct evdev_device *device,
uint64_t time, uint64_t time,
int button, evdev_usage_t button,
enum libinput_button_state state); enum libinput_button_state state);
void void
@ -590,7 +591,7 @@ evdev_set_button_scroll_lock_enabled(struct evdev_device *device,
int int
evdev_update_key_down_count(struct evdev_device *device, evdev_update_key_down_count(struct evdev_device *device,
int code, evdev_usage_t code,
int pressed); int pressed);
void void
@ -636,7 +637,7 @@ evdev_device_destroy(struct evdev_device *device);
bool bool
evdev_middlebutton_filter_button(struct evdev_device *device, evdev_middlebutton_filter_button(struct evdev_device *device,
uint64_t time, uint64_t time,
int button, evdev_usage_t button,
enum libinput_button_state state); enum libinput_button_state state);
void void
@ -668,15 +669,15 @@ void
evdev_init_left_handed(struct evdev_device *device, evdev_init_left_handed(struct evdev_device *device,
void (*change_to_left_handed)(struct evdev_device *)); void (*change_to_left_handed)(struct evdev_device *));
static inline uint32_t static inline evdev_usage_t
evdev_to_left_handed(struct evdev_device *device, evdev_to_left_handed(struct evdev_device *device,
uint32_t button) evdev_usage_t button)
{ {
if (device->left_handed.enabled) { if (device->left_handed.enabled) {
if (button == BTN_LEFT) if (evdev_usage_eq(button, EVDEV_BTN_LEFT))
return BTN_RIGHT; return evdev_usage_from(EVDEV_BTN_RIGHT);
else if (button == BTN_RIGHT) else if (evdev_usage_eq(button, EVDEV_BTN_RIGHT))
return BTN_LEFT; return evdev_usage_from(EVDEV_BTN_LEFT);
} }
return button; return button;
} }
@ -1002,19 +1003,19 @@ evdev_device_init_abs_range_warnings(struct evdev_device *device)
static inline void static inline void
evdev_device_check_abs_axis_range(struct evdev_device *device, evdev_device_check_abs_axis_range(struct evdev_device *device,
unsigned int code, evdev_usage_t usage,
int value) int value)
{ {
int min, max; int min, max;
switch(code) { switch (evdev_usage_enum(usage)) {
case ABS_X: case EVDEV_ABS_X:
case ABS_MT_POSITION_X: case EVDEV_ABS_MT_POSITION_X:
min = device->abs.warning_range.min.x; min = device->abs.warning_range.min.x;
max = device->abs.warning_range.max.x; max = device->abs.warning_range.max.x;
break; break;
case ABS_Y: case EVDEV_ABS_Y:
case ABS_MT_POSITION_Y: case EVDEV_ABS_MT_POSITION_Y:
min = device->abs.warning_range.min.y; min = device->abs.warning_range.min.y;
max = device->abs.warning_range.max.y; max = device->abs.warning_range.max.y;
break; break;
@ -1027,7 +1028,7 @@ evdev_device_check_abs_axis_range(struct evdev_device *device,
&device->abs.warning_range.range_warn_limit, &device->abs.warning_range.range_warn_limit,
"Axis %#x value %d is outside expected range [%d, %d]\n" "Axis %#x value %d is outside expected range [%d, %d]\n"
"See %s/absolute-coordinate-ranges.html for details\n", "See %s/absolute-coordinate-ranges.html for details\n",
code, value, min, max, evdev_usage_enum(usage), value, min, max,
HTTP_DOC_LINK); HTTP_DOC_LINK);
} }
} }