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 PCMouseAccelerateCurves {
40 data: Vec<CurveItem>,
41 }
42 struct SoftPcproMouseAccelerateCurves {
43 data: Vec<CurveItem>,
44 }
45 struct HardPcproMouseAccelerateCurves {
46 data: Vec<CurveItem>,
47 }
48 struct PCTouchpadAccelerateCurves {
49 data: Vec<CurveItem>,
50 }
51 struct SoftPcproTouchpadAccelerateCurves {
52 data: Vec<CurveItem>,
53 }
54 struct HardPcproTouchpadAccelerateCurves {
55 data: Vec<CurveItem>,
56 }
57 struct TabletTouchpadAccelerateCurves {
58 data: Vec<CurveItem>,
59 }
60 struct AxisAccelerateCurvesTouchpad {
61 data: Vec<CurveItem>,
62 }
63 impl PCMouseAccelerateCurves {
pc_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem64 fn pc_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
65 &self.data[speed - 1]
66 }
67 }
68 impl SoftPcproMouseAccelerateCurves {
soft_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem69 fn soft_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
70 &self.data[speed - 1]
71 }
72 }
73 impl HardPcproMouseAccelerateCurves {
hard_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem74 fn hard_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
75 &self.data[speed - 1]
76 }
77 }
78 impl PCTouchpadAccelerateCurves {
pc_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem79 fn pc_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
80 &self.data[speed - 1]
81 }
82 }
83 impl SoftPcproTouchpadAccelerateCurves {
soft_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem84 fn soft_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
85 &self.data[speed - 1]
86 }
87 }
88 impl HardPcproTouchpadAccelerateCurves {
hard_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem89 fn hard_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
90 &self.data[speed - 1]
91 }
92 }
93 impl TabletTouchpadAccelerateCurves {
tablet_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem94 fn tablet_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
95 &self.data[speed - 1]
96 }
97 }
98 impl AxisAccelerateCurvesTouchpad {
get_axis_curve_by_speed_touchpad(&self, device_type: usize) -> &CurveItem99 fn get_axis_curve_by_speed_touchpad(&self, device_type: usize) -> &CurveItem {
100 &self.data[device_type - 1]
101 }
102 }
103
104 impl PCMouseAccelerateCurves {
get_instance() -> &'static PCMouseAccelerateCurves105 fn get_instance() -> &'static PCMouseAccelerateCurves {
106 static mut GLOBAL_CURVES: Option<PCMouseAccelerateCurves> = None;
107 static ONCE: Once = Once::new();
108
109 ONCE.call_once(|| unsafe {
110 GLOBAL_CURVES = Some(PCMouseAccelerateCurves {
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 SoftPcproMouseAccelerateCurves {
get_instance() -> &'static SoftPcproMouseAccelerateCurves175 fn get_instance() -> &'static SoftPcproMouseAccelerateCurves {
176 static mut GLOBAL_CURVES: Option<SoftPcproMouseAccelerateCurves> = None;
177 static ONCE: Once = Once::new();
178
179 ONCE.call_once(|| unsafe {
180 GLOBAL_CURVES = Some(SoftPcproMouseAccelerateCurves {
181 data: vec![
182 CurveItem {
183 speeds: vec![8.0, 32.0, 128.0],
184 slopes: vec![0.22, 0.41, 0.77],
185 diff_nums: vec![0.0, -1.54, -12.99],
186 },
187 CurveItem {
188 speeds: vec![8.0, 32.0, 128.0],
189 slopes: vec![0.44, 0.83, 1.54],
190 diff_nums: vec![0.0, -3.08, -25.97],
191 },
192 CurveItem {
193 speeds: vec![8.0, 32.0, 128.0],
194 slopes: vec![0.88, 1.65, 3.08],
195 diff_nums: vec![0.0, -6.16, -51.94],
196 },
197 CurveItem {
198 speeds: vec![8.0, 32.0, 128.0],
199 slopes: vec![1.10, 2.06, 3.85],
200 diff_nums: vec![0.0, -7.70, -64.93],
201 },
202 CurveItem {
203 speeds: vec![8.0, 32.0, 128.0],
204 slopes: vec![1.27, 3.30, 6.16],
205 diff_nums: vec![0.0, -16.29, -107.85],
206 },
207 CurveItem {
208 speeds: vec![8.0, 32.0, 128.0],
209 slopes: vec![1.43, 4.54, 8.47],
210 diff_nums: vec![0.0, -24.87, -150.77],
211 },
212 CurveItem {
213 speeds: vec![8.0, 32.0, 128.0],
214 slopes: vec![1.51, 5.16, 9.63],
215 diff_nums: vec![0.0, -29.16, -172.23],
216 },
217 CurveItem {
218 speeds: vec![8.0, 32.0, 128.0],
219 slopes: vec![1.60, 5.78, 10.79],
220 diff_nums: vec![0.0, -33.46, -193.69],
221 },
222 CurveItem {
223 speeds: vec![8.0, 32.0, 128.0],
224 slopes: vec![1.68, 6.40, 11.94],
225 diff_nums: vec![0.0, -37.75, -215.15],
226 },
227 CurveItem {
228 speeds: vec![8.0, 32.0, 128.0],
229 slopes: vec![1.76, 7.02, 13.10],
230 diff_nums: vec![0.0, -42.04, -236.61],
231 },
232 CurveItem {
233 speeds: vec![8.0, 32.0, 128.0],
234 slopes: vec![1.84, 7.63, 14.25],
235 diff_nums: vec![0.0, -46.33, -258.07],
236 },
237 ],
238 });
239 });
240 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
241 }
242 }
243
244 impl HardPcproMouseAccelerateCurves {
get_instance() -> &'static HardPcproMouseAccelerateCurves245 fn get_instance() -> &'static HardPcproMouseAccelerateCurves {
246 static mut GLOBAL_CURVES: Option<HardPcproMouseAccelerateCurves> = None;
247 static ONCE: Once = Once::new();
248
249 ONCE.call_once(|| unsafe {
250 GLOBAL_CURVES = Some(HardPcproMouseAccelerateCurves {
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 PCTouchpadAccelerateCurves {
get_instance() -> &'static PCTouchpadAccelerateCurves315 fn get_instance() -> &'static PCTouchpadAccelerateCurves {
316 static mut GLOBAL_CURVES: Option<PCTouchpadAccelerateCurves> = None;
317 static ONCE: Once = Once::new();
318
319 ONCE.call_once(|| unsafe {
320 GLOBAL_CURVES = Some(PCTouchpadAccelerateCurves {
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 SoftPcproTouchpadAccelerateCurves {
get_instance() -> &'static SoftPcproTouchpadAccelerateCurves385 fn get_instance() -> &'static SoftPcproTouchpadAccelerateCurves {
386 static mut GLOBAL_CURVES: Option<SoftPcproTouchpadAccelerateCurves> = None;
387 static ONCE: Once = Once::new();
388
389 ONCE.call_once(|| unsafe {
390 GLOBAL_CURVES = Some(SoftPcproTouchpadAccelerateCurves {
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 HardPcproTouchpadAccelerateCurves {
get_instance() -> &'static HardPcproTouchpadAccelerateCurves455 fn get_instance() -> &'static HardPcproTouchpadAccelerateCurves {
456 static mut GLOBAL_CURVES: Option<HardPcproTouchpadAccelerateCurves> = None;
457 static ONCE: Once = Once::new();
458
459 ONCE.call_once(|| unsafe {
460 GLOBAL_CURVES = Some(HardPcproTouchpadAccelerateCurves {
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_instance() -> &'static AxisAccelerateCurvesTouchpad525 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 TabletTouchpadAccelerateCurves {
get_instance() -> &'static TabletTouchpadAccelerateCurves550 fn get_instance() -> &'static TabletTouchpadAccelerateCurves {
551 static mut GLOBAL_CURVES: Option<TabletTouchpadAccelerateCurves> = None;
552 static ONCE: Once = Once::new();
553
554 ONCE.call_once(|| unsafe {
555 GLOBAL_CURVES = Some(TabletTouchpadAccelerateCurves {
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 {
fabs(z: f64) -> f64622 fn fabs(z: f64) -> f64;
fmax(a: f64, b: f64) -> f64623 fn fmax(a: f64, b: f64) -> f64;
fmin(a: f64, b: f64) -> f64624 fn fmin(a: f64, b: f64) -> f64;
625 }
626
get_speed_gain_mouse(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool627 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 => PCMouseAccelerateCurves::get_instance().pc_mouse_get_curve_by_speed(speed as usize),
642 2 => SoftPcproMouseAccelerateCurves::get_instance().soft_pc_pro_mouse_get_curve_by_speed(speed as usize),
643 3 => HardPcproMouseAccelerateCurves::get_instance().hard_pc_pro_mouse_get_curve_by_speed(speed as usize),
644 _ => PCMouseAccelerateCurves::get_instance().pc_mouse_get_curve_by_speed(speed as usize),
645 };
646 unsafe {
647 let num: f64 = fabs(vin);
648 for i in 0..3 {
649 if num <= item.speeds[i] {
650 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
651 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[i])/ vin));
652 return true;
653 }
654 }
655 *gain = (item.slopes[2] * vin + item.diff_nums[2]) / vin;
656 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[2])/ vin));
657 }
658 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
659 true
660 }
661
662
get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool663 fn get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
664 debug!(LOG_LABEL, "get_speed_gain_touchpad enter vin is set to {}, speed {}, device_type {}",
665 @public(vin), @public(speed), @public(device_type));
666 unsafe {
667 if fabs(vin) < DOUBLE_ZERO {
668 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
669 return false;
670 }
671 }
672 if speed < 1 {
673 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
674 return false;
675 }
676 let item = match device_type {
677 1 => PCTouchpadAccelerateCurves::get_instance().pc_touchpad_get_curve_by_speed(speed as usize),
678 2 => SoftPcproTouchpadAccelerateCurves::get_instance().soft_pc_pro_touchpad_get_curve_by_speed(speed as usize),
679 3 => HardPcproTouchpadAccelerateCurves::get_instance().hard_pc_pro_touchpad_get_curve_by_speed(speed as usize),
680 4 => TabletTouchpadAccelerateCurves::get_instance().tablet_touchpad_get_curve_by_speed(speed as usize),
681 _ => PCTouchpadAccelerateCurves::get_instance().pc_touchpad_get_curve_by_speed(speed as usize),
682 };
683 unsafe {
684 let num: f64 = fabs(vin);
685 for i in 0..4 {
686 if num <= item.speeds[i] {
687 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
688 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[i])/ vin));
689 return true;
690 }
691 }
692 *gain = (item.slopes[3] * vin + item.diff_nums[3]) / vin;
693 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[3])/ vin));
694 }
695 debug!(LOG_LABEL, "get_speed_gain_touchpad leave");
696 true
697 }
698
get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool699 fn get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool {
700 debug!(LOG_LABEL, "get_axis_gain_touchpad enter axis_speed is set to {}, device_type {}",
701 @public(axis_speed), @public(device_type));
702 let valid_device_type = match device_type {
703 1..=2 => device_type,
704 _ => 1,
705 };
706 let item = AxisAccelerateCurvesTouchpad::get_instance().get_axis_curve_by_speed_touchpad(valid_device_type as usize);
707 unsafe {
708 let num: f64 = fabs(axis_speed);
709 let len = item.speeds.len();
710 for i in 0..len {
711 if num <= item.speeds[i] {
712 *gain = item.slopes[i] * num + item.diff_nums[i];
713 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[i]) / num));
714 return true;
715 }
716 }
717 *gain = item.slopes[len - 1] * num + item.diff_nums[len - 1];
718 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[len - 1]) / num));
719 }
720 debug!(LOG_LABEL, "get_axis_gain_touchpad leave");
721 true
722 }
723
724 /// Offset struct is defined in C++, which give the vlaue
725 /// dx = libinput_event_pointer_get_dx
726 /// dy = libinput_event_pointer_get_dy
727 #[repr(C)]
728 pub struct Offset {
729 dx: f64,
730 dy: f64,
731 }
732
733 /// # Safety
734 /// HandleMotionAccelerateMouse is the origin C++ function name
735 /// C++ will call for rust realization using this name
736 #[no_mangle]
HandleMotionAccelerateMouse( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, device_type: i32 ) -> i32737 pub unsafe extern "C" fn HandleMotionAccelerateMouse (
738 offset: *const Offset,
739 mode: bool,
740 abs_x: *mut f64,
741 abs_y: *mut f64,
742 speed: i32,
743 device_type: i32
744 ) -> i32 {
745 let mut gain = 0.0;
746 let vin: f64;
747 let dx: f64;
748 let dy: f64;
749 unsafe {
750 dx = (*offset).dx;
751 dy = (*offset).dy;
752 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
753 debug!(
754 LOG_LABEL,
755 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
756 @private(*abs_x),
757 @private(*abs_y),
758 @public(mode),
759 @private(dx),
760 @private(dy),
761 @public(gain)
762 );
763 if !get_speed_gain_mouse(vin, &mut gain as *mut f64, speed, device_type) {
764 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
765 return RET_ERR;
766 }
767 if !mode {
768 *abs_x += dx * gain;
769 *abs_y += dy * gain;
770 }
771 debug!(
772 LOG_LABEL,
773 "abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
774 );
775 }
776 RET_OK
777 }
778
779 /// # Safety
780 /// HandleMotionAccelerateTouchpad is the origin C++ function name
781 /// C++ will call for rust realization using this name
782 #[no_mangle]
HandleMotionAccelerateTouchpad( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, device_type: i32 ) -> i32783 pub unsafe extern "C" fn HandleMotionAccelerateTouchpad (
784 offset: *const Offset,
785 mode: bool,
786 abs_x: *mut f64,
787 abs_y: *mut f64,
788 speed: i32,
789 device_type: i32
790 ) -> i32 {
791 let mut gain = 0.0;
792 let vin: f64;
793 let dx: f64;
794 let dy: f64;
795 let deltax: f64;
796 let deltay: f64;
797 unsafe {
798 dx = (*offset).dx;
799 dy = (*offset).dy;
800 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
801 debug!(
802 LOG_LABEL,
803 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
804 @private(*abs_x),
805 @private(*abs_y),
806 @public(mode),
807 @private(dx),
808 @private(dy),
809 @public(gain)
810 );
811 if !get_speed_gain_touchpad(vin, &mut gain as *mut f64, speed, device_type) {
812 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
813 return RET_ERR;
814 }
815 if !mode {
816 deltax = (dx * gain + COMPENSATE_VALUEX).trunc();
817 deltay = (dy * gain + COMPENSATE_VALUEY).trunc();
818 COMPENSATE_VALUEX = (dx * gain + COMPENSATE_VALUEX).fract();
819 COMPENSATE_VALUEY = (dy * gain + COMPENSATE_VALUEY).fract();
820 *abs_x += deltax;
821 *abs_y += deltay;
822 }
823 debug!(
824 LOG_LABEL,
825 "output the abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
826 );
827 }
828 RET_OK
829 }
830
831 /// # Safety
832 /// HandleAxisAccelerateTouchpad is the origin C++ function name
833 /// C++ will call for rust realization using this name
834 #[no_mangle]
HandleAxisAccelerateTouchpad( mode: bool, abs_axis: *mut f64, device_type: i32 ) -> i32835 pub unsafe extern "C" fn HandleAxisAccelerateTouchpad (
836 mode: bool,
837 abs_axis: *mut f64,
838 device_type: i32
839 ) -> i32 {
840 let mut gain = 0.0;
841 unsafe {
842 debug!(
843 LOG_LABEL,
844 "input the abs_axis {} and captureMode {} gain {}",
845 @public(*abs_axis),
846 @public(mode),
847 @public(gain)
848 );
849 if !get_axis_gain_touchpad(&mut gain as *mut f64, *abs_axis, device_type) {
850 error!(LOG_LABEL, "{} getAxisGain failed!", @public(*abs_axis));
851 return RET_ERR;
852 }
853 if !mode {
854 *abs_axis = if *abs_axis >= 0.0 { gain } else { -gain };
855 }
856 debug!(
857 LOG_LABEL,
858 "output the abs_axis {}", @public(*abs_axis)
859 );
860 }
861 RET_OK
862 }
863
864 #[test]
test_handle_motion_accelerate_normal()865 fn test_handle_motion_accelerate_normal()
866 {
867 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
868 let mut abs_x: f64 = 0.0;
869 let mut abs_y: f64 = 0.0;
870 let ret: i32;
871 unsafe {
872 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
873 }
874 assert_eq!(ret, RET_OK);
875 }
876
877 #[test]
test_handle_motion_accelerate_mini_limit()878 fn test_handle_motion_accelerate_mini_limit()
879 {
880 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
881 let mut abs_x: f64 = 0.0;
882 let mut abs_y: f64 = 0.0;
883 let ret: i32;
884 unsafe {
885 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
886 }
887 assert_eq!(ret, RET_ERR);
888 }
889
890 #[test]
test_handle_motion_accelerate_capture_mode_false()891 fn test_handle_motion_accelerate_capture_mode_false()
892 {
893 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
894 let mut abs_x: f64 = 0.0;
895 let mut abs_y: f64 = 0.0;
896 let ret: i32;
897 unsafe {
898 ret = HandleMotionAccelerateMouse(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
899 }
900 assert_eq!(ret, RET_OK);
901 assert_eq!(abs_x, 0.0);
902 assert_eq!(abs_y, 0.0);
903 }
904
905 /* test for touchpad */
906 #[test]
test_handle_motion_accelerate_normal_touchpad()907 fn test_handle_motion_accelerate_normal_touchpad()
908 {
909 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
910 let mut abs_x: f64 = 0.0;
911 let mut abs_y: f64 = 0.0;
912 let ret: i32;
913 unsafe {
914 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
915 }
916 assert_eq!(ret, RET_OK);
917 }
918
919 #[test]
test_handle_motion_accelerate_mini_limit_touchpad()920 fn test_handle_motion_accelerate_mini_limit_touchpad()
921 {
922 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
923 let mut abs_x: f64 = 0.0;
924 let mut abs_y: f64 = 0.0;
925 let ret: i32;
926 unsafe {
927 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
928 }
929 assert_eq!(ret, RET_ERR);
930 }
931
932 #[test]
test_handle_motion_accelerate_capture_mode_false_touchpad()933 fn test_handle_motion_accelerate_capture_mode_false_touchpad()
934 {
935 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
936 let mut abs_x: f64 = 0.0;
937 let mut abs_y: f64 = 0.0;
938 let ret: i32;
939 unsafe {
940 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
941 }
942 assert_eq!(ret, RET_OK);
943 assert_eq!(abs_x, 0.0);
944 assert_eq!(abs_y, 0.0);
945 }
946
947 /* test for touchpad pc */
948 #[test]
test_handle_motion_accelerate_capture_pc_offset_false_touchpad()949 fn test_handle_motion_accelerate_capture_pc_offset_false_touchpad()
950 {
951 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
952 let mut abs_x: f64 = 0.0;
953 let mut abs_y: f64 = 0.0;
954 let ret: i32;
955 unsafe {
956 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
957 }
958 assert_eq!(ret, RET_ERR);
959 assert_eq!(abs_x, 0.0);
960 assert_eq!(abs_y, 0.0);
961 }
962
963 #[test]
test_handle_motion_accelerate_capture_pc_speed_false_touchpad()964 fn test_handle_motion_accelerate_capture_pc_speed_false_touchpad()
965 {
966 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
967 let mut abs_x: f64 = 0.0;
968 let mut abs_y: f64 = 0.0;
969 let ret: i32;
970 unsafe {
971 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 1);
972 }
973 assert_eq!(ret, RET_ERR);
974 assert_eq!(abs_x, 0.0);
975 assert_eq!(abs_y, 0.0);
976 }
977
978 #[test]
test_handle_motion_accelerate_capture_pc_mode_false_touchpad()979 fn test_handle_motion_accelerate_capture_pc_mode_false_touchpad()
980 {
981 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
982 let mut abs_x: f64 = 0.0;
983 let mut abs_y: f64 = 0.0;
984 let ret: i32;
985 unsafe {
986 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
987 }
988 assert_eq!(ret, RET_OK);
989 }
990
991 #[test]
test_handle_motion_accelerate_capture_pc_nomarl_touchpad()992 fn test_handle_motion_accelerate_capture_pc_nomarl_touchpad()
993 {
994 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
995 let mut abs_x: f64 = 0.0;
996 let mut abs_y: f64 = 0.0;
997 let ret: i32;
998 unsafe {
999 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1000 }
1001 assert_eq!(ret, RET_OK);
1002 }
1003
1004 #[test]
test_handle_motion_accelerate_capture_pc_offset_exceed_max_touchpad()1005 fn test_handle_motion_accelerate_capture_pc_offset_exceed_max_touchpad()
1006 {
1007 let offset: Offset = Offset{ dx: 82.00002, dy: 82.00004 };
1008 let mut abs_x: f64 = 0.0;
1009 let mut abs_y: f64 = 0.0;
1010 let ret: i32;
1011 unsafe {
1012 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1013 }
1014 assert_eq!(ret, RET_OK);
1015 assert_eq!(abs_x, 0.0);
1016 assert_eq!(abs_y, 0.0);
1017 }
1018
1019 /* test for touchpad soft_pc_pro */
1020 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_offset_false_touchpad()1021 fn test_handle_motion_accelerate_capture_soft_pc_pro_offset_false_touchpad()
1022 {
1023 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1024 let mut abs_x: f64 = 0.0;
1025 let mut abs_y: f64 = 0.0;
1026 let ret: i32;
1027 unsafe {
1028 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1029 debug!(
1030 LOG_LABEL,
1031 "ret = {}", @public(ret)
1032 );
1033 }
1034 assert_eq!(ret, RET_ERR);
1035 assert_eq!(abs_x, 0.0);
1036 assert_eq!(abs_y, 0.0);
1037 }
1038
1039 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_speed_false_touchpad()1040 fn test_handle_motion_accelerate_capture_soft_pc_pro_speed_false_touchpad()
1041 {
1042 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1043 let mut abs_x: f64 = 0.0;
1044 let mut abs_y: f64 = 0.0;
1045 let ret: i32;
1046 unsafe {
1047 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 2);
1048 }
1049 assert_eq!(ret, RET_ERR);
1050 assert_eq!(abs_x, 0.0);
1051 assert_eq!(abs_y, 0.0);
1052 }
1053
1054 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_mode_false_touchpad()1055 fn test_handle_motion_accelerate_capture_soft_pc_pro_mode_false_touchpad()
1056 {
1057 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1058 let mut abs_x: f64 = 0.0;
1059 let mut abs_y: f64 = 0.0;
1060 let ret: i32;
1061 unsafe {
1062 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1063 }
1064 assert_eq!(ret, RET_OK);
1065 }
1066
1067 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_nomarl_touchpad()1068 fn test_handle_motion_accelerate_capture_soft_pc_pro_nomarl_touchpad()
1069 {
1070 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1071 let mut abs_x: f64 = 0.0;
1072 let mut abs_y: f64 = 0.0;
1073 let ret: i32;
1074 unsafe {
1075 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1076 }
1077 assert_eq!(ret, RET_OK);
1078 }
1079
1080 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_offset_exceed_max_touchpad()1081 fn test_handle_motion_accelerate_capture_soft_pc_pro_offset_exceed_max_touchpad()
1082 {
1083 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1084 let mut abs_x: f64 = 0.0;
1085 let mut abs_y: f64 = 0.0;
1086 let ret: i32;
1087 unsafe {
1088 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1089 }
1090 assert_eq!(ret, RET_OK);
1091 assert_eq!(abs_x, 0.0);
1092 assert_eq!(abs_y, 0.0);
1093 }
1094
1095 /* test for touchpad hard_pc_pro */
1096 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_offset_false_touchpad()1097 fn test_handle_motion_accelerate_capture_hard_pc_pro_offset_false_touchpad()
1098 {
1099 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1100 let mut abs_x: f64 = 0.0;
1101 let mut abs_y: f64 = 0.0;
1102 let ret: i32;
1103 unsafe {
1104 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1105 }
1106 assert_eq!(ret, RET_ERR);
1107 assert_eq!(abs_x, 0.0);
1108 assert_eq!(abs_y, 0.0);
1109 }
1110
1111 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_speed_false_touchpad()1112 fn test_handle_motion_accelerate_capture_hard_pc_pro_speed_false_touchpad()
1113 {
1114 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1115 let mut abs_x: f64 = 0.0;
1116 let mut abs_y: f64 = 0.0;
1117 let ret: i32;
1118 unsafe {
1119 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 3);
1120 }
1121 assert_eq!(ret, RET_ERR);
1122 assert_eq!(abs_x, 0.0);
1123 assert_eq!(abs_y, 0.0);
1124 }
1125
1126 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_mode_false_touchpad()1127 fn test_handle_motion_accelerate_capture_hard_pc_pro_mode_false_touchpad()
1128 {
1129 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1130 let mut abs_x: f64 = 0.0;
1131 let mut abs_y: f64 = 0.0;
1132 let ret: i32;
1133 unsafe {
1134 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1135 }
1136 assert_eq!(ret, RET_OK);
1137 }
1138
1139 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_nomarl_touchpad()1140 fn test_handle_motion_accelerate_capture_hard_pc_pro_nomarl_touchpad()
1141 {
1142 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1143 let mut abs_x: f64 = 0.0;
1144 let mut abs_y: f64 = 0.0;
1145 let ret: i32;
1146 unsafe {
1147 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1148 }
1149 assert_eq!(ret, RET_OK);
1150 }
1151
1152 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_offset_exceed_max_touchpad()1153 fn test_handle_motion_accelerate_capture_hard_pc_pro_offset_exceed_max_touchpad()
1154 {
1155 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1156 let mut abs_x: f64 = 0.0;
1157 let mut abs_y: f64 = 0.0;
1158 let ret: i32;
1159 unsafe {
1160 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1161 }
1162 assert_eq!(ret, RET_OK);
1163 assert_eq!(abs_x, 0.0);
1164 assert_eq!(abs_y, 0.0);
1165 }
1166 /* test touchpad axis */
1167 #[test]
test_handle_axis_accelerate_normal_touchpad()1168 fn test_handle_axis_accelerate_normal_touchpad()
1169 {
1170 let mut abs_axis: f64 = 19.29931034482759;
1171 let ret: i32;
1172 unsafe {
1173 ret = HandleAxisAccelerateTouchpad(false, &mut abs_axis as *mut f64, 1);
1174 }
1175 assert_eq!(ret, RET_OK);
1176 }
1177
1178 #[test]
test_handle_axis_accelerate_capture_mode_false_touchpad()1179 fn test_handle_axis_accelerate_capture_mode_false_touchpad()
1180 {
1181 let mut abs_axis: f64 = 19.29931034482759;
1182 let ret: i32;
1183 unsafe {
1184 ret = HandleAxisAccelerateTouchpad(true, &mut abs_axis as *mut f64, 1);
1185 }
1186 assert_eq!(ret, RET_OK);
1187 }