1 /*
2 * Copyright © 2014 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 <check.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <libinput.h>
30 #include <unistd.h>
31
32 #include "libinput-util.h"
33 #include "litest.h"
34
START_TEST(touchpad_button)35 START_TEST(touchpad_button)
36 {
37 struct litest_device *dev = litest_current_device();
38 struct libinput *li = dev->libinput;
39
40 if (!libevdev_has_event_code(dev->evdev, EV_KEY, BTN_LEFT))
41 return;
42
43 litest_drain_events(li);
44
45 litest_button_click(dev, BTN_LEFT, true);
46 libinput_dispatch(li);
47 litest_assert_button_event(li,
48 BTN_LEFT,
49 LIBINPUT_BUTTON_STATE_PRESSED);
50 litest_button_click(dev, BTN_LEFT, false);
51 libinput_dispatch(li);
52 litest_assert_button_event(li,
53 BTN_LEFT,
54 LIBINPUT_BUTTON_STATE_RELEASED);
55 }
56 END_TEST
57
START_TEST(touchpad_click_defaults_clickfinger)58 START_TEST(touchpad_click_defaults_clickfinger)
59 {
60 struct litest_device *dev = litest_current_device();
61 struct libinput_device *device = dev->libinput_device;
62 uint32_t methods, method;
63 enum libinput_config_status status;
64
65 /* call this test for apple touchpads */
66
67 methods = libinput_device_config_click_get_methods(device);
68 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
69 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
70
71 method = libinput_device_config_click_get_method(device);
72 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
73 method = libinput_device_config_click_get_default_method(device);
74 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
75
76 status = libinput_device_config_click_set_method(device,
77 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
78 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
79 status = libinput_device_config_click_set_method(device,
80 LIBINPUT_CONFIG_CLICK_METHOD_NONE);
81 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
82 }
83 END_TEST
84
START_TEST(touchpad_click_defaults_btnarea)85 START_TEST(touchpad_click_defaults_btnarea)
86 {
87 struct litest_device *dev = litest_current_device();
88 struct libinput_device *device = dev->libinput_device;
89 uint32_t methods, method;
90 enum libinput_config_status status;
91
92 /* call this test for non-apple clickpads */
93
94 methods = libinput_device_config_click_get_methods(device);
95 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
96 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
97
98 method = libinput_device_config_click_get_method(device);
99 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
100 method = libinput_device_config_click_get_default_method(device);
101 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
102
103 status = libinput_device_config_click_set_method(device,
104 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
105 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
106 status = libinput_device_config_click_set_method(device,
107 LIBINPUT_CONFIG_CLICK_METHOD_NONE);
108 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
109 }
110 END_TEST
111
START_TEST(touchpad_click_defaults_none)112 START_TEST(touchpad_click_defaults_none)
113 {
114 struct litest_device *dev = litest_current_device();
115 struct libinput_device *device = dev->libinput_device;
116 uint32_t methods, method;
117 enum libinput_config_status status;
118
119 if (libevdev_get_id_vendor(dev->evdev) == VENDOR_ID_APPLE &&
120 libevdev_get_id_product(dev->evdev) == PRODUCT_ID_APPLE_APPLETOUCH)
121 return;
122
123 /* call this test for non-clickpads and non-touchpads */
124
125 methods = libinput_device_config_click_get_methods(device);
126 ck_assert_int_eq(methods, 0);
127
128 method = libinput_device_config_click_get_method(device);
129 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
130 method = libinput_device_config_click_get_default_method(device);
131 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_NONE);
132
133 status = libinput_device_config_click_set_method(device,
134 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
135 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
136 status = libinput_device_config_click_set_method(device,
137 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
138 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
139 }
140 END_TEST
141
START_TEST(touchpad_1fg_clickfinger)142 START_TEST(touchpad_1fg_clickfinger)
143 {
144 struct litest_device *dev = litest_current_device();
145 struct libinput *li = dev->libinput;
146
147 litest_enable_clickfinger(dev);
148
149 litest_drain_events(li);
150
151 litest_touch_down(dev, 0, 50, 50);
152 litest_event(dev, EV_KEY, BTN_LEFT, 1);
153 litest_event(dev, EV_SYN, SYN_REPORT, 0);
154 litest_event(dev, EV_KEY, BTN_LEFT, 0);
155 litest_event(dev, EV_SYN, SYN_REPORT, 0);
156 litest_touch_up(dev, 0);
157
158 libinput_dispatch(li);
159
160 litest_assert_button_event(li, BTN_LEFT,
161 LIBINPUT_BUTTON_STATE_PRESSED);
162 litest_assert_button_event(li, BTN_LEFT,
163 LIBINPUT_BUTTON_STATE_RELEASED);
164 }
165 END_TEST
166
START_TEST(touchpad_1fg_clickfinger_no_touch)167 START_TEST(touchpad_1fg_clickfinger_no_touch)
168 {
169 struct litest_device *dev = litest_current_device();
170 struct libinput *li = dev->libinput;
171
172 litest_enable_clickfinger(dev);
173
174 litest_drain_events(li);
175
176 litest_event(dev, EV_KEY, BTN_LEFT, 1);
177 litest_event(dev, EV_SYN, SYN_REPORT, 0);
178 litest_event(dev, EV_KEY, BTN_LEFT, 0);
179 litest_event(dev, EV_SYN, SYN_REPORT, 0);
180
181 libinput_dispatch(li);
182
183 litest_assert_button_event(li, BTN_LEFT,
184 LIBINPUT_BUTTON_STATE_PRESSED);
185 litest_assert_button_event(li, BTN_LEFT,
186 LIBINPUT_BUTTON_STATE_RELEASED);
187 }
188 END_TEST
189
START_TEST(touchpad_2fg_clickfinger)190 START_TEST(touchpad_2fg_clickfinger)
191 {
192 struct litest_device *dev = litest_current_device();
193 struct libinput *li = dev->libinput;
194
195 litest_enable_clickfinger(dev);
196
197 litest_drain_events(li);
198
199 litest_touch_down(dev, 0, 50, 50);
200 litest_touch_down(dev, 1, 70, 70);
201 litest_event(dev, EV_KEY, BTN_LEFT, 1);
202 litest_event(dev, EV_SYN, SYN_REPORT, 0);
203 litest_event(dev, EV_KEY, BTN_LEFT, 0);
204 litest_event(dev, EV_SYN, SYN_REPORT, 0);
205 litest_touch_up(dev, 0);
206 litest_touch_up(dev, 1);
207
208 libinput_dispatch(li);
209
210 litest_assert_button_event(li, BTN_RIGHT,
211 LIBINPUT_BUTTON_STATE_PRESSED);
212 litest_assert_button_event(li, BTN_RIGHT,
213 LIBINPUT_BUTTON_STATE_RELEASED);
214 }
215 END_TEST
216
START_TEST(touchpad_3fg_clickfinger)217 START_TEST(touchpad_3fg_clickfinger)
218 {
219 struct litest_device *dev = litest_current_device();
220 struct libinput *li = dev->libinput;
221
222 if (litest_slot_count(dev) < 3)
223 return;
224
225 litest_enable_clickfinger(dev);
226
227 litest_drain_events(li);
228
229 litest_touch_down(dev, 0, 50, 50);
230 litest_touch_down(dev, 1, 60, 70);
231 litest_touch_down(dev, 2, 70, 70);
232 litest_event(dev, EV_KEY, BTN_LEFT, 1);
233 litest_event(dev, EV_SYN, SYN_REPORT, 0);
234 litest_event(dev, EV_KEY, BTN_LEFT, 0);
235 litest_event(dev, EV_SYN, SYN_REPORT, 0);
236 litest_touch_up(dev, 0);
237 litest_touch_up(dev, 1);
238 litest_touch_up(dev, 2);
239
240 libinput_dispatch(li);
241
242 litest_assert_button_event(li,
243 BTN_MIDDLE,
244 LIBINPUT_BUTTON_STATE_PRESSED);
245 litest_assert_button_event(li,
246 BTN_MIDDLE,
247 LIBINPUT_BUTTON_STATE_RELEASED);
248 }
249 END_TEST
250
START_TEST(touchpad_3fg_clickfinger_btntool)251 START_TEST(touchpad_3fg_clickfinger_btntool)
252 {
253 struct litest_device *dev = litest_current_device();
254 struct libinput *li = dev->libinput;
255
256 if (litest_slot_count(dev) >= 3 ||
257 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
258 return;
259
260 litest_enable_clickfinger(dev);
261
262 litest_drain_events(li);
263
264 litest_touch_down(dev, 0, 50, 50);
265 litest_touch_down(dev, 1, 60, 70);
266 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
267 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
268 litest_event(dev, EV_SYN, SYN_REPORT, 0);
269 litest_event(dev, EV_KEY, BTN_LEFT, 1);
270 litest_event(dev, EV_SYN, SYN_REPORT, 0);
271 litest_event(dev, EV_KEY, BTN_LEFT, 0);
272 litest_event(dev, EV_SYN, SYN_REPORT, 0);
273 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
274 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
275 litest_event(dev, EV_SYN, SYN_REPORT, 0);
276 litest_touch_up(dev, 0);
277 litest_touch_up(dev, 1);
278
279 libinput_dispatch(li);
280
281 litest_assert_button_event(li,
282 BTN_MIDDLE,
283 LIBINPUT_BUTTON_STATE_PRESSED);
284 litest_assert_button_event(li,
285 BTN_MIDDLE,
286 LIBINPUT_BUTTON_STATE_RELEASED);
287 }
288 END_TEST
289
START_TEST(touchpad_4fg_clickfinger)290 START_TEST(touchpad_4fg_clickfinger)
291 {
292 struct litest_device *dev = litest_current_device();
293 struct libinput *li = dev->libinput;
294
295 if (litest_slot_count(dev) < 4)
296 return;
297
298 litest_enable_clickfinger(dev);
299
300 litest_drain_events(li);
301
302 litest_touch_down(dev, 0, 50, 50);
303 litest_touch_down(dev, 1, 60, 70);
304 litest_touch_down(dev, 2, 70, 70);
305 litest_touch_down(dev, 3, 80, 70);
306 litest_event(dev, EV_KEY, BTN_LEFT, 1);
307 litest_event(dev, EV_SYN, SYN_REPORT, 0);
308 litest_event(dev, EV_KEY, BTN_LEFT, 0);
309 litest_event(dev, EV_SYN, SYN_REPORT, 0);
310 litest_touch_up(dev, 0);
311 litest_touch_up(dev, 1);
312 litest_touch_up(dev, 2);
313 litest_touch_up(dev, 3);
314
315 libinput_dispatch(li);
316
317 litest_assert_empty_queue(li);
318 }
319 END_TEST
320
START_TEST(touchpad_4fg_clickfinger_btntool_2slots)321 START_TEST(touchpad_4fg_clickfinger_btntool_2slots)
322 {
323 struct litest_device *dev = litest_current_device();
324 struct libinput *li = dev->libinput;
325
326 if (litest_slot_count(dev) >= 3 ||
327 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_QUADTAP))
328 return;
329
330 litest_enable_clickfinger(dev);
331
332 litest_drain_events(li);
333
334 litest_touch_down(dev, 0, 50, 50);
335 litest_touch_down(dev, 1, 60, 70);
336 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
337 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1);
338 litest_event(dev, EV_SYN, SYN_REPORT, 0);
339 litest_event(dev, EV_KEY, BTN_LEFT, 1);
340 litest_event(dev, EV_SYN, SYN_REPORT, 0);
341 litest_event(dev, EV_KEY, BTN_LEFT, 0);
342 litest_event(dev, EV_SYN, SYN_REPORT, 0);
343 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
344 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 0);
345 litest_event(dev, EV_SYN, SYN_REPORT, 0);
346 litest_touch_up(dev, 0);
347 litest_touch_up(dev, 1);
348
349 litest_assert_empty_queue(li);
350 }
351 END_TEST
352
START_TEST(touchpad_4fg_clickfinger_btntool_3slots)353 START_TEST(touchpad_4fg_clickfinger_btntool_3slots)
354 {
355 struct litest_device *dev = litest_current_device();
356 struct libinput *li = dev->libinput;
357
358 if (litest_slot_count(dev) != 3 ||
359 !libevdev_has_event_code(dev->evdev, EV_KEY, BTN_TOOL_TRIPLETAP))
360 return;
361
362 litest_enable_clickfinger(dev);
363
364 litest_drain_events(li);
365
366 litest_touch_down(dev, 0, 50, 50);
367 litest_touch_down(dev, 1, 60, 70);
368 litest_touch_down(dev, 2, 70, 70);
369 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
370 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1);
371 litest_event(dev, EV_SYN, SYN_REPORT, 0);
372 litest_event(dev, EV_KEY, BTN_LEFT, 1);
373 litest_event(dev, EV_SYN, SYN_REPORT, 0);
374 litest_event(dev, EV_KEY, BTN_LEFT, 0);
375 litest_event(dev, EV_SYN, SYN_REPORT, 0);
376 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
377 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 0);
378 litest_event(dev, EV_SYN, SYN_REPORT, 0);
379 litest_touch_up(dev, 0);
380 litest_touch_up(dev, 1);
381 litest_touch_up(dev, 2);
382
383 libinput_dispatch(li);
384
385 litest_assert_empty_queue(li);
386 }
387 END_TEST
388
START_TEST(touchpad_2fg_clickfinger_distance)389 START_TEST(touchpad_2fg_clickfinger_distance)
390 {
391 struct litest_device *dev = litest_current_device();
392 struct libinput *li = dev->libinput;
393 double w, h;
394 bool small_touchpad = false;
395 unsigned int expected_button;
396
397 if (libinput_device_get_size(dev->libinput_device, &w, &h) == 0 &&
398 h < 50.0)
399 small_touchpad = true;
400
401 litest_enable_clickfinger(dev);
402
403 litest_drain_events(li);
404
405 litest_touch_down(dev, 0, 90, 50);
406 litest_touch_down(dev, 1, 10, 50);
407 litest_event(dev, EV_KEY, BTN_LEFT, 1);
408 litest_event(dev, EV_SYN, SYN_REPORT, 0);
409 litest_event(dev, EV_KEY, BTN_LEFT, 0);
410 litest_event(dev, EV_SYN, SYN_REPORT, 0);
411 litest_touch_up(dev, 0);
412 litest_touch_up(dev, 1);
413
414 litest_assert_button_event(li,
415 BTN_LEFT,
416 LIBINPUT_BUTTON_STATE_PRESSED);
417 litest_assert_button_event(li,
418 BTN_LEFT,
419 LIBINPUT_BUTTON_STATE_RELEASED);
420
421 litest_assert_empty_queue(li);
422
423 litest_touch_down(dev, 0, 50, 5);
424 litest_touch_down(dev, 1, 50, 95);
425 litest_event(dev, EV_KEY, BTN_LEFT, 1);
426 litest_event(dev, EV_SYN, SYN_REPORT, 0);
427 litest_event(dev, EV_KEY, BTN_LEFT, 0);
428 litest_event(dev, EV_SYN, SYN_REPORT, 0);
429 litest_touch_up(dev, 0);
430 litest_touch_up(dev, 1);
431
432 /* if the touchpad is small enough, we expect all fingers to count
433 * for clickfinger */
434 if (small_touchpad)
435 expected_button = BTN_RIGHT;
436 else
437 expected_button = BTN_LEFT;
438
439 litest_assert_button_event(li,
440 expected_button,
441 LIBINPUT_BUTTON_STATE_PRESSED);
442 litest_assert_button_event(li,
443 expected_button,
444 LIBINPUT_BUTTON_STATE_RELEASED);
445 }
446 END_TEST
447
START_TEST(touchpad_3fg_clickfinger_distance)448 START_TEST(touchpad_3fg_clickfinger_distance)
449 {
450 struct litest_device *dev = litest_current_device();
451 struct libinput *li = dev->libinput;
452
453 if (litest_slot_count(dev) < 3)
454 return;
455
456 litest_enable_clickfinger(dev);
457
458 litest_drain_events(li);
459
460 litest_touch_down(dev, 0, 90, 20);
461 litest_touch_down(dev, 1, 10, 15);
462 litest_touch_down(dev, 2, 10, 15);
463
464 litest_event(dev, EV_KEY, BTN_LEFT, 1);
465 litest_event(dev, EV_SYN, SYN_REPORT, 0);
466 litest_event(dev, EV_KEY, BTN_LEFT, 0);
467 litest_event(dev, EV_SYN, SYN_REPORT, 0);
468 litest_touch_up(dev, 0);
469 litest_touch_up(dev, 1);
470 litest_touch_up(dev, 2);
471
472 litest_assert_button_event(li,
473 BTN_MIDDLE,
474 LIBINPUT_BUTTON_STATE_PRESSED);
475 litest_assert_button_event(li,
476 BTN_MIDDLE,
477 LIBINPUT_BUTTON_STATE_RELEASED);
478 }
479 END_TEST
480
START_TEST(touchpad_3fg_clickfinger_distance_btntool)481 START_TEST(touchpad_3fg_clickfinger_distance_btntool)
482 {
483 struct litest_device *dev = litest_current_device();
484 struct libinput *li = dev->libinput;
485
486 if (litest_slot_count(dev) > 2)
487 return;
488
489 litest_enable_clickfinger(dev);
490
491 litest_drain_events(li);
492
493 litest_touch_down(dev, 0, 90, 15);
494 litest_touch_down(dev, 1, 10, 15);
495 libinput_dispatch(li);
496 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
497 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
498 litest_event(dev, EV_SYN, SYN_REPORT, 0);
499 libinput_dispatch(li);
500 litest_event(dev, EV_KEY, BTN_LEFT, 1);
501 litest_event(dev, EV_SYN, SYN_REPORT, 0);
502 litest_event(dev, EV_KEY, BTN_LEFT, 0);
503 litest_event(dev, EV_SYN, SYN_REPORT, 0);
504 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
505 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
506 litest_event(dev, EV_SYN, SYN_REPORT, 0);
507 litest_touch_up(dev, 0);
508 litest_touch_up(dev, 1);
509
510 litest_assert_button_event(li,
511 BTN_MIDDLE,
512 LIBINPUT_BUTTON_STATE_PRESSED);
513 litest_assert_button_event(li,
514 BTN_MIDDLE,
515 LIBINPUT_BUTTON_STATE_RELEASED);
516 }
517 END_TEST
518
START_TEST(touchpad_2fg_clickfinger_bottom)519 START_TEST(touchpad_2fg_clickfinger_bottom)
520 {
521 struct litest_device *dev = litest_current_device();
522 struct libinput *li = dev->libinput;
523
524 /* this test is run for the T440s touchpad only, makes getting the
525 * mm correct easier */
526
527 libinput_device_config_click_set_method(dev->libinput_device,
528 LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
529 litest_drain_events(li);
530
531 /* one above, one below the magic line, vert spread ca 27mm */
532 litest_touch_down(dev, 0, 40, 60);
533 litest_touch_down(dev, 1, 60, 100);
534 litest_event(dev, EV_KEY, BTN_LEFT, 1);
535 litest_event(dev, EV_SYN, SYN_REPORT, 0);
536 litest_event(dev, EV_KEY, BTN_LEFT, 0);
537 litest_event(dev, EV_SYN, SYN_REPORT, 0);
538 litest_touch_up(dev, 0);
539 litest_touch_up(dev, 1);
540
541 litest_assert_button_event(li,
542 BTN_LEFT,
543 LIBINPUT_BUTTON_STATE_PRESSED);
544 litest_assert_button_event(li,
545 BTN_LEFT,
546 LIBINPUT_BUTTON_STATE_RELEASED);
547
548 litest_assert_empty_queue(li);
549
550 /* both below the magic line */
551 litest_touch_down(dev, 0, 40, 100);
552 litest_touch_down(dev, 1, 60, 95);
553 litest_event(dev, EV_KEY, BTN_LEFT, 1);
554 litest_event(dev, EV_SYN, SYN_REPORT, 0);
555 litest_event(dev, EV_KEY, BTN_LEFT, 0);
556 litest_event(dev, EV_SYN, SYN_REPORT, 0);
557 litest_touch_up(dev, 0);
558 litest_touch_up(dev, 1);
559
560 litest_assert_button_event(li,
561 BTN_RIGHT,
562 LIBINPUT_BUTTON_STATE_PRESSED);
563 litest_assert_button_event(li,
564 BTN_RIGHT,
565 LIBINPUT_BUTTON_STATE_RELEASED);
566
567 /* one above, one below the magic line, vert spread 17mm */
568 litest_touch_down(dev, 0, 50, 75);
569 litest_touch_down(dev, 1, 55, 100);
570 litest_event(dev, EV_KEY, BTN_LEFT, 1);
571 litest_event(dev, EV_SYN, SYN_REPORT, 0);
572 litest_event(dev, EV_KEY, BTN_LEFT, 0);
573 litest_event(dev, EV_SYN, SYN_REPORT, 0);
574 litest_touch_up(dev, 0);
575 litest_touch_up(dev, 1);
576
577 litest_assert_button_event(li,
578 BTN_RIGHT,
579 LIBINPUT_BUTTON_STATE_PRESSED);
580 litest_assert_button_event(li,
581 BTN_RIGHT,
582 LIBINPUT_BUTTON_STATE_RELEASED);
583 }
584 END_TEST
585
START_TEST(touchpad_clickfinger_to_area_method)586 START_TEST(touchpad_clickfinger_to_area_method)
587 {
588 struct litest_device *dev = litest_current_device();
589 struct libinput *li = dev->libinput;
590
591 litest_drain_events(li);
592
593 litest_enable_buttonareas(dev);
594
595 litest_touch_down(dev, 0, 95, 95);
596 litest_event(dev, EV_KEY, BTN_LEFT, 1);
597 litest_event(dev, EV_SYN, SYN_REPORT, 0);
598 litest_event(dev, EV_KEY, BTN_LEFT, 0);
599 litest_event(dev, EV_SYN, SYN_REPORT, 0);
600 litest_touch_up(dev, 0);
601 libinput_dispatch(li);
602
603 litest_assert_button_event(li, BTN_RIGHT,
604 LIBINPUT_BUTTON_STATE_PRESSED);
605 litest_assert_button_event(li, BTN_RIGHT,
606 LIBINPUT_BUTTON_STATE_RELEASED);
607
608 litest_enable_clickfinger(dev);
609
610 litest_drain_events(li);
611
612 /* use bottom right corner to catch accidental softbutton right */
613 litest_touch_down(dev, 0, 95, 95);
614 litest_event(dev, EV_KEY, BTN_LEFT, 1);
615 litest_event(dev, EV_SYN, SYN_REPORT, 0);
616 litest_event(dev, EV_KEY, BTN_LEFT, 0);
617 litest_event(dev, EV_SYN, SYN_REPORT, 0);
618 litest_touch_up(dev, 0);
619 libinput_dispatch(li);
620
621 litest_assert_button_event(li, BTN_LEFT,
622 LIBINPUT_BUTTON_STATE_PRESSED);
623 litest_assert_button_event(li, BTN_LEFT,
624 LIBINPUT_BUTTON_STATE_RELEASED);
625
626 }
627 END_TEST
628
START_TEST(touchpad_clickfinger_to_area_method_while_down)629 START_TEST(touchpad_clickfinger_to_area_method_while_down)
630 {
631 struct litest_device *dev = litest_current_device();
632 struct libinput *li = dev->libinput;
633
634 litest_drain_events(li);
635
636 litest_enable_buttonareas(dev);
637
638 litest_touch_down(dev, 0, 95, 95);
639 litest_event(dev, EV_KEY, BTN_LEFT, 1);
640 litest_event(dev, EV_SYN, SYN_REPORT, 0);
641 libinput_dispatch(li);
642 litest_assert_button_event(li, BTN_RIGHT,
643 LIBINPUT_BUTTON_STATE_PRESSED);
644
645 litest_enable_clickfinger(dev);
646
647 litest_event(dev, EV_KEY, BTN_LEFT, 0);
648 litest_event(dev, EV_SYN, SYN_REPORT, 0);
649 litest_touch_up(dev, 0);
650 libinput_dispatch(li);
651
652 litest_assert_button_event(li, BTN_RIGHT,
653 LIBINPUT_BUTTON_STATE_RELEASED);
654
655 litest_drain_events(li);
656
657 /* use bottom right corner to catch accidental softbutton right */
658 litest_touch_down(dev, 0, 95, 95);
659 litest_event(dev, EV_KEY, BTN_LEFT, 1);
660 litest_event(dev, EV_SYN, SYN_REPORT, 0);
661 litest_event(dev, EV_KEY, BTN_LEFT, 0);
662 litest_event(dev, EV_SYN, SYN_REPORT, 0);
663 litest_touch_up(dev, 0);
664 libinput_dispatch(li);
665
666 litest_assert_button_event(li, BTN_LEFT,
667 LIBINPUT_BUTTON_STATE_PRESSED);
668 litest_assert_button_event(li, BTN_LEFT,
669 LIBINPUT_BUTTON_STATE_RELEASED);
670
671 }
672 END_TEST
673
START_TEST(touchpad_area_to_clickfinger_method)674 START_TEST(touchpad_area_to_clickfinger_method)
675 {
676 struct litest_device *dev = litest_current_device();
677 struct libinput *li = dev->libinput;
678
679 litest_enable_clickfinger(dev);
680
681 litest_drain_events(li);
682
683 /* use bottom right corner to catch accidental softbutton right */
684 litest_touch_down(dev, 0, 95, 95);
685 litest_event(dev, EV_KEY, BTN_LEFT, 1);
686 litest_event(dev, EV_SYN, SYN_REPORT, 0);
687 litest_event(dev, EV_KEY, BTN_LEFT, 0);
688 litest_event(dev, EV_SYN, SYN_REPORT, 0);
689 litest_touch_up(dev, 0);
690 libinput_dispatch(li);
691
692 litest_assert_button_event(li, BTN_LEFT,
693 LIBINPUT_BUTTON_STATE_PRESSED);
694 litest_assert_button_event(li, BTN_LEFT,
695 LIBINPUT_BUTTON_STATE_RELEASED);
696
697 litest_enable_buttonareas(dev);
698
699 litest_touch_down(dev, 0, 95, 95);
700 litest_event(dev, EV_KEY, BTN_LEFT, 1);
701 litest_event(dev, EV_SYN, SYN_REPORT, 0);
702 litest_event(dev, EV_KEY, BTN_LEFT, 0);
703 litest_event(dev, EV_SYN, SYN_REPORT, 0);
704 litest_touch_up(dev, 0);
705 libinput_dispatch(li);
706
707 litest_assert_button_event(li, BTN_RIGHT,
708 LIBINPUT_BUTTON_STATE_PRESSED);
709 litest_assert_button_event(li, BTN_RIGHT,
710 LIBINPUT_BUTTON_STATE_RELEASED);
711
712 }
713 END_TEST
714
START_TEST(touchpad_area_to_clickfinger_method_while_down)715 START_TEST(touchpad_area_to_clickfinger_method_while_down)
716 {
717 struct litest_device *dev = litest_current_device();
718 struct libinput *li = dev->libinput;
719
720 litest_enable_clickfinger(dev);
721
722 litest_drain_events(li);
723
724 /* use bottom right corner to catch accidental softbutton right */
725 litest_touch_down(dev, 0, 95, 95);
726 litest_event(dev, EV_KEY, BTN_LEFT, 1);
727 litest_event(dev, EV_SYN, SYN_REPORT, 0);
728 litest_assert_button_event(li, BTN_LEFT,
729 LIBINPUT_BUTTON_STATE_PRESSED);
730
731 litest_enable_buttonareas(dev);
732
733 litest_event(dev, EV_KEY, BTN_LEFT, 0);
734 litest_event(dev, EV_SYN, SYN_REPORT, 0);
735 litest_touch_up(dev, 0);
736 libinput_dispatch(li);
737
738 litest_assert_button_event(li, BTN_LEFT,
739 LIBINPUT_BUTTON_STATE_RELEASED);
740
741 litest_touch_down(dev, 0, 95, 95);
742 litest_event(dev, EV_KEY, BTN_LEFT, 1);
743 litest_event(dev, EV_SYN, SYN_REPORT, 0);
744 litest_event(dev, EV_KEY, BTN_LEFT, 0);
745 litest_event(dev, EV_SYN, SYN_REPORT, 0);
746 litest_touch_up(dev, 0);
747 libinput_dispatch(li);
748
749 litest_assert_button_event(li, BTN_RIGHT,
750 LIBINPUT_BUTTON_STATE_PRESSED);
751 litest_assert_button_event(li, BTN_RIGHT,
752 LIBINPUT_BUTTON_STATE_RELEASED);
753
754 }
755 END_TEST
756
START_TEST(touchpad_clickfinger_3fg_tool_position)757 START_TEST(touchpad_clickfinger_3fg_tool_position)
758 {
759 struct litest_device *dev = litest_current_device();
760 struct libinput *li = dev->libinput;
761
762 litest_enable_clickfinger(dev);
763 litest_drain_events(li);
764
765 /* one in thumb area, one in normal area + TRIPLETAP. spread is wide
766 * but any non-palm 3fg touch+click counts as middle */
767 litest_touch_down(dev, 0, 20, 99);
768 litest_touch_down(dev, 1, 90, 15);
769 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
770 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
771 litest_event(dev, EV_SYN, SYN_REPORT, 0);
772 libinput_dispatch(li);
773
774 litest_event(dev, EV_KEY, BTN_LEFT, 1);
775 litest_event(dev, EV_SYN, SYN_REPORT, 0);
776 litest_event(dev, EV_KEY, BTN_LEFT, 0);
777 litest_event(dev, EV_SYN, SYN_REPORT, 0);
778 libinput_dispatch(li);
779
780 litest_assert_button_event(li, BTN_RIGHT,
781 LIBINPUT_BUTTON_STATE_PRESSED);
782 litest_assert_button_event(li, BTN_RIGHT,
783 LIBINPUT_BUTTON_STATE_RELEASED);
784 }
785 END_TEST
786
START_TEST(touchpad_clickfinger_4fg_tool_position)787 START_TEST(touchpad_clickfinger_4fg_tool_position)
788 {
789 struct litest_device *dev = litest_current_device();
790 struct libinput *li = dev->libinput;
791
792 litest_enable_clickfinger(dev);
793 litest_drain_events(li);
794
795 litest_touch_down(dev, 0, 5, 99);
796 litest_touch_down(dev, 1, 90, 15);
797 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
798 litest_event(dev, EV_KEY, BTN_TOOL_QUADTAP, 1);
799 litest_event(dev, EV_SYN, SYN_REPORT, 0);
800 libinput_dispatch(li);
801
802 litest_event(dev, EV_KEY, BTN_LEFT, 1);
803 litest_event(dev, EV_SYN, SYN_REPORT, 0);
804 litest_event(dev, EV_KEY, BTN_LEFT, 0);
805 litest_event(dev, EV_SYN, SYN_REPORT, 0);
806 libinput_dispatch(li);
807
808 litest_assert_button_event(li,
809 BTN_MIDDLE,
810 LIBINPUT_BUTTON_STATE_PRESSED);
811 litest_assert_button_event(li,
812 BTN_MIDDLE,
813 LIBINPUT_BUTTON_STATE_RELEASED);
814 }
815 END_TEST
816
START_TEST(touchpad_clickfinger_appletouch_config)817 START_TEST(touchpad_clickfinger_appletouch_config)
818 {
819 struct litest_device *dev = litest_current_device();
820 struct libinput_device *device = dev->libinput_device;
821 uint32_t methods, method;
822 enum libinput_config_status status;
823
824 methods = libinput_device_config_click_get_methods(device);
825 ck_assert(!(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS));
826 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
827
828 method = libinput_device_config_click_get_method(device);
829 ck_assert_int_eq(method, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
830
831 status = libinput_device_config_click_set_method(device,
832 LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
833 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_UNSUPPORTED);
834 status = libinput_device_config_click_set_method(device,
835 LIBINPUT_CONFIG_CLICK_METHOD_NONE);
836 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
837 }
838 END_TEST
839
START_TEST(touchpad_clickfinger_appletouch_1fg)840 START_TEST(touchpad_clickfinger_appletouch_1fg)
841 {
842 struct litest_device *dev = litest_current_device();
843 struct libinput *li = dev->libinput;
844
845 litest_enable_clickfinger(dev);
846
847 litest_drain_events(li);
848
849 litest_touch_down(dev, 0, 50, 50);
850 litest_event(dev, EV_KEY, BTN_LEFT, 1);
851 litest_event(dev, EV_SYN, SYN_REPORT, 0);
852 litest_event(dev, EV_KEY, BTN_LEFT, 0);
853 litest_event(dev, EV_SYN, SYN_REPORT, 0);
854 litest_touch_up(dev, 0);
855
856 libinput_dispatch(li);
857
858 litest_assert_button_event(li, BTN_LEFT,
859 LIBINPUT_BUTTON_STATE_PRESSED);
860 litest_assert_button_event(li, BTN_LEFT,
861 LIBINPUT_BUTTON_STATE_RELEASED);
862 }
863 END_TEST
864
START_TEST(touchpad_clickfinger_appletouch_2fg)865 START_TEST(touchpad_clickfinger_appletouch_2fg)
866 {
867 struct litest_device *dev = litest_current_device();
868 struct libinput *li = dev->libinput;
869
870 litest_enable_clickfinger(dev);
871
872 litest_drain_events(li);
873
874 litest_touch_down(dev, 0, 50, 50);
875 litest_touch_down(dev, 1, 50, 50);
876 litest_event(dev, EV_KEY, BTN_LEFT, 1);
877 litest_event(dev, EV_SYN, SYN_REPORT, 0);
878 litest_event(dev, EV_KEY, BTN_LEFT, 0);
879 litest_event(dev, EV_SYN, SYN_REPORT, 0);
880 litest_touch_up(dev, 0);
881 litest_touch_up(dev, 1);
882
883 libinput_dispatch(li);
884
885 litest_assert_button_event(li, BTN_RIGHT,
886 LIBINPUT_BUTTON_STATE_PRESSED);
887 litest_assert_button_event(li, BTN_RIGHT,
888 LIBINPUT_BUTTON_STATE_RELEASED);
889 }
890 END_TEST
891
START_TEST(touchpad_clickfinger_appletouch_3fg)892 START_TEST(touchpad_clickfinger_appletouch_3fg)
893 {
894 struct litest_device *dev = litest_current_device();
895 struct libinput *li = dev->libinput;
896
897 litest_enable_clickfinger(dev);
898
899 litest_drain_events(li);
900
901 litest_touch_down(dev, 0, 50, 50);
902 litest_touch_down(dev, 1, 50, 50);
903 litest_touch_down(dev, 2, 50, 50);
904 litest_event(dev, EV_KEY, BTN_LEFT, 1);
905 litest_event(dev, EV_SYN, SYN_REPORT, 0);
906 litest_event(dev, EV_KEY, BTN_LEFT, 0);
907 litest_event(dev, EV_SYN, SYN_REPORT, 0);
908 litest_touch_up(dev, 0);
909 litest_touch_up(dev, 1);
910 litest_touch_up(dev, 2);
911
912 libinput_dispatch(li);
913
914 litest_assert_button_event(li, BTN_MIDDLE,
915 LIBINPUT_BUTTON_STATE_PRESSED);
916 litest_assert_button_event(li, BTN_MIDDLE,
917 LIBINPUT_BUTTON_STATE_RELEASED);
918 }
919 END_TEST
920
START_TEST(touchpad_clickfinger_click_drag)921 START_TEST(touchpad_clickfinger_click_drag)
922 {
923 struct litest_device *dev = litest_current_device();
924 struct libinput *li = dev->libinput;
925 int nfingers = _i; /* ranged test */
926 unsigned int button;
927 int nslots = litest_slot_count(dev);
928
929 litest_enable_clickfinger(dev);
930 litest_drain_events(li);
931
932 litest_touch_down(dev, 0, 40, 50);
933 button = BTN_LEFT;
934
935 if (nfingers > 1) {
936 if (nslots > 1) {
937 litest_touch_down(dev, 1, 50, 50);
938 } else {
939 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
940 }
941 button = BTN_RIGHT;
942 }
943
944 if (nfingers > 2) {
945 if (nslots > 2) {
946 litest_touch_down(dev, 2, 60, 50);
947 } else {
948 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
949 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 1);
950 }
951 button = BTN_MIDDLE;
952 }
953
954 litest_button_click(dev, BTN_LEFT, true);
955
956 libinput_dispatch(li);
957 litest_assert_button_event(li, button,
958 LIBINPUT_BUTTON_STATE_PRESSED);
959
960 for (int i = 0; i < 20; i++) {
961 litest_push_event_frame(dev);
962 switch (nfingers) {
963 case 3:
964 if (nslots >= nfingers)
965 litest_touch_move(dev, 2, 60, 50 + i);
966 _fallthrough_;
967 case 2:
968 if (nslots >= nfingers)
969 litest_touch_move(dev, 1, 50, 50 + i);
970 _fallthrough_;
971 case 1:
972 litest_touch_move(dev, 0, 40, 50 + i);
973 break;
974 }
975 litest_pop_event_frame(dev);
976 libinput_dispatch(li);
977 }
978
979 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
980
981 litest_button_click(dev, BTN_LEFT, false);
982 litest_assert_button_event(li, button,
983 LIBINPUT_BUTTON_STATE_RELEASED);
984
985 if (nfingers > 3) {
986 if (nslots > 3) {
987 litest_touch_up(dev, 2);
988 } else {
989 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 1);
990 litest_event(dev, EV_KEY, BTN_TOOL_TRIPLETAP, 0);
991 }
992 }
993
994 if (nfingers > 2) {
995 if (nslots > 2) {
996 litest_touch_up(dev, 1);
997 } else {
998 litest_event(dev, EV_KEY, BTN_TOOL_DOUBLETAP, 0);
999 }
1000 }
1001
1002 litest_touch_up(dev, 0);
1003
1004
1005 libinput_dispatch(li);
1006 litest_assert_empty_queue(li);
1007 }
1008 END_TEST
1009
START_TEST(touchpad_btn_left)1010 START_TEST(touchpad_btn_left)
1011 {
1012 struct litest_device *dev = litest_current_device();
1013 struct libinput *li = dev->libinput;
1014
1015 litest_drain_events(li);
1016
1017 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1018 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1019 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1020 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1021
1022 libinput_dispatch(li);
1023
1024 litest_assert_button_event(li, BTN_LEFT,
1025 LIBINPUT_BUTTON_STATE_PRESSED);
1026 litest_assert_button_event(li, BTN_LEFT,
1027 LIBINPUT_BUTTON_STATE_RELEASED);
1028 }
1029 END_TEST
1030
START_TEST(clickpad_btn_left)1031 START_TEST(clickpad_btn_left)
1032 {
1033 struct litest_device *dev = litest_current_device();
1034 struct libinput *li = dev->libinput;
1035
1036 litest_enable_buttonareas(dev);
1037
1038 litest_drain_events(li);
1039
1040 /* A clickpad always needs a finger down to tell where the
1041 click happens */
1042 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1043 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1044 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1045 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1046
1047 libinput_dispatch(li);
1048 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
1049 }
1050 END_TEST
1051
START_TEST(clickpad_click_n_drag)1052 START_TEST(clickpad_click_n_drag)
1053 {
1054 struct litest_device *dev = litest_current_device();
1055 struct libinput *li = dev->libinput;
1056
1057 litest_drain_events(li);
1058
1059 litest_touch_down(dev, 0, 50, 50);
1060 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1061 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1062
1063 libinput_dispatch(li);
1064 litest_assert_button_event(li, BTN_LEFT,
1065 LIBINPUT_BUTTON_STATE_PRESSED);
1066
1067 libinput_dispatch(li);
1068 ck_assert_int_eq(libinput_next_event_type(li), LIBINPUT_EVENT_NONE);
1069
1070 /* now put a second finger down */
1071 litest_touch_down(dev, 1, 70, 70);
1072 litest_touch_move_to(dev, 1, 70, 70, 80, 50, 5);
1073 litest_touch_up(dev, 1);
1074
1075 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1076
1077 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1078 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1079 litest_touch_up(dev, 0);
1080
1081 litest_assert_button_event(li, BTN_LEFT,
1082 LIBINPUT_BUTTON_STATE_RELEASED);
1083 }
1084 END_TEST
1085
START_TEST(clickpad_finger_pin)1086 START_TEST(clickpad_finger_pin)
1087 {
1088 struct litest_device *dev = litest_current_device();
1089 struct libinput *li = dev->libinput;
1090 struct libevdev *evdev = dev->evdev;
1091 const struct input_absinfo *abs;
1092 double w, h;
1093 double dist;
1094
1095 abs = libevdev_get_abs_info(evdev, ABS_MT_POSITION_X);
1096 ck_assert_notnull(abs);
1097 if (abs->resolution == 0)
1098 return;
1099
1100 if (libinput_device_get_size(dev->libinput_device, &w, &h) != 0)
1101 return;
1102
1103 dist = 100.0/max(w, h);
1104
1105 litest_drain_events(li);
1106
1107 /* make sure the movement generates pointer events when
1108 not pinned */
1109 litest_touch_down(dev, 0, 50, 50);
1110 litest_touch_move_to(dev, 0, 50, 50, 54, 54, 10);
1111 litest_touch_move_to(dev, 0, 54, 54, 46, 46, 10);
1112 litest_touch_move_to(dev, 0, 46, 46, 50, 50, 10);
1113 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1114
1115 litest_button_click(dev, BTN_LEFT, true);
1116 litest_drain_events(li);
1117
1118 litest_touch_move_to(dev, 0, 50, 50, 50 + dist, 50 + dist, 10);
1119 litest_touch_move_to(dev, 0, 50 + dist, 50 + dist, 50, 50, 10);
1120 litest_touch_move_to(dev, 0, 50, 50, 50 - dist, 50 - dist, 10);
1121
1122 litest_assert_empty_queue(li);
1123
1124 litest_button_click(dev, BTN_LEFT, false);
1125 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_BUTTON);
1126
1127 /* still pinned after release */
1128 litest_touch_move_to(dev, 0, 50, 50, 50 + dist, 50 + dist, 10);
1129 litest_touch_move_to(dev, 0, 50 + dist, 50 + dist, 50, 50, 10);
1130 litest_touch_move_to(dev, 0, 50, 50, 50 - dist, 50 - dist, 10);
1131
1132 litest_assert_empty_queue(li);
1133
1134 /* move to unpin */
1135 litest_touch_move_to(dev, 0, 50, 50, 70, 70, 10);
1136 litest_assert_only_typed_events(li, LIBINPUT_EVENT_POINTER_MOTION);
1137 }
1138 END_TEST
1139
START_TEST(clickpad_softbutton_left)1140 START_TEST(clickpad_softbutton_left)
1141 {
1142 struct litest_device *dev = litest_current_device();
1143 struct libinput *li = dev->libinput;
1144
1145 litest_drain_events(li);
1146
1147 litest_touch_down(dev, 0, 10, 90);
1148 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1149 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1150
1151 litest_assert_button_event(li,
1152 BTN_LEFT,
1153 LIBINPUT_BUTTON_STATE_PRESSED);
1154
1155 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1156 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1157 litest_touch_up(dev, 0);
1158
1159 litest_assert_button_event(li,
1160 BTN_LEFT,
1161 LIBINPUT_BUTTON_STATE_RELEASED);
1162
1163 libinput_dispatch(li);
1164
1165 litest_assert_empty_queue(li);
1166 }
1167 END_TEST
1168
START_TEST(clickpad_softbutton_middle)1169 START_TEST(clickpad_softbutton_middle)
1170 {
1171 struct litest_device *dev = litest_current_device();
1172 struct libinput *li = dev->libinput;
1173
1174 litest_drain_events(li);
1175
1176 litest_touch_down(dev, 0, 50, 90);
1177 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1178 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1179
1180 litest_assert_button_event(li,
1181 BTN_MIDDLE,
1182 LIBINPUT_BUTTON_STATE_PRESSED);
1183
1184 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1185 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1186 litest_touch_up(dev, 0);
1187
1188 litest_assert_button_event(li,
1189 BTN_MIDDLE,
1190 LIBINPUT_BUTTON_STATE_RELEASED);
1191
1192 libinput_dispatch(li);
1193
1194 litest_assert_empty_queue(li);
1195 }
1196 END_TEST
1197
START_TEST(clickpad_softbutton_right)1198 START_TEST(clickpad_softbutton_right)
1199 {
1200 struct litest_device *dev = litest_current_device();
1201 struct libinput *li = dev->libinput;
1202
1203 litest_drain_events(li);
1204
1205 litest_touch_down(dev, 0, 90, 90);
1206 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1207 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1208
1209 litest_assert_button_event(li,
1210 BTN_RIGHT,
1211 LIBINPUT_BUTTON_STATE_PRESSED);
1212
1213 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1214 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1215 litest_touch_up(dev, 0);
1216
1217 litest_assert_button_event(li,
1218 BTN_RIGHT,
1219 LIBINPUT_BUTTON_STATE_RELEASED);
1220
1221 libinput_dispatch(li);
1222
1223 litest_assert_empty_queue(li);
1224 }
1225 END_TEST
1226
START_TEST(clickpad_softbutton_left_tap_n_drag)1227 START_TEST(clickpad_softbutton_left_tap_n_drag)
1228 {
1229 struct litest_device *dev = litest_current_device();
1230 struct libinput *li = dev->libinput;
1231
1232 litest_enable_tap(dev->libinput_device);
1233
1234 litest_drain_events(li);
1235
1236 /* Tap in left button area, then finger down, button click
1237 -> expect left button press/release and left button press
1238 Release button, finger up
1239 -> expect right button release
1240 */
1241 litest_touch_down(dev, 0, 20, 90);
1242 litest_touch_up(dev, 0);
1243 litest_touch_down(dev, 0, 20, 90);
1244 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1245 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1246
1247 litest_assert_button_event(li,
1248 BTN_LEFT,
1249 LIBINPUT_BUTTON_STATE_PRESSED);
1250 litest_assert_button_event(li,
1251 BTN_LEFT,
1252 LIBINPUT_BUTTON_STATE_RELEASED);
1253 litest_assert_button_event(li,
1254 BTN_LEFT,
1255 LIBINPUT_BUTTON_STATE_PRESSED);
1256 litest_assert_empty_queue(li);
1257
1258 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1259 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1260 litest_touch_up(dev, 0);
1261
1262 litest_assert_button_event(li,
1263 BTN_LEFT,
1264 LIBINPUT_BUTTON_STATE_RELEASED);
1265 litest_assert_empty_queue(li);
1266 }
1267 END_TEST
1268
START_TEST(clickpad_softbutton_right_tap_n_drag)1269 START_TEST(clickpad_softbutton_right_tap_n_drag)
1270 {
1271 struct litest_device *dev = litest_current_device();
1272 struct libinput *li = dev->libinput;
1273
1274 litest_enable_tap(dev->libinput_device);
1275
1276 litest_drain_events(li);
1277
1278 /* Tap in right button area, then finger down, button click
1279 -> expect left button press/release and right button press
1280 Release button, finger up
1281 -> expect right button release
1282 */
1283 litest_touch_down(dev, 0, 90, 90);
1284 litest_touch_up(dev, 0);
1285 litest_touch_down(dev, 0, 90, 90);
1286 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1287 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1288
1289 litest_assert_button_event(li,
1290 BTN_LEFT,
1291 LIBINPUT_BUTTON_STATE_PRESSED);
1292 litest_assert_button_event(li,
1293 BTN_LEFT,
1294 LIBINPUT_BUTTON_STATE_RELEASED);
1295 litest_assert_button_event(li,
1296 BTN_RIGHT,
1297 LIBINPUT_BUTTON_STATE_PRESSED);
1298 litest_assert_empty_queue(li);
1299
1300 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1301 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1302 litest_touch_up(dev, 0);
1303
1304 litest_assert_button_event(li,
1305 BTN_RIGHT,
1306 LIBINPUT_BUTTON_STATE_RELEASED);
1307 litest_assert_empty_queue(li);
1308 }
1309 END_TEST
1310
START_TEST(clickpad_softbutton_left_1st_fg_move)1311 START_TEST(clickpad_softbutton_left_1st_fg_move)
1312 {
1313 struct litest_device *dev = litest_current_device();
1314 struct libinput *li = dev->libinput;
1315 struct libinput_event *event;
1316 double x = 0, y = 0;
1317 int nevents = 0;
1318
1319 litest_drain_events(li);
1320
1321 /* One finger down in the left button area, button press
1322 -> expect a button event
1323 Move finger up out of the area, wait for timeout
1324 Move finger around diagonally down left
1325 -> expect motion events down left
1326 Release finger
1327 -> expect a button event */
1328
1329 /* finger down, press in left button */
1330 litest_touch_down(dev, 0, 20, 90);
1331 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1332 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1333
1334 litest_assert_button_event(li,
1335 BTN_LEFT,
1336 LIBINPUT_BUTTON_STATE_PRESSED);
1337 litest_assert_empty_queue(li);
1338
1339 /* move out of the area, then wait for softbutton timer */
1340 litest_touch_move_to(dev, 0, 20, 90, 50, 50, 20);
1341 libinput_dispatch(li);
1342 litest_timeout_softbuttons();
1343 libinput_dispatch(li);
1344 litest_drain_events(li);
1345
1346 /* move down left, expect motion */
1347 litest_touch_move_to(dev, 0, 50, 50, 20, 90, 20);
1348
1349 libinput_dispatch(li);
1350 event = libinput_get_event(li);
1351 ck_assert_notnull(event);
1352 while (event) {
1353 struct libinput_event_pointer *p;
1354
1355 ck_assert_int_eq(libinput_event_get_type(event),
1356 LIBINPUT_EVENT_POINTER_MOTION);
1357 p = libinput_event_get_pointer_event(event);
1358
1359 /* we moved up/right, now down/left so the pointer accel
1360 code may lag behind with the dx/dy vectors. Hence, add up
1361 the x/y movements and expect that on average we moved
1362 left and down */
1363 x += libinput_event_pointer_get_dx(p);
1364 y += libinput_event_pointer_get_dy(p);
1365 nevents++;
1366
1367 libinput_event_destroy(event);
1368 libinput_dispatch(li);
1369 event = libinput_get_event(li);
1370 }
1371
1372 ck_assert(x/nevents < 0);
1373 ck_assert(y/nevents > 0);
1374
1375 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1376 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1377 litest_touch_up(dev, 0);
1378
1379 litest_assert_button_event(li,
1380 BTN_LEFT,
1381 LIBINPUT_BUTTON_STATE_RELEASED);
1382
1383 litest_assert_empty_queue(li);
1384 }
1385 END_TEST
1386
START_TEST(clickpad_softbutton_left_2nd_fg_move)1387 START_TEST(clickpad_softbutton_left_2nd_fg_move)
1388 {
1389 struct litest_device *dev = litest_current_device();
1390 struct libinput *li = dev->libinput;
1391 struct libinput_event *event;
1392
1393 litest_drain_events(li);
1394
1395 /* One finger down in the left button area, button press
1396 -> expect a button event
1397 Put a second finger down in the area, move it right, release
1398 -> expect motion events right
1399 Put a second finger down in the area, move it down, release
1400 -> expect motion events down
1401 Release second finger, release first finger
1402 -> expect a button event */
1403 litest_touch_down(dev, 0, 20, 90);
1404 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1405 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1406
1407 litest_assert_button_event(li,
1408 BTN_LEFT,
1409 LIBINPUT_BUTTON_STATE_PRESSED);
1410 litest_assert_empty_queue(li);
1411
1412 litest_touch_down(dev, 1, 20, 20);
1413 litest_touch_move_to(dev, 1, 20, 20, 80, 20, 10);
1414
1415 libinput_dispatch(li);
1416 event = libinput_get_event(li);
1417 ck_assert_notnull(event);
1418 while (event) {
1419 struct libinput_event_pointer *p;
1420 double x, y;
1421
1422 ck_assert_int_eq(libinput_event_get_type(event),
1423 LIBINPUT_EVENT_POINTER_MOTION);
1424 p = libinput_event_get_pointer_event(event);
1425
1426 x = libinput_event_pointer_get_dx(p);
1427 y = libinput_event_pointer_get_dy(p);
1428
1429 /* Ignore events only containing an unaccelerated motion
1430 * vector. */
1431 if (x != 0 || y != 0) {
1432 ck_assert(x > 0);
1433 ck_assert(y == 0);
1434 }
1435
1436 libinput_event_destroy(event);
1437 libinput_dispatch(li);
1438 event = libinput_get_event(li);
1439 }
1440 litest_touch_up(dev, 1);
1441
1442 /* second finger down */
1443 litest_touch_down(dev, 1, 20, 20);
1444 litest_touch_move_to(dev, 1, 20, 20, 20, 80, 10);
1445
1446 libinput_dispatch(li);
1447 event = libinput_get_event(li);
1448 ck_assert_notnull(event);
1449 while (event) {
1450 struct libinput_event_pointer *p;
1451 double x, y;
1452
1453 ck_assert_int_eq(libinput_event_get_type(event),
1454 LIBINPUT_EVENT_POINTER_MOTION);
1455 p = libinput_event_get_pointer_event(event);
1456
1457 x = libinput_event_pointer_get_dx(p);
1458 y = libinput_event_pointer_get_dy(p);
1459
1460 ck_assert(x == 0);
1461 ck_assert(y > 0);
1462
1463 libinput_event_destroy(event);
1464 libinput_dispatch(li);
1465 event = libinput_get_event(li);
1466 }
1467
1468 litest_touch_up(dev, 1);
1469
1470 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1471 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1472 litest_touch_up(dev, 0);
1473
1474 litest_assert_button_event(li,
1475 BTN_LEFT,
1476 LIBINPUT_BUTTON_STATE_RELEASED);
1477
1478 litest_assert_empty_queue(li);
1479 }
1480 END_TEST
1481
START_TEST(clickpad_softbutton_left_to_right)1482 START_TEST(clickpad_softbutton_left_to_right)
1483 {
1484 struct litest_device *dev = litest_current_device();
1485 struct libinput *li = dev->libinput;
1486
1487 litest_drain_events(li);
1488
1489 /* One finger down in left software button area,
1490 move to right button area immediately, click
1491 -> expect right button event
1492 */
1493
1494 litest_touch_down(dev, 0, 30, 90);
1495 litest_touch_move_to(dev, 0, 30, 90, 90, 90, 10);
1496 litest_drain_events(li);
1497
1498 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1499 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1500
1501 litest_assert_button_event(li,
1502 BTN_RIGHT,
1503 LIBINPUT_BUTTON_STATE_PRESSED);
1504 litest_assert_empty_queue(li);
1505
1506 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1507 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1508 litest_touch_up(dev, 0);
1509
1510 litest_assert_button_event(li,
1511 BTN_RIGHT,
1512 LIBINPUT_BUTTON_STATE_RELEASED);
1513
1514 litest_assert_empty_queue(li);
1515 }
1516 END_TEST
1517
START_TEST(clickpad_softbutton_right_to_left)1518 START_TEST(clickpad_softbutton_right_to_left)
1519 {
1520 struct litest_device *dev = litest_current_device();
1521 struct libinput *li = dev->libinput;
1522
1523 litest_drain_events(li);
1524
1525 /* One finger down in right software button area,
1526 move to left button area immediately, click
1527 -> expect left button event
1528 */
1529
1530 litest_touch_down(dev, 0, 80, 90);
1531 litest_touch_move_to(dev, 0, 80, 90, 30, 90, 10);
1532 litest_drain_events(li);
1533
1534 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1535 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1536
1537 litest_assert_button_event(li,
1538 BTN_LEFT,
1539 LIBINPUT_BUTTON_STATE_PRESSED);
1540 litest_assert_empty_queue(li);
1541
1542 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1543 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1544 litest_touch_up(dev, 0);
1545
1546 litest_assert_button_event(li,
1547 BTN_LEFT,
1548 LIBINPUT_BUTTON_STATE_RELEASED);
1549
1550 litest_assert_empty_queue(li);
1551 }
1552 END_TEST
1553
START_TEST(clickpad_softbutton_hover_into_buttons)1554 START_TEST(clickpad_softbutton_hover_into_buttons)
1555 {
1556 struct litest_device *dev = litest_current_device();
1557 struct libinput *li = dev->libinput;
1558
1559 litest_drain_events(li);
1560
1561 litest_hover_start(dev, 0, 50, 50);
1562 libinput_dispatch(li);
1563 litest_hover_move_to(dev, 0, 50, 50, 90, 90, 10);
1564 libinput_dispatch(li);
1565
1566 litest_touch_move_to(dev, 0, 90, 90, 91, 91, 1);
1567
1568 litest_button_click(dev, BTN_LEFT, true);
1569 libinput_dispatch(li);
1570
1571 litest_assert_button_event(li,
1572 BTN_RIGHT,
1573 LIBINPUT_BUTTON_STATE_PRESSED);
1574 litest_assert_empty_queue(li);
1575
1576 litest_button_click(dev, BTN_LEFT, false);
1577 litest_touch_up(dev, 0);
1578
1579 litest_assert_button_event(li,
1580 BTN_RIGHT,
1581 LIBINPUT_BUTTON_STATE_RELEASED);
1582 }
1583 END_TEST
1584
START_TEST(clickpad_topsoftbuttons_left)1585 START_TEST(clickpad_topsoftbuttons_left)
1586 {
1587 struct litest_device *dev = litest_current_device();
1588 struct libinput *li = dev->libinput;
1589
1590 litest_drain_events(li);
1591
1592 litest_touch_down(dev, 0, 10, 5);
1593 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1594 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1595
1596 litest_assert_button_event(li,
1597 BTN_LEFT,
1598 LIBINPUT_BUTTON_STATE_PRESSED);
1599 litest_assert_empty_queue(li);
1600
1601 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1602 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1603 litest_touch_up(dev, 0);
1604
1605 litest_assert_button_event(li,
1606 BTN_LEFT,
1607 LIBINPUT_BUTTON_STATE_RELEASED);
1608
1609 litest_assert_empty_queue(li);
1610 }
1611 END_TEST
1612
START_TEST(clickpad_topsoftbuttons_right)1613 START_TEST(clickpad_topsoftbuttons_right)
1614 {
1615 struct litest_device *dev = litest_current_device();
1616 struct libinput *li = dev->libinput;
1617
1618 litest_drain_events(li);
1619
1620 litest_touch_down(dev, 0, 90, 5);
1621 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1622 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1623
1624 litest_assert_button_event(li,
1625 BTN_RIGHT,
1626 LIBINPUT_BUTTON_STATE_PRESSED);
1627 litest_assert_empty_queue(li);
1628
1629 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1630 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1631 litest_touch_up(dev, 0);
1632
1633 litest_assert_button_event(li,
1634 BTN_RIGHT,
1635 LIBINPUT_BUTTON_STATE_RELEASED);
1636
1637 litest_assert_empty_queue(li);
1638 }
1639 END_TEST
1640
START_TEST(clickpad_topsoftbuttons_middle)1641 START_TEST(clickpad_topsoftbuttons_middle)
1642 {
1643 struct litest_device *dev = litest_current_device();
1644 struct libinput *li = dev->libinput;
1645
1646 litest_drain_events(li);
1647
1648 litest_touch_down(dev, 0, 50, 5);
1649 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1650 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1651
1652 litest_assert_button_event(li,
1653 BTN_MIDDLE,
1654 LIBINPUT_BUTTON_STATE_PRESSED);
1655 litest_assert_empty_queue(li);
1656
1657 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1658 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1659 litest_touch_up(dev, 0);
1660
1661 litest_assert_button_event(li,
1662 BTN_MIDDLE,
1663 LIBINPUT_BUTTON_STATE_RELEASED);
1664
1665 litest_assert_empty_queue(li);
1666 }
1667 END_TEST
1668
START_TEST(clickpad_topsoftbuttons_move_out_leftclick_before_timeout)1669 START_TEST(clickpad_topsoftbuttons_move_out_leftclick_before_timeout)
1670 {
1671 struct litest_device *dev = litest_current_device();
1672 struct libinput *li = dev->libinput;
1673
1674 /* Finger down in top right button area, wait past enter timeout
1675 Move into main area, wait past leave timeout
1676 Click
1677 -> expect left click
1678 */
1679
1680 litest_drain_events(li);
1681
1682 litest_touch_down(dev, 0, 80, 5);
1683 libinput_dispatch(li);
1684 litest_timeout_softbuttons();
1685 libinput_dispatch(li);
1686 litest_assert_empty_queue(li);
1687
1688 litest_touch_move_to(dev, 0, 80, 5, 80, 90, 20);
1689 libinput_dispatch(li);
1690
1691 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1692 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1693 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1694 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1695
1696 litest_touch_up(dev, 0);
1697
1698 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_PRESSED);
1699 litest_assert_button_event(li, BTN_RIGHT, LIBINPUT_BUTTON_STATE_RELEASED);
1700 }
1701 END_TEST
1702
START_TEST(clickpad_topsoftbuttons_move_out_leftclick)1703 START_TEST(clickpad_topsoftbuttons_move_out_leftclick)
1704 {
1705 struct litest_device *dev = litest_current_device();
1706 struct libinput *li = dev->libinput;
1707
1708 /* Finger down in top right button area, wait past enter timeout
1709 Move into main area, wait past leave timeout
1710 Click
1711 -> expect left click
1712 */
1713
1714 litest_drain_events(li);
1715
1716 litest_touch_down(dev, 0, 80, 5);
1717 libinput_dispatch(li);
1718 litest_timeout_softbuttons();
1719 libinput_dispatch(li);
1720 litest_assert_empty_queue(li);
1721
1722 litest_touch_move_to(dev, 0, 80, 5, 80, 90, 20);
1723 libinput_dispatch(li);
1724 litest_timeout_softbuttons();
1725 libinput_dispatch(li);
1726
1727 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1728 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1729 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1730 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1731
1732 litest_touch_up(dev, 0);
1733
1734 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_PRESSED);
1735 litest_assert_button_event(li, BTN_LEFT, LIBINPUT_BUTTON_STATE_RELEASED);
1736 }
1737 END_TEST
1738
START_TEST(clickpad_topsoftbuttons_clickfinger)1739 START_TEST(clickpad_topsoftbuttons_clickfinger)
1740 {
1741 struct litest_device *dev = litest_current_device();
1742 struct libinput *li = dev->libinput;
1743
1744 litest_enable_clickfinger(dev);
1745
1746 litest_drain_events(li);
1747
1748 litest_touch_down(dev, 0, 90, 5);
1749 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1750 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1751 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1752 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1753 litest_touch_up(dev, 0);
1754
1755 litest_assert_button_event(li,
1756 BTN_LEFT,
1757 LIBINPUT_BUTTON_STATE_PRESSED);
1758 litest_assert_button_event(li,
1759 BTN_LEFT,
1760 LIBINPUT_BUTTON_STATE_RELEASED);
1761
1762 litest_assert_empty_queue(li);
1763
1764 litest_touch_down(dev, 0, 90, 5);
1765 litest_touch_down(dev, 1, 80, 5);
1766 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1767 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1768 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1769 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1770 litest_touch_up(dev, 0);
1771 litest_touch_up(dev, 1);
1772
1773 litest_assert_button_event(li,
1774 BTN_RIGHT,
1775 LIBINPUT_BUTTON_STATE_PRESSED);
1776 litest_assert_button_event(li,
1777 BTN_RIGHT,
1778 LIBINPUT_BUTTON_STATE_RELEASED);
1779 }
1780 END_TEST
1781
START_TEST(clickpad_topsoftbuttons_clickfinger_dev_disabled)1782 START_TEST(clickpad_topsoftbuttons_clickfinger_dev_disabled)
1783 {
1784 struct litest_device *dev = litest_current_device();
1785 struct libinput *li = dev->libinput;
1786 struct litest_device *trackpoint = litest_add_device(li,
1787 LITEST_TRACKPOINT);
1788
1789 libinput_device_config_send_events_set_mode(dev->libinput_device,
1790 LIBINPUT_CONFIG_SEND_EVENTS_DISABLED);
1791 litest_enable_clickfinger(dev);
1792 litest_drain_events(li);
1793
1794 litest_touch_down(dev, 0, 90, 5);
1795 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1796 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1797 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1798 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1799 litest_touch_up(dev, 0);
1800
1801 litest_assert_button_event(li,
1802 BTN_RIGHT,
1803 LIBINPUT_BUTTON_STATE_PRESSED);
1804 litest_assert_button_event(li,
1805 BTN_RIGHT,
1806 LIBINPUT_BUTTON_STATE_RELEASED);
1807
1808 litest_assert_empty_queue(li);
1809
1810 litest_touch_down(dev, 0, 90, 5);
1811 litest_touch_down(dev, 1, 10, 5);
1812 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1813 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1814 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1815 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1816 litest_touch_up(dev, 0);
1817 litest_touch_up(dev, 1);
1818
1819 litest_assert_button_event(li,
1820 BTN_MIDDLE,
1821 LIBINPUT_BUTTON_STATE_PRESSED);
1822 litest_assert_button_event(li,
1823 BTN_MIDDLE,
1824 LIBINPUT_BUTTON_STATE_RELEASED);
1825
1826 litest_delete_device(trackpoint);
1827 }
1828 END_TEST
1829
START_TEST(clickpad_middleemulation_config_delayed)1830 START_TEST(clickpad_middleemulation_config_delayed)
1831 {
1832 struct litest_device *dev = litest_current_device();
1833 struct libinput_device *device = dev->libinput_device;
1834 struct libinput *li = dev->libinput;
1835 enum libinput_config_status status;
1836 int enabled;
1837
1838 enabled = libinput_device_config_middle_emulation_get_enabled(device);
1839 ck_assert(!enabled);
1840
1841 litest_touch_down(dev, 0, 30, 95);
1842 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1843 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1844 libinput_dispatch(li);
1845
1846 /* actual config is delayed, but status is immediate */
1847 status = libinput_device_config_middle_emulation_set_enabled(device,
1848 LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
1849 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1850
1851 enabled = libinput_device_config_middle_emulation_get_enabled(device);
1852 ck_assert(enabled);
1853
1854 status = libinput_device_config_middle_emulation_set_enabled(device,
1855 LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED);
1856 ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
1857 enabled = libinput_device_config_middle_emulation_get_enabled(device);
1858 ck_assert(!enabled);
1859 }
1860 END_TEST
1861
START_TEST(clickpad_middleemulation_click)1862 START_TEST(clickpad_middleemulation_click)
1863 {
1864 struct litest_device *dev = litest_current_device();
1865 struct libinput *li = dev->libinput;
1866
1867 litest_enable_buttonareas(dev);
1868 litest_enable_middleemu(dev);
1869 litest_drain_events(li);
1870
1871 litest_touch_down(dev, 0, 30, 95);
1872 litest_touch_down(dev, 1, 80, 95);
1873 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1874 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1875
1876 litest_assert_button_event(li,
1877 BTN_MIDDLE,
1878 LIBINPUT_BUTTON_STATE_PRESSED);
1879
1880 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1881 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1882 litest_touch_up(dev, 0);
1883 litest_touch_up(dev, 1);
1884
1885 litest_assert_button_event(li,
1886 BTN_MIDDLE,
1887 LIBINPUT_BUTTON_STATE_RELEASED);
1888
1889 libinput_dispatch(li);
1890
1891 litest_assert_empty_queue(li);
1892 }
1893 END_TEST
1894
START_TEST(clickpad_middleemulation_click_middle_left)1895 START_TEST(clickpad_middleemulation_click_middle_left)
1896 {
1897 struct litest_device *dev = litest_current_device();
1898 struct libinput *li = dev->libinput;
1899
1900 litest_enable_buttonareas(dev);
1901 litest_enable_middleemu(dev);
1902 litest_drain_events(li);
1903
1904 litest_touch_down(dev, 0, 49, 95);
1905 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1906 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1907
1908 litest_assert_button_event(li,
1909 BTN_LEFT,
1910 LIBINPUT_BUTTON_STATE_PRESSED);
1911
1912 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1913 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1914 litest_touch_up(dev, 0);
1915
1916 litest_assert_button_event(li,
1917 BTN_LEFT,
1918 LIBINPUT_BUTTON_STATE_RELEASED);
1919
1920 libinput_dispatch(li);
1921
1922 litest_assert_empty_queue(li);
1923 }
1924 END_TEST
1925
START_TEST(clickpad_middleemulation_click_middle_right)1926 START_TEST(clickpad_middleemulation_click_middle_right)
1927 {
1928 struct litest_device *dev = litest_current_device();
1929 struct libinput *li = dev->libinput;
1930
1931 litest_enable_buttonareas(dev);
1932 litest_enable_middleemu(dev);
1933 litest_drain_events(li);
1934
1935 litest_touch_down(dev, 0, 51, 95);
1936 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1937 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1938
1939 litest_assert_button_event(li,
1940 BTN_RIGHT,
1941 LIBINPUT_BUTTON_STATE_PRESSED);
1942
1943 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1944 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1945 litest_touch_up(dev, 0);
1946
1947 litest_assert_button_event(li,
1948 BTN_RIGHT,
1949 LIBINPUT_BUTTON_STATE_RELEASED);
1950
1951 libinput_dispatch(li);
1952
1953 litest_assert_empty_queue(li);
1954 }
1955 END_TEST
1956
START_TEST(clickpad_middleemulation_click_enable_while_down)1957 START_TEST(clickpad_middleemulation_click_enable_while_down)
1958 {
1959 struct litest_device *dev = litest_current_device();
1960 struct libinput *li = dev->libinput;
1961
1962 litest_enable_buttonareas(dev);
1963 litest_drain_events(li);
1964
1965 litest_touch_down(dev, 0, 49, 95);
1966 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1967 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1968
1969 litest_assert_button_event(li,
1970 BTN_MIDDLE,
1971 LIBINPUT_BUTTON_STATE_PRESSED);
1972
1973 litest_enable_middleemu(dev);
1974
1975 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1976 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1977 litest_touch_up(dev, 0);
1978
1979 litest_assert_button_event(li,
1980 BTN_MIDDLE,
1981 LIBINPUT_BUTTON_STATE_RELEASED);
1982
1983 libinput_dispatch(li);
1984
1985 litest_assert_empty_queue(li);
1986
1987 litest_touch_down(dev, 0, 49, 95);
1988 litest_event(dev, EV_KEY, BTN_LEFT, 1);
1989 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1990 litest_event(dev, EV_KEY, BTN_LEFT, 0);
1991 litest_event(dev, EV_SYN, SYN_REPORT, 0);
1992 litest_touch_up(dev, 0);
1993
1994 litest_assert_button_event(li,
1995 BTN_LEFT,
1996 LIBINPUT_BUTTON_STATE_PRESSED);
1997 litest_assert_button_event(li,
1998 BTN_LEFT,
1999 LIBINPUT_BUTTON_STATE_RELEASED);
2000
2001 libinput_dispatch(li);
2002 }
2003 END_TEST
2004
START_TEST(clickpad_middleemulation_click_disable_while_down)2005 START_TEST(clickpad_middleemulation_click_disable_while_down)
2006 {
2007 struct litest_device *dev = litest_current_device();
2008 struct libinput *li = dev->libinput;
2009
2010 litest_enable_buttonareas(dev);
2011 litest_enable_middleemu(dev);
2012
2013 litest_drain_events(li);
2014
2015 litest_touch_down(dev, 0, 30, 95);
2016 litest_touch_down(dev, 1, 70, 95);
2017 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2018 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2019
2020 litest_assert_button_event(li,
2021 BTN_MIDDLE,
2022 LIBINPUT_BUTTON_STATE_PRESSED);
2023
2024 litest_disable_middleemu(dev);
2025
2026 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2027 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2028 litest_touch_up(dev, 0);
2029 litest_touch_up(dev, 1);
2030
2031 litest_assert_button_event(li,
2032 BTN_MIDDLE,
2033 LIBINPUT_BUTTON_STATE_RELEASED);
2034 libinput_dispatch(li);
2035
2036 litest_assert_empty_queue(li);
2037
2038 litest_touch_down(dev, 0, 49, 95);
2039 litest_event(dev, EV_KEY, BTN_LEFT, 1);
2040 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2041 litest_event(dev, EV_KEY, BTN_LEFT, 0);
2042 litest_event(dev, EV_SYN, SYN_REPORT, 0);
2043 litest_touch_up(dev, 0);
2044
2045 litest_assert_button_event(li,
2046 BTN_MIDDLE,
2047 LIBINPUT_BUTTON_STATE_PRESSED);
2048 litest_assert_button_event(li,
2049 BTN_MIDDLE,
2050 LIBINPUT_BUTTON_STATE_RELEASED);
2051
2052 libinput_dispatch(li);
2053 }
2054 END_TEST
2055
START_TEST(touchpad_non_clickpad_detection)2056 START_TEST(touchpad_non_clickpad_detection)
2057 {
2058 struct libinput *li;
2059 struct libinput_device *device;
2060 struct libevdev_uinput *uinput;
2061 static struct input_absinfo absinfo[] = {
2062 { ABS_X, 1472, 5472, 0, 0, 75 },
2063 { ABS_Y, 1408, 4448, 0, 0, 129 },
2064 { ABS_PRESSURE, 0, 255, 0, 0, 0 },
2065 { ABS_TOOL_WIDTH, 0, 15, 0, 0, 0 },
2066 { ABS_MT_SLOT, 0, 1, 0, 0, 0 },
2067 { ABS_MT_POSITION_X, 1472, 5472, 0, 0, 75 },
2068 { ABS_MT_POSITION_Y, 1408, 4448, 0, 0, 129 },
2069 { ABS_MT_TRACKING_ID, 0, 65535, 0, 0, 0 },
2070 { ABS_MT_PRESSURE, 0, 255, 0, 0, 0 },
2071 { .value = -1 }
2072 };
2073 uint32_t methods;
2074
2075 /* Create a touchpad with only a left button but missing
2076 * INPUT_PROP_BUTTONPAD. We should treat this as clickpad.
2077 */
2078 uinput = litest_create_uinput_abs_device("litest NonClickpad",
2079 NULL,
2080 absinfo,
2081 EV_KEY, BTN_LEFT,
2082 EV_KEY, BTN_TOOL_FINGER,
2083 EV_KEY, BTN_TOUCH,
2084 -1);
2085
2086 li = litest_create_context();
2087 device = libinput_path_add_device(li,
2088 libevdev_uinput_get_devnode(uinput));
2089
2090 methods = libinput_device_config_click_get_methods(device);
2091 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
2092 ck_assert(methods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
2093
2094
2095 libinput_path_remove_device(device);
2096 libevdev_uinput_destroy(uinput);
2097 litest_destroy_context(li);
2098 }
2099 END_TEST
2100
START_TEST(touchpad_clickpad_detection)2101 START_TEST(touchpad_clickpad_detection)
2102 {
2103 struct litest_device *dev;
2104 uint32_t methods;
2105 int codes[] = {
2106 INPUT_PROP_MAX, INPUT_PROP_BUTTONPAD,
2107 -1, -1,
2108 };
2109
2110 /* Create a device with LR buttons and INPUT_PROP_BUTTONPAD set - we
2111 * should ignore the property and assume it's a non-clickpad.
2112 * Only way to check that is to verify no click methods are set.
2113 */
2114 dev = litest_create_device_with_overrides(LITEST_SYNAPTICS_TOUCHPAD,
2115 "litest Fake Clickpad",
2116 NULL, NULL, codes);
2117
2118 methods = libinput_device_config_click_get_methods(dev->libinput_device);
2119 ck_assert(methods == 0);
2120 litest_delete_device(dev);
2121 }
2122 END_TEST
2123
TEST_COLLECTION(touchpad_buttons)2124 TEST_COLLECTION(touchpad_buttons)
2125 {
2126 struct range finger_count = {1, 4};
2127
2128 litest_add(touchpad_button, LITEST_TOUCHPAD, LITEST_CLICKPAD);
2129
2130 litest_add(touchpad_1fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY);
2131 litest_add(touchpad_1fg_clickfinger_no_touch, LITEST_CLICKPAD, LITEST_ANY);
2132 litest_add(touchpad_2fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY);
2133 litest_add(touchpad_3fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY);
2134 litest_add(touchpad_3fg_clickfinger_btntool, LITEST_CLICKPAD, LITEST_ANY);
2135 litest_add(touchpad_4fg_clickfinger, LITEST_CLICKPAD, LITEST_ANY);
2136 litest_add(touchpad_4fg_clickfinger_btntool_2slots, LITEST_CLICKPAD, LITEST_ANY);
2137 litest_add(touchpad_4fg_clickfinger_btntool_3slots, LITEST_CLICKPAD, LITEST_ANY);
2138 litest_add(touchpad_2fg_clickfinger_distance, LITEST_CLICKPAD, LITEST_ANY);
2139 litest_add(touchpad_3fg_clickfinger_distance, LITEST_CLICKPAD, LITEST_ANY);
2140 litest_add(touchpad_3fg_clickfinger_distance_btntool, LITEST_CLICKPAD, LITEST_ANY);
2141 litest_add_for_device(touchpad_2fg_clickfinger_bottom, LITEST_SYNAPTICS_TOPBUTTONPAD);
2142 litest_add(touchpad_clickfinger_to_area_method, LITEST_CLICKPAD, LITEST_ANY);
2143 litest_add(touchpad_clickfinger_to_area_method_while_down, LITEST_CLICKPAD, LITEST_ANY);
2144 litest_add(touchpad_area_to_clickfinger_method, LITEST_CLICKPAD, LITEST_ANY);
2145 litest_add(touchpad_area_to_clickfinger_method_while_down, LITEST_CLICKPAD, LITEST_ANY);
2146 /* run those two for the T440 one only so we don't have to worry
2147 * about small touchpads messing with thumb detection expectations */
2148 litest_add_for_device(touchpad_clickfinger_3fg_tool_position, LITEST_SYNAPTICS_TOPBUTTONPAD);
2149 litest_add_for_device(touchpad_clickfinger_4fg_tool_position, LITEST_SYNAPTICS_TOPBUTTONPAD);
2150
2151 litest_add_for_device(touchpad_clickfinger_appletouch_config, LITEST_APPLETOUCH);
2152 litest_add_for_device(touchpad_clickfinger_appletouch_1fg, LITEST_APPLETOUCH);
2153 litest_add_for_device(touchpad_clickfinger_appletouch_2fg, LITEST_APPLETOUCH);
2154 litest_add_for_device(touchpad_clickfinger_appletouch_3fg, LITEST_APPLETOUCH);
2155
2156 litest_add_ranged(touchpad_clickfinger_click_drag, LITEST_CLICKPAD, LITEST_ANY, &finger_count);
2157
2158 litest_add(touchpad_click_defaults_clickfinger, LITEST_APPLE_CLICKPAD, LITEST_ANY);
2159 litest_add(touchpad_click_defaults_btnarea, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2160 litest_add(touchpad_click_defaults_none, LITEST_TOUCHPAD, LITEST_CLICKPAD);
2161 litest_add(touchpad_click_defaults_none, LITEST_ANY, LITEST_TOUCHPAD);
2162
2163 litest_add(touchpad_btn_left, LITEST_TOUCHPAD|LITEST_BUTTON, LITEST_CLICKPAD);
2164 litest_add(clickpad_btn_left, LITEST_CLICKPAD, LITEST_ANY);
2165 litest_add(clickpad_click_n_drag, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
2166 litest_add(clickpad_finger_pin, LITEST_CLICKPAD, LITEST_ANY);
2167
2168 litest_add(clickpad_softbutton_left, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2169 litest_add(clickpad_softbutton_middle, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2170 litest_add(clickpad_softbutton_right, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2171 litest_add(clickpad_softbutton_left_tap_n_drag, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2172 litest_add(clickpad_softbutton_right_tap_n_drag, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2173 litest_add(clickpad_softbutton_left_1st_fg_move, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2174 litest_add(clickpad_softbutton_left_2nd_fg_move, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2175 litest_add(clickpad_softbutton_left_to_right, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2176 litest_add(clickpad_softbutton_right_to_left, LITEST_CLICKPAD, LITEST_APPLE_CLICKPAD);
2177 litest_add(clickpad_softbutton_hover_into_buttons, LITEST_CLICKPAD|LITEST_HOVER, LITEST_APPLE_CLICKPAD);
2178
2179 litest_add(clickpad_topsoftbuttons_left, LITEST_TOPBUTTONPAD, LITEST_ANY);
2180 litest_add(clickpad_topsoftbuttons_right, LITEST_TOPBUTTONPAD, LITEST_ANY);
2181 litest_add(clickpad_topsoftbuttons_middle, LITEST_TOPBUTTONPAD, LITEST_ANY);
2182 litest_add(clickpad_topsoftbuttons_move_out_leftclick, LITEST_TOPBUTTONPAD, LITEST_ANY);
2183 litest_add(clickpad_topsoftbuttons_move_out_leftclick_before_timeout, LITEST_TOPBUTTONPAD, LITEST_ANY);
2184 litest_add(clickpad_topsoftbuttons_clickfinger, LITEST_TOPBUTTONPAD, LITEST_ANY);
2185 litest_add(clickpad_topsoftbuttons_clickfinger_dev_disabled, LITEST_TOPBUTTONPAD, LITEST_ANY);
2186
2187 litest_add(clickpad_middleemulation_config_delayed, LITEST_CLICKPAD, LITEST_ANY);
2188 litest_add(clickpad_middleemulation_click, LITEST_CLICKPAD, LITEST_ANY);
2189 litest_add(clickpad_middleemulation_click_middle_left, LITEST_CLICKPAD, LITEST_ANY);
2190 litest_add(clickpad_middleemulation_click_middle_right, LITEST_CLICKPAD, LITEST_ANY);
2191 litest_add(clickpad_middleemulation_click_enable_while_down, LITEST_CLICKPAD, LITEST_ANY);
2192 litest_add(clickpad_middleemulation_click_disable_while_down, LITEST_CLICKPAD, LITEST_ANY);
2193
2194 litest_add_no_device(touchpad_clickpad_detection);
2195 litest_add_no_device(touchpad_non_clickpad_detection);
2196 }
2197