fdo-mirrors/libinput
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libinput/libinput.git synced 2026-03-21 21:30:36 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

touchpad: if a device has a tablet mode switch, disable the touchpad

Browse source 
On some devices with a tablet mode switch, the touchpad is inacessible when
in tablet mode and we don't really need this except to avoid possible ghost
touches (none have been mentioned so far). On other devices like the Lenovo
Yoga, the touchpad points to the back of the device and it's hard to use the
device without accidentally using the touchpad. For those, disabling the
touchpad is the best solution.

https://bugs.freedesktop.org/show_bug.cgi?id=102408

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
This commit is contained in:
Peter Hutterer 2017-09-01 17:30:08 +10:00
parent 82f2dd8faa
commit 986604fd9d
5 changed files with 198 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -1479,6 +1479,10 @@ tp_remove_sendevents(struct tp_dispatch *tp)
if (tp->lid_switch.lid_switch)
libinput_device_remove_event_listener(
&tp->lid_switch.listener);
if (tp->tablet_mode_switch.tablet_mode_switch)
libinput_device_remove_event_listener(
&tp->tablet_mode_switch.listener);
}
static void
@ -1861,23 +1865,34 @@ tp_pair_trackpoint(struct evdev_device *touchpad,
}
static void
tp_lid_switch_event(uint64_t time, struct libinput_event *event, void *data)
tp_switch_event(uint64_t time, struct libinput_event *event, void *data)
{
struct tp_dispatch *tp = data;
struct libinput_event_switch *swev;
const char *which = NULL;
if (libinput_event_get_type(event) != LIBINPUT_EVENT_SWITCH_TOGGLE)
return;
swev = libinput_event_get_switch_event(event);
switch (libinput_event_switch_get_switch(swev)) {
case LIBINPUT_SWITCH_LID:
which = "lid";
break;
case LIBINPUT_SWITCH_TABLET_MODE:
which = "tablet-mode";
break;
}
switch (libinput_event_switch_get_switch_state(swev)) {
case LIBINPUT_SWITCH_STATE_OFF:
tp_resume(tp, tp->device);
evdev_log_debug(tp->device, "lid: resume touchpad\n");
evdev_log_debug(tp->device, "%s: resume touchpad\n", which);
break;
case LIBINPUT_SWITCH_STATE_ON:
tp_suspend(tp, tp->device);
evdev_log_debug(tp->device, "lid: suspend touchpad\n");
evdev_log_debug(tp->device, "%s: suspend touchpad\n", which);
break;
}
}
@ -1899,11 +1914,39 @@ tp_pair_lid_switch(struct evdev_device *touchpad,
libinput_device_add_event_listener(&lid_switch->base,
&tp->lid_switch.listener,
tp_lid_switch_event, tp);
tp_switch_event, tp);
tp->lid_switch.lid_switch = lid_switch;
}
}
static void
tp_pair_tablet_mode_switch(struct evdev_device *touchpad,
struct evdev_device *tablet_mode_switch)
{
struct tp_dispatch *tp = (struct tp_dispatch*)touchpad->dispatch;
if ((tablet_mode_switch->tags & EVDEV_TAG_TABLET_MODE_SWITCH) == 0)
return;
if (tp->tablet_mode_switch.tablet_mode_switch == NULL) {
evdev_log_debug(touchpad,
"tablet_mode_switch: activated for %s<->%s\n",
touchpad->devname,
tablet_mode_switch->devname);
libinput_device_add_event_listener(&tablet_mode_switch->base,
&tp->tablet_mode_switch.listener,
tp_switch_event, tp);
tp->tablet_mode_switch.tablet_mode_switch = tablet_mode_switch;
if (evdev_device_switch_get_state(tablet_mode_switch,
LIBINPUT_SWITCH_TABLET_MODE)
== LIBINPUT_SWITCH_STATE_ON) {
tp_suspend(tp, touchpad);
}
}
}
static void
tp_interface_device_added(struct evdev_device *device,
struct evdev_device *added_device)
@ -1913,6 +1956,7 @@ tp_interface_device_added(struct evdev_device *device,
tp_pair_trackpoint(device, added_device);
tp_dwt_pair_keyboard(device, added_device);
tp_pair_lid_switch(device, added_device);
tp_pair_tablet_mode_switch(device, added_device);
if (tp->sendevents.current_mode !=
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE)
@ -1954,6 +1998,12 @@ tp_interface_device_removed(struct evdev_device *device,
tp->lid_switch.lid_switch = NULL;
}
if (removed_device == tp->tablet_mode_switch.tablet_mode_switch) {
libinput_device_remove_event_listener(
&tp->tablet_mode_switch.listener);
tp->tablet_mode_switch.tablet_mode_switch = NULL;
}
if (tp->sendevents.current_mode !=
LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE)
return;

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

@ -407,6 +407,11 @@ struct tp_dispatch {
struct libinput_event_listener listener;
struct evdev_device *lid_switch;
} lid_switch;
struct {
struct libinput_event_listener listener;
struct evdev_device *tablet_mode_switch;
} tablet_mode_switch;
};
static inline struct tp_dispatch*

19
src/evdev.c
View file

@ -185,6 +185,25 @@ fallback_lid_notify_toggle(struct fallback_dispatch *dispatch,
}
}
enum libinput_switch_state
evdev_device_switch_get_state(struct evdev_device *device,
enum libinput_switch sw)
{
struct fallback_dispatch *dispatch = fallback_dispatch(device->dispatch);
switch (sw) {
case LIBINPUT_SWITCH_TABLET_MODE:
break;
default:
/* Internal function only, so we can abort here */
abort();
}
return dispatch->tablet_mode.state ?
LIBINPUT_SWITCH_STATE_ON :
LIBINPUT_SWITCH_STATE_OFF;
}
void
evdev_pointer_notify_physical_button(struct evdev_device *device,
uint64_t time,

4
src/evdev.h
View file

@ -524,6 +524,10 @@ struct libinput_tablet_pad_mode_group *
evdev_device_tablet_pad_get_mode_group(struct evdev_device *device,
unsigned int index);
enum libinput_switch_state
evdev_device_switch_get_state(struct evdev_device *device,
enum libinput_switch sw);
double
evdev_device_transform_x(struct evdev_device *device,
double x,

177
test/test-switch.c
View file

@ -36,6 +36,13 @@ switch_has_lid(struct litest_device *dev)
LIBINPUT_SWITCH_LID);
}
static inline bool
switch_has_tablet_mode(struct litest_device *dev)
{
return libinput_device_switch_has_switch(dev->libinput_device,
LIBINPUT_SWITCH_TABLET_MODE);
}
START_TEST(switch_has_cap)
{
struct litest_device *dev = litest_current_device();
@ -228,30 +235,29 @@ START_TEST(switch_not_down_on_init)
END_TEST
static inline struct litest_device *
lid_init_paired_touchpad(struct libinput *li)
switch_init_paired_touchpad(struct libinput *li)
{
enum litest_device_type which = LITEST_SYNAPTICS_I2C;
return litest_add_device(li, which);
}
START_TEST(lid_disable_touchpad)
START_TEST(switch_disable_touchpad)
{
struct litest_device *sw = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = sw->libinput;
enum libinput_switch which = _i; /* ranged test */
if (!switch_has_lid(sw))
if (!libinput_device_switch_has_switch(sw->libinput_device, which))
return;
touchpad = lid_init_paired_touchpad(li);
touchpad = switch_init_paired_touchpad(li);
litest_disable_tap(touchpad->libinput_device);
litest_drain_events(li);
/* lid is down - no events */
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_ON);
/* switch is on - no events */
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_SWITCH_TOGGLE);
litest_touch_down(touchpad, 0, 50, 50);
@ -259,10 +265,8 @@ START_TEST(lid_disable_touchpad)
litest_touch_up(touchpad, 0);
litest_assert_empty_queue(li);
/* lid is up - motion events */
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_OFF);
/* switch is off - motion events */
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_OFF);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_SWITCH_TOGGLE);
litest_touch_down(touchpad, 0, 50, 50);
@ -274,16 +278,17 @@ START_TEST(lid_disable_touchpad)
}
END_TEST
START_TEST(lid_disable_touchpad_during_touch)
START_TEST(switch_disable_touchpad_during_touch)
{
struct litest_device *sw = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = sw->libinput;
enum libinput_switch which = _i; /* ranged test */
if (!switch_has_lid(sw))
if (!libinput_device_switch_has_switch(sw->libinput_device, which))
return;
touchpad = lid_init_paired_touchpad(li);
touchpad = switch_init_paired_touchpad(li);
litest_disable_tap(touchpad->libinput_device);
litest_drain_events(li);
@ -291,9 +296,7 @@ START_TEST(lid_disable_touchpad_during_touch)
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 5, 1);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_ON);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_SWITCH_TOGGLE);
litest_touch_move_to(touchpad, 0, 70, 50, 50, 50, 5, 1);
@ -304,23 +307,22 @@ START_TEST(lid_disable_touchpad_during_touch)
}
END_TEST
START_TEST(lid_disable_touchpad_edge_scroll)
START_TEST(switch_disable_touchpad_edge_scroll)
{
struct litest_device *sw = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = sw->libinput;
enum libinput_switch which = _i; /* ranged test */
if (!switch_has_lid(sw))
if (!libinput_device_switch_has_switch(sw->libinput_device, which))
return;
touchpad = lid_init_paired_touchpad(li);
touchpad = switch_init_paired_touchpad(li);
litest_enable_edge_scroll(touchpad);
litest_drain_events(li);
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_ON);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_SWITCH_TOGGLE);
litest_touch_down(touchpad, 0, 99, 20);
@ -342,17 +344,18 @@ START_TEST(lid_disable_touchpad_edge_scroll)
}
END_TEST
START_TEST(lid_disable_touchpad_edge_scroll_interrupt)
START_TEST(switch_disable_touchpad_edge_scroll_interrupt)
{
struct litest_device *sw = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = sw->libinput;
struct libinput_event *event;
enum libinput_switch which = _i; /* ranged test */
if (!switch_has_lid(sw))
if (!libinput_device_switch_has_switch(sw->libinput_device, which))
return;
touchpad = lid_init_paired_touchpad(li);
touchpad = switch_init_paired_touchpad(li);
litest_enable_edge_scroll(touchpad);
litest_drain_events(li);
@ -364,9 +367,7 @@ START_TEST(lid_disable_touchpad_edge_scroll_interrupt)
libinput_dispatch(li);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_AXIS);
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_ON);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
libinput_dispatch(li);
event = libinput_get_event(li);
@ -376,38 +377,36 @@ START_TEST(lid_disable_touchpad_edge_scroll_interrupt)
libinput_event_destroy(event);
event = libinput_get_event(li);
litest_is_switch_event(event,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_ON);
litest_is_switch_event(event, which, LIBINPUT_SWITCH_STATE_ON);
libinput_event_destroy(event);
litest_delete_device(touchpad);
}
END_TEST
START_TEST(lid_disable_touchpad_already_open)
START_TEST(switch_disable_touchpad_already_open)
{
struct litest_device *sw = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = sw->libinput;
enum libinput_switch which = _i; /* ranged test */
if (!switch_has_lid(sw))
if (!libinput_device_switch_has_switch(sw->libinput_device, which))
return;
touchpad = lid_init_paired_touchpad(li);
touchpad = switch_init_paired_touchpad(li);
litest_disable_tap(touchpad->libinput_device);
litest_drain_events(li);
/* default: lid is up - motion events */
/* default: switch is off - motion events */
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10, 1);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
/* open lid - motion events */
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_OFF);
/* disable switch - motion events */
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_OFF);
litest_assert_empty_queue(li);
litest_touch_down(touchpad, 0, 50, 50);
@ -495,27 +494,34 @@ START_TEST(lid_open_on_key_touchpad_enabled)
}
END_TEST
START_TEST(lid_suspend_with_keyboard)
START_TEST(switch_suspend_with_keyboard)
{
struct libinput *li;
struct litest_device *keyboard;
struct litest_device *sw;
enum libinput_switch which = _i; /* ranged test */
li = litest_create_context();
sw = litest_add_device(li, LITEST_LID_SWITCH);
switch(which) {
case LIBINPUT_SWITCH_LID:
sw = litest_add_device(li, LITEST_LID_SWITCH);
break;
case LIBINPUT_SWITCH_TABLET_MODE:
sw = litest_add_device(li, LITEST_THINKPAD_EXTRABUTTONS);
break;
default:
abort();
}
libinput_dispatch(li);
keyboard = litest_add_device(li, LITEST_KEYBOARD);
libinput_dispatch(li);
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_ON);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_ON);
litest_drain_events(li);
litest_switch_action(sw,
LIBINPUT_SWITCH_LID,
LIBINPUT_SWITCH_STATE_OFF);
litest_switch_action(sw, which, LIBINPUT_SWITCH_STATE_OFF);
litest_drain_events(li);
litest_delete_device(keyboard);
@ -528,14 +534,25 @@ START_TEST(lid_suspend_with_keyboard)
}
END_TEST
START_TEST(lid_suspend_with_touchpad)
START_TEST(switch_suspend_with_touchpad)
{
struct libinput *li;
struct litest_device *touchpad, *sw;
enum libinput_switch which = _i; /* ranged test */
li = litest_create_context();
sw = litest_add_device(li, LITEST_LID_SWITCH);
switch(which) {
case LIBINPUT_SWITCH_LID:
sw = litest_add_device(li, LITEST_LID_SWITCH);
break;
case LIBINPUT_SWITCH_TABLET_MODE:
sw = litest_add_device(li, LITEST_THINKPAD_EXTRABUTTONS);
break;
default:
abort();
}
litest_drain_events(li);
touchpad = litest_add_device(li, LITEST_SYNAPTICS_I2C);
@ -671,6 +688,44 @@ START_TEST(lid_key_press)
}
END_TEST
START_TEST(tablet_mode_disable_touchpad_on_init)
{
struct litest_device *sw = litest_current_device();
struct litest_device *touchpad;
struct libinput *li = sw->libinput;
if (!switch_has_tablet_mode(sw))
return;
litest_switch_action(sw,
LIBINPUT_SWITCH_TABLET_MODE,
LIBINPUT_SWITCH_STATE_ON);
litest_drain_events(li);
/* touchpad comes with switch already on - no events */
touchpad = switch_init_paired_touchpad(li);
litest_disable_tap(touchpad->libinput_device);
litest_drain_events(li);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10, 1);
litest_touch_up(touchpad, 0);
litest_assert_empty_queue(li);
litest_switch_action(sw,
LIBINPUT_SWITCH_TABLET_MODE,
LIBINPUT_SWITCH_STATE_OFF);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_SWITCH_TOGGLE);
litest_touch_down(touchpad, 0, 50, 50);
litest_touch_move_to(touchpad, 0, 50, 50, 70, 50, 10, 1);
litest_touch_up(touchpad, 0);
litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
litest_delete_device(touchpad);
}
END_TEST
void
litest_setup_tests_lid(void)
{
@ -684,20 +739,20 @@ litest_setup_tests_lid(void)
litest_add_ranged("switch:toggle", switch_toggle_double, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add_ranged("switch:toggle", switch_down_on_init, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add("switch:toggle", switch_not_down_on_init, LITEST_SWITCH, LITEST_ANY);
litest_add("lid:disable_touchpad", lid_disable_touchpad, LITEST_SWITCH, LITEST_ANY);
litest_add("lid:disable_touchpad", lid_disable_touchpad_during_touch, LITEST_SWITCH, LITEST_ANY);
litest_add("lid:disable_touchpad", lid_disable_touchpad_edge_scroll, LITEST_SWITCH, LITEST_ANY);
litest_add("lid:disable_touchpad", lid_disable_touchpad_edge_scroll_interrupt, LITEST_SWITCH, LITEST_ANY);
litest_add("lid:disable_touchpad", lid_disable_touchpad_already_open, LITEST_SWITCH, LITEST_ANY);
litest_add_ranged("switch:touchpad", switch_disable_touchpad, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add_ranged("switch:touchpad", switch_disable_touchpad_during_touch, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add_ranged("switch:touchpad", switch_disable_touchpad_edge_scroll, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add_ranged("switch:touchpad", switch_disable_touchpad_edge_scroll_interrupt, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add_ranged("switch:touchpad", switch_disable_touchpad_already_open, LITEST_SWITCH, LITEST_ANY, &switches);
litest_add_ranged_no_device("switch:keyboard", switch_suspend_with_keyboard, &switches);
litest_add_ranged_no_device("switch:touchpad", switch_suspend_with_touchpad, &switches);
litest_add("lid:keyboard", lid_open_on_key, LITEST_SWITCH, LITEST_ANY);
litest_add("lid:keyboard", lid_open_on_key_touchpad_enabled, LITEST_SWITCH, LITEST_ANY);
litest_add_no_device("lid:keyboard", lid_suspend_with_keyboard);
litest_add_no_device("lid:disable_touchpad", lid_suspend_with_touchpad);
litest_add_for_device("lid:buggy", lid_update_hw_on_key, LITEST_LID_SWITCH_SURFACE3);
litest_add_for_device("lid:buggy", lid_update_hw_on_key_closed_on_init, LITEST_LID_SWITCH_SURFACE3);
litest_add_for_device("lid:keypress", lid_key_press, LITEST_GPIO_KEYS);
litest_add("tablet-mode:touchpad", tablet_mode_disable_touchpad_on_init, LITEST_SWITCH, LITEST_ANY);
}