All touchpad recordings seen so far show that a value above 100 is definitely a thumb or a palm. Values below are harder to discern, and the same isn't true for touchpads supporting ABS_PRESSURE instead of ABS_MT_PRESSURE.
The handling of a touch is as outlined in tp_thumb_detect: * thumbs are ignored for pointer motion * thumbs cancel gestures * thumbs are ignored for clickfinger count * edge scrolling doesn't care either way * software buttons don't care either way * tap: only if thumb on begin The handling of thumbs while tapping is the simplest approach only, more to come in follow-up patches. Note that "thumb" is the synonym for "this touch is too big to be a fingertip". Which means that a light thumb touch will still be counted as a finger. The side-effect here is that thumbs resting a the bottom edge of the touchpad will almost certainly not trigger the pressure threshold because most of the thumb is off the touchpad. Signed-off-by: Peter Hutterer <[email protected]> --- src/evdev-mt-touchpad-buttons.c | 3 ++ src/evdev-mt-touchpad-gestures.c | 25 +++++++++++++++- src/evdev-mt-touchpad-tap.c | 13 +++++++++ src/evdev-mt-touchpad.c | 61 ++++++++++++++++++++++++++++++++++++++++ src/evdev-mt-touchpad.h | 9 ++++++ 5 files changed, 110 insertions(+), 1 deletion(-) diff --git a/src/evdev-mt-touchpad-buttons.c b/src/evdev-mt-touchpad-buttons.c index 3352c66..5d8a382 100644 --- a/src/evdev-mt-touchpad-buttons.c +++ b/src/evdev-mt-touchpad-buttons.c @@ -829,6 +829,9 @@ tp_check_clickfinger_distance(struct tp_dispatch *tp, if (!t1 || !t2) return 0; + if (t1->is_thumb || t2->is_thumb) + return 0; + x = abs(t1->point.x - t2->point.x); y = abs(t1->point.y - t2->point.y); diff --git a/src/evdev-mt-touchpad-gestures.c b/src/evdev-mt-touchpad-gestures.c index cd853ec..81bbd4d 100644 --- a/src/evdev-mt-touchpad-gestures.c +++ b/src/evdev-mt-touchpad-gestures.c @@ -525,11 +525,34 @@ tp_gesture_handle_state(struct tp_dispatch *tp, uint64_t time) { unsigned int active_touches = 0; struct tp_touch *t; + uint32_t old_thumb_mask, thumb_mask = 0; + int i = 0; - tp_for_each_touch(tp, t) + tp_for_each_touch(tp, t) { if (tp_touch_active(tp, t)) active_touches++; + if (t->is_thumb) + thumb_mask |= 1 << i; + i++; + } + + old_thumb_mask = tp->gesture.thumb_mask; + tp->gesture.thumb_mask = thumb_mask; + + /* active touches does not include thumb touches, need to count those + * separately, in a bitmask. + * then, if the finger count changes and/or the thumb count changes + * -> cancel gesture. + */ + if (thumb_mask != old_thumb_mask) { + /* if a thumb is detected during a gesture, that gesture is + * cancelled and the user effectively needs to restart. we + * could be smarter, but the complexity isn't worth it */ + tp_gesture_cancel(tp, time); + return; + } + if (active_touches != tp->gesture.finger_count) { /* If all fingers are lifted immediately end the gesture */ if (active_touches == 0) { diff --git a/src/evdev-mt-touchpad-tap.c b/src/evdev-mt-touchpad-tap.c index 7f241de..a43e235 100644 --- a/src/evdev-mt-touchpad-tap.c +++ b/src/evdev-mt-touchpad-tap.c @@ -691,7 +691,20 @@ tp_tap_handle_state(struct tp_dispatch *tp, uint64_t time) tp->queued & TOUCHPAD_EVENT_BUTTON_PRESS) t->tap.state = TAP_TOUCH_STATE_DEAD; + /* If a touch was considered thumb for tapping once, we + * ignore it for the rest of lifetime */ + if (t->tap.is_thumb) + continue; + if (t->state == TOUCH_BEGIN) { + /* The simple version: if a touch is a thumb on + * begin we ignore it. All other thumb touches + * follow the normal tap state for now */ + if (t->is_thumb) { + t->tap.is_thumb = true; + continue; + } + t->tap.state = TAP_TOUCH_STATE_TOUCH; t->tap.initial = t->point; tp_tap_handle_event(tp, t, TAP_EVENT_TOUCH, time); diff --git a/src/evdev-mt-touchpad.c b/src/evdev-mt-touchpad.c index f610c60..6b8b7dc 100644 --- a/src/evdev-mt-touchpad.c +++ b/src/evdev-mt-touchpad.c @@ -212,6 +212,8 @@ tp_begin_touch(struct tp_dispatch *tp, struct tp_touch *t, uint64_t time) t->millis = time; tp->nfingers_down++; t->palm.time = time; + t->is_thumb = false; + t->tap.is_thumb = false; assert(tp->nfingers_down >= 1); } @@ -314,6 +316,9 @@ tp_process_absolute(struct tp_dispatch *tp, else tp_end_sequence(tp, t, time); break; + case ABS_MT_PRESSURE: + t->pressure = e->value; + break; } } @@ -461,6 +466,7 @@ tp_touch_active(struct tp_dispatch *tp, struct tp_touch *t) return (t->state == TOUCH_BEGIN || t->state == TOUCH_UPDATE) && t->palm.state == PALM_NONE && !t->pinned.is_pinned && + !t->is_thumb && tp_button_touch_active(tp, t) && tp_edge_scroll_touch_active(tp, t); } @@ -604,6 +610,33 @@ out: } static void +tp_thumb_detect(struct tp_dispatch *tp, struct tp_touch *t) +{ + /* once a thumb, always a thumb */ + if (!tp->thumb.detect_thumbs || t->is_thumb) + return; + + /* Note: a thumb at the edge of the touchpad won't trigger the + * threshold, the surface areas is usually too small. + */ + if (t->pressure < tp->thumb.threshold) + return; + + t->is_thumb = true; + + /* now what? we marked it as thumb, so: + * + * - pointer motion must ignore this touch + * - clickfinger must ignore this touch for finger count + * - software buttons are unaffected + * - edge scrolling unaffected + * - gestures: cancel + * - tapping: honour thumb on begin, ignore it otherwise for now, + * this gets a tad complicated otherwise + */ +} + +static void tp_unhover_abs_distance(struct tp_dispatch *tp, uint64_t time) { struct tp_touch *t; @@ -721,6 +754,7 @@ tp_process_state(struct tp_dispatch *tp, uint64_t time) if (!t->dirty) continue; + tp_thumb_detect(tp, t); tp_palm_detect(tp, t, time); tp_motion_hysteresis(tp, t); @@ -1478,6 +1512,30 @@ tp_init_sendevents(struct tp_dispatch *tp, } static int +tp_init_thumb(struct tp_dispatch *tp) +{ + struct evdev_device *device = tp->device; + const struct input_absinfo *abs; + + abs = libevdev_get_abs_info(device->evdev, ABS_MT_PRESSURE); + if (!abs) + return 0; + + if (abs->maximum - abs->minimum < 255) + return 0; + + /* The touchpads we looked at so far have a clear thumb threshold of + * ~100, you don't reach that with a normal finger interaction. + * Note: "thumb" means massive touch that should not interact, not + * "using the tip of my thumb for a pinch gestures". + */ + tp->thumb.threshold = 100; + tp->thumb.detect_thumbs = true; + + return 0; +} + +static int tp_sanity_check(struct tp_dispatch *tp, struct evdev_device *device) { @@ -1559,6 +1617,9 @@ tp_init(struct tp_dispatch *tp, if (tp_init_gesture(tp) != 0) return -1; + if (tp_init_thumb(tp) != 0) + return -1; + device->seat_caps |= EVDEV_DEVICE_POINTER; return 0; diff --git a/src/evdev-mt-touchpad.h b/src/evdev-mt-touchpad.h index df8be94..eda17a9 100644 --- a/src/evdev-mt-touchpad.h +++ b/src/evdev-mt-touchpad.h @@ -141,9 +141,11 @@ struct tp_touch { enum touch_state state; bool has_ended; /* TRACKING_ID == -1 */ bool dirty; + bool is_thumb; struct device_coords point; uint64_t millis; int distance; /* distance == 0 means touch */ + int pressure; struct { struct device_coords samples[TOUCHPAD_HISTORY_LENGTH]; @@ -173,6 +175,7 @@ struct tp_touch { struct { enum tp_tap_touch_state state; struct device_coords initial; + bool is_thumb; } tap; struct { @@ -234,6 +237,7 @@ struct tp_dispatch { double prev_scale; double angle; struct device_float_coords center; + uint32_t thumb_mask; } gesture; struct { @@ -317,6 +321,11 @@ struct tp_dispatch { uint64_t keyboard_last_press_time; } dwt; + + struct { + bool detect_thumbs; + int threshold; + } thumb; }; #define tp_for_each_touch(_tp, _t) \ -- 2.4.3 _______________________________________________ wayland-devel mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/wayland-devel
