1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 //!
17 use hilog_rust::{error, hilog, debug, HiLogLabel, LogType};
18 use std::ffi::{c_char, CString};
19 use std::sync::Once;
20
21 const LOG_LABEL: HiLogLabel = HiLogLabel {
22 log_type: LogType::LogCore,
23 domain: 0xd002800,
24 tag: "MMIRustLib",
25 };
26
27 static DOUBLE_ZERO: f64 = 1e-6;
28 static RET_OK: i32 = 0;
29 static RET_ERR: i32 = -1;
30 static mut COMPENSATE_VALUEX: f64 = 0.0;
31 static mut COMPENSATE_VALUEY: f64 = 0.0;
32
33 struct CurveItem {
34 pub speeds: Vec<f64>,
35 pub slopes: Vec<f64>,
36 pub diff_nums: Vec<f64>,
37 }
38
39 struct KLVMouseAccelerateCurves {
40 data: Vec<CurveItem>,
41 }
42 struct SoftHardenMouseAccelerateCurves {
43 data: Vec<CurveItem>,
44 }
45 struct HardHardenMouseAccelerateCurves {
46 data: Vec<CurveItem>,
47 }
48 struct KLVTouchpadAccelerateCurves {
49 data: Vec<CurveItem>,
50 }
51 struct SoftHardenTouchpadAccelerateCurves {
52 data: Vec<CurveItem>,
53 }
54 struct HardHardenTouchpadAccelerateCurves {
55 data: Vec<CurveItem>,
56 }
57 struct WeberTouchpadAccelerateCurves {
58 data: Vec<CurveItem>,
59 }
60 struct AxisAccelerateCurvesTouchpad {
61 data: Vec<CurveItem>,
62 }
63 impl KLVMouseAccelerateCurves {
klv_mouse_get_curve_by_speednull64 fn klv_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
65 &self.data[speed - 1]
66 }
67 }
68 impl SoftHardenMouseAccelerateCurves {
soft_harden_mouse_get_curve_by_speednull69 fn soft_harden_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
70 &self.data[speed - 1]
71 }
72 }
73 impl HardHardenMouseAccelerateCurves {
hard_harden_mouse_get_curve_by_speednull74 fn hard_harden_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
75 &self.data[speed - 1]
76 }
77 }
78 impl KLVTouchpadAccelerateCurves {
klv_touchpad_get_curve_by_speednull79 fn klv_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
80 &self.data[speed - 1]
81 }
82 }
83 impl SoftHardenTouchpadAccelerateCurves {
soft_harden_touchpad_get_curve_by_speednull84 fn soft_harden_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
85 &self.data[speed - 1]
86 }
87 }
88 impl HardHardenTouchpadAccelerateCurves {
hard_harden_touchpad_get_curve_by_speednull89 fn hard_harden_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
90 &self.data[speed - 1]
91 }
92 }
93 impl WeberTouchpadAccelerateCurves {
weber_touchpad_get_curve_by_speednull94 fn weber_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
95 &self.data[speed - 1]
96 }
97 }
98 impl AxisAccelerateCurvesTouchpad {
get_axis_curve_by_speed_touchpadnull99 fn get_axis_curve_by_speed_touchpad(&self, device_type: usize) -> &CurveItem {
100 &self.data[device_type - 1]
101 }
102 }
103
104 impl KLVMouseAccelerateCurves {
get_instancenull105 fn get_instance() -> &'static KLVMouseAccelerateCurves {
106 static mut GLOBAL_CURVES: Option<KLVMouseAccelerateCurves> = None;
107 static ONCE: Once = Once::new();
108
109 ONCE.call_once(|| unsafe {
110 GLOBAL_CURVES = Some(KLVMouseAccelerateCurves {
111 data: vec![
112 CurveItem {
113 speeds: vec![8.0, 32.0, 128.0],
114 slopes: vec![0.16, 0.30, 0.56],
115 diff_nums: vec![0.0, -1.12, -9.44],
116 },
117 CurveItem {
118 speeds: vec![8.0, 32.0, 128.0],
119 slopes: vec![0.32, 0.60, 1.12],
120 diff_nums: vec![0.0, -2.24, -18.88],
121 },
122 CurveItem {
123 speeds: vec![8.0, 32.0, 128.0],
124 slopes: vec![0.64, 1.2, 2.24],
125 diff_nums: vec![0.0, -4.48, -37.76],
126 },
127 CurveItem {
128 speeds: vec![8.0, 32.0, 128.0],
129 slopes: vec![0.80, 1.50, 2.80],
130 diff_nums: vec![0.0, -5.6, -47.2],
131 },
132 CurveItem {
133 speeds: vec![8.0, 32.0, 128.0],
134 slopes: vec![0.92, 2.40, 4.48],
135 diff_nums: vec![0.0, -11.84, -78.4],
136 },
137 CurveItem {
138 speeds: vec![8.0, 32.0, 128.0],
139 slopes: vec![1.04, 3.30, 6.16],
140 diff_nums: vec![0.0, -18.08, -109.60],
141 },
142 CurveItem {
143 speeds: vec![8.0, 32.0, 128.0],
144 slopes: vec![1.10, 3.75, 7.00],
145 diff_nums: vec![0.0, -21.2, -125.20],
146 },
147 CurveItem {
148 speeds: vec![8.0, 32.0, 128.0],
149 slopes: vec![1.16, 4.20, 7.84],
150 diff_nums: vec![0.0, -24.32, -140.8],
151 },
152 CurveItem {
153 speeds: vec![8.0, 32.0, 128.0],
154 slopes: vec![1.22, 4.65, 8.68],
155 diff_nums: vec![0.0, -27.44, -156.40],
156 },
157 CurveItem {
158 speeds: vec![8.0, 32.0, 128.0],
159 slopes: vec![1.28, 5.1, 9.52],
160 diff_nums: vec![0.0, -30.56, -172.00],
161 },
162 CurveItem {
163 speeds: vec![8.0, 32.0, 128.0],
164 slopes: vec![1.34, 5.55, 10.36],
165 diff_nums: vec![0.0, -33.68, -187.6],
166 },
167 ],
168 });
169 });
170 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
171 }
172 }
173
174 impl SoftHardenMouseAccelerateCurves {
get_instancenull175 fn get_instance() -> &'static SoftHardenMouseAccelerateCurves {
176 static mut GLOBAL_CURVES: Option<SoftHardenMouseAccelerateCurves> = None;
177 static ONCE: Once = Once::new();
178
179 ONCE.call_once(|| unsafe {
180 GLOBAL_CURVES = Some(SoftHardenMouseAccelerateCurves {
181 data: vec![
182 CurveItem {
183 speeds: vec![3.76, 9.77, 16.54, 128.0],
184 slopes: vec![0.10, 0.13, 0.27, 0.44],
185 diff_nums: vec![0.00, -0.11, -1.53, -4.26],
186 },
187 CurveItem {
188 speeds: vec![3.76, 9.77, 16.54, 128.0],
189 slopes: vec![0.19, 0.25, 0.54, 0.87],
190 diff_nums: vec![0.00, -0.21, -3.06, -8.52],
191 },
192 CurveItem {
193 speeds: vec![3.76, 9.77, 16.54, 128.0],
194 slopes: vec![0.29, 0.38, 0.81, 1.31],
195 diff_nums: vec![0.00, -0.32, -4.60, -12.78],
196 },
197 CurveItem {
198 speeds: vec![3.76, 9.77, 16.54, 128.0],
199 slopes: vec![0.39, 0.50, 1.08, 1.74],
200 diff_nums: vec![0.00, -0.42, -6.13, -17.04],
201 },
202 CurveItem {
203 speeds: vec![3.76, 9.77, 16.54, 128.0],
204 slopes: vec![0.58, 0.75, 1.63, 2.62],
205 diff_nums: vec![0.00, -0.63, -9.19, -25.56],
206 },
207 CurveItem {
208 speeds: vec![3.76, 9.77, 16.54, 128.0],
209 slopes: vec![0.78, 1.00, 2.17, 3.49],
210 diff_nums: vec![0.00, -0.84, -12.25, -34.09],
211 },
212 CurveItem {
213 speeds: vec![3.76, 9.77, 16.54, 128.0],
214 slopes: vec![0.97, 1.25, 2.71, 4.36],
215 diff_nums: vec![0.00, -1.05, -15.32, -42.61],
216 },
217 CurveItem {
218 speeds: vec![3.76, 9.77, 16.54, 128.0],
219 slopes: vec![1.16, 1.50, 3.25, 5.23],
220 diff_nums: vec![0.00, -1.26, -18.38, -51.13],
221 },
222 CurveItem {
223 speeds: vec![3.76, 9.77, 16.54, 128.0],
224 slopes: vec![1.36, 1.75, 3.79, 6.10],
225 diff_nums: vec![0.00, -1.47, -21.44, -59.65],
226 },
227 CurveItem {
228 speeds: vec![3.76, 9.77, 16.54, 128.0],
229 slopes: vec![1.65, 2.13, 4.61, 7.41],
230 diff_nums: vec![0.00, -1.79, -26.04, -72.43],
231 },
232 CurveItem {
233 speeds: vec![3.76, 9.77, 16.54, 128.0],
234 slopes: vec![1.94, 2.50, 5.42, 8.72],
235 diff_nums: vec![0.00, -2.11, -30.63, -85.22],
236 },
237 ],
238 });
239 });
240 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
241 }
242 }
243
244 impl HardHardenMouseAccelerateCurves {
get_instancenull245 fn get_instance() -> &'static HardHardenMouseAccelerateCurves {
246 static mut GLOBAL_CURVES: Option<HardHardenMouseAccelerateCurves> = None;
247 static ONCE: Once = Once::new();
248
249 ONCE.call_once(|| unsafe {
250 GLOBAL_CURVES = Some(HardHardenMouseAccelerateCurves {
251 data: vec![
252 CurveItem {
253 speeds: vec![8.0, 32.0, 128.0],
254 slopes: vec![0.20, 0.38, 0.71],
255 diff_nums: vec![0.0, -1.42, -11.98],
256 },
257 CurveItem {
258 speeds: vec![8.0, 32.0, 128.0],
259 slopes: vec![0.41, 0.76, 1.42],
260 diff_nums: vec![0.0, -2.84, -23.97],
261 },
262 CurveItem {
263 speeds: vec![8.0, 32.0, 128.0],
264 slopes: vec![0.81, 1.52, 2.84],
265 diff_nums: vec![0.0, -5.69, -47.94],
266 },
267 CurveItem {
268 speeds: vec![8.0, 32.0, 128.0],
269 slopes: vec![1.02, 1.90, 3.55],
270 diff_nums: vec![0.0, -7.11, -59.92],
271 },
272 CurveItem {
273 speeds: vec![8.0, 32.0, 128.0],
274 slopes: vec![1.17, 3.05, 5.69],
275 diff_nums: vec![0.0, -15.03, -99.53],
276 },
277 CurveItem {
278 speeds: vec![8.0, 32.0, 128.0],
279 slopes: vec![1.32, 4.19, 7.82],
280 diff_nums: vec![0.0, -22.95, -139.14],
281 },
282 CurveItem {
283 speeds: vec![8.0, 32.0, 128.0],
284 slopes: vec![1.40, 4.76, 8.89],
285 diff_nums: vec![0.0, -26.91, -158.95],
286 },
287 CurveItem {
288 speeds: vec![8.0, 32.0, 128.0],
289 slopes: vec![1.47, 5.33, 9.95],
290 diff_nums: vec![0.0, -30.88, -178.75],
291 },
292 CurveItem {
293 speeds: vec![8.0, 32.0, 128.0],
294 slopes: vec![1.55, 5.90, 11.02],
295 diff_nums: vec![0.0, -34.84, -198.56],
296 },
297 CurveItem {
298 speeds: vec![8.0, 32.0, 128.0],
299 slopes: vec![1.63, 6.47, 12.09],
300 diff_nums: vec![0.0, -38.80, -218.36],
301 },
302 CurveItem {
303 speeds: vec![8.0, 32.0, 128.0],
304 slopes: vec![1.70, 7.05, 13.15],
305 diff_nums: vec![0.0, -42.76, -238.17],
306 },
307 ],
308 });
309 });
310 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
311 }
312 }
313
314 impl KLVTouchpadAccelerateCurves {
get_instancenull315 fn get_instance() -> &'static KLVTouchpadAccelerateCurves {
316 static mut GLOBAL_CURVES: Option<KLVTouchpadAccelerateCurves> = None;
317 static ONCE: Once = Once::new();
318
319 ONCE.call_once(|| unsafe {
320 GLOBAL_CURVES = Some(KLVTouchpadAccelerateCurves {
321 data: vec![
322 CurveItem {
323 speeds: vec![1.27, 12.73, 19.09, 81.46],
324 slopes: vec![0.14, 0.25, 0.53, 1.03],
325 diff_nums: vec![0.0, -0.14, -3.74, -13.19]
326 },
327 CurveItem {
328 speeds: vec![1.27, 12.73, 19.09, 81.46],
329 slopes: vec![0.19, 0.33, 0.71, 1.37],
330 diff_nums: vec![0.0, -0.18, -4.98, -17.58],
331 },
332 CurveItem {
333 speeds: vec![1.27, 12.73, 19.09, 81.46],
334 slopes: vec![0.24, 0.41, 0.88, 1.71],
335 diff_nums: vec![0.0, -0.21, -5.91, -20.88],
336 },
337 CurveItem {
338 speeds: vec![1.27, 12.73, 19.09, 81.46],
339 slopes: vec![0.28, 0.49, 1.06, 2.05],
340 diff_nums: vec![0.0, -0.27, -7.47, -26.37],
341 },
342 CurveItem {
343 speeds: vec![1.27, 12.73, 19.09, 81.46],
344 slopes: vec![0.38, 0.66, 1.41, 2.73],
345 diff_nums: vec![0.0, -0.36, -9.96, -35.16],
346 },
347 CurveItem {
348 speeds: vec![1.27, 12.73, 19.09, 81.46],
349 slopes: vec![0.47, 0.82, 1.77, 3.42],
350 diff_nums: vec![0.0, -0.45, -12.45, -43.95],
351 },
352 CurveItem {
353 speeds: vec![1.27, 12.73, 19.09, 81.46],
354 slopes: vec![0.57, 0.99, 2.12, 4.10],
355 diff_nums: vec![0.0, -0.54, -14.94, -52.74],
356 },
357 CurveItem {
358 speeds: vec![1.27, 12.73, 19.09, 81.46],
359 slopes: vec![0.71, 1.24, 2.65, 5.13],
360 diff_nums: vec![0.0, -0.68, -18.68, -65.93],
361 },
362 CurveItem {
363 speeds: vec![1.27, 12.73, 19.09, 81.46],
364 slopes: vec![0.90, 1.57, 3.36, 6.49],
365 diff_nums: vec![0.0, -0.86, -23.66, -83.51],
366 },
367 CurveItem {
368 speeds: vec![1.27, 12.73, 19.09, 81.46],
369 slopes: vec![1.08, 1.90, 4.07, 7.86],
370 diff_nums: vec![0.0, -1.04, -28.64, -101.09],
371 },
372 CurveItem {
373 speeds: vec![1.27, 12.73, 19.09, 81.46],
374 slopes: vec![1.27, 2.23, 4.77, 9.23],
375 diff_nums: vec![0.0, -1.22, -33.62, -118.67],
376 },
377 ],
378 });
379 });
380 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
381 }
382 }
383
384 impl SoftHardenTouchpadAccelerateCurves {
get_instancenull385 fn get_instance() -> &'static SoftHardenTouchpadAccelerateCurves {
386 static mut GLOBAL_CURVES: Option<SoftHardenTouchpadAccelerateCurves> = None;
387 static ONCE: Once = Once::new();
388
389 ONCE.call_once(|| unsafe {
390 GLOBAL_CURVES = Some(SoftHardenTouchpadAccelerateCurves {
391 data: vec![
392 CurveItem {
393 speeds: vec![2.45, 24.51, 36.77, 156.87],
394 slopes: vec![0.10, 0.18, 0.39, 0.75],
395 diff_nums: vec![0.0, -0.19, -5.25, -18.52]
396 },
397 CurveItem {
398 speeds: vec![2.45, 24.51, 36.77, 156.87],
399 slopes: vec![0.14, 0.24, 0.52, 1.00],
400 diff_nums: vec![0.0, -0.25, -6.99, -24.69],
401 },
402 CurveItem {
403 speeds: vec![2.45, 24.51, 36.77, 156.87],
404 slopes: vec![0.17, 0.30, 0.64, 1.25],
405 diff_nums: vec![0.0, -0.32, -8.74, -30.86],
406 },
407 CurveItem {
408 speeds: vec![2.45, 24.51, 36.77, 156.87],
409 slopes: vec![0.21, 0.36, 0.77, 1.50],
410 diff_nums: vec![0.0, -0.38, -10.49, -37.03],
411 },
412 CurveItem {
413 speeds: vec![2.45, 24.51, 36.77, 156.87],
414 slopes: vec![0.28, 0.48, 1.03, 1.99],
415 diff_nums: vec![0.0, -0.51, -13.99, -49.38],
416 },
417 CurveItem {
418 speeds: vec![2.45, 24.51, 36.77, 156.87],
419 slopes: vec![0.34, 0.60, 1.29, 2.49],
420 diff_nums: vec![0.0, -0.63, -17.48, -61.72],
421 },
422 CurveItem {
423 speeds: vec![2.45, 24.51, 36.77, 156.87],
424 slopes: vec![0.41, 0.72, 1.55, 2.99],
425 diff_nums: vec![0.0, -0.76, -20.98, -74.06],
426 },
427 CurveItem {
428 speeds: vec![2.45, 24.51, 36.77, 156.87],
429 slopes: vec![0.52, 0.90, 1.93, 3.74],
430 diff_nums: vec![0.0, -0.95, -26.23, -92.58],
431 },
432 CurveItem {
433 speeds: vec![2.45, 24.51, 36.77, 156.87],
434 slopes: vec![0.65, 1.14, 2.45, 4.74],
435 diff_nums: vec![0.0, -0.86, -23.66, -83.51],
436 },
437 CurveItem {
438 speeds: vec![2.45, 24.51, 36.77, 156.87],
439 slopes: vec![0.79, 1.38, 2.96, 5.73],
440 diff_nums: vec![0.0, -1.45, -40.21, -141.96],
441 },
442 CurveItem {
443 speeds: vec![2.45, 24.51, 36.77, 156.87],
444 slopes: vec![0.93, 1.62, 3.48, 6.73],
445 diff_nums: vec![0.0, -1.71, -47.21, -166.64],
446 },
447 ],
448 });
449 });
450 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
451 }
452 }
453
454 impl HardHardenTouchpadAccelerateCurves {
get_instancenull455 fn get_instance() -> &'static HardHardenTouchpadAccelerateCurves {
456 static mut GLOBAL_CURVES: Option<HardHardenTouchpadAccelerateCurves> = None;
457 static ONCE: Once = Once::new();
458
459 ONCE.call_once(|| unsafe {
460 GLOBAL_CURVES = Some(HardHardenTouchpadAccelerateCurves {
461 data: vec![
462 CurveItem {
463 speeds: vec![2.45, 24.51, 36.77, 156.87],
464 slopes: vec![0.10, 0.17, 0.36, 0.69],
465 diff_nums: vec![0.0, -0.18, -4.84, -17.09]
466 },
467 CurveItem {
468 speeds: vec![2.45, 24.51, 36.77, 156.87],
469 slopes: vec![0.13, 0.22, 0.48, 0.92],
470 diff_nums: vec![0.0, -0.23, -6.46, -22.79],
471 },
472 CurveItem {
473 speeds: vec![2.45, 24.51, 36.77, 156.87],
474 slopes: vec![0.16, 0.28, 0.59, 1.15],
475 diff_nums: vec![0.0, -0.29, -8.07, -28.49],
476 },
477 CurveItem {
478 speeds: vec![2.45, 24.51, 36.77, 156.87],
479 slopes: vec![0.19, 0.33, 0.71, 1.38],
480 diff_nums: vec![0.0, -0.35, -9.68, -34.18],
481 },
482 CurveItem {
483 speeds: vec![2.45, 24.51, 36.77, 156.87],
484 slopes: vec![0.25, 0.44, 0.95, 1.84],
485 diff_nums: vec![0.0, -0.47, -12.91, -45.58],
486 },
487 CurveItem {
488 speeds: vec![2.45, 24.51, 36.77, 156.87],
489 slopes: vec![0.32, 0.56, 1.19, 2.30],
490 diff_nums: vec![0.0, -0.58, -16.14, -56.97],
491 },
492 CurveItem {
493 speeds: vec![2.45, 24.51, 36.77, 156.87],
494 slopes: vec![0.38, 0.67, 1.43, 2.76],
495 diff_nums: vec![0.0, -0.70, -19.37, -68.37],
496 },
497 CurveItem {
498 speeds: vec![2.45, 24.51, 36.77, 156.87],
499 slopes: vec![0.48, 0.83, 1.78, 3.45],
500 diff_nums: vec![0.0, -0.88, -24.21, -85.46],
501 },
502 CurveItem {
503 speeds: vec![2.45, 24.51, 36.77, 156.87],
504 slopes: vec![0.60, 1.06, 2.26, 4.37],
505 diff_nums: vec![0.0, -1.11, -30.66, -108.25],
506 },
507 CurveItem {
508 speeds: vec![2.45, 24.51, 36.77, 156.87],
509 slopes: vec![0.73, 1.28, 2.74, 5.29],
510 diff_nums: vec![0.0, -1.34, -37.12, -131.04],
511 },
512 CurveItem {
513 speeds: vec![2.45, 24.51, 36.77, 156.87],
514 slopes: vec![0.86, 1.50, 3.21, 6.21],
515 diff_nums: vec![0.0, -1.58, -43.58, -153.83],
516 },
517 ],
518 });
519 });
520 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
521 }
522 }
523
524 impl AxisAccelerateCurvesTouchpad {
get_instancenull525 fn get_instance() -> &'static AxisAccelerateCurvesTouchpad {
526 static mut GLOBAL_CURVES: Option<AxisAccelerateCurvesTouchpad> = None;
527 static ONCE: Once = Once::new();
528
529 ONCE.call_once(|| unsafe {
530 GLOBAL_CURVES = Some(AxisAccelerateCurvesTouchpad {
531 data: vec![
532 CurveItem {
533 speeds: vec![3.0, 5.0, 6.0, 8.0, 10.0, 41.0],
534 slopes: vec![1.07, 0.80, 0.65, 0.55, 0.52, 0.81],
535 diff_nums: vec![0.0, 0.81, 1.56, 2.16, 2.4, -0.5]
536 },
537 CurveItem {
538 speeds: vec![1.0, 3.0, 5.0, 6.0, 7.0, 8.0, 41.0],
539 slopes: vec![1.52, 0.96, 0.71, 0.57, 0.47, 0.67, 0.75],
540 diff_nums: vec![0.0, 0.56, 1.31, 2.01, 2.61, 1.21, 0.57]
541 },
542 ],
543 });
544 });
545 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
546 }
547 }
548
549 impl WeberTouchpadAccelerateCurves {
get_instancenull550 fn get_instance() -> &'static WeberTouchpadAccelerateCurves {
551 static mut GLOBAL_CURVES: Option<WeberTouchpadAccelerateCurves> = None;
552 static ONCE: Once = Once::new();
553
554 ONCE.call_once(|| unsafe {
555 GLOBAL_CURVES = Some(WeberTouchpadAccelerateCurves {
556 data: vec![
557 CurveItem {
558 speeds: vec![2.0, 20.0, 30.0, 128.0],
559 slopes: vec![0.12, 0.21, 0.45, 0.87],
560 diff_nums: vec![0.0, -0.18, -4.98, -17.58]
561 },
562 CurveItem {
563 speeds: vec![2.0, 20.0, 30.0, 128.0],
564 slopes: vec![0.16, 0.28, 0.60, 1.16],
565 diff_nums: vec![0.0, -0.24, -6.64, -23.44],
566 },
567 CurveItem {
568 speeds: vec![2.0, 20.0, 30.0, 128.0],
569 slopes: vec![0.20, 0.35, 0.75, 1.45],
570 diff_nums: vec![0.0, -0.30, -8.30, -29.30],
571 },
572 CurveItem {
573 speeds: vec![2.0, 20.0, 30.0, 128.0],
574 slopes: vec![0.24, 0.42, 0.90, 1.74],
575 diff_nums: vec![0.0, -0.36, -9.96, -35.16],
576 },
577 CurveItem {
578 speeds: vec![2.0, 20.0, 30.0, 128.0],
579 slopes: vec![0.32, 0.56, 1.20, 2.32],
580 diff_nums: vec![0.0, -0.48, -13.28, -46.88],
581 },
582 CurveItem {
583 speeds: vec![2.0, 20.0, 30.0, 128.0],
584 slopes: vec![0.40, 0.70, 1.50, 2.90],
585 diff_nums: vec![0.0, -0.60, -16.60, -58.60],
586 },
587 CurveItem {
588 speeds: vec![2.0, 20.0, 30.0, 128.0],
589 slopes: vec![0.48, 0.84, 1.80, 3.48],
590 diff_nums: vec![0.0, -0.72, -19.92, -70.32],
591 },
592 CurveItem {
593 speeds: vec![2.0, 20.0, 30.0, 128.0],
594 slopes: vec![0.60, 1.05, 2.25, 4.35],
595 diff_nums: vec![0.0, -0.90, -24.90, -87.90],
596 },
597 CurveItem {
598 speeds: vec![2.0, 20.0, 30.0, 128.0],
599 slopes: vec![0.76, 1.33, 2.85, 5.51],
600 diff_nums: vec![0.0, -1.14, -31.54, -111.34],
601 },
602 CurveItem {
603 speeds: vec![2.0, 20.0, 30.0, 128.0],
604 slopes: vec![0.92, 1.61, 3.45, 6.67],
605 diff_nums: vec![0.0, -1.38, -38.18, -134.78],
606 },
607 CurveItem {
608 speeds: vec![2.0, 20.0, 30.0, 128.0],
609 slopes: vec![1.08, 1.89, 4.05, 7.83],
610 diff_nums: vec![0.0, -1.62, -44.82, -158.22],
611 },
612 ],
613 });
614 });
615 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
616 }
617 }
618
619 // 这个 extern 代码块链接到 libm 库
620 #[link(name = "m")]
621 extern {
fabsnull622 fn fabs(z: f64) -> f64;
fmaxnull623 fn fmax(a: f64, b: f64) -> f64;
fminnull624 fn fmin(a: f64, b: f64) -> f64;
625 }
626
get_speed_gain_mousenull627 fn get_speed_gain_mouse(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
628 debug!(LOG_LABEL, "get_speed_gain_mouse enter vin is set to {} speed {}, device_type {}",
629 @public(vin), @public(speed), @public(device_type));
630 unsafe {
631 if fabs(vin) < DOUBLE_ZERO {
632 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
633 return false;
634 }
635 }
636 if speed < 1 {
637 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
638 return false;
639 }
640 let item = match device_type {
641 1 => KLVMouseAccelerateCurves::get_instance().klv_mouse_get_curve_by_speed(speed as usize),
642 2 => SoftHardenMouseAccelerateCurves::get_instance().soft_harden_mouse_get_curve_by_speed(speed as usize),
643 3 => HardHardenMouseAccelerateCurves::get_instance().hard_harden_mouse_get_curve_by_speed(speed as usize),
644 _ => KLVMouseAccelerateCurves::get_instance().klv_mouse_get_curve_by_speed(speed as usize),
645 };
646 unsafe {
647 let num: f64 = fabs(vin);
648 let len = item.speeds.len();
649 for i in 0..len {
650 if num <= item.speeds[i] {
651 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
652 debug!(LOG_LABEL, "slope is set to {}, gain is {}", @public(item.slopes[i]), @public(*gain));
653 return true;
654 }
655 }
656 *gain = (item.slopes[len - 1] * vin + item.diff_nums[len - 1]) / vin;
657 debug!(LOG_LABEL, "slope is set to {}, gain is {}", @public(item.slopes[len - 1]), @public(*gain));
658 }
659 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
660 true
661 }
662
663
get_speed_gain_touchpadnull664 fn get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
665 debug!(LOG_LABEL, "get_speed_gain_touchpad enter vin is set to {}, speed {}, device_type {}",
666 @public(vin), @public(speed), @public(device_type));
667 unsafe {
668 if fabs(vin) < DOUBLE_ZERO {
669 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
670 return false;
671 }
672 }
673 if speed < 1 {
674 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
675 return false;
676 }
677 let item = match device_type {
678 1 => KLVTouchpadAccelerateCurves::get_instance().klv_touchpad_get_curve_by_speed(speed as usize),
679 2 => SoftHardenTouchpadAccelerateCurves::get_instance().soft_harden_touchpad_get_curve_by_speed(speed as usize),
680 3 => HardHardenTouchpadAccelerateCurves::get_instance().hard_harden_touchpad_get_curve_by_speed(speed as usize),
681 4 => WeberTouchpadAccelerateCurves::get_instance().weber_touchpad_get_curve_by_speed(speed as usize),
682 _ => KLVTouchpadAccelerateCurves::get_instance().klv_touchpad_get_curve_by_speed(speed as usize),
683 };
684 unsafe {
685 let num: f64 = fabs(vin);
686 for i in 0..4 {
687 if num <= item.speeds[i] {
688 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
689 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[i])/ vin));
690 return true;
691 }
692 }
693 *gain = (item.slopes[3] * vin + item.diff_nums[3]) / vin;
694 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[3])/ vin));
695 }
696 debug!(LOG_LABEL, "get_speed_gain_touchpad leave");
697 true
698 }
699
get_axis_gain_touchpadnull700 fn get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool {
701 debug!(LOG_LABEL, "get_axis_gain_touchpad enter axis_speed is set to {}, device_type {}",
702 @public(axis_speed), @public(device_type));
703 let valid_device_type = match device_type {
704 1..=2 => device_type,
705 _ => 1,
706 };
707 let item = AxisAccelerateCurvesTouchpad::get_instance().get_axis_curve_by_speed_touchpad(valid_device_type as usize);
708 unsafe {
709 let num: f64 = fabs(axis_speed);
710 let len = item.speeds.len();
711 for i in 0..len {
712 if num <= item.speeds[i] {
713 *gain = item.slopes[i] * num + item.diff_nums[i];
714 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[i]) / num));
715 return true;
716 }
717 }
718 *gain = item.slopes[len - 1] * num + item.diff_nums[len - 1];
719 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[len - 1]) / num));
720 }
721 debug!(LOG_LABEL, "get_axis_gain_touchpad leave");
722 true
723 }
724
725 /// Offset struct is defined in C++, which give the vlaue
726 /// dx = libinput_event_pointer_get_dx
727 /// dy = libinput_event_pointer_get_dy
728 #[repr(C)]
729 pub struct Offset {
730 dx: f64,
731 dy: f64,
732 }
733
734 /// # Safety
735 /// HandleMotionAccelerateMouse is the origin C++ function name
736 /// C++ will call for rust realization using this name
737 #[no_mangle]
738 pub unsafe extern "C" fn HandleMotionAccelerateMouse (
739 offset: *const Offset,
740 mode: bool,
741 abs_x: *mut f64,
742 abs_y: *mut f64,
743 speed: i32,
744 device_type: i32
745 ) -> i32 {
746 let mut gain = 0.0;
747 let vin: f64;
748 let dx: f64;
749 let dy: f64;
750 unsafe {
751 dx = (*offset).dx;
752 dy = (*offset).dy;
753 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
754 debug!(
755 LOG_LABEL,
756 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
757 @private(*abs_x),
758 @private(*abs_y),
759 @public(mode),
760 @private(dx),
761 @private(dy),
762 @public(gain)
763 );
764 if !get_speed_gain_mouse(vin, &mut gain as *mut f64, speed, device_type) {
765 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
766 return RET_ERR;
767 }
768 if !mode {
769 *abs_x += dx * gain;
770 *abs_y += dy * gain;
771 }
772 debug!(
773 LOG_LABEL,
774 "abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
775 );
776 }
777 RET_OK
778 }
779
780 /// # Safety
781 /// HandleMotionAccelerateTouchpad is the origin C++ function name
782 /// C++ will call for rust realization using this name
783 #[no_mangle]
784 pub unsafe extern "C" fn HandleMotionAccelerateTouchpad (
785 offset: *const Offset,
786 mode: bool,
787 abs_x: *mut f64,
788 abs_y: *mut f64,
789 speed: i32,
790 device_type: i32
791 ) -> i32 {
792 let mut gain = 0.0;
793 let vin: f64;
794 let dx: f64;
795 let dy: f64;
796 let deltax: f64;
797 let deltay: f64;
798 unsafe {
799 dx = (*offset).dx;
800 dy = (*offset).dy;
801 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
802 debug!(
803 LOG_LABEL,
804 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
805 @private(*abs_x),
806 @private(*abs_y),
807 @public(mode),
808 @private(dx),
809 @private(dy),
810 @public(gain)
811 );
812 if !get_speed_gain_touchpad(vin, &mut gain as *mut f64, speed, device_type) {
813 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
814 return RET_ERR;
815 }
816 if !mode {
817 deltax = (dx * gain + COMPENSATE_VALUEX).trunc();
818 deltay = (dy * gain + COMPENSATE_VALUEY).trunc();
819 COMPENSATE_VALUEX = (dx * gain + COMPENSATE_VALUEX).fract();
820 COMPENSATE_VALUEY = (dy * gain + COMPENSATE_VALUEY).fract();
821 *abs_x += deltax;
822 *abs_y += deltay;
823 }
824 debug!(
825 LOG_LABEL,
826 "output the abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
827 );
828 }
829 RET_OK
830 }
831
832 /// # Safety
833 /// HandleAxisAccelerateTouchpad is the origin C++ function name
834 /// C++ will call for rust realization using this name
835 #[no_mangle]
836 pub unsafe extern "C" fn HandleAxisAccelerateTouchpad (
837 mode: bool,
838 abs_axis: *mut f64,
839 device_type: i32
840 ) -> i32 {
841 let mut gain = 0.0;
842 unsafe {
843 debug!(
844 LOG_LABEL,
845 "input the abs_axis {} and captureMode {} gain {}",
846 @public(*abs_axis),
847 @public(mode),
848 @public(gain)
849 );
850 if !get_axis_gain_touchpad(&mut gain as *mut f64, *abs_axis, device_type) {
851 error!(LOG_LABEL, "{} getAxisGain failed!", @public(*abs_axis));
852 return RET_ERR;
853 }
854 if !mode {
855 *abs_axis = if *abs_axis >= 0.0 { gain } else { -gain };
856 }
857 debug!(
858 LOG_LABEL,
859 "output the abs_axis {}", @public(*abs_axis)
860 );
861 }
862 RET_OK
863 }
864
865 #[test]
test_handle_motion_accelerate_normalnull866 fn test_handle_motion_accelerate_normal()
867 {
868 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
869 let mut abs_x: f64 = 0.0;
870 let mut abs_y: f64 = 0.0;
871 let ret: i32;
872 unsafe {
873 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
874 }
875 assert_eq!(ret, RET_OK);
876 }
877
878 #[test]
test_handle_motion_accelerate_mini_limitnull879 fn test_handle_motion_accelerate_mini_limit()
880 {
881 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
882 let mut abs_x: f64 = 0.0;
883 let mut abs_y: f64 = 0.0;
884 let ret: i32;
885 unsafe {
886 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
887 }
888 assert_eq!(ret, RET_ERR);
889 }
890
891 #[test]
test_handle_motion_accelerate_capture_mode_falsenull892 fn test_handle_motion_accelerate_capture_mode_false()
893 {
894 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
895 let mut abs_x: f64 = 0.0;
896 let mut abs_y: f64 = 0.0;
897 let ret: i32;
898 unsafe {
899 ret = HandleMotionAccelerateMouse(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
900 }
901 assert_eq!(ret, RET_OK);
902 assert_eq!(abs_x, 0.0);
903 assert_eq!(abs_y, 0.0);
904 }
905
906 /* test for touchpad */
907 #[test]
test_handle_motion_accelerate_normal_touchpadnull908 fn test_handle_motion_accelerate_normal_touchpad()
909 {
910 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
911 let mut abs_x: f64 = 0.0;
912 let mut abs_y: f64 = 0.0;
913 let ret: i32;
914 unsafe {
915 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
916 }
917 assert_eq!(ret, RET_OK);
918 }
919
920 #[test]
test_handle_motion_accelerate_mini_limit_touchpadnull921 fn test_handle_motion_accelerate_mini_limit_touchpad()
922 {
923 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
924 let mut abs_x: f64 = 0.0;
925 let mut abs_y: f64 = 0.0;
926 let ret: i32;
927 unsafe {
928 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
929 }
930 assert_eq!(ret, RET_ERR);
931 }
932
933 #[test]
test_handle_motion_accelerate_capture_mode_false_touchpadnull934 fn test_handle_motion_accelerate_capture_mode_false_touchpad()
935 {
936 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
937 let mut abs_x: f64 = 0.0;
938 let mut abs_y: f64 = 0.0;
939 let ret: i32;
940 unsafe {
941 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
942 }
943 assert_eq!(ret, RET_OK);
944 assert_eq!(abs_x, 0.0);
945 assert_eq!(abs_y, 0.0);
946 }
947
948 /* test for touchpad klv */
949 #[test]
test_handle_motion_accelerate_capture_klv_offset_false_touchpadnull950 fn test_handle_motion_accelerate_capture_klv_offset_false_touchpad()
951 {
952 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
953 let mut abs_x: f64 = 0.0;
954 let mut abs_y: f64 = 0.0;
955 let ret: i32;
956 unsafe {
957 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
958 }
959 assert_eq!(ret, RET_ERR);
960 assert_eq!(abs_x, 0.0);
961 assert_eq!(abs_y, 0.0);
962 }
963
964 #[test]
test_handle_motion_accelerate_capture_klv_speed_false_touchpadnull965 fn test_handle_motion_accelerate_capture_klv_speed_false_touchpad()
966 {
967 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
968 let mut abs_x: f64 = 0.0;
969 let mut abs_y: f64 = 0.0;
970 let ret: i32;
971 unsafe {
972 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 1);
973 }
974 assert_eq!(ret, RET_ERR);
975 assert_eq!(abs_x, 0.0);
976 assert_eq!(abs_y, 0.0);
977 }
978
979 #[test]
test_handle_motion_accelerate_capture_klv_mode_false_touchpadnull980 fn test_handle_motion_accelerate_capture_klv_mode_false_touchpad()
981 {
982 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
983 let mut abs_x: f64 = 0.0;
984 let mut abs_y: f64 = 0.0;
985 let ret: i32;
986 unsafe {
987 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
988 }
989 assert_eq!(ret, RET_OK);
990 }
991
992 #[test]
test_handle_motion_accelerate_capture_klv_nomarl_touchpadnull993 fn test_handle_motion_accelerate_capture_klv_nomarl_touchpad()
994 {
995 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
996 let mut abs_x: f64 = 0.0;
997 let mut abs_y: f64 = 0.0;
998 let ret: i32;
999 unsafe {
1000 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1001 }
1002 assert_eq!(ret, RET_OK);
1003 }
1004
1005 #[test]
test_handle_motion_accelerate_capture_klv_offset_exceed_max_touchpadnull1006 fn test_handle_motion_accelerate_capture_klv_offset_exceed_max_touchpad()
1007 {
1008 let offset: Offset = Offset{ dx: 82.00002, dy: 82.00004 };
1009 let mut abs_x: f64 = 0.0;
1010 let mut abs_y: f64 = 0.0;
1011 let ret: i32;
1012 unsafe {
1013 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1014 }
1015 assert_eq!(ret, RET_OK);
1016 assert_eq!(abs_x, 0.0);
1017 assert_eq!(abs_y, 0.0);
1018 }
1019
1020 /* test for touchpad soft_harden */
1021 #[test]
test_handle_motion_accelerate_capture_soft_harden_offset_false_touchpadnull1022 fn test_handle_motion_accelerate_capture_soft_harden_offset_false_touchpad()
1023 {
1024 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1025 let mut abs_x: f64 = 0.0;
1026 let mut abs_y: f64 = 0.0;
1027 let ret: i32;
1028 unsafe {
1029 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1030 debug!(
1031 LOG_LABEL,
1032 "ret = {}", @public(ret)
1033 );
1034 }
1035 assert_eq!(ret, RET_ERR);
1036 assert_eq!(abs_x, 0.0);
1037 assert_eq!(abs_y, 0.0);
1038 }
1039
1040 #[test]
test_handle_motion_accelerate_capture_soft_harden_speed_false_touchpadnull1041 fn test_handle_motion_accelerate_capture_soft_harden_speed_false_touchpad()
1042 {
1043 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1044 let mut abs_x: f64 = 0.0;
1045 let mut abs_y: f64 = 0.0;
1046 let ret: i32;
1047 unsafe {
1048 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 2);
1049 }
1050 assert_eq!(ret, RET_ERR);
1051 assert_eq!(abs_x, 0.0);
1052 assert_eq!(abs_y, 0.0);
1053 }
1054
1055 #[test]
test_handle_motion_accelerate_capture_soft_harden_mode_false_touchpadnull1056 fn test_handle_motion_accelerate_capture_soft_harden_mode_false_touchpad()
1057 {
1058 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1059 let mut abs_x: f64 = 0.0;
1060 let mut abs_y: f64 = 0.0;
1061 let ret: i32;
1062 unsafe {
1063 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1064 }
1065 assert_eq!(ret, RET_OK);
1066 }
1067
1068 #[test]
test_handle_motion_accelerate_capture_soft_harden_nomarl_touchpadnull1069 fn test_handle_motion_accelerate_capture_soft_harden_nomarl_touchpad()
1070 {
1071 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1072 let mut abs_x: f64 = 0.0;
1073 let mut abs_y: f64 = 0.0;
1074 let ret: i32;
1075 unsafe {
1076 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1077 }
1078 assert_eq!(ret, RET_OK);
1079 }
1080
1081 #[test]
test_handle_motion_accelerate_capture_soft_harden_offset_exceed_max_touchpadnull1082 fn test_handle_motion_accelerate_capture_soft_harden_offset_exceed_max_touchpad()
1083 {
1084 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1085 let mut abs_x: f64 = 0.0;
1086 let mut abs_y: f64 = 0.0;
1087 let ret: i32;
1088 unsafe {
1089 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1090 }
1091 assert_eq!(ret, RET_OK);
1092 assert_eq!(abs_x, 0.0);
1093 assert_eq!(abs_y, 0.0);
1094 }
1095
1096 /* test for touchpad hard_harden */
1097 #[test]
test_handle_motion_accelerate_capture_hard_harden_offset_false_touchpadnull1098 fn test_handle_motion_accelerate_capture_hard_harden_offset_false_touchpad()
1099 {
1100 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1101 let mut abs_x: f64 = 0.0;
1102 let mut abs_y: f64 = 0.0;
1103 let ret: i32;
1104 unsafe {
1105 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1106 }
1107 assert_eq!(ret, RET_ERR);
1108 assert_eq!(abs_x, 0.0);
1109 assert_eq!(abs_y, 0.0);
1110 }
1111
1112 #[test]
test_handle_motion_accelerate_capture_hard_harden_speed_false_touchpadnull1113 fn test_handle_motion_accelerate_capture_hard_harden_speed_false_touchpad()
1114 {
1115 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1116 let mut abs_x: f64 = 0.0;
1117 let mut abs_y: f64 = 0.0;
1118 let ret: i32;
1119 unsafe {
1120 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 3);
1121 }
1122 assert_eq!(ret, RET_ERR);
1123 assert_eq!(abs_x, 0.0);
1124 assert_eq!(abs_y, 0.0);
1125 }
1126
1127 #[test]
test_handle_motion_accelerate_capture_hard_harden_mode_false_touchpadnull1128 fn test_handle_motion_accelerate_capture_hard_harden_mode_false_touchpad()
1129 {
1130 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1131 let mut abs_x: f64 = 0.0;
1132 let mut abs_y: f64 = 0.0;
1133 let ret: i32;
1134 unsafe {
1135 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1136 }
1137 assert_eq!(ret, RET_OK);
1138 }
1139
1140 #[test]
test_handle_motion_accelerate_capture_hard_harden_nomarl_touchpadnull1141 fn test_handle_motion_accelerate_capture_hard_harden_nomarl_touchpad()
1142 {
1143 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1144 let mut abs_x: f64 = 0.0;
1145 let mut abs_y: f64 = 0.0;
1146 let ret: i32;
1147 unsafe {
1148 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1149 }
1150 assert_eq!(ret, RET_OK);
1151 }
1152
1153 #[test]
test_handle_motion_accelerate_capture_hard_harden_offset_exceed_max_touchpadnull1154 fn test_handle_motion_accelerate_capture_hard_harden_offset_exceed_max_touchpad()
1155 {
1156 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1157 let mut abs_x: f64 = 0.0;
1158 let mut abs_y: f64 = 0.0;
1159 let ret: i32;
1160 unsafe {
1161 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1162 }
1163 assert_eq!(ret, RET_OK);
1164 assert_eq!(abs_x, 0.0);
1165 assert_eq!(abs_y, 0.0);
1166 }
1167 /* test touchpad axis */
1168 #[test]
test_handle_axis_accelerate_normal_touchpadnull1169 fn test_handle_axis_accelerate_normal_touchpad()
1170 {
1171 let mut abs_axis: f64 = 19.29931034482759;
1172 let ret: i32;
1173 unsafe {
1174 ret = HandleAxisAccelerateTouchpad(false, &mut abs_axis as *mut f64, 1);
1175 }
1176 assert_eq!(ret, RET_OK);
1177 }
1178
1179 #[test]
test_handle_axis_accelerate_capture_mode_false_touchpadnull1180 fn test_handle_axis_accelerate_capture_mode_false_touchpad()
1181 {
1182 let mut abs_axis: f64 = 19.29931034482759;
1183 let ret: i32;
1184 unsafe {
1185 ret = HandleAxisAccelerateTouchpad(true, &mut abs_axis as *mut f64, 1);
1186 }
1187 assert_eq!(ret, RET_OK);
1188 }
1189