File: | dev/wscons/wstpad.c |
Warning: | line 942, column 2 The result of the left shift is undefined because the left operand is negative |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: wstpad.c,v 1.30 2021/03/24 18:28:24 bru Exp $ */ | ||||
2 | |||||
3 | /* | ||||
4 | * Copyright (c) 2015, 2016 Ulf Brosziewski | ||||
5 | * | ||||
6 | * Permission to use, copy, modify, and distribute this software for any | ||||
7 | * purpose with or without fee is hereby granted, provided that the above | ||||
8 | * copyright notice and this permission notice appear in all copies. | ||||
9 | * | ||||
10 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||||
11 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||||
12 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||||
13 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||||
14 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||||
15 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||||
16 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||||
17 | */ | ||||
18 | |||||
19 | /* | ||||
20 | * touchpad input processing | ||||
21 | */ | ||||
22 | |||||
23 | #include <sys/param.h> | ||||
24 | #include <sys/kernel.h> | ||||
25 | #include <sys/malloc.h> | ||||
26 | #include <sys/proc.h> | ||||
27 | #include <sys/systm.h> | ||||
28 | #include <sys/signalvar.h> | ||||
29 | #include <sys/timeout.h> | ||||
30 | |||||
31 | #include <dev/wscons/wsconsio.h> | ||||
32 | #include <dev/wscons/wsmousevar.h> | ||||
33 | #include <dev/wscons/wseventvar.h> | ||||
34 | #include <dev/wscons/wsmouseinput.h> | ||||
35 | |||||
36 | #define BTNMASK(n)((n) > 0 && (n) <= 32 ? 1 << ((n) - 1) : 0 ) ((n) > 0 && (n) <= 32 ? 1 << ((n) - 1) : 0) | ||||
37 | |||||
38 | #define LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) BTNMASK(1)((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) | ||||
39 | #define MIDDLEBTN((2) > 0 && (2) <= 32 ? 1 << ((2) - 1) : 0 ) BTNMASK(2)((2) > 0 && (2) <= 32 ? 1 << ((2) - 1) : 0 ) | ||||
40 | #define RIGHTBTN((3) > 0 && (3) <= 32 ? 1 << ((3) - 1) : 0 ) BTNMASK(3)((3) > 0 && (3) <= 32 ? 1 << ((3) - 1) : 0 ) | ||||
41 | |||||
42 | #define PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) | ||||
43 | |||||
44 | #define PRIMARYBTN_CLICKED(tp)((tp)->btns_sync & ((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0) & (tp)->btns) ((tp)->btns_sync & PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) & (tp)->btns) | ||||
45 | #define PRIMARYBTN_RELEASED(tp)((tp)->btns_sync & ((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0) & ~(tp)->btns) ((tp)->btns_sync & PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) & ~(tp)->btns) | ||||
46 | |||||
47 | #define IS_MT(tp)((tp)->features & (1 << 31)) ((tp)->features & WSTPAD_MT(1 << 31)) | ||||
48 | #define DISABLE(tp)((tp)->features & (1 << 7)) ((tp)->features & WSTPAD_DISABLE(1 << 7)) | ||||
49 | |||||
50 | /* | ||||
51 | * Ratios to the height or width of the touchpad surface, in | ||||
52 | * [*.12] fixed-point format: | ||||
53 | */ | ||||
54 | #define V_EDGE_RATIO_DEFAULT205 205 | ||||
55 | #define B_EDGE_RATIO_DEFAULT410 410 | ||||
56 | #define T_EDGE_RATIO_DEFAULT512 512 | ||||
57 | #define CENTER_RATIO_DEFAULT512 512 | ||||
58 | |||||
59 | #define TAP_MAXTIME_DEFAULT180 180 | ||||
60 | #define TAP_CLICKTIME_DEFAULT180 180 | ||||
61 | #define TAP_LOCKTIME_DEFAULT0 0 | ||||
62 | #define TAP_BTNMAP_SIZE3 3 | ||||
63 | |||||
64 | #define CLICKDELAY_MS20 20 | ||||
65 | #define FREEZE_MS100 100 | ||||
66 | #define MATCHINTERVAL_MS45 45 | ||||
67 | #define STOPINTERVAL_MS55 55 | ||||
68 | |||||
69 | #define MAG_LOW(10 << 12) (10 << 12) | ||||
70 | #define MAG_MEDIUM(18 << 12) (18 << 12) | ||||
71 | |||||
72 | enum tpad_handlers { | ||||
73 | SOFTBUTTON_HDLR, | ||||
74 | TOPBUTTON_HDLR, | ||||
75 | TAP_HDLR, | ||||
76 | F2SCROLL_HDLR, | ||||
77 | EDGESCROLL_HDLR, | ||||
78 | CLICK_HDLR, | ||||
79 | }; | ||||
80 | |||||
81 | enum tap_state { | ||||
82 | TAP_DETECT, | ||||
83 | TAP_IGNORE, | ||||
84 | TAP_LIFTED, | ||||
85 | TAP_2ND_TOUCH, | ||||
86 | TAP_LOCKED, | ||||
87 | TAP_NTH_TOUCH, | ||||
88 | }; | ||||
89 | |||||
90 | enum tpad_cmd { | ||||
91 | CLEAR_MOTION_DELTAS, | ||||
92 | SOFTBUTTON_DOWN, | ||||
93 | SOFTBUTTON_UP, | ||||
94 | TAPBUTTON_DOWN, | ||||
95 | TAPBUTTON_UP, | ||||
96 | TAPBUTTON_DOUBLECLK, | ||||
97 | VSCROLL, | ||||
98 | HSCROLL, | ||||
99 | }; | ||||
100 | |||||
101 | /* | ||||
102 | * tpad_touch.flags: | ||||
103 | */ | ||||
104 | #define L_EDGE(1 << 0) (1 << 0) | ||||
105 | #define R_EDGE(1 << 1) (1 << 1) | ||||
106 | #define T_EDGE(1 << 2) (1 << 2) | ||||
107 | #define B_EDGE(1 << 3) (1 << 3) | ||||
108 | #define THUMB(1 << 4) (1 << 4) | ||||
109 | |||||
110 | #define EDGES((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3)) (L_EDGE(1 << 0) | R_EDGE(1 << 1) | T_EDGE(1 << 2) | B_EDGE(1 << 3)) | ||||
111 | |||||
112 | /* | ||||
113 | * A touch is "centered" if it does not start and remain at the top | ||||
114 | * edge or one of the vertical edges. Two-finger scrolling and tapping | ||||
115 | * require that at least one touch is centered. | ||||
116 | */ | ||||
117 | #define CENTERED(t)(((t)->flags & ((1 << 0) | (1 << 1) | (1 << 2))) == 0) (((t)->flags & (L_EDGE(1 << 0) | R_EDGE(1 << 1) | T_EDGE(1 << 2))) == 0) | ||||
118 | |||||
119 | enum touchstates { | ||||
120 | TOUCH_NONE, | ||||
121 | TOUCH_BEGIN, | ||||
122 | TOUCH_UPDATE, | ||||
123 | TOUCH_END, | ||||
124 | }; | ||||
125 | |||||
126 | struct tpad_touch { | ||||
127 | u_int flags; | ||||
128 | enum touchstates state; | ||||
129 | int x; | ||||
130 | int y; | ||||
131 | int dir; | ||||
132 | struct timespec start; | ||||
133 | struct timespec match; | ||||
134 | struct position *pos; | ||||
135 | struct { | ||||
136 | int x; | ||||
137 | int y; | ||||
138 | struct timespec time; | ||||
139 | } orig; | ||||
140 | }; | ||||
141 | |||||
142 | /* | ||||
143 | * wstpad.features | ||||
144 | */ | ||||
145 | #define WSTPAD_SOFTBUTTONS(1 << 0) (1 << 0) | ||||
146 | #define WSTPAD_SOFTMBTN(1 << 1) (1 << 1) | ||||
147 | #define WSTPAD_TOPBUTTONS(1 << 2) (1 << 2) | ||||
148 | #define WSTPAD_TWOFINGERSCROLL(1 << 3) (1 << 3) | ||||
149 | #define WSTPAD_EDGESCROLL(1 << 4) (1 << 4) | ||||
150 | #define WSTPAD_HORIZSCROLL(1 << 5) (1 << 5) | ||||
151 | #define WSTPAD_SWAPSIDES(1 << 6) (1 << 6) | ||||
152 | #define WSTPAD_DISABLE(1 << 7) (1 << 7) | ||||
153 | |||||
154 | #define WSTPAD_MT(1 << 31) (1 << 31) | ||||
155 | |||||
156 | |||||
157 | struct wstpad { | ||||
158 | u_int features; | ||||
159 | u_int handlers; | ||||
160 | |||||
161 | /* | ||||
162 | * t always points into the tpad_touches array, which has at | ||||
163 | * least one element. If there is more than one, t selects | ||||
164 | * the pointer-controlling touch. | ||||
165 | */ | ||||
166 | struct tpad_touch *t; | ||||
167 | struct tpad_touch *tpad_touches; | ||||
168 | |||||
169 | u_int mtcycle; | ||||
170 | u_int ignore; | ||||
171 | |||||
172 | int contacts; | ||||
173 | int prev_contacts; | ||||
174 | u_int btns; | ||||
175 | u_int btns_sync; | ||||
176 | int ratio; | ||||
177 | |||||
178 | struct timespec time; | ||||
179 | |||||
180 | u_int freeze; | ||||
181 | struct timespec freeze_ts; | ||||
182 | |||||
183 | /* edge coordinates */ | ||||
184 | struct { | ||||
185 | int left; | ||||
186 | int right; | ||||
187 | int top; | ||||
188 | int bottom; | ||||
189 | int center; | ||||
190 | int center_left; | ||||
191 | int center_right; | ||||
192 | int low; | ||||
193 | } edge; | ||||
194 | |||||
195 | struct { | ||||
196 | /* ratios to the surface width or height */ | ||||
197 | int left_edge; | ||||
198 | int right_edge; | ||||
199 | int top_edge; | ||||
200 | int bottom_edge; | ||||
201 | int center_width; | ||||
202 | /* two-finger contacts */ | ||||
203 | int f2pressure; | ||||
204 | int f2width; | ||||
205 | } params; | ||||
206 | |||||
207 | /* handler state and configuration: */ | ||||
208 | |||||
209 | u_int softbutton; | ||||
210 | u_int sbtnswap; | ||||
211 | |||||
212 | struct { | ||||
213 | enum tap_state state; | ||||
214 | int contacts; | ||||
215 | int centered; | ||||
216 | u_int button; | ||||
217 | int maxdist; | ||||
218 | struct timeout to; | ||||
219 | /* parameters: */ | ||||
220 | struct timespec maxtime; | ||||
221 | int clicktime; | ||||
222 | int locktime; | ||||
223 | u_int btnmap[TAP_BTNMAP_SIZE3]; | ||||
224 | } tap; | ||||
225 | |||||
226 | struct { | ||||
227 | int dz; | ||||
228 | int dw; | ||||
229 | int hdist; | ||||
230 | int vdist; | ||||
231 | int mag; | ||||
232 | } scroll; | ||||
233 | }; | ||||
234 | |||||
235 | static const struct timespec match_interval = | ||||
236 | { .tv_sec = 0, .tv_nsec = MATCHINTERVAL_MS45 * 1000000 }; | ||||
237 | |||||
238 | static const struct timespec stop_interval = | ||||
239 | { .tv_sec = 0, .tv_nsec = STOPINTERVAL_MS55 * 1000000 }; | ||||
240 | |||||
241 | /* | ||||
242 | * Coordinates in the wstpad struct are "normalized" device coordinates, | ||||
243 | * the orientation is left-to-right and upward. | ||||
244 | */ | ||||
245 | static inline int | ||||
246 | normalize_abs(struct axis_filter *filter, int val) | ||||
247 | { | ||||
248 | return (filter->inv ? filter->inv - val : val); | ||||
249 | } | ||||
250 | |||||
251 | static inline int | ||||
252 | normalize_rel(struct axis_filter *filter, int val) | ||||
253 | { | ||||
254 | return (filter->inv ? -val : val); | ||||
255 | } | ||||
256 | |||||
257 | /* | ||||
258 | * Directions of motion are represented by numbers in the range 0 - 11, | ||||
259 | * corresponding to clockwise counted circle sectors: | ||||
260 | * | ||||
261 | * 11 | 0 | ||||
262 | * 10 | 1 | ||||
263 | * 9 | 2 | ||||
264 | * -------+------- | ||||
265 | * 8 | 3 | ||||
266 | * 7 | 4 | ||||
267 | * 6 | 5 | ||||
268 | * | ||||
269 | */ | ||||
270 | /* Tangent constants in [*.12] fixed-point format: */ | ||||
271 | #define TAN_DEG_607094 7094 | ||||
272 | #define TAN_DEG_302365 2365 | ||||
273 | |||||
274 | #define NORTH(d)((d) == 0 || (d) == 11) ((d) == 0 || (d) == 11) | ||||
275 | #define SOUTH(d)((d) == 5 || (d) == 6) ((d) == 5 || (d) == 6) | ||||
276 | #define EAST(d)((d) == 2 || (d) == 3) ((d) == 2 || (d) == 3) | ||||
277 | #define WEST(d)((d) == 8 || (d) == 9) ((d) == 8 || (d) == 9) | ||||
278 | |||||
279 | static inline int | ||||
280 | direction(int dx, int dy, int ratio) | ||||
281 | { | ||||
282 | int rdy, dir = -1; | ||||
283 | |||||
284 | if (dx || dy) { | ||||
285 | rdy = abs(dy) * ratio; | ||||
286 | if (abs(dx) * TAN_DEG_607094 < rdy) | ||||
287 | dir = 0; | ||||
288 | else if (abs(dx) * TAN_DEG_302365 < rdy) | ||||
289 | dir = 1; | ||||
290 | else | ||||
291 | dir = 2; | ||||
292 | if ((dx < 0) != (dy < 0)) | ||||
293 | dir = 5 - dir; | ||||
294 | if (dx < 0) | ||||
295 | dir += 6; | ||||
296 | } | ||||
297 | return dir; | ||||
298 | } | ||||
299 | |||||
300 | static inline int | ||||
301 | dircmp(int dir1, int dir2) | ||||
302 | { | ||||
303 | int diff = abs(dir1 - dir2); | ||||
304 | return (diff <= 6 ? diff : 12 - diff); | ||||
305 | } | ||||
306 | |||||
307 | /* | ||||
308 | * Update direction and timespec attributes for a touch. They are used to | ||||
309 | * determine whether it is moving - or resting - stably. | ||||
310 | * | ||||
311 | * The callers pass touches from the current frame and the touches that are | ||||
312 | * no longer present in the update cycle to this function. Even though this | ||||
313 | * ensures that pairs of zero deltas do not result from stale coordinates, | ||||
314 | * zero deltas do not reset the state immediately. A short time span - the | ||||
315 | * "stop interval" - must pass before the state is cleared, which is | ||||
316 | * necessary because some touchpads report intermediate stops when a touch | ||||
317 | * is moving very slowly. | ||||
318 | */ | ||||
319 | void | ||||
320 | wstpad_set_direction(struct wstpad *tp, struct tpad_touch *t, int dx, int dy) | ||||
321 | { | ||||
322 | int dir; | ||||
323 | struct timespec ts; | ||||
324 | |||||
325 | if (t->state != TOUCH_UPDATE) { | ||||
326 | t->dir = -1; | ||||
327 | memcpy(&t->start, &tp->time, sizeof(struct timespec))__builtin_memcpy((&t->start), (&tp->time), (sizeof (struct timespec))); | ||||
328 | return; | ||||
329 | } | ||||
330 | |||||
331 | dir = direction(dx, dy, tp->ratio); | ||||
332 | if (dir >= 0) { | ||||
333 | if (t->dir < 0 || dircmp(dir, t->dir) > 1) { | ||||
334 | memcpy(&t->start, &tp->time, sizeof(struct timespec))__builtin_memcpy((&t->start), (&tp->time), (sizeof (struct timespec))); | ||||
335 | } | ||||
336 | t->dir = dir; | ||||
337 | memcpy(&t->match, &tp->time, sizeof(struct timespec))__builtin_memcpy((&t->match), (&tp->time), (sizeof (struct timespec))); | ||||
338 | } else if (t->dir >= 0) { | ||||
339 | timespecsub(&tp->time, &t->match, &ts)do { (&ts)->tv_sec = (&tp->time)->tv_sec - ( &t->match)->tv_sec; (&ts)->tv_nsec = (&tp ->time)->tv_nsec - (&t->match)->tv_nsec; if ( (&ts)->tv_nsec < 0) { (&ts)->tv_sec--; (& ts)->tv_nsec += 1000000000L; } } while (0); | ||||
340 | if (timespeccmp(&ts, &stop_interval, >=)(((&ts)->tv_sec == (&stop_interval)->tv_sec) ? ( (&ts)->tv_nsec >= (&stop_interval)->tv_nsec) : ((&ts)->tv_sec >= (&stop_interval)->tv_sec ))) { | ||||
341 | t->dir = -1; | ||||
342 | memcpy(&t->start, &t->match, sizeof(struct timespec))__builtin_memcpy((&t->start), (&t->match), (sizeof (struct timespec))); | ||||
343 | } | ||||
344 | } | ||||
345 | } | ||||
346 | |||||
347 | /* | ||||
348 | * Make a rough, but quick estimation of the speed of a touch. Its | ||||
349 | * distance to the previous position is scaled by factors derived | ||||
350 | * from the average update rate and the deceleration parameter | ||||
351 | * (filter.dclr). The unit of the result is: | ||||
352 | * (filter.dclr / 100) device units per millisecond | ||||
353 | * | ||||
354 | * Magnitudes are returned in [*.12] fixed-point format. For purposes | ||||
355 | * of filtering, they are divided into medium and high speeds | ||||
356 | * (> MAG_MEDIUM), low speeds, and very low speeds (< MAG_LOW). | ||||
357 | * | ||||
358 | * The scale factors are not affected if deceleration is turned off. | ||||
359 | */ | ||||
360 | static inline int | ||||
361 | magnitude(struct wsmouseinput *input, int dx, int dy) | ||||
362 | { | ||||
363 | int h, v; | ||||
364 | |||||
365 | h = abs(dx) * input->filter.h.mag_scale; | ||||
366 | v = abs(dy) * input->filter.v.mag_scale; | ||||
367 | /* Return an "alpha-max-plus-beta-min" approximation: */ | ||||
368 | return (h >= v ? h + 3 * v / 8 : v + 3 * h / 8); | ||||
369 | } | ||||
370 | |||||
371 | /* | ||||
372 | * Treat a touch as stable if it is moving at a medium or high speed, | ||||
373 | * if it is moving continuously, or if it has stopped for a certain | ||||
374 | * time span. | ||||
375 | */ | ||||
376 | int | ||||
377 | wstpad_is_stable(struct wsmouseinput *input, struct tpad_touch *t) | ||||
378 | { | ||||
379 | struct timespec ts; | ||||
380 | |||||
381 | if (t->dir >= 0) { | ||||
382 | if (magnitude(input, t->pos->dx, t->pos->dy) > MAG_MEDIUM(18 << 12)) | ||||
383 | return (1); | ||||
384 | timespecsub(&t->match, &t->start, &ts)do { (&ts)->tv_sec = (&t->match)->tv_sec - ( &t->start)->tv_sec; (&ts)->tv_nsec = (&t ->match)->tv_nsec - (&t->start)->tv_nsec; if ( (&ts)->tv_nsec < 0) { (&ts)->tv_sec--; (& ts)->tv_nsec += 1000000000L; } } while (0); | ||||
385 | } else { | ||||
386 | timespecsub(&input->tp->time, &t->start, &ts)do { (&ts)->tv_sec = (&input->tp->time)-> tv_sec - (&t->start)->tv_sec; (&ts)->tv_nsec = (&input->tp->time)->tv_nsec - (&t->start )->tv_nsec; if ((&ts)->tv_nsec < 0) { (&ts)-> tv_sec--; (&ts)->tv_nsec += 1000000000L; } } while (0); | ||||
387 | } | ||||
388 | |||||
389 | return (timespeccmp(&ts, &match_interval, >=)(((&ts)->tv_sec == (&match_interval)->tv_sec) ? ((&ts)->tv_nsec >= (&match_interval)->tv_nsec ) : ((&ts)->tv_sec >= (&match_interval)->tv_sec ))); | ||||
390 | } | ||||
391 | |||||
392 | /* | ||||
393 | * If a touch starts in an edge area, pointer movement will be | ||||
394 | * suppressed as long as it stays in that area. | ||||
395 | */ | ||||
396 | static inline u_int | ||||
397 | edge_flags(struct wstpad *tp, int x, int y) | ||||
398 | { | ||||
399 | u_int flags = 0; | ||||
400 | |||||
401 | if (x < tp->edge.left) | ||||
402 | flags |= L_EDGE(1 << 0); | ||||
403 | else if (x >= tp->edge.right) | ||||
404 | flags |= R_EDGE(1 << 1); | ||||
405 | if (y < tp->edge.bottom) | ||||
406 | flags |= B_EDGE(1 << 3); | ||||
407 | else if (y >= tp->edge.top) | ||||
408 | flags |= T_EDGE(1 << 2); | ||||
409 | |||||
410 | return (flags); | ||||
411 | } | ||||
412 | |||||
413 | static inline struct tpad_touch * | ||||
414 | get_2nd_touch(struct wsmouseinput *input) | ||||
415 | { | ||||
416 | struct wstpad *tp = input->tp; | ||||
417 | int slot; | ||||
418 | |||||
419 | if (IS_MT(tp)((tp)->features & (1 << 31))) { | ||||
420 | slot = ffs(input->mt.touches & ~(input->mt.ptr | tp->ignore)); | ||||
421 | if (slot) | ||||
422 | return &tp->tpad_touches[--slot]; | ||||
423 | } | ||||
424 | return NULL((void *)0); | ||||
425 | } | ||||
426 | |||||
427 | /* Suppress pointer motion for a short period of time. */ | ||||
428 | static inline void | ||||
429 | set_freeze_ts(struct wstpad *tp, int sec, int ms) | ||||
430 | { | ||||
431 | tp->freeze_ts.tv_sec = sec; | ||||
432 | tp->freeze_ts.tv_nsec = ms * 1000000; | ||||
433 | timespecadd(&tp->time, &tp->freeze_ts, &tp->freeze_ts)do { (&tp->freeze_ts)->tv_sec = (&tp->time)-> tv_sec + (&tp->freeze_ts)->tv_sec; (&tp->freeze_ts )->tv_nsec = (&tp->time)->tv_nsec + (&tp-> freeze_ts)->tv_nsec; if ((&tp->freeze_ts)->tv_nsec >= 1000000000L) { (&tp->freeze_ts)->tv_sec++; ( &tp->freeze_ts)->tv_nsec -= 1000000000L; } } while ( 0); | ||||
434 | } | ||||
435 | |||||
436 | |||||
437 | /* Return TRUE if two-finger- or edge-scrolling would be valid. */ | ||||
438 | int | ||||
439 | wstpad_scroll_coords(struct wsmouseinput *input, int *dx, int *dy) | ||||
440 | { | ||||
441 | struct wstpad *tp = input->tp; | ||||
442 | |||||
443 | if (tp->contacts != tp->prev_contacts || tp->btns || tp->btns_sync) { | ||||
444 | tp->scroll.dz = 0; | ||||
445 | tp->scroll.dw = 0; | ||||
446 | return (0); | ||||
447 | } | ||||
448 | if ((input->motion.sync & SYNC_POSITION((1 << 1) | (1 << 2))) == 0) | ||||
449 | return (0); | ||||
450 | /* | ||||
451 | * Try to exclude accidental scroll events by checking whether the | ||||
452 | * pointer-controlling touch is stable. The check, which may cause | ||||
453 | * a short delay, is only applied initially, a touch that stops and | ||||
454 | * resumes scrolling is not affected. | ||||
455 | */ | ||||
456 | if (tp->scroll.dz || tp->scroll.dw || wstpad_is_stable(input, tp->t)) { | ||||
457 | *dx = normalize_rel(&input->filter.h, input->motion.pos.dx); | ||||
458 | *dy = normalize_rel(&input->filter.v, input->motion.pos.dy); | ||||
459 | return (*dx || *dy); | ||||
460 | } | ||||
461 | |||||
462 | return (0); | ||||
463 | } | ||||
464 | |||||
465 | void | ||||
466 | wstpad_scroll(struct wstpad *tp, int dx, int dy, int mag, u_int *cmds) | ||||
467 | { | ||||
468 | int dz, dw, n = 1; | ||||
469 | |||||
470 | /* | ||||
471 | * The function applies strong deceleration, but only to input with | ||||
472 | * very low speeds. A higher threshold might make applications | ||||
473 | * without support for precision scrolling appear unresponsive. | ||||
474 | */ | ||||
475 | mag = tp->scroll.mag = imin(MAG_MEDIUM(18 << 12), | ||||
476 | (mag + 3 * tp->scroll.mag) / 4); | ||||
477 | if (mag < MAG_LOW(10 << 12)) | ||||
478 | n = (MAG_LOW(10 << 12) - mag) / 4096 + 1; | ||||
479 | |||||
480 | if (dy && tp->scroll.vdist) { | ||||
481 | if (tp->scroll.dw) { | ||||
482 | /* | ||||
483 | * Before switching the axis, wstpad_scroll_coords() | ||||
484 | * should check again whether the movement is stable. | ||||
485 | */ | ||||
486 | tp->scroll.dw = 0; | ||||
487 | return; | ||||
488 | } | ||||
489 | dz = -dy * 4096 / (tp->scroll.vdist * n); | ||||
490 | if (tp->scroll.dz) { | ||||
491 | if ((dy < 0) != (tp->scroll.dz > 0)) | ||||
492 | tp->scroll.dz = -tp->scroll.dz; | ||||
493 | dz = (dz + 3 * tp->scroll.dz) / 4; | ||||
494 | } | ||||
495 | if (dz) { | ||||
496 | tp->scroll.dz = dz; | ||||
497 | *cmds |= 1 << VSCROLL; | ||||
498 | } | ||||
499 | |||||
500 | } else if (dx && tp->scroll.hdist) { | ||||
501 | if (tp->scroll.dz) { | ||||
502 | tp->scroll.dz = 0; | ||||
503 | return; | ||||
504 | } | ||||
505 | dw = dx * 4096 / (tp->scroll.hdist * n); | ||||
506 | if (tp->scroll.dw) { | ||||
507 | if ((dx > 0) != (tp->scroll.dw > 0)) | ||||
508 | tp->scroll.dw = -tp->scroll.dw; | ||||
509 | dw = (dw + 3 * tp->scroll.dw) / 4; | ||||
510 | } | ||||
511 | if (dw) { | ||||
512 | tp->scroll.dw = dw; | ||||
513 | *cmds |= 1 << HSCROLL; | ||||
514 | } | ||||
515 | } | ||||
516 | } | ||||
517 | |||||
518 | void | ||||
519 | wstpad_f2scroll(struct wsmouseinput *input, u_int *cmds) | ||||
520 | { | ||||
521 | struct wstpad *tp = input->tp; | ||||
522 | struct tpad_touch *t2; | ||||
523 | int dir, dx, dy, centered; | ||||
524 | |||||
525 | if (tp->ignore == 0) { | ||||
526 | if (tp->contacts != 2) | ||||
527 | return; | ||||
528 | } else if (tp->contacts != 3 || (tp->ignore == input->mt.ptr)) { | ||||
529 | return; | ||||
530 | } | ||||
531 | |||||
532 | if (!wstpad_scroll_coords(input, &dx, &dy)) | ||||
533 | return; | ||||
534 | |||||
535 | dir = tp->t->dir; | ||||
536 | if (!(NORTH(dir)((dir) == 0 || (dir) == 11) || SOUTH(dir)((dir) == 5 || (dir) == 6))) | ||||
537 | dy = 0; | ||||
538 | if (!(EAST(dir)((dir) == 2 || (dir) == 3) || WEST(dir)((dir) == 8 || (dir) == 9))) | ||||
539 | dx = 0; | ||||
540 | |||||
541 | if (dx || dy) { | ||||
542 | centered = CENTERED(tp->t)(((tp->t)->flags & ((1 << 0) | (1 << 1) | (1 << 2))) == 0); | ||||
543 | if (IS_MT(tp)((tp)->features & (1 << 31))) { | ||||
544 | t2 = get_2nd_touch(input); | ||||
545 | if (t2 == NULL((void *)0)) | ||||
546 | return; | ||||
547 | dir = t2->dir; | ||||
548 | if ((dy > 0 && !NORTH(dir)((dir) == 0 || (dir) == 11)) || (dy < 0 && !SOUTH(dir)((dir) == 5 || (dir) == 6))) | ||||
549 | return; | ||||
550 | if ((dx > 0 && !EAST(dir)((dir) == 2 || (dir) == 3)) || (dx < 0 && !WEST(dir)((dir) == 8 || (dir) == 9))) | ||||
551 | return; | ||||
552 | if (!wstpad_is_stable(input, t2) && | ||||
553 | !(tp->scroll.dz || tp->scroll.dw)) | ||||
554 | return; | ||||
555 | centered |= CENTERED(t2)(((t2)->flags & ((1 << 0) | (1 << 1) | (1 << 2))) == 0); | ||||
556 | } | ||||
557 | if (centered) { | ||||
558 | wstpad_scroll(tp, dx, dy, | ||||
559 | magnitude(input, dx, dy), cmds); | ||||
560 | set_freeze_ts(tp, 0, FREEZE_MS100); | ||||
561 | } | ||||
562 | } | ||||
563 | } | ||||
564 | |||||
565 | void | ||||
566 | wstpad_edgescroll(struct wsmouseinput *input, u_int *cmds) | ||||
567 | { | ||||
568 | struct wstpad *tp = input->tp; | ||||
569 | struct tpad_touch *t = tp->t; | ||||
570 | u_int v_edge, b_edge; | ||||
571 | int dx, dy; | ||||
572 | |||||
573 | if (!wstpad_scroll_coords(input, &dx, &dy) || tp->contacts != 1) | ||||
574 | return; | ||||
575 | |||||
576 | v_edge = (tp->features & WSTPAD_SWAPSIDES(1 << 6)) ? L_EDGE(1 << 0) : R_EDGE(1 << 1); | ||||
577 | b_edge = (tp->features & WSTPAD_HORIZSCROLL(1 << 5)) ? B_EDGE(1 << 3) : 0; | ||||
578 | |||||
579 | if ((t->flags & v_edge) == 0) | ||||
580 | dy = 0; | ||||
581 | if ((t->flags & b_edge) == 0) | ||||
582 | dx = 0; | ||||
583 | |||||
584 | if (dx || dy) | ||||
585 | wstpad_scroll(tp, dx, dy, magnitude(input, dx, dy), cmds); | ||||
586 | } | ||||
587 | |||||
588 | static inline u_int | ||||
589 | sbtn(struct wstpad *tp, int x, int y) | ||||
590 | { | ||||
591 | if (y >= tp->edge.bottom) | ||||
592 | return (0); | ||||
593 | if ((tp->features & WSTPAD_SOFTMBTN(1 << 1)) | ||||
594 | && x >= tp->edge.center_left | ||||
595 | && x < tp->edge.center_right) | ||||
596 | return (MIDDLEBTN((2) > 0 && (2) <= 32 ? 1 << ((2) - 1) : 0 )); | ||||
597 | return ((x < tp->edge.center ? LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) : RIGHTBTN((3) > 0 && (3) <= 32 ? 1 << ((3) - 1) : 0 )) ^ tp->sbtnswap); | ||||
598 | } | ||||
599 | |||||
600 | static inline u_int | ||||
601 | top_sbtn(struct wstpad *tp, int x, int y) | ||||
602 | { | ||||
603 | if (y < tp->edge.top) | ||||
604 | return (0); | ||||
605 | if (x < tp->edge.center_left) | ||||
606 | return (LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) ^ tp->sbtnswap); | ||||
607 | return (x > tp->edge.center_right | ||||
608 | ? (RIGHTBTN((3) > 0 && (3) <= 32 ? 1 << ((3) - 1) : 0 ) ^ tp->sbtnswap) : MIDDLEBTN((2) > 0 && (2) <= 32 ? 1 << ((2) - 1) : 0 )); | ||||
609 | } | ||||
610 | |||||
611 | u_int | ||||
612 | wstpad_get_sbtn(struct wsmouseinput *input, int top) | ||||
613 | { | ||||
614 | struct wstpad *tp = input->tp; | ||||
615 | struct tpad_touch *t = tp->t; | ||||
616 | u_int btn; | ||||
617 | |||||
618 | btn = 0; | ||||
619 | if (tp->contacts) { | ||||
620 | btn = top ? top_sbtn(tp, t->x, t->y) : sbtn(tp, t->x, t->y); | ||||
621 | /* | ||||
622 | * If there is no middle-button area, but contacts in both | ||||
623 | * halves of the edge zone, generate a middle-button event: | ||||
624 | */ | ||||
625 | if (btn && IS_MT(tp)((tp)->features & (1 << 31)) && tp->contacts == 2 | ||||
626 | && !top && !(tp->features & WSTPAD_SOFTMBTN(1 << 1))) { | ||||
627 | if ((t = get_2nd_touch(input)) != NULL((void *)0)) | ||||
628 | btn |= sbtn(tp, t->x, t->y); | ||||
629 | if (btn == (LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) | RIGHTBTN((3) > 0 && (3) <= 32 ? 1 << ((3) - 1) : 0 ))) | ||||
630 | btn = MIDDLEBTN((2) > 0 && (2) <= 32 ? 1 << ((2) - 1) : 0 ); | ||||
631 | } | ||||
632 | } | ||||
633 | return (btn != PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) ? btn : 0); | ||||
634 | } | ||||
635 | |||||
636 | void | ||||
637 | wstpad_softbuttons(struct wsmouseinput *input, u_int *cmds, int hdlr) | ||||
638 | { | ||||
639 | struct wstpad *tp = input->tp; | ||||
640 | int top = (hdlr == TOPBUTTON_HDLR); | ||||
641 | |||||
642 | if (tp->softbutton && PRIMARYBTN_RELEASED(tp)((tp)->btns_sync & ((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0) & ~(tp)->btns)) { | ||||
643 | *cmds |= 1 << SOFTBUTTON_UP; | ||||
644 | return; | ||||
645 | } | ||||
646 | |||||
647 | if (tp->softbutton == 0 && PRIMARYBTN_CLICKED(tp)((tp)->btns_sync & ((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0) & (tp)->btns)) { | ||||
648 | tp->softbutton = wstpad_get_sbtn(input, top); | ||||
649 | if (tp->softbutton) | ||||
650 | *cmds |= 1 << SOFTBUTTON_DOWN; | ||||
651 | } | ||||
652 | } | ||||
653 | |||||
654 | int | ||||
655 | wstpad_is_tap(struct wstpad *tp, struct tpad_touch *t) | ||||
656 | { | ||||
657 | struct timespec ts; | ||||
658 | |||||
659 | timespecsub(&tp->time, &t->orig.time, &ts)do { (&ts)->tv_sec = (&tp->time)->tv_sec - ( &t->orig.time)->tv_sec; (&ts)->tv_nsec = (& tp->time)->tv_nsec - (&t->orig.time)->tv_nsec ; if ((&ts)->tv_nsec < 0) { (&ts)->tv_sec--; (&ts)->tv_nsec += 1000000000L; } } while (0); | ||||
660 | return (timespeccmp(&ts, &tp->tap.maxtime, <)(((&ts)->tv_sec == (&tp->tap.maxtime)->tv_sec ) ? ((&ts)->tv_nsec < (&tp->tap.maxtime)-> tv_nsec) : ((&ts)->tv_sec < (&tp->tap.maxtime )->tv_sec))); | ||||
661 | } | ||||
662 | |||||
663 | /* | ||||
664 | * At least one MT touch must remain close to its origin and end | ||||
665 | * in the main area. The same conditions apply to one-finger taps | ||||
666 | * on single-touch devices. | ||||
667 | */ | ||||
668 | void | ||||
669 | wstpad_tap_filter(struct wstpad *tp, struct tpad_touch *t) | ||||
670 | { | ||||
671 | int dx, dy, dist = 0; | ||||
672 | |||||
673 | if (IS_MT(tp)((tp)->features & (1 << 31)) || tp->tap.contacts == 1) { | ||||
674 | dx = abs(t->x - t->orig.x) << 12; | ||||
675 | dy = abs(t->y - t->orig.y) * tp->ratio; | ||||
676 | dist = (dx >= dy ? dx + 3 * dy / 8 : dy + 3 * dx / 8); | ||||
677 | } | ||||
678 | tp->tap.centered = (CENTERED(t)(((t)->flags & ((1 << 0) | (1 << 1) | (1 << 2))) == 0) && dist <= (tp->tap.maxdist << 12)); | ||||
679 | } | ||||
680 | |||||
681 | |||||
682 | /* | ||||
683 | * Return the oldest touch in the TOUCH_END state, or NULL. | ||||
684 | */ | ||||
685 | struct tpad_touch * | ||||
686 | wstpad_tap_touch(struct wsmouseinput *input) | ||||
687 | { | ||||
688 | struct wstpad *tp = input->tp; | ||||
689 | struct tpad_touch *s, *t = NULL((void *)0); | ||||
690 | u_int lifted; | ||||
691 | int slot; | ||||
692 | |||||
693 | if (IS_MT(tp)((tp)->features & (1 << 31))) { | ||||
694 | lifted = (input->mt.sync[MTS_TOUCH0] & ~input->mt.touches); | ||||
695 | FOREACHBIT(lifted, slot)for ((slot) = ffs(lifted) - 1; (slot) != -1; (slot) = ffs((lifted ) & (~1 << (slot))) - 1) { | ||||
696 | s = &tp->tpad_touches[slot]; | ||||
697 | if (tp->tap.state == TAP_DETECT && !tp->tap.centered) | ||||
698 | wstpad_tap_filter(tp, s); | ||||
699 | if (t == NULL((void *)0) || timespeccmp(&t->orig.time,(((&t->orig.time)->tv_sec == (&s->orig.time) ->tv_sec) ? ((&t->orig.time)->tv_nsec > (& s->orig.time)->tv_nsec) : ((&t->orig.time)->tv_sec > (&s->orig.time)->tv_sec)) | ||||
700 | &s->orig.time, >)(((&t->orig.time)->tv_sec == (&s->orig.time) ->tv_sec) ? ((&t->orig.time)->tv_nsec > (& s->orig.time)->tv_nsec) : ((&t->orig.time)->tv_sec > (&s->orig.time)->tv_sec))) | ||||
701 | t = s; | ||||
702 | } | ||||
703 | } else { | ||||
704 | if (tp->t->state == TOUCH_END) { | ||||
705 | t = tp->t; | ||||
706 | if (tp->tap.state == TAP_DETECT && !tp->tap.centered) | ||||
707 | wstpad_tap_filter(tp, t); | ||||
708 | } | ||||
709 | } | ||||
710 | |||||
711 | return (t); | ||||
712 | } | ||||
713 | |||||
714 | /* | ||||
715 | * If each contact in a sequence of contacts that overlap in time | ||||
716 | * is a tap, a button event may be generated when the number of | ||||
717 | * contacts drops to zero, or to one if there is a masked touch. | ||||
718 | */ | ||||
719 | static inline int | ||||
720 | tap_finished(struct wstpad *tp, int nmasked) | ||||
721 | { | ||||
722 | return (tp->contacts == nmasked | ||||
723 | && (nmasked == 0 || !wstpad_is_tap(tp, tp->t))); | ||||
724 | } | ||||
725 | |||||
726 | static inline u_int | ||||
727 | tap_btn(struct wstpad *tp, int nmasked) | ||||
728 | { | ||||
729 | int n = tp->tap.contacts - nmasked; | ||||
730 | |||||
731 | return (n <= TAP_BTNMAP_SIZE3 ? tp->tap.btnmap[n - 1] : 0); | ||||
732 | } | ||||
733 | |||||
734 | /* | ||||
735 | * This handler supports one-, two-, and three-finger-taps, which | ||||
736 | * are mapped to left-button, right-button and middle-button events, | ||||
737 | * respectively; moreover, it supports tap-and-drag operations with | ||||
738 | * "locked drags", which are finished by a timeout or a tap-to-end | ||||
739 | * gesture. | ||||
740 | */ | ||||
741 | void | ||||
742 | wstpad_tap(struct wsmouseinput *input, u_int *cmds) | ||||
743 | { | ||||
744 | struct wstpad *tp = input->tp; | ||||
745 | struct tpad_touch *t; | ||||
746 | int nmasked, err = 0; | ||||
747 | |||||
748 | if (tp->btns) { | ||||
749 | /* | ||||
750 | * Don't process tapping while hardware buttons are being | ||||
751 | * pressed. If the handler is not in its initial state, | ||||
752 | * release the "tap button". | ||||
753 | */ | ||||
754 | if (tp->tap.state > TAP_IGNORE) { | ||||
755 | timeout_del(&tp->tap.to); | ||||
756 | *cmds |= 1 << TAPBUTTON_UP; | ||||
757 | } | ||||
758 | /* | ||||
759 | * It might be possible to produce a click within the tap | ||||
760 | * timeout; ignore the current touch. | ||||
761 | */ | ||||
762 | tp->tap.state = TAP_IGNORE; | ||||
763 | tp->tap.contacts = 0; | ||||
764 | tp->tap.centered = 0; | ||||
765 | } | ||||
766 | |||||
767 | /* | ||||
768 | * If a touch from the bottom area is masked, reduce the | ||||
769 | * contact counts and ignore it. | ||||
770 | */ | ||||
771 | nmasked = (input->mt.ptr_mask ? 1 : 0); | ||||
772 | |||||
773 | /* | ||||
774 | * Only touches in the TOUCH_END state are relevant here. | ||||
775 | * t is NULL if no touch has been lifted. | ||||
776 | */ | ||||
777 | t = wstpad_tap_touch(input); | ||||
778 | |||||
779 | switch (tp->tap.state) { | ||||
780 | case TAP_DETECT: | ||||
781 | if (tp->contacts > tp->tap.contacts) | ||||
782 | tp->tap.contacts = tp->contacts; | ||||
783 | |||||
784 | if (t) { | ||||
785 | if (wstpad_is_tap(tp, t)) { | ||||
786 | if (tap_finished(tp, nmasked)) { | ||||
787 | if (tp->tap.centered) { | ||||
788 | tp->tap.state = TAP_LIFTED; | ||||
789 | tp->tap.button = | ||||
790 | tap_btn(tp, nmasked); | ||||
791 | } | ||||
792 | tp->tap.contacts = 0; | ||||
793 | tp->tap.centered = 0; | ||||
794 | } | ||||
795 | } else { | ||||
796 | if (tp->contacts > nmasked) | ||||
797 | tp->tap.state = TAP_IGNORE; | ||||
798 | tp->tap.contacts = 0; | ||||
799 | tp->tap.centered = 0; | ||||
800 | } | ||||
801 | if (tp->tap.state == TAP_LIFTED) { | ||||
802 | if (tp->tap.button != 0) { | ||||
803 | *cmds |= 1 << TAPBUTTON_DOWN; | ||||
804 | err = !timeout_add_msec(&tp->tap.to, | ||||
805 | tp->tap.clicktime); | ||||
806 | } else { | ||||
807 | tp->tap.state = TAP_DETECT; | ||||
808 | } | ||||
809 | } | ||||
810 | } | ||||
811 | break; | ||||
812 | |||||
813 | case TAP_IGNORE: | ||||
814 | if (tp->contacts == nmasked) | ||||
815 | tp->tap.state = TAP_DETECT; | ||||
816 | break; | ||||
817 | case TAP_LIFTED: | ||||
818 | if (tp->contacts > nmasked) { | ||||
819 | timeout_del(&tp->tap.to); | ||||
820 | if (tp->tap.button == LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 )) { | ||||
821 | tp->tap.state = TAP_2ND_TOUCH; | ||||
822 | } else { | ||||
823 | *cmds |= 1 << TAPBUTTON_UP; | ||||
824 | tp->tap.state = TAP_DETECT; | ||||
825 | } | ||||
826 | } | ||||
827 | break; | ||||
828 | case TAP_2ND_TOUCH: | ||||
829 | if (t) { | ||||
830 | if (wstpad_is_tap(tp, t)) { | ||||
831 | *cmds |= 1 << TAPBUTTON_DOUBLECLK; | ||||
832 | tp->tap.state = TAP_LIFTED; | ||||
833 | err = !timeout_add_msec(&tp->tap.to, | ||||
834 | CLICKDELAY_MS20); | ||||
835 | } else if (tp->contacts == nmasked) { | ||||
836 | if (tp->tap.locktime == 0) { | ||||
837 | *cmds |= 1 << TAPBUTTON_UP; | ||||
838 | tp->tap.state = TAP_DETECT; | ||||
839 | } else { | ||||
840 | tp->tap.state = TAP_LOCKED; | ||||
841 | err = !timeout_add_msec(&tp->tap.to, | ||||
842 | tp->tap.locktime); | ||||
843 | } | ||||
844 | } | ||||
845 | } else if (tp->contacts != nmasked + 1) { | ||||
846 | *cmds |= 1 << TAPBUTTON_UP; | ||||
847 | tp->tap.state = TAP_DETECT; | ||||
848 | } | ||||
849 | break; | ||||
850 | case TAP_LOCKED: | ||||
851 | if (tp->contacts > nmasked) { | ||||
852 | timeout_del(&tp->tap.to); | ||||
853 | tp->tap.state = TAP_NTH_TOUCH; | ||||
854 | } | ||||
855 | break; | ||||
856 | case TAP_NTH_TOUCH: | ||||
857 | if (t) { | ||||
858 | if (wstpad_is_tap(tp, t)) { | ||||
859 | /* "tap-to-end" */ | ||||
860 | *cmds |= 1 << TAPBUTTON_UP; | ||||
861 | tp->tap.state = TAP_DETECT; | ||||
862 | } else if (tp->contacts == nmasked) { | ||||
863 | tp->tap.state = TAP_LOCKED; | ||||
864 | err = !timeout_add_msec(&tp->tap.to, | ||||
865 | tp->tap.locktime); | ||||
866 | } | ||||
867 | } else if (tp->contacts != nmasked + 1) { | ||||
868 | *cmds |= 1 << TAPBUTTON_UP; | ||||
869 | tp->tap.state = TAP_DETECT; | ||||
870 | } | ||||
871 | break; | ||||
872 | } | ||||
873 | |||||
874 | if (err) { /* Did timeout_add fail? */ | ||||
875 | if (tp->tap.state == TAP_LIFTED) | ||||
876 | *cmds &= ~(1 << TAPBUTTON_DOWN); | ||||
877 | else | ||||
878 | *cmds |= 1 << TAPBUTTON_UP; | ||||
879 | |||||
880 | tp->tap.state = TAP_DETECT; | ||||
881 | } | ||||
882 | } | ||||
883 | |||||
884 | void | ||||
885 | wstpad_tap_timeout(void *p) | ||||
886 | { | ||||
887 | struct wsmouseinput *input = p; | ||||
888 | struct wstpad *tp = input->tp; | ||||
889 | struct evq_access evq; | ||||
890 | u_int btn; | ||||
891 | int s; | ||||
892 | |||||
893 | s = spltty()splraise(0x9); | ||||
894 | evq.evar = *input->evar; | ||||
895 | if (evq.evar != NULL((void *)0) && tp != NULL((void *)0) && | ||||
896 | (tp->tap.state == TAP_LIFTED || tp->tap.state == TAP_LOCKED)) { | ||||
897 | tp->tap.state = TAP_DETECT; | ||||
898 | input->sbtn.buttons &= ~tp->tap.button; | ||||
899 | btn = ffs(tp->tap.button) - 1; | ||||
900 | evq.put = evq.evar->put; | ||||
901 | evq.result = EVQ_RESULT_NONE0; | ||||
902 | getnanotime(&evq.ts); | ||||
903 | wsmouse_evq_put(&evq, BTN_UP_EV4, btn); | ||||
904 | wsmouse_evq_put(&evq, SYNC_EV18, 0); | ||||
905 | if (evq.result == EVQ_RESULT_SUCCESS1) { | ||||
906 | if (input->flags & LOG_EVENTS(1 << 20)) { | ||||
907 | wsmouse_log_events(input, &evq); | ||||
908 | } | ||||
909 | evq.evar->put = evq.put; | ||||
910 | WSEVENT_WAKEUP(evq.evar){ selwakeup(&(evq.evar)->sel); if ((evq.evar)->wanted ) { (evq.evar)->wanted = 0; wakeup((caddr_t)(evq.evar)); } if ((evq.evar)->async) pgsigio(&(evq.evar)->sigio, 23, 0); }; | ||||
911 | } else { | ||||
912 | input->sbtn.sync |= tp->tap.button; | ||||
913 | } | ||||
914 | } | ||||
915 | splx(s)spllower(s); | ||||
916 | } | ||||
917 | |||||
918 | /* | ||||
919 | * Suppress accidental pointer movements after a click on a clickpad. | ||||
920 | */ | ||||
921 | void | ||||
922 | wstpad_click(struct wsmouseinput *input) | ||||
923 | { | ||||
924 | struct wstpad *tp = input->tp; | ||||
925 | |||||
926 | if (tp->contacts == 1 && | ||||
927 | (PRIMARYBTN_CLICKED(tp)((tp)->btns_sync & ((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0) & (tp)->btns) || PRIMARYBTN_RELEASED(tp)((tp)->btns_sync & ((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0) & ~(tp)->btns))) | ||||
928 | set_freeze_ts(tp, 0, FREEZE_MS100); | ||||
929 | } | ||||
930 | |||||
931 | /* | ||||
932 | * Translate the "command" bits into the sync-state of wsmouse, or into | ||||
933 | * wscons events. | ||||
934 | */ | ||||
935 | void | ||||
936 | wstpad_cmds(struct wsmouseinput *input, struct evq_access *evq, u_int cmds) | ||||
937 | { | ||||
938 | struct wstpad *tp = input->tp; | ||||
939 | u_int btn, sbtns_dn = 0, sbtns_up = 0; | ||||
940 | int n; | ||||
941 | |||||
942 | FOREACHBIT(cmds, n)for ((n) = ffs(cmds) - 1; (n) != -1; (n) = ffs((cmds) & ( ~1 << (n))) - 1) { | ||||
| |||||
943 | switch (n) { | ||||
944 | case CLEAR_MOTION_DELTAS: | ||||
945 | input->motion.dx = input->motion.dy = 0; | ||||
946 | if (input->motion.dz == 0 && input->motion.dw == 0) | ||||
947 | input->motion.sync &= ~SYNC_DELTAS(1 << 0); | ||||
948 | continue; | ||||
949 | case SOFTBUTTON_DOWN: | ||||
950 | input->btn.sync &= ~PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ); | ||||
951 | sbtns_dn |= tp->softbutton; | ||||
952 | continue; | ||||
953 | case SOFTBUTTON_UP: | ||||
954 | input->btn.sync &= ~PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ); | ||||
955 | sbtns_up |= tp->softbutton; | ||||
956 | tp->softbutton = 0; | ||||
957 | continue; | ||||
958 | case TAPBUTTON_DOWN: | ||||
959 | sbtns_dn |= tp->tap.button; | ||||
960 | continue; | ||||
961 | case TAPBUTTON_UP: | ||||
962 | sbtns_up |= tp->tap.button; | ||||
963 | continue; | ||||
964 | case TAPBUTTON_DOUBLECLK: | ||||
965 | /* | ||||
966 | * We cannot add the final BTN_UP event here, a | ||||
967 | * delay is required. This is the reason why the | ||||
968 | * tap handler returns from the 2ND_TOUCH state | ||||
969 | * into the LIFTED state with a short timeout | ||||
970 | * (CLICKDELAY_MS). | ||||
971 | */ | ||||
972 | btn = ffs(PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 )) - 1; | ||||
973 | wsmouse_evq_put(evq, BTN_UP_EV4, btn); | ||||
974 | wsmouse_evq_put(evq, SYNC_EV18, 0); | ||||
975 | wsmouse_evq_put(evq, BTN_DOWN_EV5, btn); | ||||
976 | continue; | ||||
977 | case HSCROLL: | ||||
978 | input->motion.dw = tp->scroll.dw; | ||||
979 | input->motion.sync |= SYNC_DELTAS(1 << 0); | ||||
980 | continue; | ||||
981 | case VSCROLL: | ||||
982 | input->motion.dz = tp->scroll.dz; | ||||
983 | input->motion.sync |= SYNC_DELTAS(1 << 0); | ||||
984 | continue; | ||||
985 | default: | ||||
986 | printf("[wstpad] invalid cmd %d\n", n); | ||||
987 | break; | ||||
988 | } | ||||
989 | } | ||||
990 | if (sbtns_dn || sbtns_up) { | ||||
991 | input->sbtn.buttons |= sbtns_dn; | ||||
992 | input->sbtn.buttons &= ~sbtns_up; | ||||
993 | input->sbtn.sync |= (sbtns_dn | sbtns_up); | ||||
994 | } | ||||
995 | } | ||||
996 | |||||
997 | |||||
998 | /* | ||||
999 | * Set the state of touches that have ended. TOUCH_END is a transitional | ||||
1000 | * state and will be changed to TOUCH_NONE before process_input() returns. | ||||
1001 | */ | ||||
1002 | static inline void | ||||
1003 | clear_touchstates(struct wsmouseinput *input, enum touchstates state) | ||||
1004 | { | ||||
1005 | u_int touches; | ||||
1006 | int slot; | ||||
1007 | |||||
1008 | touches = input->mt.sync[MTS_TOUCH0] & ~input->mt.touches; | ||||
1009 | FOREACHBIT(touches, slot)for ((slot) = ffs(touches) - 1; (slot) != -1; (slot) = ffs((touches ) & (~1 << (slot))) - 1) | ||||
1010 | input->tp->tpad_touches[slot].state = state; | ||||
1011 | } | ||||
1012 | |||||
1013 | void | ||||
1014 | wstpad_mt_inputs(struct wsmouseinput *input) | ||||
1015 | { | ||||
1016 | struct wstpad *tp = input->tp; | ||||
1017 | struct tpad_touch *t; | ||||
1018 | int slot, dx, dy; | ||||
1019 | u_int touches, inactive; | ||||
1020 | |||||
1021 | /* TOUCH_BEGIN */ | ||||
1022 | touches = input->mt.touches & input->mt.sync[MTS_TOUCH0]; | ||||
1023 | FOREACHBIT(touches, slot)for ((slot) = ffs(touches) - 1; (slot) != -1; (slot) = ffs((touches ) & (~1 << (slot))) - 1) { | ||||
1024 | t = &tp->tpad_touches[slot]; | ||||
1025 | t->state = TOUCH_BEGIN; | ||||
1026 | t->x = normalize_abs(&input->filter.h, t->pos->x); | ||||
1027 | t->y = normalize_abs(&input->filter.v, t->pos->y); | ||||
1028 | t->orig.x = t->x; | ||||
1029 | t->orig.y = t->y; | ||||
1030 | memcpy(&t->orig.time, &tp->time, sizeof(struct timespec))__builtin_memcpy((&t->orig.time), (&tp->time), ( sizeof(struct timespec))); | ||||
1031 | t->flags = edge_flags(tp, t->x, t->y); | ||||
1032 | wstpad_set_direction(tp, t, 0, 0); | ||||
1033 | } | ||||
1034 | |||||
1035 | /* TOUCH_UPDATE */ | ||||
1036 | touches = input->mt.touches & input->mt.frame; | ||||
1037 | if (touches & tp->mtcycle) { | ||||
1038 | /* | ||||
1039 | * Slot data may be synchronized separately, in any order, | ||||
1040 | * or not at all if there is no delta. Identify the touches | ||||
1041 | * without deltas. | ||||
1042 | */ | ||||
1043 | inactive = input->mt.touches & ~tp->mtcycle; | ||||
1044 | tp->mtcycle = touches; | ||||
1045 | } else { | ||||
1046 | inactive = 0; | ||||
1047 | tp->mtcycle |= touches; | ||||
1048 | } | ||||
1049 | touches = input->mt.touches & ~input->mt.sync[MTS_TOUCH0]; | ||||
1050 | FOREACHBIT(touches, slot)for ((slot) = ffs(touches) - 1; (slot) != -1; (slot) = ffs((touches ) & (~1 << (slot))) - 1) { | ||||
1051 | t = &tp->tpad_touches[slot]; | ||||
1052 | t->state = TOUCH_UPDATE; | ||||
1053 | if ((1 << slot) & input->mt.frame) { | ||||
1054 | dx = normalize_abs(&input->filter.h, t->pos->x) - t->x; | ||||
1055 | t->x += dx; | ||||
1056 | dy = normalize_abs(&input->filter.v, t->pos->y) - t->y; | ||||
1057 | t->y += dy; | ||||
1058 | t->flags &= (~EDGES((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3)) | edge_flags(tp, t->x, t->y)); | ||||
1059 | if (wsmouse_hysteresis(input, t->pos)) | ||||
1060 | dx = dy = 0; | ||||
1061 | wstpad_set_direction(tp, t, dx, dy); | ||||
1062 | } else if ((1 << slot) & inactive) { | ||||
1063 | wstpad_set_direction(tp, t, 0, 0); | ||||
1064 | } | ||||
1065 | } | ||||
1066 | |||||
1067 | clear_touchstates(input, TOUCH_END); | ||||
1068 | } | ||||
1069 | |||||
1070 | /* | ||||
1071 | * Identify "thumb" contacts in the bottom area. The identification | ||||
1072 | * has three stages: | ||||
1073 | * 1. If exactly one of two or more touches is in the bottom area, it | ||||
1074 | * is masked, which means it does not receive pointer control as long | ||||
1075 | * as there are alternatives. Once set, the mask will only be cleared | ||||
1076 | * when the touch is released. | ||||
1077 | * Tap detection ignores a masked touch if it does not participate in | ||||
1078 | * a tap gesture. | ||||
1079 | * 2. If the pointer-controlling touch is moving stably while a masked | ||||
1080 | * touch in the bottom area is resting, or only moving minimally, the | ||||
1081 | * pointer mask is copied to tp->ignore. In this stage, the masked | ||||
1082 | * touch does not block pointer movement, and it is ignored by | ||||
1083 | * wstpad_f2scroll(). | ||||
1084 | * Decisions are made more or less immediately, there may be errors | ||||
1085 | * in edge cases. If a fast or long upward movement is detected, | ||||
1086 | * tp->ignore is cleared. There is no other transition from stage 2 | ||||
1087 | * to scrolling, or vice versa, for a pair of touches. | ||||
1088 | * 3. If tp->ignore is set and the touch is resting, it is marked as | ||||
1089 | * thumb, and it will be ignored until it ends. | ||||
1090 | */ | ||||
1091 | void | ||||
1092 | wstpad_mt_masks(struct wsmouseinput *input) | ||||
1093 | { | ||||
1094 | struct wstpad *tp = input->tp; | ||||
1095 | struct tpad_touch *t; | ||||
1096 | struct position *pos; | ||||
1097 | u_int mask; | ||||
1098 | int slot; | ||||
1099 | |||||
1100 | tp->ignore &= input->mt.touches; | ||||
1101 | |||||
1102 | if (tp->contacts < 2) | ||||
1103 | return; | ||||
1104 | |||||
1105 | if (tp->ignore) { | ||||
1106 | slot = ffs(tp->ignore) - 1; | ||||
1107 | t = &tp->tpad_touches[slot]; | ||||
1108 | if (t->flags & THUMB(1 << 4)) | ||||
1109 | return; | ||||
1110 | if (t->dir < 0 && wstpad_is_stable(input, t)) { | ||||
1111 | t->flags |= THUMB(1 << 4); | ||||
1112 | return; | ||||
1113 | } | ||||
1114 | /* The edge.low area is a bit larger than the bottom area. */ | ||||
1115 | if (t->y >= tp->edge.low || (NORTH(t->dir)((t->dir) == 0 || (t->dir) == 11) && | ||||
1116 | magnitude(input, t->pos->dx, t->pos->dy) >= MAG_MEDIUM(18 << 12))) | ||||
1117 | tp->ignore = 0; | ||||
1118 | return; | ||||
1119 | } | ||||
1120 | |||||
1121 | if (input->mt.ptr_mask == 0) { | ||||
1122 | mask = ~0; | ||||
1123 | FOREACHBIT(input->mt.touches, slot)for ((slot) = ffs(input->mt.touches) - 1; (slot) != -1; (slot ) = ffs((input->mt.touches) & (~1 << (slot))) - 1 ) { | ||||
1124 | t = &tp->tpad_touches[slot]; | ||||
1125 | if (t->flags & B_EDGE(1 << 3)) { | ||||
1126 | mask &= (1 << slot); | ||||
1127 | input->mt.ptr_mask = mask; | ||||
1128 | } | ||||
1129 | } | ||||
1130 | } | ||||
1131 | |||||
1132 | if ((input->mt.ptr_mask & ~input->mt.ptr) | ||||
1133 | && !(tp->scroll.dz || tp->scroll.dw) | ||||
1134 | && tp->t->dir >= 0 | ||||
1135 | && wstpad_is_stable(input, tp->t)) { | ||||
1136 | |||||
1137 | slot = ffs(input->mt.ptr_mask) - 1; | ||||
1138 | t = &tp->tpad_touches[slot]; | ||||
1139 | |||||
1140 | if (t->y >= tp->edge.low) | ||||
1141 | return; | ||||
1142 | |||||
1143 | if (!wstpad_is_stable(input, t)) | ||||
1144 | return; | ||||
1145 | |||||
1146 | /* Default hysteresis limits are low. Make a strict check. */ | ||||
1147 | pos = tp->t->pos; | ||||
1148 | if (abs(pos->acc_dx) < 3 * input->filter.h.hysteresis | ||||
1149 | && abs(pos->acc_dy) < 3 * input->filter.v.hysteresis) | ||||
1150 | return; | ||||
1151 | |||||
1152 | if (t->dir >= 0) { | ||||
1153 | /* Treat t as thumb if it is slow while tp->t is fast. */ | ||||
1154 | if (magnitude(input, t->pos->dx, t->pos->dy) > MAG_LOW(10 << 12) | ||||
1155 | || magnitude(input, pos->dx, pos->dy) < MAG_MEDIUM(18 << 12)) | ||||
1156 | return; | ||||
1157 | } | ||||
1158 | |||||
1159 | tp->ignore = input->mt.ptr_mask; | ||||
1160 | } | ||||
1161 | } | ||||
1162 | |||||
1163 | void | ||||
1164 | wstpad_touch_inputs(struct wsmouseinput *input) | ||||
1165 | { | ||||
1166 | struct wstpad *tp = input->tp; | ||||
1167 | struct tpad_touch *t; | ||||
1168 | int slot, x, y, dx, dy; | ||||
1169 | |||||
1170 | tp->btns = input->btn.buttons; | ||||
1171 | tp->btns_sync = input->btn.sync; | ||||
1172 | |||||
1173 | tp->prev_contacts = tp->contacts; | ||||
1174 | tp->contacts = input->touch.contacts; | ||||
1175 | |||||
1176 | if (tp->contacts == 1 && | ||||
1177 | ((tp->params.f2width && | ||||
1178 | input->touch.width >= tp->params.f2width) | ||||
1179 | || (tp->params.f2pressure && | ||||
1180 | input->touch.pressure >= tp->params.f2pressure))) | ||||
1181 | tp->contacts = 2; | ||||
1182 | |||||
1183 | if (IS_MT(tp)((tp)->features & (1 << 31))) { | ||||
1184 | wstpad_mt_inputs(input); | ||||
1185 | if (input->mt.ptr) { | ||||
1186 | slot = ffs(input->mt.ptr) - 1; | ||||
1187 | tp->t = &tp->tpad_touches[slot]; | ||||
1188 | } | ||||
1189 | wstpad_mt_masks(input); | ||||
1190 | } else { | ||||
1191 | t = tp->t; | ||||
1192 | if (tp->contacts) | ||||
1193 | t->state = (tp->prev_contacts ? | ||||
1194 | TOUCH_UPDATE : TOUCH_BEGIN); | ||||
1195 | else | ||||
1196 | t->state = (tp->prev_contacts ? | ||||
1197 | TOUCH_END : TOUCH_NONE); | ||||
1198 | |||||
1199 | dx = dy = 0; | ||||
1200 | x = normalize_abs(&input->filter.h, t->pos->x); | ||||
1201 | y = normalize_abs(&input->filter.v, t->pos->y); | ||||
1202 | if (t->state == TOUCH_BEGIN) { | ||||
1203 | t->x = t->orig.x = x; | ||||
1204 | t->y = t->orig.y = y; | ||||
1205 | memcpy(&t->orig.time, &tp->time,__builtin_memcpy((&t->orig.time), (&tp->time), ( sizeof(struct timespec))) | ||||
1206 | sizeof(struct timespec))__builtin_memcpy((&t->orig.time), (&tp->time), ( sizeof(struct timespec))); | ||||
1207 | t->flags = edge_flags(tp, x, y); | ||||
1208 | } else if (input->motion.sync & SYNC_POSITION((1 << 1) | (1 << 2))) { | ||||
1209 | if (!wsmouse_hysteresis(input, t->pos)) { | ||||
1210 | dx = x - t->x; | ||||
1211 | dy = y - t->y; | ||||
1212 | } | ||||
1213 | t->x = x; | ||||
1214 | t->y = y; | ||||
1215 | t->flags &= (~EDGES((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3)) | edge_flags(tp, x, y)); | ||||
1216 | } | ||||
1217 | wstpad_set_direction(tp, t, dx, dy); | ||||
1218 | } | ||||
1219 | } | ||||
1220 | |||||
1221 | static inline int | ||||
1222 | t2_ignore(struct wsmouseinput *input) | ||||
1223 | { | ||||
1224 | /* | ||||
1225 | * If there are two touches, do not block pointer movement if they | ||||
1226 | * perform a click-and-drag action, or if the second touch is | ||||
1227 | * resting in the bottom area. | ||||
1228 | */ | ||||
1229 | return (input->tp->contacts == 2 && ((input->tp->btns & PRIMARYBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 )) | ||||
1230 | || (input->tp->ignore & ~input->mt.ptr))); | ||||
1231 | } | ||||
1232 | |||||
1233 | void | ||||
1234 | wstpad_process_input(struct wsmouseinput *input, struct evq_access *evq) | ||||
1235 | { | ||||
1236 | struct wstpad *tp = input->tp; | ||||
1237 | u_int handlers, hdlr, cmds; | ||||
1238 | |||||
1239 | memcpy(&tp->time, &evq->ts, sizeof(struct timespec))__builtin_memcpy((&tp->time), (&evq->ts), (sizeof (struct timespec))); | ||||
1240 | wstpad_touch_inputs(input); | ||||
1241 | |||||
1242 | cmds = 0; | ||||
1243 | handlers = tp->handlers; | ||||
1244 | if (DISABLE(tp)((tp)->features & (1 << 7))) | ||||
1245 | handlers &= ((1 << TOPBUTTON_HDLR) | (1 << SOFTBUTTON_HDLR)); | ||||
1246 | |||||
1247 | FOREACHBIT(handlers, hdlr)for ((hdlr) = ffs(handlers) - 1; (hdlr) != -1; (hdlr) = ffs(( handlers) & (~1 << (hdlr))) - 1) { | ||||
1248 | switch (hdlr) { | ||||
1249 | case SOFTBUTTON_HDLR: | ||||
1250 | case TOPBUTTON_HDLR: | ||||
1251 | wstpad_softbuttons(input, &cmds, hdlr); | ||||
1252 | continue; | ||||
1253 | case TAP_HDLR: | ||||
1254 | wstpad_tap(input, &cmds); | ||||
1255 | continue; | ||||
1256 | case F2SCROLL_HDLR: | ||||
1257 | wstpad_f2scroll(input, &cmds); | ||||
1258 | continue; | ||||
1259 | case EDGESCROLL_HDLR: | ||||
1260 | wstpad_edgescroll(input, &cmds); | ||||
1261 | continue; | ||||
1262 | case CLICK_HDLR: | ||||
1263 | wstpad_click(input); | ||||
1264 | continue; | ||||
1265 | } | ||||
1266 | } | ||||
1267 | |||||
1268 | /* Check whether pointer movement should be blocked. */ | ||||
1269 | if (input->motion.dx
| ||||
1270 | if (DISABLE(tp)((tp)->features & (1 << 7)) | ||||
1271 | || (tp->t->flags & tp->freeze) | ||||
1272 | || timespeccmp(&tp->time, &tp->freeze_ts, <)(((&tp->time)->tv_sec == (&tp->freeze_ts)-> tv_sec) ? ((&tp->time)->tv_nsec < (&tp->freeze_ts )->tv_nsec) : ((&tp->time)->tv_sec < (&tp ->freeze_ts)->tv_sec)) | ||||
1273 | || (tp->contacts > 1 && !t2_ignore(input))) { | ||||
1274 | |||||
1275 | cmds |= 1 << CLEAR_MOTION_DELTAS; | ||||
1276 | } | ||||
1277 | } | ||||
1278 | |||||
1279 | wstpad_cmds(input, evq, cmds); | ||||
1280 | |||||
1281 | if (IS_MT(tp)((tp)->features & (1 << 31))) | ||||
1282 | clear_touchstates(input, TOUCH_NONE); | ||||
1283 | } | ||||
1284 | |||||
1285 | /* | ||||
1286 | * Try to determine the average interval between two updates. Various | ||||
1287 | * conditions are checked in order to ensure that only valid samples enter | ||||
1288 | * into the calculation. Above all, it is restricted to motion events | ||||
1289 | * occurring when there is only one contact. MT devices may need more than | ||||
1290 | * one packet to transmit their state if there are multiple touches, and | ||||
1291 | * the update frequency may be higher in this case. | ||||
1292 | */ | ||||
1293 | void | ||||
1294 | wstpad_track_interval(struct wsmouseinput *input, struct timespec *time) | ||||
1295 | { | ||||
1296 | static const struct timespec limit = { 0, 30 * 1000000L }; | ||||
1297 | struct timespec ts; | ||||
1298 | int samples; | ||||
1299 | |||||
1300 | if (input->motion.sync == 0 | ||||
1301 | || (input->touch.sync & SYNC_CONTACTS(1 << 1)) | ||||
1302 | || (input->touch.contacts > 1)) { | ||||
1303 | input->intv.track = 0; | ||||
1304 | return; | ||||
1305 | } | ||||
1306 | if (input->intv.track) { | ||||
1307 | timespecsub(time, &input->intv.ts, &ts)do { (&ts)->tv_sec = (time)->tv_sec - (&input-> intv.ts)->tv_sec; (&ts)->tv_nsec = (time)->tv_nsec - (&input->intv.ts)->tv_nsec; if ((&ts)->tv_nsec < 0) { (&ts)->tv_sec--; (&ts)->tv_nsec += 1000000000L ; } } while (0); | ||||
1308 | if (timespeccmp(&ts, &limit, <)(((&ts)->tv_sec == (&limit)->tv_sec) ? ((&ts )->tv_nsec < (&limit)->tv_nsec) : ((&ts)-> tv_sec < (&limit)->tv_sec))) { | ||||
1309 | /* The unit of the sum is 4096 nanoseconds. */ | ||||
1310 | input->intv.sum += ts.tv_nsec >> 12; | ||||
1311 | samples = ++input->intv.samples; | ||||
1312 | /* | ||||
1313 | * Make the first calculation quickly and later | ||||
1314 | * a more reliable one: | ||||
1315 | */ | ||||
1316 | if (samples == 8) { | ||||
1317 | input->intv.avg = input->intv.sum << 9; | ||||
1318 | wstpad_init_deceleration(input); | ||||
1319 | } else if (samples == 128) { | ||||
1320 | input->intv.avg = input->intv.sum << 5; | ||||
1321 | wstpad_init_deceleration(input); | ||||
1322 | input->intv.samples = 0; | ||||
1323 | input->intv.sum = 0; | ||||
1324 | input->flags &= ~TRACK_INTERVAL(1 << 17); | ||||
1325 | } | ||||
1326 | } | ||||
1327 | } | ||||
1328 | memcpy(&input->intv.ts, time, sizeof(struct timespec))__builtin_memcpy((&input->intv.ts), (time), (sizeof(struct timespec))); | ||||
1329 | input->intv.track = 1; | ||||
1330 | } | ||||
1331 | |||||
1332 | |||||
1333 | |||||
1334 | /* | ||||
1335 | * The default acceleration options of X don't work convincingly with | ||||
1336 | * touchpads (the synaptics driver installs its own "acceleration | ||||
1337 | * profile" and callback function). As a preliminary workaround, this | ||||
1338 | * filter applies a simple deceleration scheme to small deltas, based | ||||
1339 | * on the "magnitude" of the delta pair. A magnitude of 8 corresponds, | ||||
1340 | * roughly, to a speed of (filter.dclr / 12.5) device units per milli- | ||||
1341 | * second. If its magnitude is smaller than 7 a delta will be downscaled | ||||
1342 | * by the factor 2/8, deltas with magnitudes from 7 to 11 by factors | ||||
1343 | * ranging from 3/8 to 7/8. | ||||
1344 | */ | ||||
1345 | int | ||||
1346 | wstpad_decelerate(struct wsmouseinput *input, int *dx, int *dy) | ||||
1347 | { | ||||
1348 | int mag, n, h, v; | ||||
1349 | |||||
1350 | mag = magnitude(input, *dx, *dy); | ||||
1351 | |||||
1352 | /* Don't change deceleration levels abruptly. */ | ||||
1353 | mag = (mag + 7 * input->filter.mag) / 8; | ||||
1354 | /* Don't use arbitrarily high values. */ | ||||
1355 | input->filter.mag = imin(mag, 24 << 12); | ||||
1356 | |||||
1357 | n = imax((mag >> 12) - 4, 2); | ||||
1358 | if (n < 8) { | ||||
1359 | /* Scale by (n / 8). */ | ||||
1360 | h = *dx * n + input->filter.h.dclr_rmdr; | ||||
1361 | v = *dy * n + input->filter.v.dclr_rmdr; | ||||
1362 | input->filter.h.dclr_rmdr = (h >= 0 ? h & 7 : -(-h & 7)); | ||||
1363 | input->filter.v.dclr_rmdr = (v >= 0 ? v & 7 : -(-v & 7)); | ||||
1364 | *dx = h / 8; | ||||
1365 | *dy = v / 8; | ||||
1366 | return (1); | ||||
1367 | } | ||||
1368 | return (0); | ||||
1369 | } | ||||
1370 | |||||
1371 | void | ||||
1372 | wstpad_filter(struct wsmouseinput *input) | ||||
1373 | { | ||||
1374 | struct axis_filter *h = &input->filter.h; | ||||
1375 | struct axis_filter *v = &input->filter.v; | ||||
1376 | struct position *pos = &input->motion.pos; | ||||
1377 | int strength = input->filter.mode & 7; | ||||
1378 | int dx, dy; | ||||
1379 | |||||
1380 | if (!(input->motion.sync & SYNC_POSITION((1 << 1) | (1 << 2))) | ||||
1381 | || (h->dmax && (abs(pos->dx) > h->dmax)) | ||||
1382 | || (v->dmax && (abs(pos->dy) > v->dmax))) { | ||||
1383 | dx = dy = 0; | ||||
1384 | } else { | ||||
1385 | dx = pos->dx; | ||||
1386 | dy = pos->dy; | ||||
1387 | } | ||||
1388 | |||||
1389 | if (wsmouse_hysteresis(input, pos)) | ||||
1390 | dx = dy = 0; | ||||
1391 | |||||
1392 | if (input->filter.dclr && wstpad_decelerate(input, &dx, &dy)) | ||||
1393 | /* Strong smoothing may hamper the precision at low speeds. */ | ||||
1394 | strength = imin(strength, 2); | ||||
1395 | |||||
1396 | if (strength) { | ||||
1397 | if ((input->touch.sync & SYNC_CONTACTS(1 << 1)) | ||||
1398 | || input->mt.ptr != input->mt.prev_ptr) { | ||||
1399 | h->avg = v->avg = 0; | ||||
1400 | } | ||||
1401 | /* Use a weighted decaying average for smoothing. */ | ||||
1402 | dx = dx * (8 - strength) + h->avg * strength + h->avg_rmdr; | ||||
1403 | dy = dy * (8 - strength) + v->avg * strength + v->avg_rmdr; | ||||
1404 | h->avg_rmdr = (dx >= 0 ? dx & 7 : -(-dx & 7)); | ||||
1405 | v->avg_rmdr = (dy >= 0 ? dy & 7 : -(-dy & 7)); | ||||
1406 | dx = h->avg = dx / 8; | ||||
1407 | dy = v->avg = dy / 8; | ||||
1408 | } | ||||
1409 | |||||
1410 | input->motion.dx = dx; | ||||
1411 | input->motion.dy = dy; | ||||
1412 | } | ||||
1413 | |||||
1414 | |||||
1415 | /* | ||||
1416 | * Compatibility-mode conversions. wstpad_filter transforms and filters | ||||
1417 | * the coordinate inputs, extended functionality is provided by | ||||
1418 | * wstpad_process_input. | ||||
1419 | */ | ||||
1420 | void | ||||
1421 | wstpad_compat_convert(struct wsmouseinput *input, struct evq_access *evq) | ||||
1422 | { | ||||
1423 | if (input->flags & TRACK_INTERVAL(1 << 17)) | ||||
| |||||
1424 | wstpad_track_interval(input, &evq->ts); | ||||
1425 | |||||
1426 | wstpad_filter(input); | ||||
1427 | |||||
1428 | if ((input->motion.dx || input->motion.dy) | ||||
1429 | && !(input->motion.sync & SYNC_DELTAS(1 << 0))) { | ||||
1430 | input->motion.dz = input->motion.dw = 0; | ||||
1431 | input->motion.sync |= SYNC_DELTAS(1 << 0); | ||||
1432 | } | ||||
1433 | |||||
1434 | if (input->tp != NULL((void *)0)) | ||||
1435 | wstpad_process_input(input, evq); | ||||
1436 | |||||
1437 | input->motion.sync &= ~SYNC_POSITION((1 << 1) | (1 << 2)); | ||||
1438 | input->touch.sync = 0; | ||||
1439 | } | ||||
1440 | |||||
1441 | int | ||||
1442 | wstpad_init(struct wsmouseinput *input) | ||||
1443 | { | ||||
1444 | struct wstpad *tp = input->tp; | ||||
1445 | int i, slots; | ||||
1446 | |||||
1447 | if (tp != NULL((void *)0)) | ||||
1448 | return (0); | ||||
1449 | |||||
1450 | input->tp = tp = malloc(sizeof(struct wstpad), | ||||
1451 | M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008); | ||||
1452 | if (tp == NULL((void *)0)) | ||||
1453 | return (-1); | ||||
1454 | |||||
1455 | slots = imax(input->mt.num_slots, 1); | ||||
1456 | tp->tpad_touches = malloc(slots * sizeof(struct tpad_touch), | ||||
1457 | M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008); | ||||
1458 | if (tp->tpad_touches == NULL((void *)0)) { | ||||
1459 | free(tp, M_DEVBUF2, sizeof(struct wstpad)); | ||||
1460 | return (-1); | ||||
1461 | } | ||||
1462 | |||||
1463 | tp->t = &tp->tpad_touches[0]; | ||||
1464 | if (input->mt.num_slots) { | ||||
1465 | tp->features |= WSTPAD_MT(1 << 31); | ||||
1466 | for (i = 0; i < input->mt.num_slots; i++) | ||||
1467 | tp->tpad_touches[i].pos = &input->mt.slots[i].pos; | ||||
1468 | } else { | ||||
1469 | tp->t->pos = &input->motion.pos; | ||||
1470 | } | ||||
1471 | |||||
1472 | timeout_set(&tp->tap.to, wstpad_tap_timeout, input); | ||||
1473 | |||||
1474 | tp->ratio = input->filter.ratio; | ||||
1475 | |||||
1476 | return (0); | ||||
1477 | } | ||||
1478 | |||||
1479 | /* | ||||
1480 | * Integer square root (Halleck's method) | ||||
1481 | * | ||||
1482 | * An adaption of code from John B. Halleck (from | ||||
1483 | * http://www.cc.utah.edu/~nahaj/factoring/code.html). This version is | ||||
1484 | * used and published under the OpenBSD license terms with his permission. | ||||
1485 | * | ||||
1486 | * Cf. also Martin Guy's "Square root by abacus" method. | ||||
1487 | */ | ||||
1488 | static inline u_int | ||||
1489 | isqrt(u_int n) | ||||
1490 | { | ||||
1491 | u_int root, sqbit; | ||||
1492 | |||||
1493 | root = 0; | ||||
1494 | sqbit = 1 << (sizeof(u_int) * 8 - 2); | ||||
1495 | while (sqbit) { | ||||
1496 | if (n >= (sqbit | root)) { | ||||
1497 | n -= (sqbit | root); | ||||
1498 | root = (root >> 1) | sqbit; | ||||
1499 | } else { | ||||
1500 | root >>= 1; | ||||
1501 | } | ||||
1502 | sqbit >>= 2; | ||||
1503 | } | ||||
1504 | return (root); | ||||
1505 | } | ||||
1506 | |||||
1507 | void | ||||
1508 | wstpad_init_deceleration(struct wsmouseinput *input) | ||||
1509 | { | ||||
1510 | int n, dclr; | ||||
1511 | |||||
1512 | if ((dclr = input->filter.dclr) == 0) | ||||
1513 | return; | ||||
1514 | |||||
1515 | dclr = imax(dclr, 4); | ||||
1516 | |||||
1517 | /* | ||||
1518 | * For a standard update rate of about 80Hz, (dclr) units | ||||
1519 | * will be mapped to a magnitude of 8. If the average rate | ||||
1520 | * is significantly higher or lower, adjust the coefficient | ||||
1521 | * accordingly: | ||||
1522 | */ | ||||
1523 | if (input->intv.avg == 0) { | ||||
1524 | n = 8; | ||||
1525 | } else { | ||||
1526 | n = 8 * 13000000 / input->intv.avg; | ||||
1527 | n = imax(imin(n, 32), 4); | ||||
1528 | } | ||||
1529 | input->filter.h.mag_scale = (n << 12) / dclr; | ||||
1530 | input->filter.v.mag_scale = (input->filter.ratio ? | ||||
1531 | n * input->filter.ratio : n << 12) / dclr; | ||||
1532 | input->filter.h.dclr_rmdr = 0; | ||||
1533 | input->filter.v.dclr_rmdr = 0; | ||||
1534 | input->flags |= TRACK_INTERVAL(1 << 17); | ||||
1535 | } | ||||
1536 | |||||
1537 | int | ||||
1538 | wstpad_configure(struct wsmouseinput *input) | ||||
1539 | { | ||||
1540 | struct wstpad *tp; | ||||
1541 | int width, height, diag, offset, h_res, v_res, h_unit, v_unit, i; | ||||
1542 | |||||
1543 | width = abs(input->hw.x_max - input->hw.x_min); | ||||
1544 | height = abs(input->hw.y_max - input->hw.y_min); | ||||
1545 | if (width == 0 || height == 0) | ||||
1546 | return (-1); /* We can't do anything. */ | ||||
1547 | |||||
1548 | if (input->tp == NULL((void *)0) && wstpad_init(input)) | ||||
1549 | return (-1); | ||||
1550 | tp = input->tp; | ||||
1551 | |||||
1552 | if (!(input->flags & CONFIGURED(1 << 18))) { | ||||
1553 | /* | ||||
1554 | * The filter parameters are derived from the length of the | ||||
1555 | * diagonal in device units, with some magic constants which | ||||
1556 | * are partly adapted from libinput or synaptics code, or are | ||||
1557 | * based on tests and guess work. The absolute resolution | ||||
1558 | * values might not be reliable, but if they are present the | ||||
1559 | * settings are adapted to the ratio. | ||||
1560 | */ | ||||
1561 | h_res = input->hw.h_res; | ||||
1562 | v_res = input->hw.v_res; | ||||
1563 | if (h_res == 0 || v_res == 0) | ||||
1564 | h_res = v_res = 1; | ||||
1565 | diag = isqrt(width * width + height * height); | ||||
1566 | input->filter.h.scale = (imin(920, diag) << 12) / diag; | ||||
1567 | input->filter.v.scale = input->filter.h.scale * h_res / v_res; | ||||
1568 | h_unit = imax(diag / 280, 3); | ||||
1569 | v_unit = imax((h_unit * v_res + h_res / 2) / h_res, 3); | ||||
1570 | input->filter.h.hysteresis = h_unit; | ||||
1571 | input->filter.v.hysteresis = v_unit; | ||||
1572 | input->filter.mode = FILTER_MODE_DEFAULT0; | ||||
1573 | input->filter.dclr = h_unit - h_unit / 5; | ||||
1574 | wstpad_init_deceleration(input); | ||||
1575 | |||||
1576 | tp->features &= (WSTPAD_MT(1 << 31) | WSTPAD_DISABLE(1 << 7)); | ||||
1577 | |||||
1578 | if (input->hw.contacts_max != 1) | ||||
1579 | tp->features |= WSTPAD_TWOFINGERSCROLL(1 << 3); | ||||
1580 | else | ||||
1581 | tp->features |= WSTPAD_EDGESCROLL(1 << 4); | ||||
1582 | |||||
1583 | if (input->hw.hw_type == WSMOUSEHW_CLICKPAD) { | ||||
1584 | if (input->hw.type == WSMOUSE_TYPE_SYNAP_SBTN19) { | ||||
1585 | tp->features |= WSTPAD_TOPBUTTONS(1 << 2); | ||||
1586 | } else { | ||||
1587 | tp->features |= WSTPAD_SOFTBUTTONS(1 << 0); | ||||
1588 | tp->features |= WSTPAD_SOFTMBTN(1 << 1); | ||||
1589 | } | ||||
1590 | } | ||||
1591 | |||||
1592 | tp->params.left_edge = V_EDGE_RATIO_DEFAULT205; | ||||
1593 | tp->params.right_edge = V_EDGE_RATIO_DEFAULT205; | ||||
1594 | tp->params.bottom_edge = ((tp->features & WSTPAD_SOFTBUTTONS(1 << 0)) | ||||
1595 | ? B_EDGE_RATIO_DEFAULT410 : 0); | ||||
1596 | tp->params.top_edge = ((tp->features & WSTPAD_TOPBUTTONS(1 << 2)) | ||||
1597 | ? T_EDGE_RATIO_DEFAULT512 : 0); | ||||
1598 | tp->params.center_width = CENTER_RATIO_DEFAULT512; | ||||
1599 | |||||
1600 | tp->tap.maxtime.tv_nsec = TAP_MAXTIME_DEFAULT180 * 1000000; | ||||
1601 | tp->tap.clicktime = TAP_CLICKTIME_DEFAULT180; | ||||
1602 | tp->tap.locktime = TAP_LOCKTIME_DEFAULT0; | ||||
1603 | |||||
1604 | tp->scroll.hdist = 4 * h_unit; | ||||
1605 | tp->scroll.vdist = 4 * v_unit; | ||||
1606 | tp->tap.maxdist = 4 * h_unit; | ||||
1607 | } | ||||
1608 | |||||
1609 | /* A touch with a flag set in this mask does not move the pointer. */ | ||||
1610 | tp->freeze = EDGES((1 << 0) | (1 << 1) | (1 << 2) | (1 << 3)); | ||||
1611 | |||||
1612 | offset = width * tp->params.left_edge / 4096; | ||||
1613 | tp->edge.left = (offset ? input->hw.x_min + offset : INT_MIN(-0x7fffffff-1)); | ||||
1614 | offset = width * tp->params.right_edge / 4096; | ||||
1615 | tp->edge.right = (offset ? input->hw.x_max - offset : INT_MAX0x7fffffff); | ||||
1616 | offset = height * tp->params.bottom_edge / 4096; | ||||
1617 | tp->edge.bottom = (offset ? input->hw.y_min + offset : INT_MIN(-0x7fffffff-1)); | ||||
1618 | tp->edge.low = tp->edge.bottom + offset / 2; | ||||
1619 | offset = height * tp->params.top_edge / 4096; | ||||
1620 | tp->edge.top = (offset ? input->hw.y_max - offset : INT_MAX0x7fffffff); | ||||
1621 | |||||
1622 | offset = width * abs(tp->params.center_width) / 8192; | ||||
1623 | tp->edge.center = input->hw.x_min + width / 2; | ||||
1624 | tp->edge.center_left = tp->edge.center - offset; | ||||
1625 | tp->edge.center_right = tp->edge.center + offset; | ||||
1626 | |||||
1627 | tp->handlers = 0; | ||||
1628 | |||||
1629 | if (tp->features & WSTPAD_SOFTBUTTONS(1 << 0)) | ||||
1630 | tp->handlers |= 1 << SOFTBUTTON_HDLR; | ||||
1631 | if (tp->features & WSTPAD_TOPBUTTONS(1 << 2)) | ||||
1632 | tp->handlers |= 1 << TOPBUTTON_HDLR; | ||||
1633 | |||||
1634 | if (tp->features & WSTPAD_TWOFINGERSCROLL(1 << 3)) | ||||
1635 | tp->handlers |= 1 << F2SCROLL_HDLR; | ||||
1636 | else if (tp->features & WSTPAD_EDGESCROLL(1 << 4)) | ||||
1637 | tp->handlers |= 1 << EDGESCROLL_HDLR; | ||||
1638 | |||||
1639 | for (i = 0; i < TAP_BTNMAP_SIZE3; i++) { | ||||
1640 | if (tp->tap.btnmap[i] == 0) | ||||
1641 | continue; | ||||
1642 | |||||
1643 | tp->tap.clicktime = imin(imax(tp->tap.clicktime, 80), 350); | ||||
1644 | if (tp->tap.locktime) | ||||
1645 | tp->tap.locktime = | ||||
1646 | imin(imax(tp->tap.locktime, 150), 5000); | ||||
1647 | tp->handlers |= 1 << TAP_HDLR; | ||||
1648 | break; | ||||
1649 | } | ||||
1650 | |||||
1651 | if (input->hw.hw_type == WSMOUSEHW_CLICKPAD) | ||||
1652 | tp->handlers |= 1 << CLICK_HDLR; | ||||
1653 | |||||
1654 | tp->sbtnswap = ((tp->features & WSTPAD_SWAPSIDES(1 << 6)) | ||||
1655 | ? (LEFTBTN((1) > 0 && (1) <= 32 ? 1 << ((1) - 1) : 0 ) | RIGHTBTN((3) > 0 && (3) <= 32 ? 1 << ((3) - 1) : 0 )) : 0); | ||||
1656 | |||||
1657 | return (0); | ||||
1658 | } | ||||
1659 | |||||
1660 | void | ||||
1661 | wstpad_reset(struct wsmouseinput *input) | ||||
1662 | { | ||||
1663 | struct wstpad *tp = input->tp; | ||||
1664 | |||||
1665 | if (tp != NULL((void *)0)) { | ||||
1666 | timeout_del(&tp->tap.to); | ||||
1667 | tp->tap.state = TAP_DETECT; | ||||
1668 | } | ||||
1669 | |||||
1670 | if (input->sbtn.buttons) { | ||||
1671 | input->sbtn.sync = input->sbtn.buttons; | ||||
1672 | input->sbtn.buttons = 0; | ||||
1673 | } | ||||
1674 | } | ||||
1675 | |||||
1676 | void | ||||
1677 | wstpad_cleanup(struct wsmouseinput *input) | ||||
1678 | { | ||||
1679 | struct wstpad *tp = input->tp; | ||||
1680 | int slots; | ||||
1681 | |||||
1682 | timeout_del(&tp->tap.to); | ||||
1683 | slots = imax(input->mt.num_slots, 1); | ||||
1684 | free(tp->tpad_touches, M_DEVBUF2, slots * sizeof(struct tpad_touch)); | ||||
1685 | free(tp, M_DEVBUF2, sizeof(struct wstpad)); | ||||
1686 | input->tp = NULL((void *)0); | ||||
1687 | } | ||||
1688 | |||||
1689 | int | ||||
1690 | wstpad_set_param(struct wsmouseinput *input, int key, int val) | ||||
1691 | { | ||||
1692 | struct wstpad *tp = input->tp; | ||||
1693 | u_int flag; | ||||
1694 | |||||
1695 | if (tp == NULL((void *)0)) | ||||
1696 | return (EINVAL22); | ||||
1697 | |||||
1698 | switch (key) { | ||||
1699 | case WSMOUSECFG_SOFTBUTTONS ... WSMOUSECFG_DISABLE: | ||||
1700 | switch (key) { | ||||
1701 | case WSMOUSECFG_SOFTBUTTONS: | ||||
1702 | flag = WSTPAD_SOFTBUTTONS(1 << 0); | ||||
1703 | break; | ||||
1704 | case WSMOUSECFG_SOFTMBTN: | ||||
1705 | flag = WSTPAD_SOFTMBTN(1 << 1); | ||||
1706 | break; | ||||
1707 | case WSMOUSECFG_TOPBUTTONS: | ||||
1708 | flag = WSTPAD_TOPBUTTONS(1 << 2); | ||||
1709 | break; | ||||
1710 | case WSMOUSECFG_TWOFINGERSCROLL: | ||||
1711 | flag = WSTPAD_TWOFINGERSCROLL(1 << 3); | ||||
1712 | break; | ||||
1713 | case WSMOUSECFG_EDGESCROLL: | ||||
1714 | flag = WSTPAD_EDGESCROLL(1 << 4); | ||||
1715 | break; | ||||
1716 | case WSMOUSECFG_HORIZSCROLL: | ||||
1717 | flag = WSTPAD_HORIZSCROLL(1 << 5); | ||||
1718 | break; | ||||
1719 | case WSMOUSECFG_SWAPSIDES: | ||||
1720 | flag = WSTPAD_SWAPSIDES(1 << 6); | ||||
1721 | break; | ||||
1722 | case WSMOUSECFG_DISABLE: | ||||
1723 | flag = WSTPAD_DISABLE(1 << 7); | ||||
1724 | break; | ||||
1725 | } | ||||
1726 | if (val) | ||||
1727 | tp->features |= flag; | ||||
1728 | else | ||||
1729 | tp->features &= ~flag; | ||||
1730 | break; | ||||
1731 | case WSMOUSECFG_LEFT_EDGE: | ||||
1732 | tp->params.left_edge = val; | ||||
1733 | break; | ||||
1734 | case WSMOUSECFG_RIGHT_EDGE: | ||||
1735 | tp->params.right_edge = val; | ||||
1736 | break; | ||||
1737 | case WSMOUSECFG_TOP_EDGE: | ||||
1738 | tp->params.top_edge = val; | ||||
1739 | break; | ||||
1740 | case WSMOUSECFG_BOTTOM_EDGE: | ||||
1741 | tp->params.bottom_edge = val; | ||||
1742 | break; | ||||
1743 | case WSMOUSECFG_CENTERWIDTH: | ||||
1744 | tp->params.center_width = val; | ||||
1745 | break; | ||||
1746 | case WSMOUSECFG_HORIZSCROLLDIST: | ||||
1747 | tp->scroll.hdist = val; | ||||
1748 | break; | ||||
1749 | case WSMOUSECFG_VERTSCROLLDIST: | ||||
1750 | tp->scroll.vdist = val; | ||||
1751 | break; | ||||
1752 | case WSMOUSECFG_F2WIDTH: | ||||
1753 | tp->params.f2width = val; | ||||
1754 | break; | ||||
1755 | case WSMOUSECFG_F2PRESSURE: | ||||
1756 | tp->params.f2pressure = val; | ||||
1757 | break; | ||||
1758 | case WSMOUSECFG_TAP_MAXTIME: | ||||
1759 | tp->tap.maxtime.tv_nsec = imin(val, 999) * 1000000; | ||||
1760 | break; | ||||
1761 | case WSMOUSECFG_TAP_CLICKTIME: | ||||
1762 | tp->tap.clicktime = val; | ||||
1763 | break; | ||||
1764 | case WSMOUSECFG_TAP_LOCKTIME: | ||||
1765 | tp->tap.locktime = val; | ||||
1766 | break; | ||||
1767 | case WSMOUSECFG_TAP_ONE_BTNMAP: | ||||
1768 | tp->tap.btnmap[0] = BTNMASK(val)((val) > 0 && (val) <= 32 ? 1 << ((val) - 1) : 0); | ||||
1769 | break; | ||||
1770 | case WSMOUSECFG_TAP_TWO_BTNMAP: | ||||
1771 | tp->tap.btnmap[1] = BTNMASK(val)((val) > 0 && (val) <= 32 ? 1 << ((val) - 1) : 0); | ||||
1772 | break; | ||||
1773 | case WSMOUSECFG_TAP_THREE_BTNMAP: | ||||
1774 | tp->tap.btnmap[2] = BTNMASK(val)((val) > 0 && (val) <= 32 ? 1 << ((val) - 1) : 0); | ||||
1775 | break; | ||||
1776 | default: | ||||
1777 | return (ENOTSUP91); | ||||
1778 | } | ||||
1779 | |||||
1780 | return (0); | ||||
1781 | } | ||||
1782 | |||||
1783 | int | ||||
1784 | wstpad_get_param(struct wsmouseinput *input, int key, int *pval) | ||||
1785 | { | ||||
1786 | struct wstpad *tp = input->tp; | ||||
1787 | u_int flag; | ||||
1788 | |||||
1789 | if (tp == NULL((void *)0)) | ||||
1790 | return (EINVAL22); | ||||
1791 | |||||
1792 | switch (key) { | ||||
1793 | case WSMOUSECFG_SOFTBUTTONS ... WSMOUSECFG_DISABLE: | ||||
1794 | switch (key) { | ||||
1795 | case WSMOUSECFG_SOFTBUTTONS: | ||||
1796 | flag = WSTPAD_SOFTBUTTONS(1 << 0); | ||||
1797 | break; | ||||
1798 | case WSMOUSECFG_SOFTMBTN: | ||||
1799 | flag = WSTPAD_SOFTMBTN(1 << 1); | ||||
1800 | break; | ||||
1801 | case WSMOUSECFG_TOPBUTTONS: | ||||
1802 | flag = WSTPAD_TOPBUTTONS(1 << 2); | ||||
1803 | break; | ||||
1804 | case WSMOUSECFG_TWOFINGERSCROLL: | ||||
1805 | flag = WSTPAD_TWOFINGERSCROLL(1 << 3); | ||||
1806 | break; | ||||
1807 | case WSMOUSECFG_EDGESCROLL: | ||||
1808 | flag = WSTPAD_EDGESCROLL(1 << 4); | ||||
1809 | break; | ||||
1810 | case WSMOUSECFG_HORIZSCROLL: | ||||
1811 | flag = WSTPAD_HORIZSCROLL(1 << 5); | ||||
1812 | break; | ||||
1813 | case WSMOUSECFG_SWAPSIDES: | ||||
1814 | flag = WSTPAD_SWAPSIDES(1 << 6); | ||||
1815 | break; | ||||
1816 | case WSMOUSECFG_DISABLE: | ||||
1817 | flag = WSTPAD_DISABLE(1 << 7); | ||||
1818 | break; | ||||
1819 | } | ||||
1820 | *pval = !!(tp->features & flag); | ||||
1821 | break; | ||||
1822 | case WSMOUSECFG_LEFT_EDGE: | ||||
1823 | *pval = tp->params.left_edge; | ||||
1824 | break; | ||||
1825 | case WSMOUSECFG_RIGHT_EDGE: | ||||
1826 | *pval = tp->params.right_edge; | ||||
1827 | break; | ||||
1828 | case WSMOUSECFG_TOP_EDGE: | ||||
1829 | *pval = tp->params.top_edge; | ||||
1830 | break; | ||||
1831 | case WSMOUSECFG_BOTTOM_EDGE: | ||||
1832 | *pval = tp->params.bottom_edge; | ||||
1833 | break; | ||||
1834 | case WSMOUSECFG_CENTERWIDTH: | ||||
1835 | *pval = tp->params.center_width; | ||||
1836 | break; | ||||
1837 | case WSMOUSECFG_HORIZSCROLLDIST: | ||||
1838 | *pval = tp->scroll.hdist; | ||||
1839 | break; | ||||
1840 | case WSMOUSECFG_VERTSCROLLDIST: | ||||
1841 | *pval = tp->scroll.vdist; | ||||
1842 | break; | ||||
1843 | case WSMOUSECFG_F2WIDTH: | ||||
1844 | *pval = tp->params.f2width; | ||||
1845 | break; | ||||
1846 | case WSMOUSECFG_F2PRESSURE: | ||||
1847 | *pval = tp->params.f2pressure; | ||||
1848 | break; | ||||
1849 | case WSMOUSECFG_TAP_MAXTIME: | ||||
1850 | *pval = tp->tap.maxtime.tv_nsec / 1000000; | ||||
1851 | break; | ||||
1852 | case WSMOUSECFG_TAP_CLICKTIME: | ||||
1853 | *pval = tp->tap.clicktime; | ||||
1854 | break; | ||||
1855 | case WSMOUSECFG_TAP_LOCKTIME: | ||||
1856 | *pval = tp->tap.locktime; | ||||
1857 | break; | ||||
1858 | case WSMOUSECFG_TAP_ONE_BTNMAP: | ||||
1859 | *pval = ffs(tp->tap.btnmap[0]); | ||||
1860 | break; | ||||
1861 | case WSMOUSECFG_TAP_TWO_BTNMAP: | ||||
1862 | *pval = ffs(tp->tap.btnmap[1]); | ||||
1863 | break; | ||||
1864 | case WSMOUSECFG_TAP_THREE_BTNMAP: | ||||
1865 | *pval = ffs(tp->tap.btnmap[2]); | ||||
1866 | break; | ||||
1867 | default: | ||||
1868 | return (ENOTSUP91); | ||||
1869 | } | ||||
1870 | |||||
1871 | return (0); | ||||
1872 | } |