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 static MOUSE_DPI: f64 = 800.0;
33 static MS_2_US: f64 = 1000.0;
34 static TOUCHPAD_STANDARD_SIZE: f64 = 140.0;
35 static DISPLAY_STANDARD_SIZE: f64 = 337.8;
36 static MOUSE_GAIN_TYPE: i32 = 1;
37
38 struct CurveItem {
39 pub speeds: Vec<f64>,
40 pub slopes: Vec<f64>,
41 pub diff_nums: Vec<f64>,
42 }
43
44 struct PCMouseAccelerateCurves {
45 data: Vec<CurveItem>,
46 }
47 struct SoftPcProMouseAccelerateCurves {
48 data: Vec<CurveItem>,
49 }
50 struct HardPcProMouseAccelerateCurves {
51 data: Vec<CurveItem>,
52 }
53 struct PCTouchpadAccelerateCurves {
54 data: Vec<CurveItem>,
55 }
56 struct SoftPcProTouchpadAccelerateCurves {
57 data: Vec<CurveItem>,
58 }
59 struct HardPcProTouchpadAccelerateCurves {
60 data: Vec<CurveItem>,
61 }
62 struct TabletTouchpadAccelerateCurves {
63 data: Vec<CurveItem>,
64 }
65 struct FoldPcTouchpadAccelerateCurves{
66 data: Vec<CurveItem>,
67 }
68 struct FoldPcVirtTouchpadAccelerateCurves{
69 data: Vec<CurveItem>,
70 }
71 struct AxisAccelerateCurvesTouchpad {
72 data: Vec<CurveItem>,
73 }
74 impl PCMouseAccelerateCurves {
pc_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem75 fn pc_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
76 &self.data[speed - 1]
77 }
78 }
79 impl SoftPcProMouseAccelerateCurves {
soft_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem80 fn soft_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
81 &self.data[speed - 1]
82 }
83 }
84 impl HardPcProMouseAccelerateCurves {
hard_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem85 fn hard_pc_pro_mouse_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
86 &self.data[speed - 1]
87 }
88 }
89 impl PCTouchpadAccelerateCurves {
pc_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem90 fn pc_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
91 &self.data[speed - 1]
92 }
93 }
94 impl SoftPcProTouchpadAccelerateCurves {
soft_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem95 fn soft_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
96 &self.data[speed - 1]
97 }
98 }
99 impl HardPcProTouchpadAccelerateCurves {
hard_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem100 fn hard_pc_pro_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
101 &self.data[speed - 1]
102 }
103 }
104 impl TabletTouchpadAccelerateCurves {
tablet_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem105 fn tablet_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
106 &self.data[speed - 1]
107 }
108 }
109 impl FoldPcTouchpadAccelerateCurves {
fold_pc_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem110 fn fold_pc_touchpad_get_curve_by_speed(&self, speed: usize) -> &CurveItem {
111 &self.data[speed- 1]
112 }
113 }
114 impl FoldPcVirtTouchpadAccelerateCurves {
fold_pc_virt_touchpad_get_curve_by_speed(&self) -> &CurveItem115 fn fold_pc_virt_touchpad_get_curve_by_speed(&self) -> &CurveItem {
116 &self.data[5]
117 }
118 }
119 impl AxisAccelerateCurvesTouchpad {
get_axis_curve_by_speed_touchpad(&self, device_type: usize) -> &CurveItem120 fn get_axis_curve_by_speed_touchpad(&self, device_type: usize) -> &CurveItem {
121 &self.data[device_type - 1]
122 }
123 }
124
125 impl PCMouseAccelerateCurves {
get_instance() -> &'static PCMouseAccelerateCurves126 fn get_instance() -> &'static PCMouseAccelerateCurves {
127 static mut GLOBAL_CURVES: Option<PCMouseAccelerateCurves> = None;
128 static ONCE: Once = Once::new();
129
130 ONCE.call_once(|| unsafe {
131 GLOBAL_CURVES = Some(PCMouseAccelerateCurves {
132 data: vec![
133 CurveItem {
134 speeds: vec![8.0, 32.0, 128.0],
135 slopes: vec![0.16, 0.30, 0.56],
136 diff_nums: vec![0.0, -1.12, -9.44],
137 },
138 CurveItem {
139 speeds: vec![8.0, 32.0, 128.0],
140 slopes: vec![0.32, 0.60, 1.12],
141 diff_nums: vec![0.0, -2.24, -18.88],
142 },
143 CurveItem {
144 speeds: vec![8.0, 32.0, 128.0],
145 slopes: vec![0.64, 1.2, 2.24],
146 diff_nums: vec![0.0, -4.48, -37.76],
147 },
148 CurveItem {
149 speeds: vec![8.0, 32.0, 128.0],
150 slopes: vec![0.80, 1.50, 2.80],
151 diff_nums: vec![0.0, -5.6, -47.2],
152 },
153 CurveItem {
154 speeds: vec![8.0, 32.0, 128.0],
155 slopes: vec![0.92, 2.40, 4.48],
156 diff_nums: vec![0.0, -11.84, -78.4],
157 },
158 CurveItem {
159 speeds: vec![8.0, 32.0, 128.0],
160 slopes: vec![1.04, 3.30, 6.16],
161 diff_nums: vec![0.0, -18.08, -109.60],
162 },
163 CurveItem {
164 speeds: vec![8.0, 32.0, 128.0],
165 slopes: vec![1.10, 3.75, 7.00],
166 diff_nums: vec![0.0, -21.2, -125.20],
167 },
168 CurveItem {
169 speeds: vec![8.0, 32.0, 128.0],
170 slopes: vec![1.16, 4.20, 7.84],
171 diff_nums: vec![0.0, -24.32, -140.8],
172 },
173 CurveItem {
174 speeds: vec![8.0, 32.0, 128.0],
175 slopes: vec![1.22, 4.65, 8.68],
176 diff_nums: vec![0.0, -27.44, -156.40],
177 },
178 CurveItem {
179 speeds: vec![8.0, 32.0, 128.0],
180 slopes: vec![1.28, 5.1, 9.52],
181 diff_nums: vec![0.0, -30.56, -172.00],
182 },
183 CurveItem {
184 speeds: vec![8.0, 32.0, 128.0],
185 slopes: vec![1.34, 5.55, 10.36],
186 diff_nums: vec![0.0, -33.68, -187.6],
187 },
188 ],
189 });
190 });
191 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
192 }
193 }
194
195 impl SoftPcProMouseAccelerateCurves {
get_instance() -> &'static SoftPcProMouseAccelerateCurves196 fn get_instance() -> &'static SoftPcProMouseAccelerateCurves {
197 static mut GLOBAL_CURVES: Option<SoftPcProMouseAccelerateCurves> = None;
198 static ONCE: Once = Once::new();
199
200 ONCE.call_once(|| unsafe {
201 GLOBAL_CURVES = Some(SoftPcProMouseAccelerateCurves {
202 data: vec![
203 CurveItem {
204 speeds: vec![3.76, 9.77, 16.54, 128.0],
205 slopes: vec![0.10, 0.13, 0.27, 0.44],
206 diff_nums: vec![0.00, -0.11, -1.53, -4.26],
207 },
208 CurveItem {
209 speeds: vec![3.76, 9.77, 16.54, 128.0],
210 slopes: vec![0.19, 0.25, 0.54, 0.87],
211 diff_nums: vec![0.00, -0.21, -3.06, -8.52],
212 },
213 CurveItem {
214 speeds: vec![3.76, 9.77, 16.54, 128.0],
215 slopes: vec![0.29, 0.38, 0.81, 1.31],
216 diff_nums: vec![0.00, -0.32, -4.60, -12.78],
217 },
218 CurveItem {
219 speeds: vec![3.76, 9.77, 16.54, 128.0],
220 slopes: vec![0.39, 0.50, 1.08, 1.74],
221 diff_nums: vec![0.00, -0.42, -6.13, -17.04],
222 },
223 CurveItem {
224 speeds: vec![3.76, 9.77, 16.54, 128.0],
225 slopes: vec![0.58, 0.75, 1.63, 2.62],
226 diff_nums: vec![0.00, -0.63, -9.19, -25.56],
227 },
228 CurveItem {
229 speeds: vec![3.76, 9.77, 16.54, 128.0],
230 slopes: vec![0.78, 1.00, 2.17, 3.49],
231 diff_nums: vec![0.00, -0.84, -12.25, -34.09],
232 },
233 CurveItem {
234 speeds: vec![3.76, 9.77, 16.54, 128.0],
235 slopes: vec![0.97, 1.25, 2.71, 4.36],
236 diff_nums: vec![0.00, -1.05, -15.32, -42.61],
237 },
238 CurveItem {
239 speeds: vec![3.76, 9.77, 16.54, 128.0],
240 slopes: vec![1.16, 1.50, 3.25, 5.23],
241 diff_nums: vec![0.00, -1.26, -18.38, -51.13],
242 },
243 CurveItem {
244 speeds: vec![3.76, 9.77, 16.54, 128.0],
245 slopes: vec![1.36, 1.75, 3.79, 6.10],
246 diff_nums: vec![0.00, -1.47, -21.44, -59.65],
247 },
248 CurveItem {
249 speeds: vec![3.76, 9.77, 16.54, 128.0],
250 slopes: vec![1.65, 2.13, 4.61, 7.41],
251 diff_nums: vec![0.00, -1.79, -26.04, -72.43],
252 },
253 CurveItem {
254 speeds: vec![3.76, 9.77, 16.54, 128.0],
255 slopes: vec![1.94, 2.50, 5.42, 8.72],
256 diff_nums: vec![0.00, -2.11, -30.63, -85.22],
257 },
258 ],
259 });
260 });
261 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
262 }
263 }
264
265 impl HardPcProMouseAccelerateCurves {
get_instance() -> &'static HardPcProMouseAccelerateCurves266 fn get_instance() -> &'static HardPcProMouseAccelerateCurves {
267 static mut GLOBAL_CURVES: Option<HardPcProMouseAccelerateCurves> = None;
268 static ONCE: Once = Once::new();
269
270 ONCE.call_once(|| unsafe {
271 GLOBAL_CURVES = Some(HardPcProMouseAccelerateCurves {
272 data: vec![
273 CurveItem {
274 speeds: vec![8.0, 32.0, 128.0],
275 slopes: vec![0.20, 0.38, 0.71],
276 diff_nums: vec![0.0, -1.42, -11.98],
277 },
278 CurveItem {
279 speeds: vec![8.0, 32.0, 128.0],
280 slopes: vec![0.41, 0.76, 1.42],
281 diff_nums: vec![0.0, -2.84, -23.97],
282 },
283 CurveItem {
284 speeds: vec![8.0, 32.0, 128.0],
285 slopes: vec![0.81, 1.52, 2.84],
286 diff_nums: vec![0.0, -5.69, -47.94],
287 },
288 CurveItem {
289 speeds: vec![8.0, 32.0, 128.0],
290 slopes: vec![1.02, 1.90, 3.55],
291 diff_nums: vec![0.0, -7.11, -59.92],
292 },
293 CurveItem {
294 speeds: vec![8.0, 32.0, 128.0],
295 slopes: vec![1.17, 3.05, 5.69],
296 diff_nums: vec![0.0, -15.03, -99.53],
297 },
298 CurveItem {
299 speeds: vec![8.0, 32.0, 128.0],
300 slopes: vec![1.32, 4.19, 7.82],
301 diff_nums: vec![0.0, -22.95, -139.14],
302 },
303 CurveItem {
304 speeds: vec![8.0, 32.0, 128.0],
305 slopes: vec![1.40, 4.76, 8.89],
306 diff_nums: vec![0.0, -26.91, -158.95],
307 },
308 CurveItem {
309 speeds: vec![8.0, 32.0, 128.0],
310 slopes: vec![1.47, 5.33, 9.95],
311 diff_nums: vec![0.0, -30.88, -178.75],
312 },
313 CurveItem {
314 speeds: vec![8.0, 32.0, 128.0],
315 slopes: vec![1.55, 5.90, 11.02],
316 diff_nums: vec![0.0, -34.84, -198.56],
317 },
318 CurveItem {
319 speeds: vec![8.0, 32.0, 128.0],
320 slopes: vec![1.63, 6.47, 12.09],
321 diff_nums: vec![0.0, -38.80, -218.36],
322 },
323 CurveItem {
324 speeds: vec![8.0, 32.0, 128.0],
325 slopes: vec![1.70, 7.05, 13.15],
326 diff_nums: vec![0.0, -42.76, -238.17],
327 },
328 ],
329 });
330 });
331 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
332 }
333 }
334
335 impl PCTouchpadAccelerateCurves {
get_instance() -> &'static PCTouchpadAccelerateCurves336 fn get_instance() -> &'static PCTouchpadAccelerateCurves {
337 static mut GLOBAL_CURVES: Option<PCTouchpadAccelerateCurves> = None;
338 static ONCE: Once = Once::new();
339
340 ONCE.call_once(|| unsafe {
341 GLOBAL_CURVES = Some(PCTouchpadAccelerateCurves {
342 data: vec![
343 CurveItem {
344 speeds: vec![1.27, 12.73, 19.09, 81.46],
345 slopes: vec![0.14, 0.25, 0.53, 1.03],
346 diff_nums: vec![0.0, -0.14, -3.74, -13.19]
347 },
348 CurveItem {
349 speeds: vec![1.27, 12.73, 19.09, 81.46],
350 slopes: vec![0.19, 0.33, 0.71, 1.37],
351 diff_nums: vec![0.0, -0.18, -4.98, -17.58],
352 },
353 CurveItem {
354 speeds: vec![1.27, 12.73, 19.09, 81.46],
355 slopes: vec![0.24, 0.41, 0.88, 1.71],
356 diff_nums: vec![0.0, -0.21, -5.91, -20.88],
357 },
358 CurveItem {
359 speeds: vec![1.27, 12.73, 19.09, 81.46],
360 slopes: vec![0.28, 0.49, 1.06, 2.05],
361 diff_nums: vec![0.0, -0.27, -7.47, -26.37],
362 },
363 CurveItem {
364 speeds: vec![1.27, 12.73, 19.09, 81.46],
365 slopes: vec![0.38, 0.66, 1.41, 2.73],
366 diff_nums: vec![0.0, -0.36, -9.96, -35.16],
367 },
368 CurveItem {
369 speeds: vec![1.27, 12.73, 19.09, 81.46],
370 slopes: vec![0.47, 0.82, 1.77, 3.42],
371 diff_nums: vec![0.0, -0.45, -12.45, -43.95],
372 },
373 CurveItem {
374 speeds: vec![1.27, 12.73, 19.09, 81.46],
375 slopes: vec![0.57, 0.99, 2.12, 4.10],
376 diff_nums: vec![0.0, -0.54, -14.94, -52.74],
377 },
378 CurveItem {
379 speeds: vec![1.27, 12.73, 19.09, 81.46],
380 slopes: vec![0.71, 1.24, 2.65, 5.13],
381 diff_nums: vec![0.0, -0.68, -18.68, -65.93],
382 },
383 CurveItem {
384 speeds: vec![1.27, 12.73, 19.09, 81.46],
385 slopes: vec![0.90, 1.57, 3.36, 6.49],
386 diff_nums: vec![0.0, -0.86, -23.66, -83.51],
387 },
388 CurveItem {
389 speeds: vec![1.27, 12.73, 19.09, 81.46],
390 slopes: vec![1.08, 1.90, 4.07, 7.86],
391 diff_nums: vec![0.0, -1.04, -28.64, -101.09],
392 },
393 CurveItem {
394 speeds: vec![1.27, 12.73, 19.09, 81.46],
395 slopes: vec![1.27, 2.23, 4.77, 9.23],
396 diff_nums: vec![0.0, -1.22, -33.62, -118.67],
397 },
398 ],
399 });
400 });
401 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
402 }
403 }
404
405 impl SoftPcProTouchpadAccelerateCurves {
get_instance() -> &'static SoftPcProTouchpadAccelerateCurves406 fn get_instance() -> &'static SoftPcProTouchpadAccelerateCurves {
407 static mut GLOBAL_CURVES: Option<SoftPcProTouchpadAccelerateCurves> = None;
408 static ONCE: Once = Once::new();
409
410 ONCE.call_once(|| unsafe {
411 GLOBAL_CURVES = Some(SoftPcProTouchpadAccelerateCurves {
412 data: vec![
413 CurveItem {
414 speeds: vec![2.45, 24.51, 36.77, 156.87],
415 slopes: vec![0.10, 0.18, 0.39, 0.75],
416 diff_nums: vec![0.0, -0.19, -5.25, -18.52]
417 },
418 CurveItem {
419 speeds: vec![2.45, 24.51, 36.77, 156.87],
420 slopes: vec![0.14, 0.24, 0.52, 1.00],
421 diff_nums: vec![0.0, -0.25, -6.99, -24.69],
422 },
423 CurveItem {
424 speeds: vec![2.45, 24.51, 36.77, 156.87],
425 slopes: vec![0.17, 0.30, 0.64, 1.25],
426 diff_nums: vec![0.0, -0.32, -8.74, -30.86],
427 },
428 CurveItem {
429 speeds: vec![2.45, 24.51, 36.77, 156.87],
430 slopes: vec![0.21, 0.36, 0.77, 1.50],
431 diff_nums: vec![0.0, -0.38, -10.49, -37.03],
432 },
433 CurveItem {
434 speeds: vec![2.45, 24.51, 36.77, 156.87],
435 slopes: vec![0.28, 0.48, 1.03, 1.99],
436 diff_nums: vec![0.0, -0.51, -13.99, -49.38],
437 },
438 CurveItem {
439 speeds: vec![2.45, 24.51, 36.77, 156.87],
440 slopes: vec![0.34, 0.60, 1.29, 2.49],
441 diff_nums: vec![0.0, -0.63, -17.48, -61.72],
442 },
443 CurveItem {
444 speeds: vec![2.45, 24.51, 36.77, 156.87],
445 slopes: vec![0.41, 0.72, 1.55, 2.99],
446 diff_nums: vec![0.0, -0.76, -20.98, -74.06],
447 },
448 CurveItem {
449 speeds: vec![2.45, 24.51, 36.77, 156.87],
450 slopes: vec![0.52, 0.90, 1.93, 3.74],
451 diff_nums: vec![0.0, -0.95, -26.23, -92.58],
452 },
453 CurveItem {
454 speeds: vec![2.45, 24.51, 36.77, 156.87],
455 slopes: vec![0.65, 1.14, 2.45, 4.74],
456 diff_nums: vec![0.0, -0.86, -23.66, -83.51],
457 },
458 CurveItem {
459 speeds: vec![2.45, 24.51, 36.77, 156.87],
460 slopes: vec![0.79, 1.38, 2.96, 5.73],
461 diff_nums: vec![0.0, -1.45, -40.21, -141.96],
462 },
463 CurveItem {
464 speeds: vec![2.45, 24.51, 36.77, 156.87],
465 slopes: vec![0.93, 1.62, 3.48, 6.73],
466 diff_nums: vec![0.0, -1.71, -47.21, -166.64],
467 },
468 ],
469 });
470 });
471 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
472 }
473 }
474
475 impl HardPcProTouchpadAccelerateCurves {
get_instance() -> &'static HardPcProTouchpadAccelerateCurves476 fn get_instance() -> &'static HardPcProTouchpadAccelerateCurves {
477 static mut GLOBAL_CURVES: Option<HardPcProTouchpadAccelerateCurves> = None;
478 static ONCE: Once = Once::new();
479
480 ONCE.call_once(|| unsafe {
481 GLOBAL_CURVES = Some(HardPcProTouchpadAccelerateCurves {
482 data: vec![
483 CurveItem {
484 speeds: vec![2.45, 24.51, 36.77, 156.87],
485 slopes: vec![0.10, 0.17, 0.36, 0.69],
486 diff_nums: vec![0.0, -0.18, -4.84, -17.09]
487 },
488 CurveItem {
489 speeds: vec![2.45, 24.51, 36.77, 156.87],
490 slopes: vec![0.13, 0.22, 0.48, 0.92],
491 diff_nums: vec![0.0, -0.23, -6.46, -22.79],
492 },
493 CurveItem {
494 speeds: vec![2.45, 24.51, 36.77, 156.87],
495 slopes: vec![0.16, 0.28, 0.59, 1.15],
496 diff_nums: vec![0.0, -0.29, -8.07, -28.49],
497 },
498 CurveItem {
499 speeds: vec![2.45, 24.51, 36.77, 156.87],
500 slopes: vec![0.19, 0.33, 0.71, 1.38],
501 diff_nums: vec![0.0, -0.35, -9.68, -34.18],
502 },
503 CurveItem {
504 speeds: vec![2.45, 24.51, 36.77, 156.87],
505 slopes: vec![0.25, 0.44, 0.95, 1.84],
506 diff_nums: vec![0.0, -0.47, -12.91, -45.58],
507 },
508 CurveItem {
509 speeds: vec![2.45, 24.51, 36.77, 156.87],
510 slopes: vec![0.32, 0.56, 1.19, 2.30],
511 diff_nums: vec![0.0, -0.58, -16.14, -56.97],
512 },
513 CurveItem {
514 speeds: vec![2.45, 24.51, 36.77, 156.87],
515 slopes: vec![0.38, 0.67, 1.43, 2.76],
516 diff_nums: vec![0.0, -0.70, -19.37, -68.37],
517 },
518 CurveItem {
519 speeds: vec![2.45, 24.51, 36.77, 156.87],
520 slopes: vec![0.48, 0.83, 1.78, 3.45],
521 diff_nums: vec![0.0, -0.88, -24.21, -85.46],
522 },
523 CurveItem {
524 speeds: vec![2.45, 24.51, 36.77, 156.87],
525 slopes: vec![0.60, 1.06, 2.26, 4.37],
526 diff_nums: vec![0.0, -1.11, -30.66, -108.25],
527 },
528 CurveItem {
529 speeds: vec![2.45, 24.51, 36.77, 156.87],
530 slopes: vec![0.73, 1.28, 2.74, 5.29],
531 diff_nums: vec![0.0, -1.34, -37.12, -131.04],
532 },
533 CurveItem {
534 speeds: vec![2.45, 24.51, 36.77, 156.87],
535 slopes: vec![0.86, 1.50, 3.21, 6.21],
536 diff_nums: vec![0.0, -1.58, -43.58, -153.83],
537 },
538 ],
539 });
540 });
541 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
542 }
543 }
544
545 impl AxisAccelerateCurvesTouchpad {
get_instance() -> &'static AxisAccelerateCurvesTouchpad546 fn get_instance() -> &'static AxisAccelerateCurvesTouchpad {
547 static mut GLOBAL_CURVES: Option<AxisAccelerateCurvesTouchpad> = None;
548 static ONCE: Once = Once::new();
549
550 ONCE.call_once(|| unsafe {
551 GLOBAL_CURVES = Some(AxisAccelerateCurvesTouchpad {
552 data: vec![
553 CurveItem {
554 speeds: vec![3.0, 5.0, 6.0, 8.0, 10.0, 41.0],
555 slopes: vec![1.07, 0.80, 0.65, 0.55, 0.52, 0.81],
556 diff_nums: vec![0.0, 0.81, 1.56, 2.16, 2.4, -0.5]
557 },
558 CurveItem {
559 speeds: vec![0.36, 0.73, 1.46, 2.19, 2.92, 5.83, 10.94, 29.17],
560 slopes: vec![4.11, 2.83, 2.19, 1.69, 1.41, 1.87, 2.03, 2.03],
561 diff_nums: vec![0.0, 0.47, 0.93, 1.66, 2.28, 0.93, 0.0, 0.0]
562 },
563 CurveItem {
564 speeds: vec![0.36, 0.72, 1.45, 2.17, 2.89, 5.78, 10.84, 28.90],
565 slopes: vec![4.14, 2.85, 2.21, 1.72, 1.42, 1.88, 2.05, 2.05],
566 diff_nums: vec![0.0, 0.47, 0.93, 1.63, 2.28, 0.95, 0.0, 0.0]
567 },
568 CurveItem {
569 speeds: vec![0.36, 0.72, 1.08, 1.44, 1.8, 2.16, 2.88, 28.83],
570 slopes: vec![4.5, 3.1, 2.57, 2.25, 1.97, 1.74, 0.83, 2.22],
571 diff_nums: vec![0.0, 0.51, 0.88, 1.23, 2.64, 2.05, 4.03, 0.0]
572 },
573 CurveItem {
574 speeds: vec![0.36, 0.72, 1.08, 1.44, 1.8, 2.16, 2.88, 28.83],
575 slopes: vec![4.5, 3.1, 2.57, 2.25, 1.97, 1.74, 0.83, 0.83],
576 diff_nums: vec![0.0, 0.51, 0.88, 1.23, 2.64, 2.05, 4.03, 0.0]
577 },
578 ],
579 });
580 });
581 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
582 }
583 }
584
585 impl TabletTouchpadAccelerateCurves {
get_instance() -> &'static TabletTouchpadAccelerateCurves586 fn get_instance() -> &'static TabletTouchpadAccelerateCurves {
587 static mut GLOBAL_CURVES: Option<TabletTouchpadAccelerateCurves> = None;
588 static ONCE: Once = Once::new();
589
590 ONCE.call_once(|| unsafe {
591 GLOBAL_CURVES = Some(TabletTouchpadAccelerateCurves {
592 data: vec![
593 CurveItem {
594 speeds: vec![2.0, 20.0, 30.0, 128.0],
595 slopes: vec![0.12, 0.21, 0.45, 0.87],
596 diff_nums: vec![0.0, -0.18, -4.98, -17.58]
597 },
598 CurveItem {
599 speeds: vec![2.0, 20.0, 30.0, 128.0],
600 slopes: vec![0.16, 0.28, 0.60, 1.16],
601 diff_nums: vec![0.0, -0.24, -6.64, -23.44],
602 },
603 CurveItem {
604 speeds: vec![2.0, 20.0, 30.0, 128.0],
605 slopes: vec![0.20, 0.35, 0.75, 1.45],
606 diff_nums: vec![0.0, -0.30, -8.30, -29.30],
607 },
608 CurveItem {
609 speeds: vec![2.0, 20.0, 30.0, 128.0],
610 slopes: vec![0.24, 0.42, 0.90, 1.74],
611 diff_nums: vec![0.0, -0.36, -9.96, -35.16],
612 },
613 CurveItem {
614 speeds: vec![2.0, 20.0, 30.0, 128.0],
615 slopes: vec![0.32, 0.56, 1.20, 2.32],
616 diff_nums: vec![0.0, -0.48, -13.28, -46.88],
617 },
618 CurveItem {
619 speeds: vec![2.0, 20.0, 30.0, 128.0],
620 slopes: vec![0.40, 0.70, 1.50, 2.90],
621 diff_nums: vec![0.0, -0.60, -16.60, -58.60],
622 },
623 CurveItem {
624 speeds: vec![2.0, 20.0, 30.0, 128.0],
625 slopes: vec![0.48, 0.84, 1.80, 3.48],
626 diff_nums: vec![0.0, -0.72, -19.92, -70.32],
627 },
628 CurveItem {
629 speeds: vec![2.0, 20.0, 30.0, 128.0],
630 slopes: vec![0.60, 1.05, 2.25, 4.35],
631 diff_nums: vec![0.0, -0.90, -24.90, -87.90],
632 },
633 CurveItem {
634 speeds: vec![2.0, 20.0, 30.0, 128.0],
635 slopes: vec![0.76, 1.33, 2.85, 5.51],
636 diff_nums: vec![0.0, -1.14, -31.54, -111.34],
637 },
638 CurveItem {
639 speeds: vec![2.0, 20.0, 30.0, 128.0],
640 slopes: vec![0.92, 1.61, 3.45, 6.67],
641 diff_nums: vec![0.0, -1.38, -38.18, -134.78],
642 },
643 CurveItem {
644 speeds: vec![2.0, 20.0, 30.0, 128.0],
645 slopes: vec![1.08, 1.89, 4.05, 7.83],
646 diff_nums: vec![0.0, -1.62, -44.82, -158.22],
647 },
648 ],
649 });
650 });
651 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
652 }
653 }
654
655 impl FoldPcTouchpadAccelerateCurves {
get_instance() -> &'static FoldPcTouchpadAccelerateCurves656 fn get_instance() -> &'static FoldPcTouchpadAccelerateCurves {
657 static mut GLOBAL_CURVES: Option<FoldPcTouchpadAccelerateCurves> = None;
658 static ONCE: Once = Once::new();
659
660 ONCE.call_once(|| unsafe {
661 GLOBAL_CURVES = Some(FoldPcTouchpadAccelerateCurves {
662 data: vec![
663 CurveItem {
664 speeds: vec![2.51, 25.07, 37.61, 160.43],
665 slopes: vec![0.12, 0.20, 0.44, 0.84],
666 diff_nums: vec![0.0, -0.22, -6.06, -21.38],
667 },
668 CurveItem {
669 speeds: vec![2.51, 25.07, 37.61, 160.43],
670 slopes: vec![0.16, 0.27, 0.58, 1.13],
671 diff_nums: vec![0.0, -0.29, -8.08, -28.51],
672 },
673 CurveItem {
674 speeds: vec![2.51, 25.07, 37.61, 160.43],
675 slopes: vec![0.19, 0.34, 0.73, 1.41],
676 diff_nums: vec![0.0, -0.37, -10.10, -35.64],
677 },
678 CurveItem {
679 speeds: vec![2.51, 25.07, 37.61, 160.43],
680 slopes: vec![0.23, 0.41, 0.87, 1.69],
681 diff_nums: vec![0.0, -0.44, -12.12, -42.77],
682 },
683 CurveItem {
684 speeds: vec![2.51, 25.07, 37.61, 160.43],
685 slopes: vec![0.31, 0.54, 1.16, 2.25],
686 diff_nums: vec![0.0, -0.58, -16.15, -57.03],
687 },
688 CurveItem {
689 speeds: vec![2.51, 25.07, 37.61, 160.43],
690 slopes: vec![0.39, 0.68, 1.46, 2.81],
691 diff_nums: vec![0.0, -0.73, -20.19, -71.28],
692 },
693 CurveItem {
694 speeds: vec![2.51, 25.07, 37.61, 160.43],
695 slopes: vec![0.47, 0.82, 1.75, 3.38],
696 diff_nums: vec![0.0, -0.88, -24.23, -85.54],
697 },
698 CurveItem {
699 speeds: vec![2.51, 25.07, 37.61, 160.43],
700 slopes: vec![0.58, 1.02, 2.18, 4.22],
701 diff_nums: vec![0.0, -1.1, -30.29, -106.92],
702 },
703 CurveItem {
704 speeds: vec![2.51, 25.07, 37.61, 160.43],
705 slopes: vec![0.74, 1.29, 2.77, 5.53],
706 diff_nums: vec![0.0, -1.39, -38.37, -135.44],
707 },
708 CurveItem {
709 speeds: vec![2.51, 25.07, 37.61, 160.43],
710 slopes: vec![0.89, 1.56, 3.35, 6.47],
711 diff_nums: vec![0.0, -1.68, -46.44, -163.95],
712 },
713 CurveItem {
714 speeds: vec![2.51, 25.07, 37.61, 160.43],
715 slopes: vec![1.05, 1.83, 3.93, 7.6],
716 diff_nums: vec![0.0, -1.97, -54.52, -192.46],
717 },
718 ],
719 });
720 });
721 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
722 }
723 }
724
725 impl FoldPcVirtTouchpadAccelerateCurves {
get_instance() -> &'static FoldPcVirtTouchpadAccelerateCurves726 fn get_instance() -> &'static FoldPcVirtTouchpadAccelerateCurves {
727 static mut GLOBAL_CURVES: Option<FoldPcVirtTouchpadAccelerateCurves> = None;
728 static ONCE: Once = Once::new();
729
730 ONCE.call_once(|| unsafe {
731 GLOBAL_CURVES = Some(FoldPcVirtTouchpadAccelerateCurves {
732 data: vec![
733 CurveItem {
734 speeds: vec![1.53, 3.73, 4.54, 5.19],
735 slopes: vec![0.45, 0.97, 2.50, 3.51],
736 diff_nums: vec![0.00, -0.79, -6.49, -11.09]
737 },
738 CurveItem {
739 speeds: vec![1.53, 3.73, 4.54, 5.19],
740 slopes: vec![0.60, 1.29, 3.33, 4.68],
741 diff_nums: vec![0.00, -1.06, -8.66, -14.79]
742 },
743 CurveItem {
744 speeds: vec![1.53, 3.73, 4.54, 5.19],
745 slopes: vec![0.75, 1.61, 4.16, 5.85],
746 diff_nums: vec![0.00, -1.32, -10.82, -18.49]
747 },
748 CurveItem {
749 speeds: vec![1.53, 3.73, 4.54, 5.19],
750 slopes: vec![0.90, 1.94, 4.99, 7.02],
751 diff_nums: vec![0.00, -1.59, -12.98, -22.19]
752 },
753 CurveItem {
754 speeds: vec![1.53, 3.73, 4.54, 5.19],
755 slopes: vec![1.20, 2.58, 6.66, 9.36],
756 diff_nums: vec![0.00, -2.12, -17.31, -29.58]
757 },
758 CurveItem {
759 speeds: vec![1.53, 3.73, 4.54, 5.19],
760 slopes: vec![1.50, 3.01, 6.34, 9.66],
761 diff_nums: vec![0.00, -2.31, -14.73, -29.8]
762 },
763 CurveItem {
764 speeds: vec![1.53, 3.73, 4.54, 5.19],
765 slopes: vec![1.80, 3.88, 9.99, 14.04],
766 diff_nums: vec![0.00, -3.18, -25.97, -44.37]
767 },
768 CurveItem {
769 speeds: vec![1.53, 3.73, 4.54, 5.19],
770 slopes: vec![2.25, 4.84, 12.48, 17.55],
771 diff_nums: vec![0.00, -3.97, -32.46, -55.46]
772 },
773 CurveItem {
774 speeds: vec![1.53, 3.73, 4.54, 5.19],
775 slopes: vec![2.85, 6.14, 15.81, 22.23],
776 diff_nums: vec![0.00, -5.03, -41.11, -70.25]
777 },
778 CurveItem {
779 speeds: vec![1.53, 3.73, 4.54, 5.19],
780 slopes: vec![3.45, 7.43, 19.14, 26.91],
781 diff_nums: vec![0.00, -6.09, -49.77, -85.04]
782 },
783 CurveItem {
784 speeds: vec![1.53, 3.73, 4.54, 5.19],
785 slopes: vec![4.05, 8.72, 22.47, 31.59],
786 diff_nums: vec![0.00, -7.14, -58.42, -99.83]
787 },
788 ],
789 });
790 });
791 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
792 }
793 }
794 // 这个 extern 代码块链接到 libm 库
795 #[link(name = "m")]
796 extern {
fabs(z: f64) -> f64797 fn fabs(z: f64) -> f64;
fmax(a: f64, b: f64) -> f64798 fn fmax(a: f64, b: f64) -> f64;
fmin(a: f64, b: f64) -> f64799 fn fmin(a: f64, b: f64) -> f64;
log(a: f64) -> f64800 fn log(a: f64) -> f64;
sqrt(a: f64) -> f64801 fn sqrt(a: f64) -> f64;
802 }
803
get_speed_dynamic_gain_mouse(vin: f64, gain: *mut f64, speed: i32, delta_time: u64, display_ppi: f64) -> bool804 fn get_speed_dynamic_gain_mouse(vin: f64, gain: *mut f64, speed: i32, delta_time: u64, display_ppi: f64) -> bool {
805 debug!(LOG_LABEL, "get_speed_gain_mouse enter vin is set to {} speed {}, delta_time {}, display_ppi {}",
806 @public(vin), @public(speed), @public(delta_time), @public(display_ppi));
807 if delta_time < 1 {
808 error!(LOG_LABEL, "{} The delta_time can't be less than 0", @public(delta_time));
809 return false;
810 }
811 if display_ppi < 1.0 {
812 error!(LOG_LABEL, "{} The display_ppi can't be less than 1", @public(display_ppi));
813 return false;
814 }
815 unsafe {
816 if fabs(vin) < DOUBLE_ZERO {
817 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
818 return false;
819 }
820 }
821 if speed < 1 {
822 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
823 return false;
824 }
825 let speeds_radio = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
826 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0];
827 let standard_slopes = [2.9394, 3.7879, 8.2121, 13.1515];
828 let vins = [0.50, 1.30, 2.20, 16.17];
829 unsafe {
830 let vin_new: f64 = vin * MS_2_US / delta_time as f64;
831 let speed_radio = speeds_radio[speed as usize - 1];
832 let mut slopes = Vec::new();
833 let mut diff_nums = Vec::new();
834 for i in 0..4 {
835 slopes.push(standard_slopes[i] * display_ppi / MOUSE_DPI);
836 if i < 1 {
837 diff_nums.push(0.0);
838 continue;
839 }
840 diff_nums.push((slopes[i - 1] - slopes[i]) * vins[i - 1] + diff_nums[i - 1]);
841 }
842 let num: f64 = fabs(vin_new);
843 for i in 0..4 {
844 if num <= vins[i] {
845 *gain = (slopes[i] * vin_new + diff_nums[i]) * speed_radio / vin_new;
846 debug!(LOG_LABEL, "gain is set to {}", @public(slopes[i]));
847 return true;
848 }
849 }
850 *gain = (slopes[3] * vin_new + diff_nums[3]) * speed_radio / vin_new;
851 debug!(LOG_LABEL, "gain is set to {}", @public(slopes[3]));
852 }
853 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
854 true
855 }
856
get_speed_dynamic_gain_touchpad( vin: f64, gain: *mut f64, speed: i32, display_size: f64, touchpad_size: f64, touchpad_ppi: f64, frequency: i32 ) -> bool857 fn get_speed_dynamic_gain_touchpad(
858 vin: f64,
859 gain: *mut f64,
860 speed: i32,
861 display_size: f64,
862 touchpad_size: f64,
863 touchpad_ppi: f64,
864 frequency: i32
865 ) -> bool {
866 debug!(LOG_LABEL,
867 "get_speed_gain_touchpad enter vin is set to {}, speed {}, touchpad_size {}, display_size {}, touchpad_ppi {}, frequency {}",
868 @public(vin), @public(speed), @public(touchpad_size), @public(display_size), @public(touchpad_ppi), @public(frequency));
869 if speed < 1 {
870 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
871 return false;
872 }
873 let speeds_radio = [0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.5, 1.9, 2.3, 2.7];
874 let standard_slopes = [0.9728, 1.7024, 3.6480, 7.0528];
875 let standard_vins = [7.5, 50.0, 160.0, 640.0];
876 unsafe {
877 let speed_radio = speeds_radio[speed as usize - 1];
878 let mut slopes = Vec::new();
879 let mut diff_nums = Vec::new();
880 let mut vins = Vec::new();
881 for i in 0..4 {
882 vins.push(standard_vins[i] * touchpad_ppi / frequency as f64);
883 slopes.push(standard_slopes[i] * (display_size / touchpad_size) *
884 (TOUCHPAD_STANDARD_SIZE / DISPLAY_STANDARD_SIZE));
885 if i < 1 {
886 diff_nums.push(0.0);
887 continue;
888 }
889 diff_nums.push((slopes[i - 1] - slopes[i]) * vins[i - 1] + diff_nums[i - 1]);
890 }
891 let num: f64 = fabs(vin);
892 for i in 0..4 {
893 if num <= vins[i] {
894 *gain = (slopes[i] * vin + diff_nums[i]) * speed_radio / vin;
895 debug!(LOG_LABEL, "gain is set to {}", @public(*gain));
896 return true;
897 }
898 }
899 *gain = (slopes[3] * vin + diff_nums[3]) * speed_radio / vin;
900 debug!(LOG_LABEL, "gain is set to {}", @public(*gain));
901 }
902 debug!(LOG_LABEL, "get_speed_gain_touchpad leave");
903 true
904 }
905
get_speed_dynamic_gain_mouse_new(vin: f64, gain: *mut f64, speed: i32, display_ppi: f64) -> bool906 fn get_speed_dynamic_gain_mouse_new(vin: f64, gain: *mut f64, speed: i32, display_ppi: f64) -> bool {
907 if display_ppi < 1.0 {
908 error!(LOG_LABEL, "{} The display_ppi can't be less than 1", @public(display_ppi));
909 return false;
910 }
911 if !(1..=20).contains(&speed) {
912 error!(LOG_LABEL, "{} The speed value error", @public(speed));
913 return false;
914 }
915 let speeds_radio = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
916 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0];
917 let slow_gain_params = [1.0341957429588597, 0.7126536301164397, 2.5813850030026853, 0.02004352388383787];
918 let fast_gain_params = [1.3556224243118067, 2.5417186406523578, 6.127531547651636, 3.2322785269552803];
919 let standard_ppi = 264.16;
920 unsafe {
921 let ppi_ratio: f64 = display_ppi / standard_ppi;
922 let speed_radio: f64 = speeds_radio[speed as usize - 1];
923 let gain_tmp: f64 = if vin < 13.5 {
924 slow_gain_params[0] * log(slow_gain_params[1] * vin + slow_gain_params[2]) + slow_gain_params[3]
925 } else {
926 fast_gain_params[0] * log(fast_gain_params[1] * log(vin) - fast_gain_params[2]) + fast_gain_params[3]
927 };
928 *gain = gain_tmp * speed_radio * ppi_ratio;
929 debug!(LOG_LABEL, "gain is set to {}", @public(*gain));
930 }
931 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
932 true
933 }
934
get_speed_gain_mouse(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool935 fn get_speed_gain_mouse(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
936 debug!(LOG_LABEL, "get_speed_gain_mouse enter vin is set to {} speed {}, device_type {}",
937 @public(vin), @public(speed), @public(device_type));
938 unsafe {
939 if fabs(vin) < DOUBLE_ZERO {
940 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
941 return false;
942 }
943 }
944 if speed < 1 {
945 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
946 return false;
947 }
948 let item = match device_type {
949 1 => PCMouseAccelerateCurves::get_instance().pc_mouse_get_curve_by_speed(speed as usize),
950 2 => SoftPcProMouseAccelerateCurves::get_instance().soft_pc_pro_mouse_get_curve_by_speed(speed as usize),
951 3 => HardPcProMouseAccelerateCurves::get_instance().hard_pc_pro_mouse_get_curve_by_speed(speed as usize),
952 _ => PCMouseAccelerateCurves::get_instance().pc_mouse_get_curve_by_speed(speed as usize),
953 };
954 unsafe {
955 let num: f64 = fabs(vin);
956 let len = item.speeds.len();
957 for i in 0..len {
958 if num <= item.speeds[i] {
959 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
960 debug!(LOG_LABEL, "slope is set to {}, gain is {}", @public(item.slopes[i]), @public(*gain));
961 return true;
962 }
963 }
964 *gain = (item.slopes[len - 1] * vin + item.diff_nums[len - 1]) / vin;
965 debug!(LOG_LABEL, "slope is set to {}, gain is {}", @public(item.slopes[len - 1]), @public(*gain));
966 }
967 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
968 true
969 }
970
971
get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool972 fn get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
973 debug!(LOG_LABEL, "get_speed_gain_touchpad enter vin is set to {}, speed {}, device_type {}",
974 @public(vin), @public(speed), @public(device_type));
975 unsafe {
976 if fabs(vin) < DOUBLE_ZERO {
977 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
978 return false;
979 }
980 }
981 if speed < 1 {
982 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
983 return false;
984 }
985 let item = match device_type {
986 1 => PCTouchpadAccelerateCurves::get_instance().pc_touchpad_get_curve_by_speed(speed as usize),
987 2 => SoftPcProTouchpadAccelerateCurves::get_instance().soft_pc_pro_touchpad_get_curve_by_speed(speed as usize),
988 3 => HardPcProTouchpadAccelerateCurves::get_instance().hard_pc_pro_touchpad_get_curve_by_speed(speed as usize),
989 4 => TabletTouchpadAccelerateCurves::get_instance().tablet_touchpad_get_curve_by_speed(speed as usize),
990 5 => FoldPcTouchpadAccelerateCurves::get_instance().fold_pc_touchpad_get_curve_by_speed(speed as usize),
991 7 => FoldPcVirtTouchpadAccelerateCurves::get_instance().fold_pc_virt_touchpad_get_curve_by_speed(),
992 _ => PCTouchpadAccelerateCurves::get_instance().pc_touchpad_get_curve_by_speed(speed as usize),
993 };
994 unsafe {
995 let num: f64 = fabs(vin);
996 for i in 0..4 {
997 if num <= item.speeds[i] {
998 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
999 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[i]) / vin));
1000 return true;
1001 }
1002 }
1003 *gain = (item.slopes[3] * vin + item.diff_nums[3]) / vin;
1004 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[3]) / vin));
1005 }
1006 debug!(LOG_LABEL, "get_speed_gain_touchpad leave");
1007 true
1008 }
1009
get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool1010 fn get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool {
1011 debug!(LOG_LABEL, "get_axis_gain_touchpad enter axis_speed is set to {}, device_type {}",
1012 @public(axis_speed), @public(device_type));
1013 let valid_device_type = match device_type {
1014 1..=2 => device_type,
1015 4 => 3,
1016 5 => 4,
1017 7 => 5,
1018 _ => 1,
1019 };
1020 let item = AxisAccelerateCurvesTouchpad::get_instance().get_axis_curve_by_speed_touchpad(valid_device_type as usize);
1021 unsafe {
1022 let num: f64 = fabs(axis_speed);
1023 let len = item.speeds.len();
1024 for i in 0..len {
1025 if num <= item.speeds[i] {
1026 *gain = item.slopes[i] * num + item.diff_nums[i];
1027 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[i]) / num));
1028 return true;
1029 }
1030 }
1031 *gain = item.slopes[len - 1] * num + item.diff_nums[len - 1];
1032 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[len - 1]) / num));
1033 }
1034 debug!(LOG_LABEL, "get_axis_gain_touchpad leave");
1035 true
1036 }
1037
1038 /// Offset struct is defined in C++, which give the vlaue
1039 /// dx = libinput_event_pointer_get_dx
1040 /// dy = libinput_event_pointer_get_dy
1041 #[repr(C)]
1042 pub struct Offset {
1043 dx: f64,
1044 dy: f64,
1045 }
1046
1047 /// # Safety
1048 /// HandleMotionDynamicAccelerateMouse is the origin C++ function name
1049 /// C++ will call for rust realization using this name
1050 #[no_mangle]
HandleMotionDynamicAccelerateMouse( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, delta_time: u64, display_ppi: f64, factor: f64 ) -> i321051 pub unsafe extern "C" fn HandleMotionDynamicAccelerateMouse (
1052 offset: *const Offset,
1053 mode: bool,
1054 abs_x: *mut f64,
1055 abs_y: *mut f64,
1056 speed: i32,
1057 delta_time: u64,
1058 display_ppi: f64,
1059 factor: f64
1060 ) -> i32 {
1061 let mut gain = 0.0;
1062 let vin: f64;
1063 let dx: f64;
1064 let dy: f64;
1065 unsafe {
1066 dx = (*offset).dx;
1067 dy = (*offset).dy;
1068 debug!(
1069 LOG_LABEL,
1070 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1071 @private(*abs_x),
1072 @private(*abs_y),
1073 @public(mode),
1074 @private(dx),
1075 @private(dy),
1076 @public(gain)
1077 );
1078 if MOUSE_GAIN_TYPE == 1 {
1079 vin = sqrt(dx * dx + dy *dy);
1080 if !get_speed_dynamic_gain_mouse_new(vin, &mut gain as *mut f64, speed, display_ppi) {
1081 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1082 return RET_ERR;
1083 }
1084 } else {
1085 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
1086 if !get_speed_dynamic_gain_mouse(vin, &mut gain as *mut f64, speed, delta_time, display_ppi) {
1087 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1088 return RET_ERR;
1089 }
1090 }
1091 if !mode {
1092 *abs_x += dx * factor * gain;
1093 *abs_y += dy * factor * gain;
1094 }
1095 debug!(
1096 LOG_LABEL,
1097 "abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1098 );
1099 }
1100 RET_OK
1101 }
1102
1103 /// # Safety
1104 /// HandleMotionAccelerateMouse is the origin C++ function name
1105 /// C++ will call for rust realization using this name
1106 #[no_mangle]
HandleMotionAccelerateMouse( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, device_type: i32 ) -> i321107 pub unsafe extern "C" fn HandleMotionAccelerateMouse (
1108 offset: *const Offset,
1109 mode: bool,
1110 abs_x: *mut f64,
1111 abs_y: *mut f64,
1112 speed: i32,
1113 device_type: i32
1114 ) -> i32 {
1115 let mut gain = 0.0;
1116 let vin: f64;
1117 let dx: f64;
1118 let dy: f64;
1119 unsafe {
1120 dx = (*offset).dx;
1121 dy = (*offset).dy;
1122 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
1123 debug!(
1124 LOG_LABEL,
1125 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1126 @private(*abs_x),
1127 @private(*abs_y),
1128 @public(mode),
1129 @private(dx),
1130 @private(dy),
1131 @public(gain)
1132 );
1133 if !get_speed_gain_mouse(vin, &mut gain as *mut f64, speed, device_type) {
1134 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1135 return RET_ERR;
1136 }
1137 if !mode {
1138 *abs_x += dx * gain;
1139 *abs_y += dy * gain;
1140 }
1141 debug!(
1142 LOG_LABEL,
1143 "abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1144 );
1145 }
1146 RET_OK
1147 }
1148
1149 /// # Safety
1150 /// HandleMotionDynamicAccelerateTouchpad is the origin C++ function name
1151 /// C++ will call for rust realization using this name
1152 #[no_mangle]
HandleMotionDynamicAccelerateTouchpad( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, display_size: f64, touchpad_size: f64, touchpad_ppi: f64, frequency: i32 ) -> i321153 pub unsafe extern "C" fn HandleMotionDynamicAccelerateTouchpad (
1154 offset: *const Offset,
1155 mode: bool,
1156 abs_x: *mut f64,
1157 abs_y: *mut f64,
1158 speed: i32,
1159 display_size: f64,
1160 touchpad_size: f64,
1161 touchpad_ppi: f64,
1162 frequency: i32
1163 ) -> i32 {
1164 let mut gain = 0.0;
1165 let vin: f64;
1166 let dx: f64;
1167 let dy: f64;
1168 let deltax: f64;
1169 let deltay: f64;
1170 unsafe {
1171 dx = (*offset).dx;
1172 dy = (*offset).dy;
1173 vin = sqrt(dx * dx + dy *dy);
1174 debug!(
1175 LOG_LABEL,
1176 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1177 @private(*abs_x),
1178 @private(*abs_y),
1179 @public(mode),
1180 @private(dx),
1181 @private(dy),
1182 @public(gain)
1183 );
1184 if !get_speed_dynamic_gain_touchpad(vin, &mut gain as *mut f64, speed, display_size,
1185 touchpad_size, touchpad_ppi, frequency) {
1186 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1187 return RET_ERR;
1188 }
1189 if !mode {
1190 deltax = (dx * gain + COMPENSATE_VALUEX).trunc();
1191 deltay = (dy * gain + COMPENSATE_VALUEY).trunc();
1192 COMPENSATE_VALUEX = (dx * gain + COMPENSATE_VALUEX).fract();
1193 COMPENSATE_VALUEY = (dy * gain + COMPENSATE_VALUEY).fract();
1194 *abs_x += deltax;
1195 *abs_y += deltay;
1196 }
1197 debug!(
1198 LOG_LABEL,
1199 "output the abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1200 );
1201 }
1202 RET_OK
1203 }
1204
1205 /// # Safety
1206 /// HandleMotionAccelerateTouchpad is the origin C++ function name
1207 /// C++ will call for rust realization using this name
1208 #[no_mangle]
HandleMotionAccelerateTouchpad( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, device_type: i32 ) -> i321209 pub unsafe extern "C" fn HandleMotionAccelerateTouchpad (
1210 offset: *const Offset,
1211 mode: bool,
1212 abs_x: *mut f64,
1213 abs_y: *mut f64,
1214 speed: i32,
1215 device_type: i32
1216 ) -> i32 {
1217 let mut gain = 0.0;
1218 let vin: f64;
1219 let dx: f64;
1220 let dy: f64;
1221 let deltax: f64;
1222 let deltay: f64;
1223 unsafe {
1224 dx = (*offset).dx;
1225 dy = (*offset).dy;
1226 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
1227 debug!(
1228 LOG_LABEL,
1229 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1230 @private(*abs_x),
1231 @private(*abs_y),
1232 @public(mode),
1233 @private(dx),
1234 @private(dy),
1235 @public(gain)
1236 );
1237 if !get_speed_gain_touchpad(vin, &mut gain as *mut f64, speed, device_type) {
1238 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1239 return RET_ERR;
1240 }
1241 if !mode {
1242 deltax = (dx * gain + COMPENSATE_VALUEX).trunc();
1243 deltay = (dy * gain + COMPENSATE_VALUEY).trunc();
1244 COMPENSATE_VALUEX = (dx * gain + COMPENSATE_VALUEX).fract();
1245 COMPENSATE_VALUEY = (dy * gain + COMPENSATE_VALUEY).fract();
1246 *abs_x += deltax;
1247 *abs_y += deltay;
1248 }
1249 debug!(
1250 LOG_LABEL,
1251 "output the abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1252 );
1253 }
1254 RET_OK
1255 }
1256
1257 /// # Safety
1258 /// HandleAxisAccelerateTouchpad is the origin C++ function name
1259 /// C++ will call for rust realization using this name
1260 #[no_mangle]
HandleAxisAccelerateTouchpad( mode: bool, abs_axis: *mut f64, device_type: i32 ) -> i321261 pub unsafe extern "C" fn HandleAxisAccelerateTouchpad (
1262 mode: bool,
1263 abs_axis: *mut f64,
1264 device_type: i32
1265 ) -> i32 {
1266 let mut gain = 0.0;
1267 unsafe {
1268 debug!(
1269 LOG_LABEL,
1270 "input the abs_axis {} and captureMode {} gain {}",
1271 @public(*abs_axis),
1272 @public(mode),
1273 @public(gain)
1274 );
1275 if !get_axis_gain_touchpad(&mut gain as *mut f64, *abs_axis, device_type) {
1276 error!(LOG_LABEL, "{} getAxisGain failed!", @public(*abs_axis));
1277 return RET_ERR;
1278 }
1279 if !mode {
1280 *abs_axis = if *abs_axis >= 0.0 { gain } else { -gain };
1281 }
1282 debug!(
1283 LOG_LABEL,
1284 "output the abs_axis {}", @public(*abs_axis)
1285 );
1286 }
1287 RET_OK
1288 }
1289
1290 #[test]
test_handle_motion_accelerate_normal()1291 fn test_handle_motion_accelerate_normal()
1292 {
1293 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1294 let mut abs_x: f64 = 0.0;
1295 let mut abs_y: f64 = 0.0;
1296 let ret: i32;
1297 unsafe {
1298 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1299 }
1300 assert_eq!(ret, RET_OK);
1301 }
1302
1303 #[test]
test_handle_motion_accelerate_mini_limit()1304 fn test_handle_motion_accelerate_mini_limit()
1305 {
1306 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1307 let mut abs_x: f64 = 0.0;
1308 let mut abs_y: f64 = 0.0;
1309 let ret: i32;
1310 unsafe {
1311 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1312 }
1313 assert_eq!(ret, RET_ERR);
1314 }
1315
1316 #[test]
test_handle_motion_accelerate_capture_mode_false()1317 fn test_handle_motion_accelerate_capture_mode_false()
1318 {
1319 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1320 let mut abs_x: f64 = 0.0;
1321 let mut abs_y: f64 = 0.0;
1322 let ret: i32;
1323 unsafe {
1324 ret = HandleMotionAccelerateMouse(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1325 }
1326 assert_eq!(ret, RET_OK);
1327 assert_eq!(abs_x, 0.0);
1328 assert_eq!(abs_y, 0.0);
1329 }
1330
1331 /* test for touchpad */
1332 #[test]
test_handle_motion_accelerate_normal_touchpad()1333 fn test_handle_motion_accelerate_normal_touchpad()
1334 {
1335 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1336 let mut abs_x: f64 = 0.0;
1337 let mut abs_y: f64 = 0.0;
1338 let ret: i32;
1339 unsafe {
1340 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1341 }
1342 assert_eq!(ret, RET_OK);
1343 }
1344
1345 #[test]
test_handle_motion_accelerate_mini_limit_touchpad()1346 fn test_handle_motion_accelerate_mini_limit_touchpad()
1347 {
1348 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1349 let mut abs_x: f64 = 0.0;
1350 let mut abs_y: f64 = 0.0;
1351 let ret: i32;
1352 unsafe {
1353 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1354 }
1355 assert_eq!(ret, RET_ERR);
1356 }
1357
1358 #[test]
test_handle_motion_accelerate_capture_mode_false_touchpad()1359 fn test_handle_motion_accelerate_capture_mode_false_touchpad()
1360 {
1361 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1362 let mut abs_x: f64 = 0.0;
1363 let mut abs_y: f64 = 0.0;
1364 let ret: i32;
1365 unsafe {
1366 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1367 }
1368 assert_eq!(ret, RET_OK);
1369 assert_eq!(abs_x, 0.0);
1370 assert_eq!(abs_y, 0.0);
1371 }
1372
1373 /* test for touchpad pc */
1374 #[test]
test_handle_motion_accelerate_capture_pc_offset_false_touchpad()1375 fn test_handle_motion_accelerate_capture_pc_offset_false_touchpad()
1376 {
1377 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1378 let mut abs_x: f64 = 0.0;
1379 let mut abs_y: f64 = 0.0;
1380 let ret: i32;
1381 unsafe {
1382 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1383 }
1384 assert_eq!(ret, RET_ERR);
1385 assert_eq!(abs_x, 0.0);
1386 assert_eq!(abs_y, 0.0);
1387 }
1388
1389 #[test]
test_handle_motion_accelerate_capture_pc_speed_false_touchpad()1390 fn test_handle_motion_accelerate_capture_pc_speed_false_touchpad()
1391 {
1392 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1393 let mut abs_x: f64 = 0.0;
1394 let mut abs_y: f64 = 0.0;
1395 let ret: i32;
1396 unsafe {
1397 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 1);
1398 }
1399 assert_eq!(ret, RET_ERR);
1400 assert_eq!(abs_x, 0.0);
1401 assert_eq!(abs_y, 0.0);
1402 }
1403
1404 #[test]
test_handle_motion_accelerate_capture_pc_mode_false_touchpad()1405 fn test_handle_motion_accelerate_capture_pc_mode_false_touchpad()
1406 {
1407 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1408 let mut abs_x: f64 = 0.0;
1409 let mut abs_y: f64 = 0.0;
1410 let ret: i32;
1411 unsafe {
1412 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1413 }
1414 assert_eq!(ret, RET_OK);
1415 }
1416
1417 #[test]
test_handle_motion_accelerate_capture_pc_nomarl_touchpad()1418 fn test_handle_motion_accelerate_capture_pc_nomarl_touchpad()
1419 {
1420 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1421 let mut abs_x: f64 = 0.0;
1422 let mut abs_y: f64 = 0.0;
1423 let ret: i32;
1424 unsafe {
1425 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1426 }
1427 assert_eq!(ret, RET_OK);
1428 }
1429
1430 #[test]
test_handle_motion_accelerate_capture_pc_offset_exceed_max_touchpad()1431 fn test_handle_motion_accelerate_capture_pc_offset_exceed_max_touchpad()
1432 {
1433 let offset: Offset = Offset{ dx: 82.00002, dy: 82.00004 };
1434 let mut abs_x: f64 = 0.0;
1435 let mut abs_y: f64 = 0.0;
1436 let ret: i32;
1437 unsafe {
1438 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1439 }
1440 assert_eq!(ret, RET_OK);
1441 assert_eq!(abs_x, 0.0);
1442 assert_eq!(abs_y, 0.0);
1443 }
1444
1445 /* test for touchpad soft_pc_pro */
1446 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_offset_false_touchpad()1447 fn test_handle_motion_accelerate_capture_soft_pc_pro_offset_false_touchpad()
1448 {
1449 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1450 let mut abs_x: f64 = 0.0;
1451 let mut abs_y: f64 = 0.0;
1452 let ret: i32;
1453 unsafe {
1454 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1455 debug!(
1456 LOG_LABEL,
1457 "ret = {}", @public(ret)
1458 );
1459 }
1460 assert_eq!(ret, RET_ERR);
1461 assert_eq!(abs_x, 0.0);
1462 assert_eq!(abs_y, 0.0);
1463 }
1464
1465 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_speed_false_touchpad()1466 fn test_handle_motion_accelerate_capture_soft_pc_pro_speed_false_touchpad()
1467 {
1468 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1469 let mut abs_x: f64 = 0.0;
1470 let mut abs_y: f64 = 0.0;
1471 let ret: i32;
1472 unsafe {
1473 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 2);
1474 }
1475 assert_eq!(ret, RET_ERR);
1476 assert_eq!(abs_x, 0.0);
1477 assert_eq!(abs_y, 0.0);
1478 }
1479
1480 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_mode_false_touchpad()1481 fn test_handle_motion_accelerate_capture_soft_pc_pro_mode_false_touchpad()
1482 {
1483 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1484 let mut abs_x: f64 = 0.0;
1485 let mut abs_y: f64 = 0.0;
1486 let ret: i32;
1487 unsafe {
1488 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1489 }
1490 assert_eq!(ret, RET_OK);
1491 }
1492
1493 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_nomarl_touchpad()1494 fn test_handle_motion_accelerate_capture_soft_pc_pro_nomarl_touchpad()
1495 {
1496 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1497 let mut abs_x: f64 = 0.0;
1498 let mut abs_y: f64 = 0.0;
1499 let ret: i32;
1500 unsafe {
1501 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1502 }
1503 assert_eq!(ret, RET_OK);
1504 }
1505
1506 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_offset_exceed_max_touchpad()1507 fn test_handle_motion_accelerate_capture_soft_pc_pro_offset_exceed_max_touchpad()
1508 {
1509 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1510 let mut abs_x: f64 = 0.0;
1511 let mut abs_y: f64 = 0.0;
1512 let ret: i32;
1513 unsafe {
1514 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1515 }
1516 assert_eq!(ret, RET_OK);
1517 assert_eq!(abs_x, 0.0);
1518 assert_eq!(abs_y, 0.0);
1519 }
1520
1521 /* test for touchpad hard_pc_pro */
1522 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_offset_false_touchpad()1523 fn test_handle_motion_accelerate_capture_hard_pc_pro_offset_false_touchpad()
1524 {
1525 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1526 let mut abs_x: f64 = 0.0;
1527 let mut abs_y: f64 = 0.0;
1528 let ret: i32;
1529 unsafe {
1530 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1531 }
1532 assert_eq!(ret, RET_ERR);
1533 assert_eq!(abs_x, 0.0);
1534 assert_eq!(abs_y, 0.0);
1535 }
1536
1537 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_speed_false_touchpad()1538 fn test_handle_motion_accelerate_capture_hard_pc_pro_speed_false_touchpad()
1539 {
1540 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1541 let mut abs_x: f64 = 0.0;
1542 let mut abs_y: f64 = 0.0;
1543 let ret: i32;
1544 unsafe {
1545 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 3);
1546 }
1547 assert_eq!(ret, RET_ERR);
1548 assert_eq!(abs_x, 0.0);
1549 assert_eq!(abs_y, 0.0);
1550 }
1551
1552 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_mode_false_touchpad()1553 fn test_handle_motion_accelerate_capture_hard_pc_pro_mode_false_touchpad()
1554 {
1555 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1556 let mut abs_x: f64 = 0.0;
1557 let mut abs_y: f64 = 0.0;
1558 let ret: i32;
1559 unsafe {
1560 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1561 }
1562 assert_eq!(ret, RET_OK);
1563 }
1564
1565 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_nomarl_touchpad()1566 fn test_handle_motion_accelerate_capture_hard_pc_pro_nomarl_touchpad()
1567 {
1568 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1569 let mut abs_x: f64 = 0.0;
1570 let mut abs_y: f64 = 0.0;
1571 let ret: i32;
1572 unsafe {
1573 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1574 }
1575 assert_eq!(ret, RET_OK);
1576 }
1577
1578 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_offset_exceed_max_touchpad()1579 fn test_handle_motion_accelerate_capture_hard_pc_pro_offset_exceed_max_touchpad()
1580 {
1581 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1582 let mut abs_x: f64 = 0.0;
1583 let mut abs_y: f64 = 0.0;
1584 let ret: i32;
1585 unsafe {
1586 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1587 }
1588 assert_eq!(ret, RET_OK);
1589 assert_eq!(abs_x, 0.0);
1590 assert_eq!(abs_y, 0.0);
1591 }
1592 /* test touchpad axis */
1593 #[test]
test_handle_axis_accelerate_normal_touchpad()1594 fn test_handle_axis_accelerate_normal_touchpad()
1595 {
1596 let mut abs_axis: f64 = 19.29931034482759;
1597 let ret: i32;
1598 unsafe {
1599 ret = HandleAxisAccelerateTouchpad(false, &mut abs_axis as *mut f64, 1);
1600 }
1601 assert_eq!(ret, RET_OK);
1602 }
1603
1604 #[test]
test_handle_axis_accelerate_capture_mode_false_touchpad()1605 fn test_handle_axis_accelerate_capture_mode_false_touchpad()
1606 {
1607 let mut abs_axis: f64 = 19.29931034482759;
1608 let ret: i32;
1609 unsafe {
1610 ret = HandleAxisAccelerateTouchpad(true, &mut abs_axis as *mut f64, 1);
1611 }
1612 assert_eq!(ret, RET_OK);
1613 }
1614