evdev-mt-touchpad-gestures.c 16.9 KB
Newer Older
1 2 3
/*
 * Copyright © 2015 Red Hat, Inc.
 *
4 5 6 7 8 9
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
10
 *
11 12 13 14 15 16 17 18 19 20 21
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
22 23 24 25 26 27 28 29 30 31
 */

#include "config.h"

#include <math.h>
#include <stdbool.h>
#include <limits.h>

#include "evdev-mt-touchpad.h"

32
#define DEFAULT_GESTURE_SWITCH_TIMEOUT ms2us(100)
33
#define DEFAULT_GESTURE_2FG_SCROLL_TIMEOUT ms2us(500)
34

35
static inline const char*
36
gesture_state_to_str(enum tp_gesture_state state)
37 38
{
	switch (state) {
39 40 41 42
	CASE_RETURN_STRING(GESTURE_STATE_NONE);
	CASE_RETURN_STRING(GESTURE_STATE_UNKNOWN);
	CASE_RETURN_STRING(GESTURE_STATE_SCROLL);
	CASE_RETURN_STRING(GESTURE_STATE_PINCH);
43
	CASE_RETURN_STRING(GESTURE_STATE_SWIPE);
44 45 46 47
	}
	return NULL;
}

48 49
static struct normalized_coords
tp_get_touches_delta(struct tp_dispatch *tp, bool average)
50 51
{
	struct tp_touch *t;
52
	unsigned int i, nchanged = 0;
53 54
	struct normalized_coords normalized;
	struct normalized_coords delta = {0.0, 0.0};
55

56
	for (i = 0; i < tp->num_slots; i++) {
57 58
		t = &tp->touches[i];

59 60
		if (tp_touch_active(tp, t) && t->dirty) {
			nchanged++;
61
			normalized = tp_get_delta(t);
62

63 64
			delta.x += normalized.x;
			delta.y += normalized.y;
65 66 67
		}
	}

68
	if (!average || nchanged == 0)
69 70 71 72
		return delta;

	delta.x /= nchanged;
	delta.y /= nchanged;
73

74
	return delta;
75 76
}

77 78
static inline struct normalized_coords
tp_get_combined_touches_delta(struct tp_dispatch *tp)
79
{
80
	return tp_get_touches_delta(tp, false);
81
}
82

83 84
static inline struct normalized_coords
tp_get_average_touches_delta(struct tp_dispatch *tp)
85
{
86
	return tp_get_touches_delta(tp, true);
87 88 89
}

static void
90 91
tp_gesture_start(struct tp_dispatch *tp, uint64_t time)
{
92
	struct libinput *libinput = tp->device->base.seat->libinput;
93 94
	const struct normalized_coords zero = { 0.0, 0.0 };

95 96 97
	if (tp->gesture.started)
		return;

98 99 100 101 102 103
	switch (tp->gesture.state) {
	case GESTURE_STATE_NONE:
	case GESTURE_STATE_UNKNOWN:
		log_bug_libinput(libinput,
				 "%s in unknown gesture mode\n",
				 __func__);
104
		break;
105 106 107 108 109 110 111 112 113 114
	case GESTURE_STATE_SCROLL:
		/* NOP */
		break;
	case GESTURE_STATE_PINCH:
		gesture_notify_pinch(&tp->device->base, time,
				    LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
				    tp->gesture.finger_count,
				    &zero, &zero, 1.0, 0.0);
		break;
	case GESTURE_STATE_SWIPE:
115 116 117 118 119
		gesture_notify_swipe(&tp->device->base, time,
				     LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
				     tp->gesture.finger_count,
				     &zero, &zero);
		break;
120
	}
121

122 123 124
	tp->gesture.started = true;
}

125 126 127
static void
tp_gesture_post_pointer_motion(struct tp_dispatch *tp, uint64_t time)
{
128
	struct normalized_coords delta, unaccel;
129
	struct device_float_coords raw;
130 131 132

	/* When a clickpad is clicked, combine motion of all active touches */
	if (tp->buttons.is_clickpad && tp->buttons.state)
133
		unaccel = tp_get_combined_touches_delta(tp);
134
	else
135
		unaccel = tp_get_average_touches_delta(tp);
136

137
	delta = tp_filter_motion(tp, &unaccel, time);
138

139
	if (!normalized_is_zero(delta) || !normalized_is_zero(unaccel)) {
140 141 142 143 144
		raw = tp_unnormalize_for_xaxis(tp, unaccel);
		pointer_notify_motion(&tp->device->base,
				      time,
				      &delta,
				      &raw);
145 146 147
	}
}

148
static unsigned int
149
tp_gesture_get_active_touches(const struct tp_dispatch *tp,
150 151 152 153 154 155 156 157
			      struct tp_touch **touches,
			      unsigned int count)
{
	unsigned int i, n = 0;
	struct tp_touch *t;

	memset(touches, 0, count * sizeof(struct tp_touch *));

158
	for (i = 0; i < tp->ntouches; i++) {
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
		t = &tp->touches[i];
		if (tp_touch_active(tp, t)) {
			touches[n++] = t;
			if (n == count)
				return count;
		}
	}

	/*
	 * This can happen when the user does .e.g:
	 * 1) Put down 1st finger in center (so active)
	 * 2) Put down 2nd finger in a button area (so inactive)
	 * 3) Put down 3th finger somewhere, gets reported as a fake finger,
	 *    so gets same coordinates as 1st -> active
	 *
	 * We could avoid this by looking at all touches, be we really only
	 * want to look at real touches.
	 */
	return n;
}

static int
tp_gesture_get_direction(struct tp_dispatch *tp, struct tp_touch *touch)
{
	struct normalized_coords normalized;
	struct device_float_coords delta;
185
	double move_threshold = TP_MM_TO_DPI_NORMALIZED(1);
186 187

	delta = device_delta(touch->point, touch->gesture.initial);
188

189 190 191 192 193 194 195 196
	normalized = tp_normalize_delta(tp, delta);

	if (normalized_length(normalized) < move_threshold)
		return UNDEFINED_DIRECTION;

	return normalized_get_direction(normalized);
}

197
static void
198 199 200 201 202 203 204 205 206 207 208 209 210
tp_gesture_get_pinch_info(struct tp_dispatch *tp,
			  double *distance,
			  double *angle,
			  struct device_float_coords *center)
{
	struct normalized_coords normalized;
	struct device_float_coords delta;
	struct tp_touch *first = tp->gesture.touches[0],
			*second = tp->gesture.touches[1];

	delta = device_delta(first->point, second->point);
	normalized = tp_normalize_delta(tp, delta);
	*distance = normalized_length(normalized);
211
	*angle = atan2(normalized.y, normalized.x) * 180.0 / M_PI;
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

	*center = device_average(first->point, second->point);
}

static void
tp_gesture_set_scroll_buildup(struct tp_dispatch *tp)
{
	struct device_float_coords d0, d1;
	struct device_float_coords average;
	struct tp_touch *first = tp->gesture.touches[0],
			*second = tp->gesture.touches[1];

	d0 = device_delta(first->point, first->gesture.initial);
	d1 = device_delta(second->point, second->gesture.initial);

	average = device_float_average(d0, d1);
	tp->device->scroll.buildup = tp_normalize_delta(tp, average);
}

231
static enum tp_gesture_state
232
tp_gesture_handle_state_none(struct tp_dispatch *tp, uint64_t time)
233 234
{
	struct tp_touch *first, *second;
235 236 237
	struct tp_touch *touches[4];
	unsigned int ntouches;
	unsigned int i;
238

239 240
	ntouches = tp_gesture_get_active_touches(tp, touches, 4);
	if (ntouches < 2)
241
		return GESTURE_STATE_NONE;
242

243 244 245 246 247 248 249
	if (!tp->gesture.enabled) {
		if (ntouches == 2)
			return GESTURE_STATE_SCROLL;
		else
			return GESTURE_STATE_SWIPE;
	}

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
	first = touches[0];
	second = touches[1];

	/* For 3+ finger gestures we cheat. A human hand's finger
	 * arrangement means that for a 3 or 4 finger swipe gesture, the
	 * fingers are roughly arranged in a horizontal line.
	 * They will all move in the same direction, so we can simply look
	 * at the left and right-most ones only. If we have fake touches, we
	 * just take the left/right-most real touch position, since the fake
	 * touch has the same location as one of those.
	 *
	 * For a 3 or 4 finger pinch gesture, 2 or 3 fingers are roughly in
	 * a horizontal line, with the thumb below and left (right-handed
	 * users) or right (left-handed users). Again, the row of non-thumb
	 * fingers moves identically so we can look at the left and
	 * right-most only and then treat it like a two-finger
	 * gesture.
	 */
	if (ntouches > 2) {
		second = touches[0];

		for (i = 1; i < ntouches && i < tp->num_slots; i++) {
			if (touches[i]->point.x < first->point.x)
				first = touches[i];
			else if (touches[i]->point.x > second->point.x)
				second = touches[i];
		}

		if (first == second)
			return GESTURE_STATE_NONE;
280

281
	}
282 283 284 285

	tp->gesture.initial_time = time;
	first->gesture.initial = first->point;
	second->gesture.initial = second->point;
286 287
	tp->gesture.touches[0] = first;
	tp->gesture.touches[1] = second;
288

289
	return GESTURE_STATE_UNKNOWN;
290 291
}

292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
static inline int
tp_gesture_same_directions(int dir1, int dir2)
{
	/*
	 * In some cases (semi-mt touchpads) we may seen one finger move
	 * e.g. N/NE and the other W/NW so we not only check for overlapping
	 * directions, but also for neighboring bits being set.
	 * The ((dira & 0x80) && (dirb & 0x01)) checks are to check for bit 0
	 * and 7 being set as they also represent neighboring directions.
	 */
	return ((dir1 | (dir1 >> 1)) & dir2) ||
		((dir2 | (dir2 >> 1)) & dir1) ||
		((dir1 & 0x80) && (dir2 & 0x01)) ||
		((dir2 & 0x80) && (dir1 & 0x01));
}

308 309 310 311 312 313 314 315 316 317
static inline void
tp_gesture_init_pinch( struct tp_dispatch *tp)
{
	tp_gesture_get_pinch_info(tp,
				  &tp->gesture.initial_distance,
				  &tp->gesture.angle,
				  &tp->gesture.center);
	tp->gesture.prev_scale = 1.0;
}

318
static enum tp_gesture_state
319
tp_gesture_handle_state_unknown(struct tp_dispatch *tp, uint64_t time)
320 321 322 323
{
	struct tp_touch *first = tp->gesture.touches[0],
			*second = tp->gesture.touches[1];
	int dir1, dir2;
324 325
	int yres = tp->device->abs.absinfo_y->resolution;
	int vert_distance;
326

327 328 329 330
	/* for two-finger gestures, if the fingers stay unmoving for a
	 * while, assume (slow) scroll */
	if (tp->gesture.finger_count == 2 &&
	    time > (tp->gesture.initial_time + DEFAULT_GESTURE_2FG_SCROLL_TIMEOUT)) {
331
		tp_gesture_set_scroll_buildup(tp);
332
		return GESTURE_STATE_SCROLL;
333 334
	}

335 336 337 338 339 340 341 342
	/* Else check if one finger is > 20mm below the others */
	vert_distance = abs(first->point.y - second->point.y);
	if (vert_distance > 20 * yres &&
	    tp->gesture.enabled) {
		tp_gesture_init_pinch(tp);
		return GESTURE_STATE_PINCH;
	}

343 344 345 346
	/* Else wait for both fingers to have moved */
	dir1 = tp_gesture_get_direction(tp, first);
	dir2 = tp_gesture_get_direction(tp, second);
	if (dir1 == UNDEFINED_DIRECTION || dir2 == UNDEFINED_DIRECTION)
347
		return GESTURE_STATE_UNKNOWN;
348

349 350
	/* If both touches are moving in the same direction assume
	 * scroll or swipe */
351
	if (tp_gesture_same_directions(dir1, dir2)) {
352 353 354 355 356 357
		if (tp->gesture.finger_count == 2) {
			tp_gesture_set_scroll_buildup(tp);
			return GESTURE_STATE_SCROLL;
		} else if (tp->gesture.enabled) {
			return GESTURE_STATE_SWIPE;
		}
358
	} else {
359
		tp_gesture_init_pinch(tp);
360
		return GESTURE_STATE_PINCH;
361
	}
362

363
	return GESTURE_STATE_UNKNOWN;
364 365
}

366
static enum tp_gesture_state
367
tp_gesture_handle_state_scroll(struct tp_dispatch *tp, uint64_t time)
368
{
369
	struct normalized_coords delta;
370

371
	if (tp->scroll.method != LIBINPUT_CONFIG_SCROLL_2FG)
372
		return GESTURE_STATE_SCROLL;
373

374
	delta = tp_get_average_touches_delta(tp);
375

376 377
	/* scroll is not accelerated */
	delta = tp_filter_motion_unaccelerated(tp, &delta, time);
378

379
	if (normalized_is_zero(delta))
380
		return GESTURE_STATE_SCROLL;
381 382 383 384 385

	tp_gesture_start(tp, time);
	evdev_post_scroll(tp->device,
			  time,
			  LIBINPUT_POINTER_AXIS_SOURCE_FINGER,
386
			  &delta);
387

388
	return GESTURE_STATE_SCROLL;
389 390
}

391
static enum tp_gesture_state
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
tp_gesture_handle_state_swipe(struct tp_dispatch *tp, uint64_t time)
{
	struct normalized_coords delta, unaccel;

	unaccel = tp_get_average_touches_delta(tp);
	delta = tp_filter_motion(tp, &unaccel, time);

	if (!normalized_is_zero(delta) || !normalized_is_zero(unaccel)) {
		tp_gesture_start(tp, time);
		gesture_notify_swipe(&tp->device->base, time,
				     LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
				     tp->gesture.finger_count,
				     &delta, &unaccel);
	}

	return GESTURE_STATE_SWIPE;
}

static enum tp_gesture_state
tp_gesture_handle_state_pinch(struct tp_dispatch *tp, uint64_t time)
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
{
	double angle, angle_delta, distance, scale;
	struct device_float_coords center, fdelta;
	struct normalized_coords delta, unaccel;

	tp_gesture_get_pinch_info(tp, &distance, &angle, &center);

	scale = distance / tp->gesture.initial_distance;

	angle_delta = angle - tp->gesture.angle;
	tp->gesture.angle = angle;
	if (angle_delta > 180.0)
		angle_delta -= 360.0;
	else if (angle_delta < -180.0)
		angle_delta += 360.0;

	fdelta = device_float_delta(center, tp->gesture.center);
	tp->gesture.center = center;
	unaccel = tp_normalize_delta(tp, fdelta);
	delta = tp_filter_motion(tp, &unaccel, time);

	if (normalized_is_zero(delta) && normalized_is_zero(unaccel) &&
	    scale == tp->gesture.prev_scale && angle_delta == 0.0)
435
		return GESTURE_STATE_PINCH;
436 437 438 439

	tp_gesture_start(tp, time);
	gesture_notify_pinch(&tp->device->base, time,
			     LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
440
			     tp->gesture.finger_count,
441 442 443 444
			     &delta, &unaccel, scale, angle_delta);

	tp->gesture.prev_scale = scale;

445
	return GESTURE_STATE_PINCH;
446 447 448
}

static void
449
tp_gesture_post_gesture(struct tp_dispatch *tp, uint64_t time)
450
{
451
	enum tp_gesture_state oldstate = tp->gesture.state;
452

453 454
	if (tp->gesture.state == GESTURE_STATE_NONE)
		tp->gesture.state =
455
			tp_gesture_handle_state_none(tp, time);
456

457 458
	if (tp->gesture.state == GESTURE_STATE_UNKNOWN)
		tp->gesture.state =
459
			tp_gesture_handle_state_unknown(tp, time);
460

461 462
	if (tp->gesture.state == GESTURE_STATE_SCROLL)
		tp->gesture.state =
463 464 465 466 467
			tp_gesture_handle_state_scroll(tp, time);

	if (tp->gesture.state == GESTURE_STATE_SWIPE)
		tp->gesture.state =
			tp_gesture_handle_state_swipe(tp, time);
468

469 470
	if (tp->gesture.state == GESTURE_STATE_PINCH)
		tp->gesture.state =
471
			tp_gesture_handle_state_pinch(tp, time);
472 473 474 475

	log_debug(tp_libinput_context(tp),
		  "gesture state: %s → %s\n",
		  gesture_state_to_str(oldstate),
476
		  gesture_state_to_str(tp->gesture.state));
477 478
}

479 480 481 482 483 484 485 486
void
tp_gesture_post_events(struct tp_dispatch *tp, uint64_t time)
{
	if (tp->gesture.finger_count == 0)
		return;

	/* When tap-and-dragging, or a clickpad is clicked force 1fg mode */
	if (tp_tap_dragging(tp) || (tp->buttons.is_clickpad && tp->buttons.state)) {
487
		tp_gesture_cancel(tp, time);
488 489 490 491 492 493 494 495 496 497 498 499 500
		tp->gesture.finger_count = 1;
		tp->gesture.finger_count_pending = 0;
	}

	/* Don't send events when we're unsure in which mode we are */
	if (tp->gesture.finger_count_pending)
		return;

	switch (tp->gesture.finger_count) {
	case 1:
		tp_gesture_post_pointer_motion(tp, time);
		break;
	case 2:
501 502
	case 3:
	case 4:
503
		tp_gesture_post_gesture(tp, time);
504
		break;
505 506 507
	}
}

508 509 510
void
tp_gesture_stop_twofinger_scroll(struct tp_dispatch *tp, uint64_t time)
{
511 512 513
	if (tp->scroll.method != LIBINPUT_CONFIG_SCROLL_2FG)
		return;

514 515 516 517 518
	evdev_stop_scroll(tp->device,
			  time,
			  LIBINPUT_POINTER_AXIS_SOURCE_FINGER);
}

519 520
static void
tp_gesture_end(struct tp_dispatch *tp, uint64_t time, bool cancelled)
521
{
522
	struct libinput *libinput = tp->device->base.seat->libinput;
523
	enum tp_gesture_state state = tp->gesture.state;
524

525
	tp->gesture.state = GESTURE_STATE_NONE;
526

527 528 529
	if (!tp->gesture.started)
		return;

530 531 532 533 534 535
	switch (state) {
	case GESTURE_STATE_NONE:
	case GESTURE_STATE_UNKNOWN:
		log_bug_libinput(libinput,
				 "%s in unknown gesture mode\n",
				 __func__);
536
		break;
537 538 539 540 541 542 543 544 545 546 547 548 549 550
	case GESTURE_STATE_SCROLL:
		tp_gesture_stop_twofinger_scroll(tp, time);
		break;
	case GESTURE_STATE_PINCH:
		gesture_notify_pinch_end(&tp->device->base, time,
					 tp->gesture.finger_count,
					 tp->gesture.prev_scale,
					 cancelled);
		break;
	case GESTURE_STATE_SWIPE:
		gesture_notify_swipe_end(&tp->device->base,
					 time,
					 tp->gesture.finger_count,
					 cancelled);
551
		break;
552
	}
553

554 555 556
	tp->gesture.started = false;
}

557 558 559 560 561 562 563 564 565 566 567 568
void
tp_gesture_cancel(struct tp_dispatch *tp, uint64_t time)
{
	tp_gesture_end(tp, time, true);
}

void
tp_gesture_stop(struct tp_dispatch *tp, uint64_t time)
{
	tp_gesture_end(tp, time, false);
}

569 570 571 572 573 574 575 576
static void
tp_gesture_finger_count_switch_timeout(uint64_t now, void *data)
{
	struct tp_dispatch *tp = data;

	if (!tp->gesture.finger_count_pending)
		return;

577
	tp_gesture_cancel(tp, now); /* End current gesture */
578 579 580 581 582 583 584 585 586 587
	tp->gesture.finger_count = tp->gesture.finger_count_pending;
	tp->gesture.finger_count_pending = 0;
}

void
tp_gesture_handle_state(struct tp_dispatch *tp, uint64_t time)
{
	unsigned int active_touches = 0;
	struct tp_touch *t;

588
	tp_for_each_touch(tp, t) {
589 590
		if (tp_touch_active(tp, t))
			active_touches++;
591 592
	}

593 594 595
	if (active_touches != tp->gesture.finger_count) {
		/* If all fingers are lifted immediately end the gesture */
		if (active_touches == 0) {
596
			tp_gesture_stop(tp, time);
597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
			tp->gesture.finger_count = 0;
			tp->gesture.finger_count_pending = 0;
		/* Immediately switch to new mode to avoid initial latency */
		} else if (!tp->gesture.started) {
			tp->gesture.finger_count = active_touches;
			tp->gesture.finger_count_pending = 0;
		/* Else debounce finger changes */
		} else if (active_touches != tp->gesture.finger_count_pending) {
			tp->gesture.finger_count_pending = active_touches;
			libinput_timer_set(&tp->gesture.finger_count_switch_timer,
				time + DEFAULT_GESTURE_SWITCH_TIMEOUT);
		}
	} else {
		 tp->gesture.finger_count_pending = 0;
	}
}

int
tp_init_gesture(struct tp_dispatch *tp)
{
617 618 619
	/* two-finger scrolling is always enabled, this flag just
	 * decides whether we detect pinch. semi-mt devices are too
	 * unreliable to do pinch gestures. */
620
	tp->gesture.enabled = !tp->semi_mt && tp->num_slots > 1;
621

622
	tp->gesture.state = GESTURE_STATE_NONE;
623

624 625 626 627 628 629 630 631 632 633 634
	libinput_timer_init(&tp->gesture.finger_count_switch_timer,
			    tp->device->base.seat->libinput,
			    tp_gesture_finger_count_switch_timeout, tp);
	return 0;
}

void
tp_remove_gesture(struct tp_dispatch *tp)
{
	libinput_timer_cancel(&tp->gesture.finger_count_switch_timer);
}