src/evdev-mt-touchpad.h

   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
  24 #ifndef EVDEV_MT_TOUCHPAD_H
  25 #define EVDEV_MT_TOUCHPAD_H
  26
  27 #include <stdbool.h>
  28
  29 #include "evdev.h"
  30 #include "filter.h"
  31 #include "timer.h"
  32
  33 #define TOUCHPAD_HISTORY_LENGTH 4
  34 #define TOUCHPAD_MIN_SAMPLES 4
  35
  36 #define VENDOR_ID_APPLE 0x5ac
  37
  38 enum touchpad_event {
  39         TOUCHPAD_EVENT_NONE             = 0,
  40         TOUCHPAD_EVENT_MOTION           = (1 << 0),
  41         TOUCHPAD_EVENT_BUTTON_PRESS     = (1 << 1),
  42         TOUCHPAD_EVENT_BUTTON_RELEASE   = (1 << 2),
  43 };
  44
  45 enum touch_state {
  46         TOUCH_NONE = 0,
  47         TOUCH_BEGIN,
  48         TOUCH_UPDATE,
  49         TOUCH_END
  50 };
  51
  52 enum button_event {
  53         BUTTON_EVENT_IN_BOTTOM_R = 30,
  54         BUTTON_EVENT_IN_BOTTOM_L,
  55         BUTTON_EVENT_IN_TOP_R,
  56         BUTTON_EVENT_IN_TOP_M,
  57         BUTTON_EVENT_IN_TOP_L,
  58         BUTTON_EVENT_IN_AREA,
  59         BUTTON_EVENT_UP,
  60         BUTTON_EVENT_PRESS,
  61         BUTTON_EVENT_RELEASE,
  62         BUTTON_EVENT_TIMEOUT,
  63 };
  64
  65 enum button_state {
  66         BUTTON_STATE_NONE,
  67         BUTTON_STATE_AREA,
  68         BUTTON_STATE_BOTTOM,
  69         BUTTON_STATE_TOP,
  70         BUTTON_STATE_TOP_NEW,
  71         BUTTON_STATE_TOP_TO_IGNORE,
  72         BUTTON_STATE_IGNORE,
  73 };
  74
  75 enum tp_tap_state {
  76         TAP_STATE_IDLE = 4,
  77         TAP_STATE_TOUCH,
  78         TAP_STATE_HOLD,
  79         TAP_STATE_TAPPED,
  80         TAP_STATE_TOUCH_2,
  81         TAP_STATE_TOUCH_2_HOLD,
  82         TAP_STATE_TOUCH_3,
  83         TAP_STATE_TOUCH_3_HOLD,
  84         TAP_STATE_DRAGGING_OR_DOUBLETAP,
  85         TAP_STATE_DRAGGING,
  86         TAP_STATE_DRAGGING_WAIT,
  87         TAP_STATE_DRAGGING_2,
  88         TAP_STATE_DEAD, /**< finger count exceeded */
  89 };
  90
  91 enum tp_tap_touch_state {
  92         TAP_TOUCH_STATE_IDLE = 16,      /**< not in touch */
  93         TAP_TOUCH_STATE_TOUCH,          /**< touching, may tap */
  94         TAP_TOUCH_STATE_DEAD,           /**< exceeded motion/timeout */
  95 };
  96
  97 struct tp_motion {
  98         int32_t x;
  99         int32_t y;
 100 };
 101
 102 struct tp_touch {
 103         struct tp_dispatch *tp;
 104         enum touch_state state;
 105         bool dirty;
 106         bool is_pointer;                        /* the pointer-controlling touch */
 107         int32_t x;
 108         int32_t y;
 109         uint64_t millis;
 110
 111         struct {
 112                 struct tp_motion samples[TOUCHPAD_HISTORY_LENGTH];
 113                 unsigned int index;
 114                 unsigned int count;
 115         } history;
 116
 117         struct {
 118                 int32_t center_x;
 119                 int32_t center_y;
 120         } hysteresis;
 121
 122         /* A pinned touchpoint is the one that pressed the physical button
 123          * on a clickpad. After the release, it won't move until the center
 124          * moves more than a threshold away from the original coordinates
 125          */
 126         struct {
 127                 bool is_pinned;
 128                 int32_t center_x;
 129                 int32_t center_y;
 130         } pinned;
 131
 132         /* Software-button state and timeout if applicable */
 133         struct {
 134                 enum button_state state;
 135                 /* We use button_event here so we can use == on events */
 136                 enum button_event curr;
 137                 struct libinput_timer timer;
 138         } button;
 139
 140         struct {
 141                 enum tp_tap_touch_state state;
 142         } tap;
 143
 144         struct {
 145                 bool is_palm;
 146                 int32_t x, y;  /* first coordinates if is_palm == true */
 147                 uint32_t time; /* first timestamp if is_palm == true */
 148         } palm;
 149 };
 150
 151 struct tp_dispatch {
 152         struct evdev_dispatch base;
 153         struct evdev_device *device;
 154         unsigned int nfingers_down;             /* number of fingers down */
 155         unsigned int old_nfingers_down;         /* previous no fingers down */
 156         unsigned int slot;                      /* current slot */
 157         bool has_mt;
 158         bool semi_mt;
 159
 160         unsigned int real_touches;              /* number of slots */
 161         unsigned int ntouches;                  /* no slots inc. fakes */
 162         struct tp_touch *touches;               /* len == ntouches */
 163         unsigned int fake_touches;              /* fake touch mask */
 164
 165         struct {
 166                 int32_t margin_x;
 167                 int32_t margin_y;
 168         } hysteresis;
 169
 170         struct {
 171                 double x_scale_coeff;
 172                 double y_scale_coeff;
 173         } accel;
 174
 175         struct {
 176                 bool is_clickpad;               /* true for clickpads */
 177                 bool has_topbuttons;
 178                 bool use_clickfinger;           /* number of fingers decides button number */
 179                 bool click_pending;
 180                 uint32_t state;
 181                 uint32_t old_state;
 182                 uint32_t motion_dist;           /* for pinned touches */
 183                 unsigned int active;            /* currently active button, for release event */
 184                 bool active_is_topbutton;       /* is active a top button? */
 185
 186                 /* Only used for clickpads. The software button areas are
 187                  * always 2 horizontal stripes across the touchpad.
 188                  * The buttons are split according to the edge settings.
 189                  */
 190                 struct {
 191                         int32_t top_edge;
 192                         int32_t rightbutton_left_edge;
 193                 } bottom_area;
 194
 195                 struct {
 196                         int32_t bottom_edge;
 197                         int32_t rightbutton_left_edge;
 198                         int32_t leftbutton_right_edge;
 199                 } top_area;
 200
 201                 struct evdev_device *trackpoint;
 202         } buttons;                              /* physical buttons */
 203
 204         struct {
 205                 struct libinput_device_config_natural_scroll config;
 206                 bool natural_scrolling_enabled;
 207         } scroll;
 208
 209         enum touchpad_event queued;
 210
 211         struct {
 212                 struct libinput_device_config_tap config;
 213                 bool enabled;
 214                 struct libinput_timer timer;
 215                 enum tp_tap_state state;
 216         } tap;
 217
 218         struct {
 219                 int32_t right_edge;
 220                 int32_t left_edge;
 221         } palm;
 222
 223         struct {
 224                 struct libinput_device_config_send_events config;
 225                 enum libinput_config_send_events_mode current_mode;
 226         } sendevents;
 227 };
 228
 229 #define tp_for_each_touch(_tp, _t) \
 230         for (unsigned int _i = 0; _i < (_tp)->ntouches && (_t = &(_tp)->touches[_i]); _i++)
 231
 232 void
 233 tp_get_delta(struct tp_touch *t, double *dx, double *dy);
 234
 235 void
 236 tp_set_pointer(struct tp_dispatch *tp, struct tp_touch *t);
 237
 238 int
 239 tp_tap_handle_state(struct tp_dispatch *tp, uint64_t time);
 240
 241 int
 242 tp_init_tap(struct tp_dispatch *tp);
 243
 244 void
 245 tp_destroy_tap(struct tp_dispatch *tp);
 246
 247 int
 248 tp_init_buttons(struct tp_dispatch *tp, struct evdev_device *device);
 249
 250 void
 251 tp_init_softbuttons(struct tp_dispatch *tp,
 252                     struct evdev_device *device,
 253                     double topbutton_size_mult);
 254
 255 void
 256 tp_destroy_buttons(struct tp_dispatch *tp);
 257
 258 int
 259 tp_process_button(struct tp_dispatch *tp,
 260                   const struct input_event *e,
 261                   uint64_t time);
 262
 263 void
 264 tp_release_all_buttons(struct tp_dispatch *tp,
 265                        uint64_t time);
 266
 267 int
 268 tp_post_button_events(struct tp_dispatch *tp, uint64_t time);
 269
 270 int
 271 tp_button_handle_state(struct tp_dispatch *tp, uint64_t time);
 272
 273 int
 274 tp_button_touch_active(struct tp_dispatch *tp, struct tp_touch *t);
 275
 276 bool
 277 tp_button_is_inside_softbutton_area(struct tp_dispatch *tp, struct tp_touch *t);
 278
 279 void
 280 tp_release_all_taps(struct tp_dispatch *tp,
 281                     uint64_t time);
 282
 283 #endif