src/evdev-mt-touchpad.c

   1 /*
   2  * Copyright © 2014 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <assert.h>
  26 #include <math.h>
  27 #include <stdbool.h>
  28
  29 #include "evdev-mt-touchpad.h"
  30
  31 #define DEFAULT_CONSTANT_ACCEL_NUMERATOR 50
  32 #define DEFAULT_MIN_ACCEL_FACTOR 0.16
  33 #define DEFAULT_MAX_ACCEL_FACTOR 1.0
  34 #define DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR 700.0
  35
  36 static inline int
  37 tp_hysteresis(int in, int center, int margin)
  38 {
  39         int diff = in - center;
  40         if (abs(diff) <= margin)
  41                 return center;
  42
  43         if (diff > margin)
  44                 return center + diff - margin;
  45         else if (diff < -margin)
  46                 return center + diff + margin;
  47         return center + diff;
  48 }
  49
  50 static double
  51 tp_accel_profile(struct motion_filter *filter,
  52                  void *data,
  53                  double velocity,
  54                  uint32_t time)
  55 {
  56         struct tp_dispatch *tp =
  57                 (struct tp_dispatch *) data;
  58
  59         double accel_factor;
  60
  61         accel_factor = velocity * tp->accel.constant_factor;
  62
  63         if (accel_factor > tp->accel.max_factor)
  64                 accel_factor = tp->accel.max_factor;
  65         else if (accel_factor < tp->accel.min_factor)
  66                 accel_factor = tp->accel.min_factor;
  67
  68         return accel_factor;
  69 }
  70
  71 static inline struct tp_motion *
  72 tp_motion_history_offset(struct tp_touch *t, int offset)
  73 {
  74         int offset_index =
  75                 (t->history.index - offset + TOUCHPAD_HISTORY_LENGTH) %
  76                 TOUCHPAD_HISTORY_LENGTH;
  77
  78         return &t->history.samples[offset_index];
  79 }
  80
  81 static void
  82 tp_filter_motion(struct tp_dispatch *tp,
  83                  double *dx, double *dy, uint32_t time)
  84 {
  85         struct motion_params motion;
  86
  87         motion.dx = *dx;
  88         motion.dy = *dy;
  89
  90         filter_dispatch(tp->filter, &motion, tp, time);
  91
  92         *dx = motion.dx;
  93         *dy = motion.dy;
  94 }
  95
  96 static inline void
  97 tp_motion_history_push(struct tp_touch *t)
  98 {
  99         int motion_index = (t->history.index + 1) % TOUCHPAD_HISTORY_LENGTH;
 100
 101         if (t->history.count < TOUCHPAD_HISTORY_LENGTH)
 102                 t->history.count++;
 103
 104         t->history.samples[motion_index].x = t->x;
 105         t->history.samples[motion_index].y = t->y;
 106         t->history.index = motion_index;
 107 }
 108
 109 static inline void
 110 tp_motion_hysteresis(struct tp_dispatch *tp,
 111                      struct tp_touch *t)
 112 {
 113         int x = t->x,
 114             y = t->y;
 115
 116         if (t->history.count == 0) {
 117                 t->hysteresis.center_x = t->x;
 118                 t->hysteresis.center_y = t->y;
 119         } else {
 120                 x = tp_hysteresis(x,
 121                                   t->hysteresis.center_x,
 122                                   tp->hysteresis.margin_x);
 123                 y = tp_hysteresis(y,
 124                                   t->hysteresis.center_y,
 125                                   tp->hysteresis.margin_y);
 126                 t->hysteresis.center_x = x;
 127                 t->hysteresis.center_y = y;
 128                 t->x = x;
 129                 t->y = y;
 130         }
 131 }
 132
 133 static inline void
 134 tp_motion_history_reset(struct tp_touch *t)
 135 {
 136         t->history.count = 0;
 137 }
 138
 139 static inline struct tp_touch *
 140 tp_current_touch(struct tp_dispatch *tp)
 141 {
 142         return &tp->touches[min(tp->slot, tp->ntouches)];
 143 }
 144
 145 static inline struct tp_touch *
 146 tp_get_touch(struct tp_dispatch *tp, unsigned int slot)
 147 {
 148         assert(slot < tp->ntouches);
 149         return &tp->touches[slot];
 150 }
 151
 152 static inline void
 153 tp_begin_touch(struct tp_dispatch *tp, struct tp_touch *t)
 154 {
 155         struct tp_touch *tmp = NULL;
 156
 157         if (t->state != TOUCH_UPDATE) {
 158                 tp_motion_history_reset(t);
 159                 t->dirty = true;
 160                 t->state = TOUCH_BEGIN;
 161                 t->pinned.is_pinned = false;
 162                 tp->nfingers_down++;
 163                 assert(tp->nfingers_down >= 1);
 164                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 165
 166                 tp_for_each_touch(tp, tmp) {
 167                         if (tmp->is_pointer)
 168                                 break;
 169                 }
 170
 171                 if (!tmp->is_pointer) {
 172                         t->is_pointer = true;
 173                 }
 174         }
 175 }
 176
 177 static inline void
 178 tp_end_touch(struct tp_dispatch *tp, struct tp_touch *t)
 179 {
 180         if (t->state == TOUCH_NONE)
 181                 return;
 182
 183         t->dirty = true;
 184         t->is_pointer = false;
 185         t->state = TOUCH_END;
 186         t->pinned.is_pinned = false;
 187         assert(tp->nfingers_down >= 1);
 188         tp->nfingers_down--;
 189         tp->queued |= TOUCHPAD_EVENT_MOTION;
 190 }
 191
 192 static double
 193 tp_estimate_delta(int x0, int x1, int x2, int x3)
 194 {
 195         return (x0 + x1 - x2 - x3) / 4;
 196 }
 197
 198 void
 199 tp_get_delta(struct tp_touch *t, double *dx, double *dy)
 200 {
 201         if (t->history.count < 4) {
 202                 *dx = 0;
 203                 *dy = 0;
 204                 return;
 205         }
 206
 207         *dx = tp_estimate_delta(tp_motion_history_offset(t, 0)->x,
 208                                 tp_motion_history_offset(t, 1)->x,
 209                                 tp_motion_history_offset(t, 2)->x,
 210                                 tp_motion_history_offset(t, 3)->x);
 211         *dy = tp_estimate_delta(tp_motion_history_offset(t, 0)->y,
 212                                 tp_motion_history_offset(t, 1)->y,
 213                                 tp_motion_history_offset(t, 2)->y,
 214                                 tp_motion_history_offset(t, 3)->y);
 215 }
 216
 217 static void
 218 tp_process_absolute(struct tp_dispatch *tp,
 219                     const struct input_event *e,
 220                     uint32_t time)
 221 {
 222         struct tp_touch *t = tp_current_touch(tp);
 223
 224         switch(e->code) {
 225         case ABS_MT_POSITION_X:
 226                 t->x = e->value;
 227                 t->millis = time;
 228                 t->dirty = true;
 229                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 230                 break;
 231         case ABS_MT_POSITION_Y:
 232                 t->y = e->value;
 233                 t->millis = time;
 234                 t->dirty = true;
 235                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 236                 break;
 237         case ABS_MT_SLOT:
 238                 tp->slot = e->value;
 239                 break;
 240         case ABS_MT_TRACKING_ID:
 241                 t->millis = time;
 242                 if (e->value != -1)
 243                         tp_begin_touch(tp, t);
 244                 else
 245                         tp_end_touch(tp, t);
 246         }
 247 }
 248
 249 static void
 250 tp_process_absolute_st(struct tp_dispatch *tp,
 251                        const struct input_event *e,
 252                        uint32_t time)
 253 {
 254         struct tp_touch *t = tp_current_touch(tp);
 255
 256         switch(e->code) {
 257         case ABS_X:
 258                 t->x = e->value;
 259                 t->millis = time;
 260                 t->dirty = true;
 261                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 262                 break;
 263         case ABS_Y:
 264                 t->y = e->value;
 265                 t->millis = time;
 266                 t->dirty = true;
 267                 tp->queued |= TOUCHPAD_EVENT_MOTION;
 268                 break;
 269         }
 270 }
 271
 272 static void
 273 tp_process_fake_touch(struct tp_dispatch *tp,
 274                       const struct input_event *e,
 275                       uint32_t time)
 276 {
 277         struct tp_touch *t;
 278         unsigned int fake_touches;
 279         unsigned int nfake_touches;
 280         unsigned int i;
 281         unsigned int shift;
 282
 283         if (e->code != BTN_TOUCH &&
 284             (e->code < BTN_TOOL_DOUBLETAP || e->code > BTN_TOOL_QUADTAP))
 285                 return;
 286
 287         shift = e->code == BTN_TOUCH ? 0 : (e->code - BTN_TOOL_DOUBLETAP + 1);
 288
 289         if (e->value)
 290                 tp->fake_touches |= 1 << shift;
 291         else
 292                 tp->fake_touches &= ~(0x1 << shift);
 293
 294         fake_touches = tp->fake_touches;
 295         nfake_touches = 0;
 296         while (fake_touches) {
 297                 nfake_touches++;
 298                 fake_touches >>= 1;
 299         }
 300
 301         for (i = 0; i < tp->ntouches; i++) {
 302                 t = tp_get_touch(tp, i);
 303                 if (i >= nfake_touches) {
 304                         if (t->state != TOUCH_NONE) {
 305                                 tp_end_touch(tp, t);
 306                                 t->millis = time;
 307                         }
 308                 } else if (t->state != TOUCH_UPDATE &&
 309                            t->state != TOUCH_BEGIN) {
 310                         t->state = TOUCH_NONE;
 311                         tp_begin_touch(tp, t);
 312                         t->millis = time;
 313                         t->fake =true;
 314                 }
 315         }
 316
 317         assert(tp->nfingers_down == nfake_touches);
 318 }
 319
 320 static void
 321 tp_process_key(struct tp_dispatch *tp,
 322                const struct input_event *e,
 323                uint32_t time)
 324 {
 325         switch (e->code) {
 326                 case BTN_LEFT:
 327                 case BTN_MIDDLE:
 328                 case BTN_RIGHT:
 329                         tp_process_button(tp, e, time);
 330                         break;
 331                 case BTN_TOUCH:
 332                 case BTN_TOOL_DOUBLETAP:
 333                 case BTN_TOOL_TRIPLETAP:
 334                 case BTN_TOOL_QUADTAP:
 335                         if (!tp->has_mt)
 336                                 tp_process_fake_touch(tp, e, time);
 337                         break;
 338         }
 339 }
 340
 341 static void
 342 tp_unpin_finger(struct tp_dispatch *tp, struct tp_touch *t)
 343 {
 344         unsigned int xdist, ydist;
 345         struct tp_touch *tmp = NULL;
 346
 347         if (!t->pinned.is_pinned)
 348                 return;
 349
 350         xdist = abs(t->x - t->pinned.center_x);
 351         ydist = abs(t->y - t->pinned.center_y);
 352
 353         if (xdist * xdist + ydist * ydist <
 354                         tp->buttons.motion_dist * tp->buttons.motion_dist)
 355                 return;
 356
 357         t->pinned.is_pinned = false;
 358
 359         tp_for_each_touch(tp, tmp) {
 360                 if (tmp->is_pointer)
 361                         break;
 362         }
 363
 364         if (t->state != TOUCH_END && !tmp->is_pointer)
 365                 t->is_pointer = true;
 366 }
 367
 368 static void
 369 tp_pin_fingers(struct tp_dispatch *tp)
 370 {
 371         struct tp_touch *t;
 372
 373         tp_for_each_touch(tp, t) {
 374                 t->is_pointer = false;
 375                 t->pinned.is_pinned = true;
 376                 t->pinned.center_x = t->x;
 377                 t->pinned.center_y = t->y;
 378         }
 379 }
 380
 381 static void
 382 tp_process_state(struct tp_dispatch *tp, uint32_t time)
 383 {
 384         struct tp_touch *t;
 385         struct tp_touch *first = tp_get_touch(tp, 0);
 386
 387         tp_for_each_touch(tp, t) {
 388                 if (!tp->has_mt && t != first && first->fake) {
 389                         t->x = first->x;
 390                         t->y = first->y;
 391                         if (!t->dirty)
 392                                 t->dirty = first->dirty;
 393                 } else if (!t->dirty)
 394                         continue;
 395
 396                 tp_motion_hysteresis(tp, t);
 397                 tp_motion_history_push(t);
 398
 399                 tp_unpin_finger(tp, t);
 400         }
 401
 402         /*
 403          * We have a physical button down event on a clickpad. To avoid
 404          * spurious pointer moves by the clicking finger we pin all fingers.
 405          * We unpin fingers when they move more then a certain threshold to
 406          * to allow drag and drop.
 407          */
 408         if ((tp->queued & TOUCHPAD_EVENT_BUTTON_PRESS) &&
 409             !tp->buttons.has_buttons)
 410                 tp_pin_fingers(tp);
 411 }
 412
 413 static void
 414 tp_post_process_state(struct tp_dispatch *tp, uint32_t time)
 415 {
 416         struct tp_touch *t;
 417
 418         tp_for_each_touch(tp, t) {
 419                 if (!t->dirty)
 420                         continue;
 421
 422                 if (t->state == TOUCH_END) {
 423                         t->state = TOUCH_NONE;
 424                         t->fake = false;
 425                 } else if (t->state == TOUCH_BEGIN)
 426                         t->state = TOUCH_UPDATE;
 427
 428                 t->dirty = false;
 429         }
 430
 431         tp->buttons.old_state = tp->buttons.state;
 432
 433         tp->queued = TOUCHPAD_EVENT_NONE;
 434 }
 435
 436 static void
 437 tp_post_twofinger_scroll(struct tp_dispatch *tp, uint32_t time)
 438 {
 439         struct tp_touch *t;
 440         int nchanged = 0;
 441         double dx = 0, dy =0;
 442         double tmpx, tmpy;
 443
 444         tp_for_each_touch(tp, t) {
 445                 if (t->dirty) {
 446                         nchanged++;
 447                         tp_get_delta(t, &tmpx, &tmpy);
 448
 449                         dx += tmpx;
 450                         dy += tmpy;
 451                 }
 452         }
 453
 454         if (nchanged == 0)
 455                 return;
 456
 457         dx /= nchanged;
 458         dy /= nchanged;
 459
 460         tp_filter_motion(tp, &dx, &dy, time);
 461
 462         if (tp->scroll.state == SCROLL_STATE_NONE) {
 463                 /* Require at least one px scrolling to start */
 464                 if (dx <= -1.0 || dx >= 1.0) {
 465                         tp->scroll.state = SCROLL_STATE_SCROLLING;
 466                         tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL);
 467                 }
 468
 469                 if (dy <= -1.0 || dy >= 1.0) {
 470                         tp->scroll.state = SCROLL_STATE_SCROLLING;
 471                         tp->scroll.direction |= (1 << LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL);
 472                 }
 473
 474                 if (tp->scroll.state == SCROLL_STATE_NONE)
 475                         return;
 476         }
 477
 478         if (dy != 0.0 &&
 479             (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL))) {
 480                 pointer_notify_axis(&tp->device->base,
 481                                     time,
 482                                     LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL,
 483                                     li_fixed_from_double(dy));
 484         }
 485
 486         if (dx != 0.0 &&
 487             (tp->scroll.direction & (1 << LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL))) {
 488                 pointer_notify_axis(&tp->device->base,
 489                                     time,
 490                                     LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL,
 491                                     li_fixed_from_double(dx));
 492         }
 493 }
 494
 495 static int
 496 tp_post_scroll_events(struct tp_dispatch *tp, uint32_t time)
 497 {
 498         /* don't scroll if a clickpad is held down */
 499         if (!tp->buttons.has_buttons &&
 500             (tp->buttons.state || tp->buttons.old_state))
 501                 return 0;
 502
 503         if (tp->nfingers_down != 2) {
 504                 /* terminate scrolling with a zero scroll event to notify
 505                  * caller that it really ended now */
 506                 if (tp->scroll.state != SCROLL_STATE_NONE) {
 507                         tp->scroll.state = SCROLL_STATE_NONE;
 508                         tp->scroll.direction = 0;
 509                         if (tp->scroll.direction & LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL)
 510                                 pointer_notify_axis(&tp->device->base,
 511                                                     time,
 512                                                     LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL,
 513                                                     0);
 514                         if (tp->scroll.direction & LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL)
 515                                 pointer_notify_axis(&tp->device->base,
 516                                                     time,
 517                                                     LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL,
 518                                                     0);
 519                 }
 520         } else {
 521                 tp_post_twofinger_scroll(tp, time);
 522                 return 1;
 523         }
 524         return 0;
 525 }
 526
 527 static void
 528 tp_post_events(struct tp_dispatch *tp, uint32_t time)
 529 {
 530         struct tp_touch *t = tp_current_touch(tp);
 531         double dx, dy;
 532
 533         if (tp_post_button_events(tp, time) != 0)
 534                 return;
 535
 536         if (tp_tap_handle_state(tp, time) != 0)
 537                 return;
 538
 539         if (tp_post_scroll_events(tp, time) != 0)
 540                 return;
 541
 542         if (t->history.count >= TOUCHPAD_MIN_SAMPLES) {
 543                 if (!t->is_pointer) {
 544                         tp_for_each_touch(tp, t) {
 545                                 if (t->is_pointer)
 546                                         break;
 547                         }
 548                 }
 549
 550                 if (!t->is_pointer)
 551                         return;
 552
 553                 tp_get_delta(t, &dx, &dy);
 554                 tp_filter_motion(tp, &dx, &dy, time);
 555
 556                 if (dx != 0 || dy != 0)
 557                         pointer_notify_motion(
 558                                 &tp->device->base,
 559                                 time,
 560                                 li_fixed_from_double(dx),
 561                                 li_fixed_from_double(dy));
 562         }
 563 }
 564
 565 static void
 566 tp_process(struct evdev_dispatch *dispatch,
 567            struct evdev_device *device,
 568            struct input_event *e,
 569            uint32_t time)
 570 {
 571         struct tp_dispatch *tp =
 572                 (struct tp_dispatch *)dispatch;
 573
 574         switch (e->type) {
 575         case EV_ABS:
 576                 if (tp->has_mt)
 577                         tp_process_absolute(tp, e, time);
 578                 else
 579                         tp_process_absolute_st(tp, e, time);
 580                 break;
 581         case EV_KEY:
 582                 tp_process_key(tp, e, time);
 583                 break;
 584         case EV_SYN:
 585                 tp_process_state(tp, time);
 586                 tp_post_events(tp, time);
 587                 tp_post_process_state(tp, time);
 588                 break;
 589         }
 590 }
 591
 592 static void
 593 tp_destroy(struct evdev_dispatch *dispatch)
 594 {
 595         struct tp_dispatch *tp =
 596                 (struct tp_dispatch*)dispatch;
 597
 598         tp_destroy_tap(tp);
 599
 600         if (tp->filter)
 601                 tp->filter->interface->destroy(tp->filter);
 602         free(tp->touches);
 603         free(tp);
 604 }
 605
 606 static struct evdev_dispatch_interface tp_interface = {
 607         tp_process,
 608         tp_destroy
 609 };
 610
 611 static int
 612 tp_init_slots(struct tp_dispatch *tp,
 613               struct evdev_device *device)
 614 {
 615         const struct input_absinfo *absinfo;
 616
 617         absinfo = libevdev_get_abs_info(device->evdev, ABS_MT_SLOT);
 618         if (absinfo) {
 619                 tp->ntouches = absinfo->maximum + 1;
 620                 tp->slot = absinfo->value;
 621                 tp->has_mt = true;
 622         } else {
 623                 struct map {
 624                         unsigned int code;
 625                         int ntouches;
 626                 } max_touches[] = {
 627                         { BTN_TOOL_QUINTTAP, 5 },
 628                         { BTN_TOOL_QUADTAP, 4 },
 629                         { BTN_TOOL_TRIPLETAP, 3 },
 630                         { BTN_TOOL_DOUBLETAP, 2 },
 631                 };
 632                 struct map *m;
 633
 634                 tp->slot = 0;
 635                 tp->has_mt = false;
 636                 tp->ntouches = 1;
 637
 638                 ARRAY_FOR_EACH(max_touches, m) {
 639                         if (libevdev_has_event_code(device->evdev,
 640                                                     EV_KEY,
 641                                                     m->code)) {
 642                                 tp->ntouches = m->ntouches;
 643                                 break;
 644                         }
 645                 }
 646         }
 647         tp->touches = calloc(tp->ntouches,
 648                              sizeof(struct tp_touch));
 649         if (!tp->touches)
 650                 return -1;
 651
 652         return 0;
 653 }
 654
 655 static int
 656 tp_init_accel(struct tp_dispatch *touchpad, double diagonal)
 657 {
 658         struct motion_filter *accel;
 659
 660         touchpad->accel.constant_factor =
 661                 DEFAULT_CONSTANT_ACCEL_NUMERATOR / diagonal;
 662         touchpad->accel.min_factor = DEFAULT_MIN_ACCEL_FACTOR;
 663         touchpad->accel.max_factor = DEFAULT_MAX_ACCEL_FACTOR;
 664
 665         accel = create_pointer_accelator_filter(tp_accel_profile);
 666         if (accel == NULL)
 667                 return -1;
 668
 669         touchpad->filter = accel;
 670
 671         return 0;
 672 }
 673
 674 static int
 675 tp_init_scroll(struct tp_dispatch *tp)
 676 {
 677         tp->scroll.direction = 0;
 678         tp->scroll.state = SCROLL_STATE_NONE;
 679
 680         return 0;
 681 }
 682
 683 static int
 684 tp_init(struct tp_dispatch *tp,
 685         struct evdev_device *device)
 686 {
 687         int width, height;
 688         double diagonal;
 689
 690         tp->base.interface = &tp_interface;
 691         tp->device = device;
 692         tp->tap.timer_fd = -1;
 693
 694         if (tp_init_slots(tp, device) != 0)
 695                 return -1;
 696
 697         width = abs(device->abs.max_x - device->abs.min_x);
 698         height = abs(device->abs.max_y - device->abs.min_y);
 699         diagonal = sqrt(width*width + height*height);
 700
 701         tp->hysteresis.margin_x =
 702                 diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
 703         tp->hysteresis.margin_y =
 704                 diagonal / DEFAULT_HYSTERESIS_MARGIN_DENOMINATOR;
 705
 706         if (tp_init_scroll(tp) != 0)
 707                 return -1;
 708
 709         if (tp_init_accel(tp, diagonal) != 0)
 710                 return -1;
 711
 712         if (tp_init_tap(tp) != 0)
 713                 return -1;
 714
 715         if (tp_init_buttons(tp, device) != 0)
 716                 return -1;
 717
 718         return 0;
 719 }
 720
 721 struct evdev_dispatch *
 722 evdev_mt_touchpad_create(struct evdev_device *device)
 723 {
 724         struct tp_dispatch *tp;
 725
 726         tp = zalloc(sizeof *tp);
 727         if (!tp)
 728                 return NULL;
 729
 730         if (tp_init(tp, device) != 0) {
 731                 tp_destroy(&tp->base);
 732                 return NULL;
 733         }
 734
 735         return  &tp->base;
 736 }