1/* 2 * Copyright © 2013-2015 Red Hat, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24#include "config.h" 25 26#include <assert.h> 27#include <stdbool.h> 28#include <stdio.h> 29 30#include "evdev-mt-touchpad.h" 31 32#define DEFAULT_TAP_TIMEOUT_PERIOD ms2us(180) 33#define DEFAULT_DRAG_TIMEOUT_PERIOD_BASE ms2us(160) 34#define DEFAULT_DRAG_TIMEOUT_PERIOD_PERFINGER ms2us(20) 35#define DEFAULT_DRAGLOCK_TIMEOUT_PERIOD ms2us(300) 36#define DEFAULT_TAP_MOVE_THRESHOLD 1.3 /* mm */ 37 38enum tap_event { 39 TAP_EVENT_TOUCH = 12, 40 TAP_EVENT_MOTION, 41 TAP_EVENT_RELEASE, 42 TAP_EVENT_BUTTON, 43 TAP_EVENT_TIMEOUT, 44 TAP_EVENT_THUMB, 45 TAP_EVENT_PALM, 46 TAP_EVENT_PALM_UP, 47}; 48 49/***************************************** 50 * DO NOT EDIT THIS FILE! 51 * 52 * Look at the state diagram in doc/touchpad-tap-state-machine.svg 53 * (generated with https://www.diagrams.net) 54 * 55 * Any changes in this file must be represented in the diagram. 56 */ 57 58static inline const char* 59tap_state_to_str(enum tp_tap_state state) 60{ 61 switch(state) { 62 CASE_RETURN_STRING(TAP_STATE_IDLE); 63 CASE_RETURN_STRING(TAP_STATE_HOLD); 64 CASE_RETURN_STRING(TAP_STATE_TOUCH); 65 CASE_RETURN_STRING(TAP_STATE_1FGTAP_TAPPED); 66 CASE_RETURN_STRING(TAP_STATE_2FGTAP_TAPPED); 67 CASE_RETURN_STRING(TAP_STATE_3FGTAP_TAPPED); 68 CASE_RETURN_STRING(TAP_STATE_TOUCH_2); 69 CASE_RETURN_STRING(TAP_STATE_TOUCH_2_HOLD); 70 CASE_RETURN_STRING(TAP_STATE_TOUCH_2_RELEASE); 71 CASE_RETURN_STRING(TAP_STATE_TOUCH_3); 72 CASE_RETURN_STRING(TAP_STATE_TOUCH_3_HOLD); 73 CASE_RETURN_STRING(TAP_STATE_TOUCH_3_RELEASE); 74 CASE_RETURN_STRING(TAP_STATE_TOUCH_3_RELEASE_2); 75 CASE_RETURN_STRING(TAP_STATE_1FGTAP_DRAGGING); 76 CASE_RETURN_STRING(TAP_STATE_2FGTAP_DRAGGING); 77 CASE_RETURN_STRING(TAP_STATE_3FGTAP_DRAGGING); 78 CASE_RETURN_STRING(TAP_STATE_1FGTAP_DRAGGING_WAIT); 79 CASE_RETURN_STRING(TAP_STATE_2FGTAP_DRAGGING_WAIT); 80 CASE_RETURN_STRING(TAP_STATE_3FGTAP_DRAGGING_WAIT); 81 CASE_RETURN_STRING(TAP_STATE_1FGTAP_DRAGGING_OR_DOUBLETAP); 82 CASE_RETURN_STRING(TAP_STATE_2FGTAP_DRAGGING_OR_DOUBLETAP); 83 CASE_RETURN_STRING(TAP_STATE_3FGTAP_DRAGGING_OR_DOUBLETAP); 84 CASE_RETURN_STRING(TAP_STATE_1FGTAP_DRAGGING_OR_TAP); 85 CASE_RETURN_STRING(TAP_STATE_2FGTAP_DRAGGING_OR_TAP); 86 CASE_RETURN_STRING(TAP_STATE_3FGTAP_DRAGGING_OR_TAP); 87 CASE_RETURN_STRING(TAP_STATE_1FGTAP_DRAGGING_2); 88 CASE_RETURN_STRING(TAP_STATE_2FGTAP_DRAGGING_2); 89 CASE_RETURN_STRING(TAP_STATE_3FGTAP_DRAGGING_2); 90 CASE_RETURN_STRING(TAP_STATE_DEAD); 91 } 92 return NULL; 93} 94 95static inline const char* 96tap_event_to_str(enum tap_event event) 97{ 98 switch(event) { 99 CASE_RETURN_STRING(TAP_EVENT_TOUCH); 100 CASE_RETURN_STRING(TAP_EVENT_MOTION); 101 CASE_RETURN_STRING(TAP_EVENT_RELEASE); 102 CASE_RETURN_STRING(TAP_EVENT_TIMEOUT); 103 CASE_RETURN_STRING(TAP_EVENT_BUTTON); 104 CASE_RETURN_STRING(TAP_EVENT_THUMB); 105 CASE_RETURN_STRING(TAP_EVENT_PALM); 106 CASE_RETURN_STRING(TAP_EVENT_PALM_UP); 107 } 108 return NULL; 109} 110 111static inline void 112log_tap_bug(struct tp_dispatch *tp, struct tp_touch *t, enum tap_event event) 113{ 114 evdev_log_bug_libinput(tp->device, 115 "%d: invalid tap event %s in state %s\n", 116 t->index, 117 tap_event_to_str(event), 118 tap_state_to_str(tp->tap.state)); 119 120} 121 122static void 123tp_tap_notify(struct tp_dispatch *tp, 124 uint64_t time, 125 int nfingers, 126 enum libinput_button_state state) 127{ 128 int32_t button; 129 int32_t button_map[2][3] = { 130 { BTN_LEFT, BTN_RIGHT, BTN_MIDDLE }, 131 { BTN_LEFT, BTN_MIDDLE, BTN_RIGHT }, 132 }; 133 134 assert(tp->tap.map < ARRAY_LENGTH(button_map)); 135 136 if (nfingers < 1 || nfingers > 3) 137 return; 138 139 button = button_map[tp->tap.map][nfingers - 1]; 140 141 if (state == LIBINPUT_BUTTON_STATE_PRESSED) 142 tp->tap.buttons_pressed |= bit(nfingers); 143 else 144 tp->tap.buttons_pressed &= ~bit(nfingers); 145 146 evdev_pointer_notify_button(tp->device, 147 time, 148 button, 149 state); 150} 151 152static void 153tp_tap_set_timer(struct tp_dispatch *tp, uint64_t time) 154{ 155 libinput_timer_set(&tp->tap.timer, time + DEFAULT_TAP_TIMEOUT_PERIOD); 156} 157 158static void 159tp_tap_set_drag_timer(struct tp_dispatch *tp, uint64_t time, 160 int nfingers_tapped) 161{ 162 libinput_timer_set(&tp->tap.timer, 163 time + DEFAULT_DRAG_TIMEOUT_PERIOD_BASE + 164 (nfingers_tapped * 165 DEFAULT_DRAG_TIMEOUT_PERIOD_PERFINGER)); 166} 167 168static void 169tp_tap_set_draglock_timer(struct tp_dispatch *tp, uint64_t time) 170{ 171 libinput_timer_set(&tp->tap.timer, 172 time + DEFAULT_DRAGLOCK_TIMEOUT_PERIOD); 173} 174 175static void 176tp_tap_clear_timer(struct tp_dispatch *tp) 177{ 178 libinput_timer_cancel(&tp->tap.timer); 179} 180 181static void 182tp_tap_move_to_dead(struct tp_dispatch *tp, struct tp_touch *t) 183{ 184 tp->tap.state = TAP_STATE_DEAD; 185 t->tap.state = TAP_TOUCH_STATE_DEAD; 186 tp_tap_clear_timer(tp); 187} 188 189static void 190tp_tap_idle_handle_event(struct tp_dispatch *tp, 191 struct tp_touch *t, 192 enum tap_event event, uint64_t time) 193{ 194 switch (event) { 195 case TAP_EVENT_TOUCH: 196 tp->tap.state = TAP_STATE_TOUCH; 197 tp->tap.saved_press_time = time; 198 tp_tap_set_timer(tp, time); 199 break; 200 case TAP_EVENT_RELEASE: 201 break; 202 case TAP_EVENT_MOTION: 203 log_tap_bug(tp, t, event); 204 break; 205 case TAP_EVENT_TIMEOUT: 206 break; 207 case TAP_EVENT_BUTTON: 208 tp->tap.state = TAP_STATE_DEAD; 209 break; 210 case TAP_EVENT_THUMB: 211 log_tap_bug(tp, t, event); 212 break; 213 case TAP_EVENT_PALM: 214 tp->tap.state = TAP_STATE_IDLE; 215 break; 216 case TAP_EVENT_PALM_UP: 217 break; 218 } 219} 220 221static void 222tp_tap_touch_handle_event(struct tp_dispatch *tp, 223 struct tp_touch *t, 224 enum tap_event event, uint64_t time) 225{ 226 227 switch (event) { 228 case TAP_EVENT_TOUCH: 229 tp->tap.state = TAP_STATE_TOUCH_2; 230 tp->tap.saved_press_time = time; 231 tp_tap_set_timer(tp, time); 232 break; 233 case TAP_EVENT_RELEASE: 234 tp_tap_notify(tp, 235 tp->tap.saved_press_time, 236 1, 237 LIBINPUT_BUTTON_STATE_PRESSED); 238 if (tp->tap.drag_enabled) { 239 tp->tap.state = TAP_STATE_1FGTAP_TAPPED; 240 tp->tap.saved_release_time = time; 241 tp_tap_set_drag_timer(tp, time, 1); 242 } else { 243 tp_tap_notify(tp, 244 time, 245 1, 246 LIBINPUT_BUTTON_STATE_RELEASED); 247 tp->tap.state = TAP_STATE_IDLE; 248 } 249 break; 250 case TAP_EVENT_MOTION: 251 tp_tap_move_to_dead(tp, t); 252 break; 253 case TAP_EVENT_TIMEOUT: 254 tp->tap.state = TAP_STATE_HOLD; 255 tp_tap_clear_timer(tp); 256 tp_gesture_tap_timeout(tp, time); 257 break; 258 case TAP_EVENT_BUTTON: 259 tp->tap.state = TAP_STATE_DEAD; 260 break; 261 case TAP_EVENT_THUMB: 262 tp->tap.state = TAP_STATE_IDLE; 263 t->tap.is_thumb = true; 264 tp->tap.nfingers_down--; 265 t->tap.state = TAP_TOUCH_STATE_DEAD; 266 tp_tap_clear_timer(tp); 267 break; 268 case TAP_EVENT_PALM: 269 tp->tap.state = TAP_STATE_IDLE; 270 tp_tap_clear_timer(tp); 271 break; 272 case TAP_EVENT_PALM_UP: 273 break; 274 } 275} 276 277static void 278tp_tap_hold_handle_event(struct tp_dispatch *tp, 279 struct tp_touch *t, 280 enum tap_event event, uint64_t time) 281{ 282 283 switch (event) { 284 case TAP_EVENT_TOUCH: 285 tp->tap.state = TAP_STATE_TOUCH_2; 286 tp->tap.saved_press_time = time; 287 tp_tap_set_timer(tp, time); 288 break; 289 case TAP_EVENT_RELEASE: 290 tp->tap.state = TAP_STATE_IDLE; 291 break; 292 case TAP_EVENT_MOTION: 293 tp_tap_move_to_dead(tp, t); 294 break; 295 case TAP_EVENT_TIMEOUT: 296 break; 297 case TAP_EVENT_BUTTON: 298 tp->tap.state = TAP_STATE_DEAD; 299 break; 300 case TAP_EVENT_THUMB: 301 tp->tap.state = TAP_STATE_IDLE; 302 t->tap.is_thumb = true; 303 tp->tap.nfingers_down--; 304 t->tap.state = TAP_TOUCH_STATE_DEAD; 305 break; 306 case TAP_EVENT_PALM: 307 tp->tap.state = TAP_STATE_IDLE; 308 break; 309 case TAP_EVENT_PALM_UP: 310 break; 311 } 312} 313 314static void 315tp_tap_tapped_handle_event(struct tp_dispatch *tp, 316 struct tp_touch *t, 317 enum tap_event event, uint64_t time, 318 int nfingers_tapped) 319{ 320 switch (event) { 321 case TAP_EVENT_MOTION: 322 case TAP_EVENT_RELEASE: 323 log_tap_bug(tp, t, event); 324 break; 325 case TAP_EVENT_TOUCH: { 326 enum tp_tap_state dest[3] = { 327 TAP_STATE_1FGTAP_DRAGGING_OR_DOUBLETAP, 328 TAP_STATE_2FGTAP_DRAGGING_OR_DOUBLETAP, 329 TAP_STATE_3FGTAP_DRAGGING_OR_DOUBLETAP, 330 }; 331 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 332 tp->tap.state = dest[nfingers_tapped - 1]; 333 tp->tap.saved_press_time = time; 334 tp_tap_set_timer(tp, time); 335 break; 336 } 337 case TAP_EVENT_TIMEOUT: 338 tp->tap.state = TAP_STATE_IDLE; 339 tp_tap_notify(tp, 340 tp->tap.saved_release_time, 341 nfingers_tapped, 342 LIBINPUT_BUTTON_STATE_RELEASED); 343 break; 344 case TAP_EVENT_BUTTON: 345 tp->tap.state = TAP_STATE_DEAD; 346 tp_tap_notify(tp, 347 tp->tap.saved_release_time, 348 nfingers_tapped, 349 LIBINPUT_BUTTON_STATE_RELEASED); 350 break; 351 case TAP_EVENT_THUMB: 352 log_tap_bug(tp, t, event); 353 break; 354 case TAP_EVENT_PALM: 355 log_tap_bug(tp, t, event); 356 break; 357 case TAP_EVENT_PALM_UP: 358 break; 359 } 360} 361 362static void 363tp_tap_touch2_handle_event(struct tp_dispatch *tp, 364 struct tp_touch *t, 365 enum tap_event event, uint64_t time) 366{ 367 368 switch (event) { 369 case TAP_EVENT_TOUCH: 370 tp->tap.state = TAP_STATE_TOUCH_3; 371 tp->tap.saved_press_time = time; 372 tp_tap_set_timer(tp, time); 373 break; 374 case TAP_EVENT_RELEASE: 375 tp->tap.state = TAP_STATE_TOUCH_2_RELEASE; 376 tp->tap.saved_release_time = time; 377 tp_tap_set_timer(tp, time); 378 break; 379 case TAP_EVENT_MOTION: 380 tp_tap_move_to_dead(tp, t); 381 break; 382 case TAP_EVENT_TIMEOUT: 383 tp->tap.state = TAP_STATE_TOUCH_2_HOLD; 384 tp_gesture_tap_timeout(tp, time); 385 break; 386 case TAP_EVENT_BUTTON: 387 tp->tap.state = TAP_STATE_DEAD; 388 break; 389 case TAP_EVENT_THUMB: 390 break; 391 case TAP_EVENT_PALM: 392 tp->tap.state = TAP_STATE_TOUCH; 393 break; 394 case TAP_EVENT_PALM_UP: 395 break; 396 } 397} 398 399static void 400tp_tap_touch2_hold_handle_event(struct tp_dispatch *tp, 401 struct tp_touch *t, 402 enum tap_event event, uint64_t time) 403{ 404 405 switch (event) { 406 case TAP_EVENT_TOUCH: 407 tp->tap.state = TAP_STATE_TOUCH_3; 408 tp->tap.saved_press_time = time; 409 tp_tap_set_timer(tp, time); 410 break; 411 case TAP_EVENT_RELEASE: 412 tp->tap.state = TAP_STATE_HOLD; 413 break; 414 case TAP_EVENT_MOTION: 415 tp_tap_move_to_dead(tp, t); 416 break; 417 case TAP_EVENT_TIMEOUT: 418 tp->tap.state = TAP_STATE_TOUCH_2_HOLD; 419 break; 420 case TAP_EVENT_BUTTON: 421 tp->tap.state = TAP_STATE_DEAD; 422 break; 423 case TAP_EVENT_THUMB: 424 break; 425 case TAP_EVENT_PALM: 426 tp->tap.state = TAP_STATE_HOLD; 427 break; 428 case TAP_EVENT_PALM_UP: 429 break; 430 } 431} 432 433static void 434tp_tap_touch2_release_handle_event(struct tp_dispatch *tp, 435 struct tp_touch *t, 436 enum tap_event event, uint64_t time) 437{ 438 439 switch (event) { 440 case TAP_EVENT_TOUCH: 441 tp->tap.state = TAP_STATE_TOUCH_2_HOLD; 442 t->tap.state = TAP_TOUCH_STATE_DEAD; 443 tp_tap_clear_timer(tp); 444 break; 445 case TAP_EVENT_RELEASE: 446 tp_tap_notify(tp, 447 tp->tap.saved_press_time, 448 2, 449 LIBINPUT_BUTTON_STATE_PRESSED); 450 if (tp->tap.drag_enabled) { 451 tp->tap.state = TAP_STATE_2FGTAP_TAPPED; 452 tp_tap_set_drag_timer(tp, time, 2); 453 } else { 454 tp_tap_notify(tp, 455 tp->tap.saved_release_time, 456 2, 457 LIBINPUT_BUTTON_STATE_RELEASED); 458 tp->tap.state = TAP_STATE_IDLE; 459 } 460 break; 461 case TAP_EVENT_MOTION: 462 tp_tap_move_to_dead(tp, t); 463 break; 464 case TAP_EVENT_TIMEOUT: 465 tp->tap.state = TAP_STATE_HOLD; 466 break; 467 case TAP_EVENT_BUTTON: 468 tp->tap.state = TAP_STATE_DEAD; 469 break; 470 case TAP_EVENT_THUMB: 471 break; 472 case TAP_EVENT_PALM: 473 /* There's only one saved press time and it's overwritten by 474 * the last touch down. So in the case of finger down, palm 475 * down, finger up, palm detected, we use the 476 * palm touch's press time here instead of the finger's press 477 * time. Let's wait and see if that's an issue. 478 */ 479 tp_tap_notify(tp, 480 tp->tap.saved_press_time, 481 1, 482 LIBINPUT_BUTTON_STATE_PRESSED); 483 if (tp->tap.drag_enabled) { 484 /* For a single-finger tap the timer delay is the same 485 * as for the release of the finger that became a palm, 486 * no reset necessary */ 487 tp->tap.state = TAP_STATE_1FGTAP_TAPPED; 488 } else { 489 tp_tap_notify(tp, 490 tp->tap.saved_release_time, 491 1, 492 LIBINPUT_BUTTON_STATE_RELEASED); 493 tp->tap.state = TAP_STATE_IDLE; 494 } 495 break; 496 case TAP_EVENT_PALM_UP: 497 break; 498 } 499} 500 501static void 502tp_tap_touch3_handle_event(struct tp_dispatch *tp, 503 struct tp_touch *t, 504 enum tap_event event, uint64_t time) 505{ 506 507 switch (event) { 508 case TAP_EVENT_TOUCH: 509 tp->tap.state = TAP_STATE_DEAD; 510 tp_tap_clear_timer(tp); 511 break; 512 case TAP_EVENT_MOTION: 513 tp_tap_move_to_dead(tp, t); 514 break; 515 case TAP_EVENT_TIMEOUT: 516 tp->tap.state = TAP_STATE_TOUCH_3_HOLD; 517 tp_tap_clear_timer(tp); 518 tp_gesture_tap_timeout(tp, time); 519 break; 520 case TAP_EVENT_RELEASE: 521 tp->tap.state = TAP_STATE_TOUCH_3_RELEASE; 522 tp->tap.saved_release_time = time; 523 tp_tap_set_timer(tp, time); 524 break; 525 case TAP_EVENT_BUTTON: 526 tp->tap.state = TAP_STATE_DEAD; 527 break; 528 case TAP_EVENT_THUMB: 529 break; 530 case TAP_EVENT_PALM: 531 tp->tap.state = TAP_STATE_TOUCH_2; 532 break; 533 case TAP_EVENT_PALM_UP: 534 break; 535 } 536} 537 538static void 539tp_tap_touch3_hold_handle_event(struct tp_dispatch *tp, 540 struct tp_touch *t, 541 enum tap_event event, uint64_t time) 542{ 543 544 switch (event) { 545 case TAP_EVENT_TOUCH: 546 tp->tap.state = TAP_STATE_DEAD; 547 tp_tap_set_timer(tp, time); 548 break; 549 case TAP_EVENT_RELEASE: 550 tp->tap.state = TAP_STATE_TOUCH_2_HOLD; 551 break; 552 case TAP_EVENT_MOTION: 553 tp_tap_move_to_dead(tp, t); 554 break; 555 case TAP_EVENT_TIMEOUT: 556 break; 557 case TAP_EVENT_BUTTON: 558 tp->tap.state = TAP_STATE_DEAD; 559 break; 560 case TAP_EVENT_THUMB: 561 break; 562 case TAP_EVENT_PALM: 563 tp->tap.state = TAP_STATE_TOUCH_2_HOLD; 564 break; 565 case TAP_EVENT_PALM_UP: 566 break; 567 } 568} 569 570static void 571tp_tap_touch3_release_handle_event(struct tp_dispatch *tp, 572 struct tp_touch *t, 573 enum tap_event event, uint64_t time) 574{ 575 576 switch (event) { 577 case TAP_EVENT_TOUCH: 578 tp_tap_notify(tp, 579 tp->tap.saved_press_time, 580 3, 581 LIBINPUT_BUTTON_STATE_PRESSED); 582 tp_tap_notify(tp, 583 tp->tap.saved_release_time, 584 3, 585 LIBINPUT_BUTTON_STATE_RELEASED); 586 tp->tap.state = TAP_STATE_TOUCH_3; 587 tp->tap.saved_press_time = time; 588 tp_tap_set_timer(tp, time); 589 break; 590 case TAP_EVENT_RELEASE: 591 tp->tap.state = TAP_STATE_TOUCH_3_RELEASE_2; 592 tp_tap_set_timer(tp, time); 593 break; 594 case TAP_EVENT_MOTION: 595 tp_tap_notify(tp, 596 tp->tap.saved_press_time, 597 3, 598 LIBINPUT_BUTTON_STATE_PRESSED); 599 tp_tap_notify(tp, 600 tp->tap.saved_release_time, 601 3, 602 LIBINPUT_BUTTON_STATE_RELEASED); 603 tp_tap_move_to_dead(tp, t); 604 break; 605 case TAP_EVENT_TIMEOUT: 606 tp_tap_notify(tp, 607 tp->tap.saved_press_time, 608 3, 609 LIBINPUT_BUTTON_STATE_PRESSED); 610 tp_tap_notify(tp, 611 tp->tap.saved_release_time, 612 3, 613 LIBINPUT_BUTTON_STATE_RELEASED); 614 tp->tap.state = TAP_STATE_TOUCH_2_HOLD; 615 break; 616 case TAP_EVENT_BUTTON: 617 tp_tap_notify(tp, 618 tp->tap.saved_press_time, 619 3, 620 LIBINPUT_BUTTON_STATE_PRESSED); 621 tp_tap_notify(tp, 622 tp->tap.saved_release_time, 623 3, 624 LIBINPUT_BUTTON_STATE_RELEASED); 625 tp->tap.state = TAP_STATE_DEAD; 626 break; 627 case TAP_EVENT_THUMB: 628 break; 629 case TAP_EVENT_PALM: 630 tp->tap.state = TAP_STATE_TOUCH_2_RELEASE; 631 break; 632 case TAP_EVENT_PALM_UP: 633 break; 634 } 635} 636 637static void 638tp_tap_touch3_release2_handle_event(struct tp_dispatch *tp, 639 struct tp_touch *t, 640 enum tap_event event, uint64_t time) 641{ 642 643 switch (event) { 644 case TAP_EVENT_TOUCH: 645 tp_tap_notify(tp, 646 tp->tap.saved_press_time, 647 3, 648 LIBINPUT_BUTTON_STATE_PRESSED); 649 tp_tap_notify(tp, 650 tp->tap.saved_release_time, 651 3, 652 LIBINPUT_BUTTON_STATE_RELEASED); 653 tp->tap.state = TAP_STATE_TOUCH_2; 654 tp->tap.saved_press_time = time; 655 tp_tap_set_timer(tp, time); 656 break; 657 case TAP_EVENT_RELEASE: 658 tp_tap_notify(tp, 659 tp->tap.saved_press_time, 660 3, 661 LIBINPUT_BUTTON_STATE_PRESSED); 662 if (tp->tap.drag_enabled) { 663 tp->tap.state = TAP_STATE_3FGTAP_TAPPED; 664 tp_tap_set_drag_timer(tp, time, 3); 665 } else { 666 tp_tap_notify(tp, 667 tp->tap.saved_release_time, 668 3, 669 LIBINPUT_BUTTON_STATE_RELEASED); 670 tp->tap.state = TAP_STATE_IDLE; 671 } 672 break; 673 case TAP_EVENT_MOTION: 674 tp_tap_notify(tp, 675 tp->tap.saved_press_time, 676 3, 677 LIBINPUT_BUTTON_STATE_PRESSED); 678 tp_tap_notify(tp, 679 tp->tap.saved_release_time, 680 3, 681 LIBINPUT_BUTTON_STATE_RELEASED); 682 tp_tap_move_to_dead(tp, t); 683 break; 684 case TAP_EVENT_TIMEOUT: 685 tp_tap_notify(tp, 686 tp->tap.saved_press_time, 687 3, 688 LIBINPUT_BUTTON_STATE_PRESSED); 689 tp_tap_notify(tp, 690 tp->tap.saved_release_time, 691 3, 692 LIBINPUT_BUTTON_STATE_RELEASED); 693 tp->tap.state = TAP_STATE_HOLD; 694 break; 695 case TAP_EVENT_BUTTON: 696 tp_tap_notify(tp, 697 tp->tap.saved_press_time, 698 3, 699 LIBINPUT_BUTTON_STATE_PRESSED); 700 tp_tap_notify(tp, 701 tp->tap.saved_release_time, 702 3, 703 LIBINPUT_BUTTON_STATE_RELEASED); 704 tp->tap.state = TAP_STATE_DEAD; 705 break; 706 case TAP_EVENT_THUMB: 707 break; 708 case TAP_EVENT_PALM: 709 tp_tap_notify(tp, 710 tp->tap.saved_press_time, 711 2, 712 LIBINPUT_BUTTON_STATE_PRESSED); 713 if (tp->tap.drag_enabled) { 714 /* Resetting the timer to the appropriate delay 715 * for a two-finger tap would be ideal, but the 716 * timestamp of the last real finger release is lost, 717 * so the in-progress similar delay for release 718 * of the finger which became a palm instead 719 * will have to do */ 720 tp->tap.state = TAP_STATE_2FGTAP_TAPPED; 721 } else { 722 tp_tap_notify(tp, 723 tp->tap.saved_release_time, 724 2, 725 LIBINPUT_BUTTON_STATE_RELEASED); 726 tp->tap.state = TAP_STATE_IDLE; 727 } 728 break; 729 case TAP_EVENT_PALM_UP: 730 break; 731 } 732} 733 734static void 735tp_tap_dragging_or_doubletap_handle_event(struct tp_dispatch *tp, 736 struct tp_touch *t, 737 enum tap_event event, uint64_t time, 738 int nfingers_tapped) 739{ 740 switch (event) { 741 case TAP_EVENT_TOUCH: { 742 tp_tap_notify(tp, 743 tp->tap.saved_release_time, 744 nfingers_tapped, 745 LIBINPUT_BUTTON_STATE_RELEASED); 746 tp->tap.state = TAP_STATE_TOUCH_2; 747 tp->tap.saved_press_time = time; 748 tp_tap_set_timer(tp, time); 749 break; 750 } 751 case TAP_EVENT_RELEASE: 752 tp->tap.state = TAP_STATE_1FGTAP_TAPPED; 753 tp_tap_notify(tp, 754 tp->tap.saved_release_time, 755 nfingers_tapped, 756 LIBINPUT_BUTTON_STATE_RELEASED); 757 tp_tap_notify(tp, 758 tp->tap.saved_press_time, 759 1, 760 LIBINPUT_BUTTON_STATE_PRESSED); 761 tp->tap.saved_release_time = time; 762 tp_tap_set_timer(tp, time); 763 break; 764 case TAP_EVENT_MOTION: 765 case TAP_EVENT_TIMEOUT: { 766 enum tp_tap_state dest[3] = { 767 TAP_STATE_1FGTAP_DRAGGING, 768 TAP_STATE_2FGTAP_DRAGGING, 769 TAP_STATE_3FGTAP_DRAGGING, 770 }; 771 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 772 tp->tap.state = dest[nfingers_tapped - 1]; 773 break; 774 } 775 case TAP_EVENT_BUTTON: 776 tp->tap.state = TAP_STATE_DEAD; 777 tp_tap_notify(tp, 778 tp->tap.saved_release_time, 779 nfingers_tapped, 780 LIBINPUT_BUTTON_STATE_RELEASED); 781 break; 782 case TAP_EVENT_THUMB: 783 break; 784 case TAP_EVENT_PALM: { 785 enum tp_tap_state dest[3] = { 786 TAP_STATE_1FGTAP_TAPPED, 787 TAP_STATE_2FGTAP_TAPPED, 788 TAP_STATE_3FGTAP_TAPPED, 789 }; 790 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 791 tp->tap.state = dest[nfingers_tapped - 1]; 792 break; 793 } 794 case TAP_EVENT_PALM_UP: 795 break; 796 } 797} 798 799static void 800tp_tap_dragging_handle_event(struct tp_dispatch *tp, 801 struct tp_touch *t, 802 enum tap_event event, uint64_t time, 803 int nfingers_tapped) 804{ 805 806 switch (event) { 807 case TAP_EVENT_TOUCH: { 808 enum tp_tap_state dest[3] = { 809 TAP_STATE_1FGTAP_DRAGGING_2, 810 TAP_STATE_2FGTAP_DRAGGING_2, 811 TAP_STATE_3FGTAP_DRAGGING_2, 812 }; 813 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 814 tp->tap.state = dest[nfingers_tapped - 1]; 815 break; 816 } 817 case TAP_EVENT_RELEASE: 818 if (tp->tap.drag_lock_enabled) { 819 enum tp_tap_state dest[3] = { 820 TAP_STATE_1FGTAP_DRAGGING_WAIT, 821 TAP_STATE_2FGTAP_DRAGGING_WAIT, 822 TAP_STATE_3FGTAP_DRAGGING_WAIT, 823 }; 824 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 825 tp->tap.state = dest[nfingers_tapped - 1]; 826 tp_tap_set_draglock_timer(tp, time); 827 } else { 828 tp_tap_notify(tp, 829 time, 830 nfingers_tapped, 831 LIBINPUT_BUTTON_STATE_RELEASED); 832 tp->tap.state = TAP_STATE_IDLE; 833 } 834 break; 835 case TAP_EVENT_MOTION: 836 case TAP_EVENT_TIMEOUT: 837 /* noop */ 838 break; 839 case TAP_EVENT_BUTTON: 840 tp->tap.state = TAP_STATE_DEAD; 841 tp_tap_notify(tp, 842 time, 843 nfingers_tapped, 844 LIBINPUT_BUTTON_STATE_RELEASED); 845 break; 846 case TAP_EVENT_THUMB: 847 break; 848 case TAP_EVENT_PALM: 849 tp_tap_notify(tp, 850 tp->tap.saved_release_time, 851 nfingers_tapped, 852 LIBINPUT_BUTTON_STATE_RELEASED); 853 tp->tap.state = TAP_STATE_IDLE; 854 break; 855 case TAP_EVENT_PALM_UP: 856 break; 857 } 858} 859 860static void 861tp_tap_dragging_wait_handle_event(struct tp_dispatch *tp, 862 struct tp_touch *t, 863 enum tap_event event, uint64_t time, 864 int nfingers_tapped) 865{ 866 867 switch (event) { 868 case TAP_EVENT_TOUCH: { 869 enum tp_tap_state dest[3] = { 870 TAP_STATE_1FGTAP_DRAGGING_OR_TAP, 871 TAP_STATE_2FGTAP_DRAGGING_OR_TAP, 872 TAP_STATE_3FGTAP_DRAGGING_OR_TAP, 873 }; 874 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 875 tp->tap.state = dest[nfingers_tapped - 1]; 876 tp_tap_set_timer(tp, time); 877 break; 878 } 879 case TAP_EVENT_RELEASE: 880 case TAP_EVENT_MOTION: 881 log_tap_bug(tp, t, event); 882 break; 883 case TAP_EVENT_TIMEOUT: 884 tp->tap.state = TAP_STATE_IDLE; 885 tp_tap_notify(tp, 886 time, 887 nfingers_tapped, 888 LIBINPUT_BUTTON_STATE_RELEASED); 889 break; 890 case TAP_EVENT_BUTTON: 891 tp->tap.state = TAP_STATE_DEAD; 892 tp_tap_notify(tp, 893 time, 894 nfingers_tapped, 895 LIBINPUT_BUTTON_STATE_RELEASED); 896 break; 897 case TAP_EVENT_THUMB: 898 case TAP_EVENT_PALM: 899 log_tap_bug(tp, t, event); 900 break; 901 case TAP_EVENT_PALM_UP: 902 break; 903 } 904} 905 906static void 907tp_tap_dragging_tap_handle_event(struct tp_dispatch *tp, 908 struct tp_touch *t, 909 enum tap_event event, uint64_t time, 910 int nfingers_tapped) 911{ 912 913 switch (event) { 914 case TAP_EVENT_TOUCH: { 915 tp_tap_notify(tp, 916 time, 917 nfingers_tapped, 918 LIBINPUT_BUTTON_STATE_RELEASED); 919 tp_tap_clear_timer(tp); 920 tp_tap_move_to_dead(tp, t); 921 break; 922 } 923 case TAP_EVENT_RELEASE: 924 tp->tap.state = TAP_STATE_IDLE; 925 tp_tap_notify(tp, 926 time, 927 nfingers_tapped, 928 LIBINPUT_BUTTON_STATE_RELEASED); 929 break; 930 case TAP_EVENT_MOTION: 931 case TAP_EVENT_TIMEOUT: { 932 enum tp_tap_state dest[3] = { 933 TAP_STATE_1FGTAP_DRAGGING, 934 TAP_STATE_2FGTAP_DRAGGING, 935 TAP_STATE_3FGTAP_DRAGGING, 936 }; 937 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 938 tp->tap.state = dest[nfingers_tapped - 1]; 939 break; 940 } 941 case TAP_EVENT_BUTTON: 942 tp->tap.state = TAP_STATE_DEAD; 943 tp_tap_notify(tp, 944 time, 945 nfingers_tapped, 946 LIBINPUT_BUTTON_STATE_RELEASED); 947 break; 948 case TAP_EVENT_THUMB: 949 break; 950 case TAP_EVENT_PALM: { 951 enum tp_tap_state dest[3] = { 952 TAP_STATE_1FGTAP_DRAGGING_WAIT, 953 TAP_STATE_2FGTAP_DRAGGING_WAIT, 954 TAP_STATE_3FGTAP_DRAGGING_WAIT, 955 }; 956 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 957 tp->tap.state = dest[nfingers_tapped - 1]; 958 break; 959 } 960 case TAP_EVENT_PALM_UP: 961 break; 962 } 963} 964 965static void 966tp_tap_dragging2_handle_event(struct tp_dispatch *tp, 967 struct tp_touch *t, 968 enum tap_event event, uint64_t time, 969 int nfingers_tapped) 970{ 971 972 switch (event) { 973 case TAP_EVENT_RELEASE: { 974 enum tp_tap_state dest[3] = { 975 TAP_STATE_1FGTAP_DRAGGING, 976 TAP_STATE_2FGTAP_DRAGGING, 977 TAP_STATE_3FGTAP_DRAGGING, 978 }; 979 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 980 tp->tap.state = dest[nfingers_tapped - 1]; 981 break; 982 } 983 case TAP_EVENT_TOUCH: 984 tp->tap.state = TAP_STATE_DEAD; 985 tp_tap_notify(tp, 986 time, 987 nfingers_tapped, 988 LIBINPUT_BUTTON_STATE_RELEASED); 989 break; 990 case TAP_EVENT_MOTION: 991 case TAP_EVENT_TIMEOUT: 992 /* noop */ 993 break; 994 case TAP_EVENT_BUTTON: 995 tp->tap.state = TAP_STATE_DEAD; 996 tp_tap_notify(tp, 997 time, 998 nfingers_tapped, 999 LIBINPUT_BUTTON_STATE_RELEASED); 1000 break; 1001 case TAP_EVENT_THUMB: 1002 break; 1003 case TAP_EVENT_PALM: { 1004 enum tp_tap_state dest[3] = { 1005 TAP_STATE_1FGTAP_DRAGGING, 1006 TAP_STATE_2FGTAP_DRAGGING, 1007 TAP_STATE_3FGTAP_DRAGGING, 1008 }; 1009 assert(nfingers_tapped >= 1 && nfingers_tapped <= 3); 1010 tp->tap.state = dest[nfingers_tapped - 1]; 1011 break; 1012 } 1013 case TAP_EVENT_PALM_UP: 1014 break; 1015 } 1016} 1017 1018static void 1019tp_tap_dead_handle_event(struct tp_dispatch *tp, 1020 struct tp_touch *t, 1021 enum tap_event event, 1022 uint64_t time) 1023{ 1024 1025 switch (event) { 1026 case TAP_EVENT_RELEASE: 1027 if (tp->tap.nfingers_down == 0) 1028 tp->tap.state = TAP_STATE_IDLE; 1029 break; 1030 case TAP_EVENT_TOUCH: 1031 case TAP_EVENT_MOTION: 1032 case TAP_EVENT_TIMEOUT: 1033 case TAP_EVENT_BUTTON: 1034 break; 1035 case TAP_EVENT_THUMB: 1036 break; 1037 case TAP_EVENT_PALM: 1038 case TAP_EVENT_PALM_UP: 1039 if (tp->tap.nfingers_down == 0) 1040 tp->tap.state = TAP_STATE_IDLE; 1041 break; 1042 } 1043} 1044 1045static void 1046tp_tap_handle_event(struct tp_dispatch *tp, 1047 struct tp_touch *t, 1048 enum tap_event event, 1049 uint64_t time) 1050{ 1051 enum tp_tap_state current; 1052 1053 current = tp->tap.state; 1054 1055 switch(tp->tap.state) { 1056 case TAP_STATE_IDLE: 1057 tp_tap_idle_handle_event(tp, t, event, time); 1058 break; 1059 case TAP_STATE_TOUCH: 1060 tp_tap_touch_handle_event(tp, t, event, time); 1061 break; 1062 case TAP_STATE_HOLD: 1063 tp_tap_hold_handle_event(tp, t, event, time); 1064 break; 1065 case TAP_STATE_1FGTAP_TAPPED: 1066 tp_tap_tapped_handle_event(tp, t, event, time, 1); 1067 break; 1068 case TAP_STATE_2FGTAP_TAPPED: 1069 tp_tap_tapped_handle_event(tp, t, event, time, 2); 1070 break; 1071 case TAP_STATE_3FGTAP_TAPPED: 1072 tp_tap_tapped_handle_event(tp, t, event, time, 3); 1073 break; 1074 case TAP_STATE_TOUCH_2: 1075 tp_tap_touch2_handle_event(tp, t, event, time); 1076 break; 1077 case TAP_STATE_TOUCH_2_HOLD: 1078 tp_tap_touch2_hold_handle_event(tp, t, event, time); 1079 break; 1080 case TAP_STATE_TOUCH_2_RELEASE: 1081 tp_tap_touch2_release_handle_event(tp, t, event, time); 1082 break; 1083 case TAP_STATE_TOUCH_3: 1084 tp_tap_touch3_handle_event(tp, t, event, time); 1085 break; 1086 case TAP_STATE_TOUCH_3_HOLD: 1087 tp_tap_touch3_hold_handle_event(tp, t, event, time); 1088 break; 1089 case TAP_STATE_TOUCH_3_RELEASE: 1090 tp_tap_touch3_release_handle_event(tp, t, event, time); 1091 break; 1092 case TAP_STATE_TOUCH_3_RELEASE_2: 1093 tp_tap_touch3_release2_handle_event(tp, t, event, time); 1094 break; 1095 case TAP_STATE_1FGTAP_DRAGGING_OR_DOUBLETAP: 1096 tp_tap_dragging_or_doubletap_handle_event(tp, t, event, time, 1097 1); 1098 break; 1099 case TAP_STATE_2FGTAP_DRAGGING_OR_DOUBLETAP: 1100 tp_tap_dragging_or_doubletap_handle_event(tp, t, event, time, 1101 2); 1102 break; 1103 case TAP_STATE_3FGTAP_DRAGGING_OR_DOUBLETAP: 1104 tp_tap_dragging_or_doubletap_handle_event(tp, t, event, time, 1105 3); 1106 break; 1107 case TAP_STATE_1FGTAP_DRAGGING: 1108 tp_tap_dragging_handle_event(tp, t, event, time, 1); 1109 break; 1110 case TAP_STATE_2FGTAP_DRAGGING: 1111 tp_tap_dragging_handle_event(tp, t, event, time, 2); 1112 break; 1113 case TAP_STATE_3FGTAP_DRAGGING: 1114 tp_tap_dragging_handle_event(tp, t, event, time, 3); 1115 break; 1116 case TAP_STATE_1FGTAP_DRAGGING_WAIT: 1117 tp_tap_dragging_wait_handle_event(tp, t, event, time, 1); 1118 break; 1119 case TAP_STATE_2FGTAP_DRAGGING_WAIT: 1120 tp_tap_dragging_wait_handle_event(tp, t, event, time, 2); 1121 break; 1122 case TAP_STATE_3FGTAP_DRAGGING_WAIT: 1123 tp_tap_dragging_wait_handle_event(tp, t, event, time, 3); 1124 break; 1125 case TAP_STATE_1FGTAP_DRAGGING_OR_TAP: 1126 tp_tap_dragging_tap_handle_event(tp, t, event, time, 1); 1127 break; 1128 case TAP_STATE_2FGTAP_DRAGGING_OR_TAP: 1129 tp_tap_dragging_tap_handle_event(tp, t, event, time, 2); 1130 break; 1131 case TAP_STATE_3FGTAP_DRAGGING_OR_TAP: 1132 tp_tap_dragging_tap_handle_event(tp, t, event, time, 3); 1133 break; 1134 case TAP_STATE_1FGTAP_DRAGGING_2: 1135 tp_tap_dragging2_handle_event(tp, t, event, time, 1); 1136 break; 1137 case TAP_STATE_2FGTAP_DRAGGING_2: 1138 tp_tap_dragging2_handle_event(tp, t, event, time, 2); 1139 break; 1140 case TAP_STATE_3FGTAP_DRAGGING_2: 1141 tp_tap_dragging2_handle_event(tp, t, event, time, 3); 1142 break; 1143 case TAP_STATE_DEAD: 1144 tp_tap_dead_handle_event(tp, t, event, time); 1145 break; 1146 } 1147 1148 if (tp->tap.state == TAP_STATE_IDLE || tp->tap.state == TAP_STATE_DEAD) 1149 tp_tap_clear_timer(tp); 1150 1151 if (current != tp->tap.state) 1152 evdev_log_debug(tp->device, 1153 "tap: touch %d (%s), tap state %s → %s → %s\n", 1154 t ? (int)t->index : -1, 1155 t ? touch_state_to_str(t->state) : "", 1156 tap_state_to_str(current), 1157 tap_event_to_str(event), 1158 tap_state_to_str(tp->tap.state)); 1159} 1160 1161static bool 1162tp_tap_exceeds_motion_threshold(struct tp_dispatch *tp, 1163 struct tp_touch *t) 1164{ 1165 struct phys_coords mm = 1166 tp_phys_delta(tp, device_delta(t->point, t->tap.initial)); 1167 1168 /* if we have more fingers down than slots, we know that synaptics 1169 * touchpads are likely to give us pointer jumps. 1170 * This triggers the movement threshold, making three-finger taps 1171 * less reliable (#101435) 1172 * 1173 * This uses the real nfingers_down, not the one for taps. 1174 */ 1175 if (tp->device->model_flags & EVDEV_MODEL_SYNAPTICS_SERIAL_TOUCHPAD && 1176 (tp->nfingers_down > 2 || tp->old_nfingers_down > 2) && 1177 (tp->nfingers_down > tp->num_slots || 1178 tp->old_nfingers_down > tp->num_slots)) { 1179 return false; 1180 } 1181 1182 /* Semi-mt devices will give us large movements on finger release, 1183 * depending which touch is released. Make sure we ignore any 1184 * movement in the same frame as a finger change. 1185 */ 1186 if (tp->semi_mt && tp->nfingers_down != tp->old_nfingers_down) 1187 return false; 1188 1189 return length_in_mm(mm) > DEFAULT_TAP_MOVE_THRESHOLD; 1190} 1191 1192static bool 1193tp_tap_enabled(struct tp_dispatch *tp) 1194{ 1195 return tp->tap.enabled && !tp->tap.suspended; 1196} 1197 1198int 1199tp_tap_handle_state(struct tp_dispatch *tp, uint64_t time) 1200{ 1201 struct tp_touch *t; 1202 int filter_motion = 0; 1203 1204 if (!tp_tap_enabled(tp)) 1205 return 0; 1206 1207 /* Handle queued button pressed events from clickpads. For touchpads 1208 * with separate physical buttons, ignore button pressed events so they 1209 * don't interfere with tapping. */ 1210 if (tp->buttons.is_clickpad && tp->queued & TOUCHPAD_EVENT_BUTTON_PRESS) 1211 tp_tap_handle_event(tp, NULL, TAP_EVENT_BUTTON, time); 1212 1213 tp_for_each_touch(tp, t) { 1214 if (!t->dirty || t->state == TOUCH_NONE) 1215 continue; 1216 1217 if (tp->buttons.is_clickpad && 1218 tp->queued & TOUCHPAD_EVENT_BUTTON_PRESS) 1219 t->tap.state = TAP_TOUCH_STATE_DEAD; 1220 1221 /* If a touch was considered thumb for tapping once, we 1222 * ignore it for the rest of lifetime */ 1223 if (t->tap.is_thumb) 1224 continue; 1225 1226 /* A palm tap needs to be properly released because we might 1227 * be who-knows-where in the state machine. Otherwise, we 1228 * ignore any event from it. 1229 */ 1230 if (t->tap.is_palm) { 1231 if (t->state == TOUCH_END) 1232 tp_tap_handle_event(tp, 1233 t, 1234 TAP_EVENT_PALM_UP, 1235 time); 1236 continue; 1237 } 1238 1239 if (t->state == TOUCH_HOVERING) 1240 continue; 1241 1242 if (t->palm.state != PALM_NONE) { 1243 assert(!t->tap.is_palm); 1244 t->tap.is_palm = true; 1245 t->tap.state = TAP_TOUCH_STATE_DEAD; 1246 if (t->state != TOUCH_BEGIN) { 1247 tp_tap_handle_event(tp, t, TAP_EVENT_PALM, time); 1248 assert(tp->tap.nfingers_down > 0); 1249 tp->tap.nfingers_down--; 1250 } 1251 } else if (t->state == TOUCH_BEGIN) { 1252 /* The simple version: if a touch is a thumb on 1253 * begin we ignore it. All other thumb touches 1254 * follow the normal tap state for now */ 1255 if (tp_thumb_ignored_for_tap(tp, t)) { 1256 t->tap.is_thumb = true; 1257 continue; 1258 } 1259 1260 t->tap.state = TAP_TOUCH_STATE_TOUCH; 1261 t->tap.initial = t->point; 1262 tp->tap.nfingers_down++; 1263 tp_tap_handle_event(tp, t, TAP_EVENT_TOUCH, time); 1264 } else if (t->state == TOUCH_END) { 1265 if (t->was_down) { 1266 assert(tp->tap.nfingers_down >= 1); 1267 tp->tap.nfingers_down--; 1268 tp_tap_handle_event(tp, t, TAP_EVENT_RELEASE, time); 1269 } 1270 t->tap.state = TAP_TOUCH_STATE_IDLE; 1271 } else if (tp->tap.state != TAP_STATE_IDLE && 1272 tp_thumb_ignored(tp, t)) { 1273 tp_tap_handle_event(tp, t, TAP_EVENT_THUMB, time); 1274 } else if (tp->tap.state != TAP_STATE_IDLE && 1275 tp_tap_exceeds_motion_threshold(tp, t)) { 1276 struct tp_touch *tmp; 1277 1278 /* Any touch exceeding the threshold turns all 1279 * touches into DEAD */ 1280 tp_for_each_touch(tp, tmp) { 1281 if (tmp->tap.state == TAP_TOUCH_STATE_TOUCH) 1282 tmp->tap.state = TAP_TOUCH_STATE_DEAD; 1283 } 1284 1285 tp_tap_handle_event(tp, t, TAP_EVENT_MOTION, time); 1286 } 1287 } 1288 1289 /** 1290 * In any state where motion exceeding the move threshold would 1291 * move to the next state, filter that motion until we actually 1292 * exceed it. This prevents small motion events while we're waiting 1293 * on a decision if a tap is a tap. 1294 */ 1295 switch (tp->tap.state) { 1296 case TAP_STATE_TOUCH: 1297 case TAP_STATE_1FGTAP_TAPPED: 1298 case TAP_STATE_2FGTAP_TAPPED: 1299 case TAP_STATE_3FGTAP_TAPPED: 1300 case TAP_STATE_1FGTAP_DRAGGING_OR_DOUBLETAP: 1301 case TAP_STATE_2FGTAP_DRAGGING_OR_DOUBLETAP: 1302 case TAP_STATE_3FGTAP_DRAGGING_OR_DOUBLETAP: 1303 case TAP_STATE_1FGTAP_DRAGGING_OR_TAP: 1304 case TAP_STATE_2FGTAP_DRAGGING_OR_TAP: 1305 case TAP_STATE_3FGTAP_DRAGGING_OR_TAP: 1306 case TAP_STATE_TOUCH_2: 1307 case TAP_STATE_TOUCH_3: 1308 filter_motion = 1; 1309 break; 1310 1311 default: 1312 break; 1313 1314 } 1315 1316 assert(tp->tap.nfingers_down <= tp->nfingers_down); 1317 if (tp->nfingers_down == 0) 1318 assert(tp->tap.nfingers_down == 0); 1319 1320 return filter_motion; 1321} 1322 1323static inline void 1324tp_tap_update_map(struct tp_dispatch *tp) 1325{ 1326 if (tp->tap.state != TAP_STATE_IDLE) 1327 return; 1328 1329 if (tp->tap.map != tp->tap.want_map) 1330 tp->tap.map = tp->tap.want_map; 1331} 1332 1333void 1334tp_tap_post_process_state(struct tp_dispatch *tp) 1335{ 1336 tp_tap_update_map(tp); 1337} 1338 1339static void 1340tp_tap_handle_timeout(uint64_t time, void *data) 1341{ 1342 struct tp_dispatch *tp = data; 1343 struct tp_touch *t; 1344 1345 tp_tap_handle_event(tp, NULL, TAP_EVENT_TIMEOUT, time); 1346 1347 tp_for_each_touch(tp, t) { 1348 if (t->state == TOUCH_NONE || 1349 t->tap.state == TAP_TOUCH_STATE_IDLE) 1350 continue; 1351 1352 t->tap.state = TAP_TOUCH_STATE_DEAD; 1353 } 1354} 1355 1356static void 1357tp_tap_enabled_update(struct tp_dispatch *tp, bool suspended, bool enabled, uint64_t time) 1358{ 1359 bool was_enabled = tp_tap_enabled(tp); 1360 1361 tp->tap.suspended = suspended; 1362 tp->tap.enabled = enabled; 1363 1364 if (tp_tap_enabled(tp) == was_enabled) 1365 return; 1366 1367 if (tp_tap_enabled(tp)) { 1368 struct tp_touch *t; 1369 1370 /* On resume, all touches are considered palms */ 1371 tp_for_each_touch(tp, t) { 1372 if (t->state == TOUCH_NONE) 1373 continue; 1374 1375 t->tap.is_palm = true; 1376 t->tap.state = TAP_TOUCH_STATE_DEAD; 1377 } 1378 1379 tp->tap.state = TAP_STATE_IDLE; 1380 tp->tap.nfingers_down = 0; 1381 } else { 1382 tp_release_all_taps(tp, time); 1383 } 1384} 1385 1386static int 1387tp_tap_config_count(struct libinput_device *device) 1388{ 1389 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1390 struct tp_dispatch *tp = tp_dispatch(dispatch); 1391 1392 return min(tp->ntouches, 3U); /* we only do up to 3 finger tap */ 1393} 1394 1395static enum libinput_config_status 1396tp_tap_config_set_enabled(struct libinput_device *device, 1397 enum libinput_config_tap_state enabled) 1398{ 1399 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1400 struct tp_dispatch *tp = tp_dispatch(dispatch); 1401 1402 tp_tap_enabled_update(tp, tp->tap.suspended, 1403 (enabled == LIBINPUT_CONFIG_TAP_ENABLED), 1404 libinput_now(device->seat->libinput)); 1405 1406 return LIBINPUT_CONFIG_STATUS_SUCCESS; 1407} 1408 1409static enum libinput_config_tap_state 1410tp_tap_config_is_enabled(struct libinput_device *device) 1411{ 1412 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1413 struct tp_dispatch *tp = tp_dispatch(dispatch); 1414 1415 return tp->tap.enabled ? LIBINPUT_CONFIG_TAP_ENABLED : 1416 LIBINPUT_CONFIG_TAP_DISABLED; 1417} 1418 1419static enum libinput_config_tap_state 1420tp_tap_default(struct evdev_device *evdev) 1421{ 1422 /** 1423 * If we don't have a left button we must have tapping enabled by 1424 * default. 1425 */ 1426 if (!libevdev_has_event_code(evdev->evdev, EV_KEY, BTN_LEFT)) 1427 return LIBINPUT_CONFIG_TAP_ENABLED; 1428 1429 /** 1430 * Tapping is disabled by default for two reasons: 1431 * * if you don't know that tapping is a thing (or enabled by 1432 * default), you get spurious mouse events that make the desktop 1433 * feel buggy. 1434 * * if you do know what tapping is and you want it, you 1435 * usually know where to enable it, or at least you can search for 1436 * it. 1437 */ 1438 return LIBINPUT_CONFIG_TAP_DISABLED; 1439} 1440 1441static enum libinput_config_tap_state 1442tp_tap_config_get_default(struct libinput_device *device) 1443{ 1444 struct evdev_device *evdev = evdev_device(device); 1445 1446 return tp_tap_default(evdev); 1447} 1448 1449static enum libinput_config_status 1450tp_tap_config_set_map(struct libinput_device *device, 1451 enum libinput_config_tap_button_map map) 1452{ 1453 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1454 struct tp_dispatch *tp = tp_dispatch(dispatch); 1455 1456 tp->tap.want_map = map; 1457 1458 tp_tap_update_map(tp); 1459 1460 return LIBINPUT_CONFIG_STATUS_SUCCESS; 1461} 1462 1463static enum libinput_config_tap_button_map 1464tp_tap_config_get_map(struct libinput_device *device) 1465{ 1466 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1467 struct tp_dispatch *tp = tp_dispatch(dispatch); 1468 1469 return tp->tap.want_map; 1470} 1471 1472static enum libinput_config_tap_button_map 1473tp_tap_config_get_default_map(struct libinput_device *device) 1474{ 1475 return LIBINPUT_CONFIG_TAP_MAP_LRM; 1476} 1477 1478static enum libinput_config_status 1479tp_tap_config_set_drag_enabled(struct libinput_device *device, 1480 enum libinput_config_drag_state enabled) 1481{ 1482 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1483 struct tp_dispatch *tp = tp_dispatch(dispatch); 1484 1485 tp->tap.drag_enabled = enabled; 1486 1487 return LIBINPUT_CONFIG_STATUS_SUCCESS; 1488} 1489 1490static enum libinput_config_drag_state 1491tp_tap_config_get_drag_enabled(struct libinput_device *device) 1492{ 1493 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1494 struct tp_dispatch *tp = tp_dispatch(dispatch); 1495 1496 return tp->tap.drag_enabled; 1497} 1498 1499static inline enum libinput_config_drag_state 1500tp_drag_default(struct evdev_device *device) 1501{ 1502 return LIBINPUT_CONFIG_DRAG_ENABLED; 1503} 1504 1505static enum libinput_config_drag_state 1506tp_tap_config_get_default_drag_enabled(struct libinput_device *device) 1507{ 1508 struct evdev_device *evdev = evdev_device(device); 1509 1510 return tp_drag_default(evdev); 1511} 1512 1513static enum libinput_config_status 1514tp_tap_config_set_draglock_enabled(struct libinput_device *device, 1515 enum libinput_config_drag_lock_state enabled) 1516{ 1517 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1518 struct tp_dispatch *tp = tp_dispatch(dispatch); 1519 1520 tp->tap.drag_lock_enabled = enabled; 1521 1522 return LIBINPUT_CONFIG_STATUS_SUCCESS; 1523} 1524 1525static enum libinput_config_drag_lock_state 1526tp_tap_config_get_draglock_enabled(struct libinput_device *device) 1527{ 1528 struct evdev_dispatch *dispatch = evdev_device(device)->dispatch; 1529 struct tp_dispatch *tp = tp_dispatch(dispatch); 1530 1531 return tp->tap.drag_lock_enabled; 1532} 1533 1534static inline enum libinput_config_drag_lock_state 1535tp_drag_lock_default(struct evdev_device *device) 1536{ 1537 return LIBINPUT_CONFIG_DRAG_LOCK_DISABLED; 1538} 1539 1540static enum libinput_config_drag_lock_state 1541tp_tap_config_get_default_draglock_enabled(struct libinput_device *device) 1542{ 1543 struct evdev_device *evdev = evdev_device(device); 1544 1545 return tp_drag_lock_default(evdev); 1546} 1547 1548void 1549tp_init_tap(struct tp_dispatch *tp) 1550{ 1551 char timer_name[64]; 1552 1553 tp->tap.config.count = tp_tap_config_count; 1554 tp->tap.config.set_enabled = tp_tap_config_set_enabled; 1555 tp->tap.config.get_enabled = tp_tap_config_is_enabled; 1556 tp->tap.config.get_default = tp_tap_config_get_default; 1557 tp->tap.config.set_map = tp_tap_config_set_map; 1558 tp->tap.config.get_map = tp_tap_config_get_map; 1559 tp->tap.config.get_default_map = tp_tap_config_get_default_map; 1560 tp->tap.config.set_drag_enabled = tp_tap_config_set_drag_enabled; 1561 tp->tap.config.get_drag_enabled = tp_tap_config_get_drag_enabled; 1562 tp->tap.config.get_default_drag_enabled = tp_tap_config_get_default_drag_enabled; 1563 tp->tap.config.set_draglock_enabled = tp_tap_config_set_draglock_enabled; 1564 tp->tap.config.get_draglock_enabled = tp_tap_config_get_draglock_enabled; 1565 tp->tap.config.get_default_draglock_enabled = tp_tap_config_get_default_draglock_enabled; 1566 tp->device->base.config.tap = &tp->tap.config; 1567 1568 tp->tap.state = TAP_STATE_IDLE; 1569 tp->tap.enabled = tp_tap_default(tp->device); 1570 tp->tap.map = LIBINPUT_CONFIG_TAP_MAP_LRM; 1571 tp->tap.want_map = tp->tap.map; 1572 tp->tap.drag_enabled = tp_drag_default(tp->device); 1573 tp->tap.drag_lock_enabled = tp_drag_lock_default(tp->device); 1574 1575 snprintf(timer_name, 1576 sizeof(timer_name), 1577 "%s tap", 1578 evdev_device_get_sysname(tp->device)); 1579 libinput_timer_init(&tp->tap.timer, 1580 tp_libinput_context(tp), 1581 timer_name, 1582 tp_tap_handle_timeout, tp); 1583} 1584 1585void 1586tp_remove_tap(struct tp_dispatch *tp) 1587{ 1588 libinput_timer_cancel(&tp->tap.timer); 1589} 1590 1591void 1592tp_release_all_taps(struct tp_dispatch *tp, uint64_t now) 1593{ 1594 struct tp_touch *t; 1595 int i; 1596 1597 for (i = 1; i <= 3; i++) { 1598 if (tp->tap.buttons_pressed & bit(i)) 1599 tp_tap_notify(tp, now, i, LIBINPUT_BUTTON_STATE_RELEASED); 1600 } 1601 1602 /* To neutralize all current touches, we make them all palms */ 1603 tp_for_each_touch(tp, t) { 1604 if (t->state == TOUCH_NONE) 1605 continue; 1606 1607 if (t->tap.is_palm) 1608 continue; 1609 1610 t->tap.is_palm = true; 1611 t->tap.state = TAP_TOUCH_STATE_DEAD; 1612 } 1613 1614 tp->tap.state = TAP_STATE_IDLE; 1615 tp->tap.nfingers_down = 0; 1616} 1617 1618void 1619tp_tap_suspend(struct tp_dispatch *tp, uint64_t time) 1620{ 1621 tp_tap_enabled_update(tp, true, tp->tap.enabled, time); 1622} 1623 1624void 1625tp_tap_resume(struct tp_dispatch *tp, uint64_t time) 1626{ 1627 tp_tap_enabled_update(tp, false, tp->tap.enabled, time); 1628} 1629 1630bool 1631tp_tap_dragging(const struct tp_dispatch *tp) 1632{ 1633 switch (tp->tap.state) { 1634 case TAP_STATE_1FGTAP_DRAGGING: 1635 case TAP_STATE_2FGTAP_DRAGGING: 1636 case TAP_STATE_3FGTAP_DRAGGING: 1637 case TAP_STATE_1FGTAP_DRAGGING_2: 1638 case TAP_STATE_2FGTAP_DRAGGING_2: 1639 case TAP_STATE_3FGTAP_DRAGGING_2: 1640 case TAP_STATE_1FGTAP_DRAGGING_WAIT: 1641 case TAP_STATE_2FGTAP_DRAGGING_WAIT: 1642 case TAP_STATE_3FGTAP_DRAGGING_WAIT: 1643 case TAP_STATE_1FGTAP_DRAGGING_OR_TAP: 1644 case TAP_STATE_2FGTAP_DRAGGING_OR_TAP: 1645 case TAP_STATE_3FGTAP_DRAGGING_OR_TAP: 1646 return true; 1647 default: 1648 return false; 1649 } 1650} 1651 1652bool 1653tp_tap_dragging_or_double_tapping(const struct tp_dispatch *tp) 1654{ 1655 switch (tp->tap.state) { 1656 case TAP_STATE_1FGTAP_DRAGGING_OR_DOUBLETAP: 1657 case TAP_STATE_2FGTAP_DRAGGING_OR_DOUBLETAP: 1658 case TAP_STATE_3FGTAP_DRAGGING_OR_DOUBLETAP: 1659 return true; 1660 default: 1661 return false; 1662 } 1663} 1664
