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![3.0, 6.0, 9.0, 12.0, 15.0, 18.0, 23.0, 40.0],
575 slopes: vec![2.84, 1.62, 1.36, 1.1, 1.18, 0.54, 0.57, 1.25],
576 diff_nums: vec![0.0, 3.66, 5.22, 7.56, 6.6, 16.2, 15.73, 0.0]
577 },
578 CurveItem {
579 speeds: vec![0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.4, 24.02],
580 slopes: vec![4.62, 2.9, 2.54, 2.2, 1.95, 1.75, 0.38, 2.09],
581 diff_nums: vec![0.0, 0.52, 0.73, 1.04, 1.34, 1.64, 4.1, 0.0]
582 },
583 CurveItem {
584 speeds: vec![0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 40.0],
585 slopes: vec![3.0, 2.07, 1.72, 1.47, 1.31, 1.19, 0.55, 1.48],
586 diff_nums: vec![0.0, 0.46, 0.82, 1.19, 1.52, 1.82, 3.74, 0.0]
587 },
588 CurveItem {
589 speeds: vec![0.5, 0.88, 1.28, 1.7, 2.08, 2.49, 3.26, 34.0],
590 slopes: vec![4.11, 2.63, 2.27, 2.02, 1.68, 1.62, 0.66, 2.03],
591 diff_nums: vec![0.0, 0.74, 1.05, 1.38, 1.95, 2.07, 4.47, 0.0]
592 },
593 ],
594 });
595 });
596 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
597 }
598 }
599
600 impl TabletTouchpadAccelerateCurves {
get_instance() -> &'static TabletTouchpadAccelerateCurves601 fn get_instance() -> &'static TabletTouchpadAccelerateCurves {
602 static mut GLOBAL_CURVES: Option<TabletTouchpadAccelerateCurves> = None;
603 static ONCE: Once = Once::new();
604
605 ONCE.call_once(|| unsafe {
606 GLOBAL_CURVES = Some(TabletTouchpadAccelerateCurves {
607 data: vec![
608 CurveItem {
609 speeds: vec![2.0, 20.0, 30.0, 128.0],
610 slopes: vec![0.12, 0.21, 0.45, 0.87],
611 diff_nums: vec![0.0, -0.18, -4.98, -17.58]
612 },
613 CurveItem {
614 speeds: vec![2.0, 20.0, 30.0, 128.0],
615 slopes: vec![0.16, 0.28, 0.60, 1.16],
616 diff_nums: vec![0.0, -0.24, -6.64, -23.44],
617 },
618 CurveItem {
619 speeds: vec![2.0, 20.0, 30.0, 128.0],
620 slopes: vec![0.20, 0.35, 0.75, 1.45],
621 diff_nums: vec![0.0, -0.30, -8.30, -29.30],
622 },
623 CurveItem {
624 speeds: vec![2.0, 20.0, 30.0, 128.0],
625 slopes: vec![0.24, 0.42, 0.90, 1.74],
626 diff_nums: vec![0.0, -0.36, -9.96, -35.16],
627 },
628 CurveItem {
629 speeds: vec![2.0, 20.0, 30.0, 128.0],
630 slopes: vec![0.32, 0.56, 1.20, 2.32],
631 diff_nums: vec![0.0, -0.48, -13.28, -46.88],
632 },
633 CurveItem {
634 speeds: vec![2.0, 20.0, 30.0, 128.0],
635 slopes: vec![0.40, 0.70, 1.50, 2.90],
636 diff_nums: vec![0.0, -0.60, -16.60, -58.60],
637 },
638 CurveItem {
639 speeds: vec![2.0, 20.0, 30.0, 128.0],
640 slopes: vec![0.48, 0.84, 1.80, 3.48],
641 diff_nums: vec![0.0, -0.72, -19.92, -70.32],
642 },
643 CurveItem {
644 speeds: vec![2.0, 20.0, 30.0, 128.0],
645 slopes: vec![0.60, 1.05, 2.25, 4.35],
646 diff_nums: vec![0.0, -0.90, -24.90, -87.90],
647 },
648 CurveItem {
649 speeds: vec![2.0, 20.0, 30.0, 128.0],
650 slopes: vec![0.76, 1.33, 2.85, 5.51],
651 diff_nums: vec![0.0, -1.14, -31.54, -111.34],
652 },
653 CurveItem {
654 speeds: vec![2.0, 20.0, 30.0, 128.0],
655 slopes: vec![0.92, 1.61, 3.45, 6.67],
656 diff_nums: vec![0.0, -1.38, -38.18, -134.78],
657 },
658 CurveItem {
659 speeds: vec![2.0, 20.0, 30.0, 128.0],
660 slopes: vec![1.08, 1.89, 4.05, 7.83],
661 diff_nums: vec![0.0, -1.62, -44.82, -158.22],
662 },
663 ],
664 });
665 });
666 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
667 }
668 }
669
670 impl FoldPcTouchpadAccelerateCurves {
get_instance() -> &'static FoldPcTouchpadAccelerateCurves671 fn get_instance() -> &'static FoldPcTouchpadAccelerateCurves {
672 static mut GLOBAL_CURVES: Option<FoldPcTouchpadAccelerateCurves> = None;
673 static ONCE: Once = Once::new();
674
675 ONCE.call_once(|| unsafe {
676 GLOBAL_CURVES = Some(FoldPcTouchpadAccelerateCurves {
677 data: vec![
678 CurveItem {
679 speeds: vec![2.51, 25.07, 37.61, 160.43],
680 slopes: vec![0.12, 0.20, 0.44, 0.84],
681 diff_nums: vec![0.0, -0.22, -6.06, -21.38],
682 },
683 CurveItem {
684 speeds: vec![2.51, 25.07, 37.61, 160.43],
685 slopes: vec![0.16, 0.27, 0.58, 1.13],
686 diff_nums: vec![0.0, -0.29, -8.08, -28.51],
687 },
688 CurveItem {
689 speeds: vec![2.51, 25.07, 37.61, 160.43],
690 slopes: vec![0.19, 0.34, 0.73, 1.41],
691 diff_nums: vec![0.0, -0.37, -10.10, -35.64],
692 },
693 CurveItem {
694 speeds: vec![2.51, 25.07, 37.61, 160.43],
695 slopes: vec![0.23, 0.41, 0.87, 1.69],
696 diff_nums: vec![0.0, -0.44, -12.12, -42.77],
697 },
698 CurveItem {
699 speeds: vec![2.51, 25.07, 37.61, 160.43],
700 slopes: vec![0.31, 0.54, 1.16, 2.25],
701 diff_nums: vec![0.0, -0.58, -16.15, -57.03],
702 },
703 CurveItem {
704 speeds: vec![2.51, 25.07, 37.61, 160.43],
705 slopes: vec![0.39, 0.68, 1.46, 2.81],
706 diff_nums: vec![0.0, -0.73, -20.19, -71.28],
707 },
708 CurveItem {
709 speeds: vec![2.51, 25.07, 37.61, 160.43],
710 slopes: vec![0.47, 0.82, 1.75, 3.38],
711 diff_nums: vec![0.0, -0.88, -24.23, -85.54],
712 },
713 CurveItem {
714 speeds: vec![2.51, 25.07, 37.61, 160.43],
715 slopes: vec![0.58, 1.02, 2.18, 4.22],
716 diff_nums: vec![0.0, -1.1, -30.29, -106.92],
717 },
718 CurveItem {
719 speeds: vec![2.51, 25.07, 37.61, 160.43],
720 slopes: vec![0.74, 1.29, 2.77, 5.53],
721 diff_nums: vec![0.0, -1.39, -38.37, -135.44],
722 },
723 CurveItem {
724 speeds: vec![2.51, 25.07, 37.61, 160.43],
725 slopes: vec![0.89, 1.56, 3.35, 6.47],
726 diff_nums: vec![0.0, -1.68, -46.44, -163.95],
727 },
728 CurveItem {
729 speeds: vec![2.51, 25.07, 37.61, 160.43],
730 slopes: vec![1.05, 1.83, 3.93, 7.6],
731 diff_nums: vec![0.0, -1.97, -54.52, -192.46],
732 },
733 ],
734 });
735 });
736 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
737 }
738 }
739
740 impl FoldPcVirtTouchpadAccelerateCurves {
get_instance() -> &'static FoldPcVirtTouchpadAccelerateCurves741 fn get_instance() -> &'static FoldPcVirtTouchpadAccelerateCurves {
742 static mut GLOBAL_CURVES: Option<FoldPcVirtTouchpadAccelerateCurves> = None;
743 static ONCE: Once = Once::new();
744
745 ONCE.call_once(|| unsafe {
746 GLOBAL_CURVES = Some(FoldPcVirtTouchpadAccelerateCurves {
747 data: vec![
748 CurveItem {
749 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
750 slopes: vec![0.31, 0.92, 0.57, 1.56, 0.99, 2.31, 2.58, 3.48],
751 diff_nums: vec![0.0, -0.61, 0.09, -2.88, -0.6, -7.2, -8.82, -15.12]
752 },
753 CurveItem {
754 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
755 slopes: vec![0.41, 1.23, 0.76, 2.08, 1.32, 3.08, 3.44, 4.64],
756 diff_nums: vec![0.0, -0.82, 0.12, -3.84, -0.8, -9.6, -11.76, -20.16]
757 },
758 CurveItem {
759 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
760 slopes: vec![0.52, 1.54, 0.95, 2.6, 1.65, 3.85, 4.3, 5.8],
761 diff_nums: vec![0.0, -1.02, 0.15, -4.8, -1.0, -12.0, -14.7, -25.2]
762 },
763 CurveItem {
764 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
765 slopes: vec![0.62, 1.84, 1.14, 3.12, 1.98, 4.62, 5.16, 6.96],
766 diff_nums: vec![0.0, -1.22, 0.18, -5.76, -1.2, -14.4, -17.64, -30.24]
767 },
768 CurveItem {
769 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
770 slopes: vec![0.82, 2.46, 1.52, 4.16, 2.64, 6.16, 6.88, 9.28],
771 diff_nums: vec![0.0, -1.63, 0.24, -7.68, -1.6, -19.2, -23.52, -40.32]
772 },
773 CurveItem {
774 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
775 slopes: vec![1.03, 3.07, 1.9, 5.2, 3.3, 7.7, 8.6, 11.6],
776 diff_nums: vec![0.0, -2.04, 0.3, -9.6, -2.0, -24.0, -29.4, -50.4]
777 },
778 CurveItem {
779 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
780 slopes: vec![1.24, 3.68, 2.28, 6.24, 3.96, 9.24, 10.32, 13.92],
781 diff_nums: vec![0.0, -2.45, 0.36, -11.52, -2.4, -28.8, -35.28, -60.48]
782 },
783 CurveItem {
784 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
785 slopes: vec![1.55, 4.61, 2.85, 7.8, 4.95, 11.55, 12.9, 17.4],
786 diff_nums: vec![0.0, -3.06, 0.45, -14.4, -3.0, -36.0, -44.1, -75.6]
787 },
788 CurveItem {
789 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
790 slopes: vec![1.96, 5.83, 3.61, 9.88, 6.27, 14.63, 16.34, 22.04],
791 diff_nums: vec![0.0, -3.88, 0.57, -18.24, -3.8, -45.6, -55.86, -95.76]
792 },
793 CurveItem {
794 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
795 slopes: vec![2.37, 7.06, 4.37, 11.96, 7.59, 17.71, 19.78, 26.68],
796 diff_nums: vec![0.0, -4.69, 0.69, -22.08, -4.6, -55.2, -67.62, -115.92]
797 },
798 CurveItem {
799 speeds: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0],
800 slopes: vec![2.78, 8.29, 5.13, 14.04, 8.91, 20.79, 23.22, 31.32],
801 diff_nums: vec![0.0, -5.51, 0.81, -25.92, -5.4, -64.8, -79.38, -136.08]
802 },
803 ],
804 });
805 });
806 unsafe { GLOBAL_CURVES.as_ref().unwrap() }
807 }
808 }
809 // 这个 extern 代码块链接到 libm 库
810 #[link(name = "m")]
811 extern {
fabs(z: f64) -> f64812 fn fabs(z: f64) -> f64;
fmax(a: f64, b: f64) -> f64813 fn fmax(a: f64, b: f64) -> f64;
fmin(a: f64, b: f64) -> f64814 fn fmin(a: f64, b: f64) -> f64;
log(a: f64) -> f64815 fn log(a: f64) -> f64;
sqrt(a: f64) -> f64816 fn sqrt(a: f64) -> f64;
817 }
818
get_speed_dynamic_gain_mouse(vin: f64, gain: *mut f64, speed: i32, delta_time: u64, display_ppi: f64) -> bool819 fn get_speed_dynamic_gain_mouse(vin: f64, gain: *mut f64, speed: i32, delta_time: u64, display_ppi: f64) -> bool {
820 debug!(LOG_LABEL, "get_speed_gain_mouse enter vin is set to {} speed {}, delta_time {}, display_ppi {}",
821 @public(vin), @public(speed), @public(delta_time), @public(display_ppi));
822 if delta_time < 1 {
823 error!(LOG_LABEL, "{} The delta_time can't be less than 0", @public(delta_time));
824 return false;
825 }
826 if display_ppi < 1.0 {
827 error!(LOG_LABEL, "{} The display_ppi can't be less than 1", @public(display_ppi));
828 return false;
829 }
830 unsafe {
831 if fabs(vin) < DOUBLE_ZERO {
832 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
833 return false;
834 }
835 }
836 if speed < 1 {
837 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
838 return false;
839 }
840 let speeds_radio = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
841 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0];
842 let standard_slopes = [2.9394, 3.7879, 8.2121, 13.1515];
843 let vins = [0.50, 1.30, 2.20, 16.17];
844 unsafe {
845 let vin_new: f64 = vin * MS_2_US / delta_time as f64;
846 let speed_radio = speeds_radio[speed as usize - 1];
847 let mut slopes = Vec::new();
848 let mut diff_nums = Vec::new();
849 for i in 0..4 {
850 slopes.push(standard_slopes[i] * display_ppi / MOUSE_DPI);
851 if i < 1 {
852 diff_nums.push(0.0);
853 continue;
854 }
855 diff_nums.push((slopes[i - 1] - slopes[i]) * vins[i - 1] + diff_nums[i - 1]);
856 }
857 let num: f64 = fabs(vin_new);
858 for i in 0..4 {
859 if num <= vins[i] {
860 *gain = (slopes[i] * vin_new + diff_nums[i]) * speed_radio / vin_new;
861 debug!(LOG_LABEL, "gain is set to {}", @public(slopes[i]));
862 return true;
863 }
864 }
865 *gain = (slopes[3] * vin_new + diff_nums[3]) * speed_radio / vin_new;
866 debug!(LOG_LABEL, "gain is set to {}", @public(slopes[3]));
867 }
868 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
869 true
870 }
871
get_speed_dynamic_gain_touchpad( vin: f64, gain: *mut f64, speed: i32, display_size: f64, touchpad_size: f64, touchpad_ppi: f64, frequency: i32 ) -> bool872 fn get_speed_dynamic_gain_touchpad(
873 vin: f64,
874 gain: *mut f64,
875 speed: i32,
876 display_size: f64,
877 touchpad_size: f64,
878 touchpad_ppi: f64,
879 frequency: i32
880 ) -> bool {
881 debug!(LOG_LABEL,
882 "get_speed_gain_touchpad enter vin is set to {}, speed {}, touchpad_size {}, display_size {}, touchpad_ppi {}, frequency {}",
883 @public(vin), @public(speed), @public(touchpad_size), @public(display_size), @public(touchpad_ppi), @public(frequency));
884 if speed < 1 {
885 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
886 return false;
887 }
888 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];
889 let standard_slopes = [0.9728, 1.7024, 3.6480, 7.0528];
890 let standard_vins = [7.5, 50.0, 160.0, 640.0];
891 unsafe {
892 let speed_radio = speeds_radio[speed as usize - 1];
893 let mut slopes = Vec::new();
894 let mut diff_nums = Vec::new();
895 let mut vins = Vec::new();
896 for i in 0..4 {
897 vins.push(standard_vins[i] * touchpad_ppi / frequency as f64);
898 slopes.push(standard_slopes[i] * (display_size / touchpad_size) *
899 (TOUCHPAD_STANDARD_SIZE / DISPLAY_STANDARD_SIZE));
900 if i < 1 {
901 diff_nums.push(0.0);
902 continue;
903 }
904 diff_nums.push((slopes[i - 1] - slopes[i]) * vins[i - 1] + diff_nums[i - 1]);
905 }
906 let num: f64 = fabs(vin);
907 for i in 0..4 {
908 if num <= vins[i] {
909 *gain = (slopes[i] * vin + diff_nums[i]) * speed_radio / vin;
910 debug!(LOG_LABEL, "gain is set to {}", @public(*gain));
911 return true;
912 }
913 }
914 *gain = (slopes[3] * vin + diff_nums[3]) * speed_radio / vin;
915 debug!(LOG_LABEL, "gain is set to {}", @public(*gain));
916 }
917 debug!(LOG_LABEL, "get_speed_gain_touchpad leave");
918 true
919 }
920
get_speed_dynamic_gain_mouse_new(vin: f64, gain: *mut f64, speed: i32, display_ppi: f64) -> bool921 fn get_speed_dynamic_gain_mouse_new(vin: f64, gain: *mut f64, speed: i32, display_ppi: f64) -> bool {
922 if display_ppi < 1.0 {
923 error!(LOG_LABEL, "{} The display_ppi can't be less than 1", @public(display_ppi));
924 return false;
925 }
926 if !(1..=20).contains(&speed) {
927 error!(LOG_LABEL, "{} The speed value error", @public(speed));
928 return false;
929 }
930 let speeds_radio = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
931 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0];
932 let slow_gain_params = [1.0341957429588597, 0.7126536301164397, 2.5813850030026853, 0.02004352388383787];
933 let fast_gain_params = [1.3556224243118067, 2.5417186406523578, 6.127531547651636, 3.2322785269552803];
934 let standard_ppi = 264.16;
935 unsafe {
936 let ppi_ratio: f64 = display_ppi / standard_ppi;
937 let speed_radio: f64 = speeds_radio[speed as usize - 1];
938 let gain_tmp: f64 = if vin < 13.5 {
939 slow_gain_params[0] * log(slow_gain_params[1] * vin + slow_gain_params[2]) + slow_gain_params[3]
940 } else {
941 fast_gain_params[0] * log(fast_gain_params[1] * log(vin) - fast_gain_params[2]) + fast_gain_params[3]
942 };
943 *gain = gain_tmp * speed_radio * ppi_ratio;
944 debug!(LOG_LABEL, "gain is set to {}", @public(*gain));
945 }
946 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
947 true
948 }
949
get_speed_gain_mouse(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool950 fn get_speed_gain_mouse(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
951 debug!(LOG_LABEL, "get_speed_gain_mouse enter vin is set to {} speed {}, device_type {}",
952 @public(vin), @public(speed), @public(device_type));
953 unsafe {
954 if fabs(vin) < DOUBLE_ZERO {
955 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
956 return false;
957 }
958 }
959 if speed < 1 {
960 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
961 return false;
962 }
963 let item = match device_type {
964 1 => PCMouseAccelerateCurves::get_instance().pc_mouse_get_curve_by_speed(speed as usize),
965 2 => SoftPcProMouseAccelerateCurves::get_instance().soft_pc_pro_mouse_get_curve_by_speed(speed as usize),
966 3 => HardPcProMouseAccelerateCurves::get_instance().hard_pc_pro_mouse_get_curve_by_speed(speed as usize),
967 _ => PCMouseAccelerateCurves::get_instance().pc_mouse_get_curve_by_speed(speed as usize),
968 };
969 unsafe {
970 let num: f64 = fabs(vin);
971 let len = item.speeds.len();
972 for i in 0..len {
973 if num <= item.speeds[i] {
974 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
975 debug!(LOG_LABEL, "slope is set to {}, gain is {}", @public(item.slopes[i]), @public(*gain));
976 return true;
977 }
978 }
979 *gain = (item.slopes[len - 1] * vin + item.diff_nums[len - 1]) / vin;
980 debug!(LOG_LABEL, "slope is set to {}, gain is {}", @public(item.slopes[len - 1]), @public(*gain));
981 }
982 debug!(LOG_LABEL, "get_speed_gain_mouse leave");
983 true
984 }
985
986
get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool987 fn get_speed_gain_touchpad(vin: f64, gain: *mut f64, speed: i32, device_type: i32) -> bool {
988 debug!(LOG_LABEL, "get_speed_gain_touchpad enter vin is set to {}, speed {}, device_type {}",
989 @public(vin), @public(speed), @public(device_type));
990 unsafe {
991 if fabs(vin) < DOUBLE_ZERO {
992 error!(LOG_LABEL, "{} less that the limit", DOUBLE_ZERO);
993 return false;
994 }
995 }
996 if speed < 1 {
997 error!(LOG_LABEL, "{} The speed value can't be less than 1", @public(speed));
998 return false;
999 }
1000 let item = match device_type {
1001 1 => PCTouchpadAccelerateCurves::get_instance().pc_touchpad_get_curve_by_speed(speed as usize),
1002 2 => SoftPcProTouchpadAccelerateCurves::get_instance().soft_pc_pro_touchpad_get_curve_by_speed(speed as usize),
1003 3 => HardPcProTouchpadAccelerateCurves::get_instance().hard_pc_pro_touchpad_get_curve_by_speed(speed as usize),
1004 4 => TabletTouchpadAccelerateCurves::get_instance().tablet_touchpad_get_curve_by_speed(speed as usize),
1005 5 => FoldPcTouchpadAccelerateCurves::get_instance().fold_pc_touchpad_get_curve_by_speed(speed as usize),
1006 7 => FoldPcVirtTouchpadAccelerateCurves::get_instance().fold_pc_virt_touchpad_get_curve_by_speed(),
1007 _ => PCTouchpadAccelerateCurves::get_instance().pc_touchpad_get_curve_by_speed(speed as usize),
1008 };
1009 unsafe {
1010 let num: f64 = fabs(vin);
1011 for i in 0..4 {
1012 if num <= item.speeds[i] {
1013 *gain = (item.slopes[i] * vin + item.diff_nums[i]) / vin;
1014 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[i]) / vin));
1015 return true;
1016 }
1017 }
1018 *gain = (item.slopes[3] * vin + item.diff_nums[3]) / vin;
1019 debug!(LOG_LABEL, "gain is set to {}", @public((*gain * vin - item.diff_nums[3]) / vin));
1020 }
1021 debug!(LOG_LABEL, "get_speed_gain_touchpad leave");
1022 true
1023 }
1024
get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool1025 fn get_axis_gain_touchpad(gain: *mut f64, axis_speed: f64, device_type: i32) -> bool {
1026 debug!(LOG_LABEL, "get_axis_gain_touchpad enter axis_speed is set to {}, device_type {}",
1027 @public(axis_speed), @public(device_type));
1028 let valid_device_type = match device_type {
1029 1..=2 => device_type,
1030 4 => 3,
1031 5 => 4,
1032 6 => 6,
1033 7 => 5,
1034 8 => 7,
1035 9 => 8,
1036 _ => 1,
1037 };
1038 let item = AxisAccelerateCurvesTouchpad::get_instance().get_axis_curve_by_speed_touchpad(valid_device_type as usize);
1039 unsafe {
1040 let num: f64 = fabs(axis_speed);
1041 let len = item.speeds.len();
1042 for i in 0..len {
1043 if num <= item.speeds[i] {
1044 *gain = item.slopes[i] * num + item.diff_nums[i];
1045 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[i]) / num));
1046 return true;
1047 }
1048 }
1049 *gain = item.slopes[len - 1] * num + item.diff_nums[len - 1];
1050 debug!(LOG_LABEL, "gain is set to {}", @public((*gain - item.diff_nums[len - 1]) / num));
1051 }
1052 debug!(LOG_LABEL, "get_axis_gain_touchpad leave");
1053 true
1054 }
1055
1056 /// Offset struct is defined in C++, which give the vlaue
1057 /// dx = libinput_event_pointer_get_dx
1058 /// dy = libinput_event_pointer_get_dy
1059 #[repr(C)]
1060 pub struct Offset {
1061 dx: f64,
1062 dy: f64,
1063 }
1064
1065 /// # Safety
1066 /// HandleMotionDynamicAccelerateMouse is the origin C++ function name
1067 /// C++ will call for rust realization using this name
1068 #[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 ) -> i321069 pub unsafe extern "C" fn HandleMotionDynamicAccelerateMouse (
1070 offset: *const Offset,
1071 mode: bool,
1072 abs_x: *mut f64,
1073 abs_y: *mut f64,
1074 speed: i32,
1075 delta_time: u64,
1076 display_ppi: f64,
1077 factor: f64
1078 ) -> i32 {
1079 let mut gain = 0.0;
1080 let vin: f64;
1081 let dx: f64;
1082 let dy: f64;
1083 unsafe {
1084 dx = (*offset).dx;
1085 dy = (*offset).dy;
1086 debug!(
1087 LOG_LABEL,
1088 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1089 @private(*abs_x),
1090 @private(*abs_y),
1091 @public(mode),
1092 @private(dx),
1093 @private(dy),
1094 @public(gain)
1095 );
1096 if MOUSE_GAIN_TYPE == 1 {
1097 vin = sqrt(dx * dx + dy *dy);
1098 if !get_speed_dynamic_gain_mouse_new(vin, &mut gain as *mut f64, speed, display_ppi) {
1099 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1100 return RET_ERR;
1101 }
1102 } else {
1103 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
1104 if !get_speed_dynamic_gain_mouse(vin, &mut gain as *mut f64, speed, delta_time, display_ppi) {
1105 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1106 return RET_ERR;
1107 }
1108 }
1109 if !mode {
1110 *abs_x += dx * factor * gain;
1111 *abs_y += dy * factor * gain;
1112 }
1113 debug!(
1114 LOG_LABEL,
1115 "abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1116 );
1117 }
1118 RET_OK
1119 }
1120
1121 /// # Safety
1122 /// HandleMotionAccelerateMouse is the origin C++ function name
1123 /// C++ will call for rust realization using this name
1124 #[no_mangle]
HandleMotionAccelerateMouse( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, device_type: i32 ) -> i321125 pub unsafe extern "C" fn HandleMotionAccelerateMouse (
1126 offset: *const Offset,
1127 mode: bool,
1128 abs_x: *mut f64,
1129 abs_y: *mut f64,
1130 speed: i32,
1131 device_type: i32
1132 ) -> i32 {
1133 let mut gain = 0.0;
1134 let vin: f64;
1135 let dx: f64;
1136 let dy: f64;
1137 unsafe {
1138 dx = (*offset).dx;
1139 dy = (*offset).dy;
1140 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
1141 debug!(
1142 LOG_LABEL,
1143 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1144 @private(*abs_x),
1145 @private(*abs_y),
1146 @public(mode),
1147 @private(dx),
1148 @private(dy),
1149 @public(gain)
1150 );
1151 if !get_speed_gain_mouse(vin, &mut gain as *mut f64, speed, device_type) {
1152 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1153 return RET_ERR;
1154 }
1155 if !mode {
1156 *abs_x += dx * gain;
1157 *abs_y += dy * gain;
1158 }
1159 debug!(
1160 LOG_LABEL,
1161 "abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1162 );
1163 }
1164 RET_OK
1165 }
1166
1167 /// # Safety
1168 /// HandleMotionDynamicAccelerateTouchpad is the origin C++ function name
1169 /// C++ will call for rust realization using this name
1170 #[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 ) -> i321171 pub unsafe extern "C" fn HandleMotionDynamicAccelerateTouchpad (
1172 offset: *const Offset,
1173 mode: bool,
1174 abs_x: *mut f64,
1175 abs_y: *mut f64,
1176 speed: i32,
1177 display_size: f64,
1178 touchpad_size: f64,
1179 touchpad_ppi: f64,
1180 frequency: i32
1181 ) -> i32 {
1182 let mut gain = 0.0;
1183 let vin: f64;
1184 let dx: f64;
1185 let dy: f64;
1186 let deltax: f64;
1187 let deltay: f64;
1188 unsafe {
1189 dx = (*offset).dx;
1190 dy = (*offset).dy;
1191 vin = sqrt(dx * dx + dy *dy);
1192 debug!(
1193 LOG_LABEL,
1194 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1195 @private(*abs_x),
1196 @private(*abs_y),
1197 @public(mode),
1198 @private(dx),
1199 @private(dy),
1200 @public(gain)
1201 );
1202 if !get_speed_dynamic_gain_touchpad(vin, &mut gain as *mut f64, speed, display_size,
1203 touchpad_size, touchpad_ppi, frequency) {
1204 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1205 return RET_ERR;
1206 }
1207 if !mode {
1208 deltax = (dx * gain + COMPENSATE_VALUEX).trunc();
1209 deltay = (dy * gain + COMPENSATE_VALUEY).trunc();
1210 COMPENSATE_VALUEX = (dx * gain + COMPENSATE_VALUEX).fract();
1211 COMPENSATE_VALUEY = (dy * gain + COMPENSATE_VALUEY).fract();
1212 *abs_x += deltax;
1213 *abs_y += deltay;
1214 }
1215 debug!(
1216 LOG_LABEL,
1217 "output the abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1218 );
1219 }
1220 RET_OK
1221 }
1222
1223 /// # Safety
1224 /// HandleMotionAccelerateTouchpad is the origin C++ function name
1225 /// C++ will call for rust realization using this name
1226 #[no_mangle]
HandleMotionAccelerateTouchpad( offset: *const Offset, mode: bool, abs_x: *mut f64, abs_y: *mut f64, speed: i32, device_type: i32 ) -> i321227 pub unsafe extern "C" fn HandleMotionAccelerateTouchpad (
1228 offset: *const Offset,
1229 mode: bool,
1230 abs_x: *mut f64,
1231 abs_y: *mut f64,
1232 speed: i32,
1233 device_type: i32
1234 ) -> i32 {
1235 let mut gain = 0.0;
1236 let vin: f64;
1237 let dx: f64;
1238 let dy: f64;
1239 let deltax: f64;
1240 let deltay: f64;
1241 unsafe {
1242 dx = (*offset).dx;
1243 dy = (*offset).dy;
1244 vin = (fmax(fabs(dx), fabs(dy))) + (fmin(fabs(dx), fabs(dy))) / 2.0;
1245 debug!(
1246 LOG_LABEL,
1247 "output the abs_x {} and abs_y {} captureMode {} dx {} dy {} gain {}",
1248 @private(*abs_x),
1249 @private(*abs_y),
1250 @public(mode),
1251 @private(dx),
1252 @private(dy),
1253 @public(gain)
1254 );
1255 if !get_speed_gain_touchpad(vin, &mut gain as *mut f64, speed, device_type) {
1256 error!(LOG_LABEL, "{} getSpeedGgain failed!", @public(speed));
1257 return RET_ERR;
1258 }
1259 if !mode {
1260 deltax = (dx * gain + COMPENSATE_VALUEX).trunc();
1261 deltay = (dy * gain + COMPENSATE_VALUEY).trunc();
1262 COMPENSATE_VALUEX = (dx * gain + COMPENSATE_VALUEX).fract();
1263 COMPENSATE_VALUEY = (dy * gain + COMPENSATE_VALUEY).fract();
1264 *abs_x += deltax;
1265 *abs_y += deltay;
1266 }
1267 debug!(
1268 LOG_LABEL,
1269 "output the abs_x {} and abs_y {}", @private(*abs_x), @private(*abs_y)
1270 );
1271 }
1272 RET_OK
1273 }
1274
1275 /// # Safety
1276 /// HandleAxisAccelerateTouchpad is the origin C++ function name
1277 /// C++ will call for rust realization using this name
1278 #[no_mangle]
HandleAxisAccelerateTouchpad( mode: bool, abs_axis: *mut f64, device_type: i32 ) -> i321279 pub unsafe extern "C" fn HandleAxisAccelerateTouchpad (
1280 mode: bool,
1281 abs_axis: *mut f64,
1282 device_type: i32
1283 ) -> i32 {
1284 let mut gain = 0.0;
1285 unsafe {
1286 debug!(
1287 LOG_LABEL,
1288 "input the abs_axis {} and captureMode {} gain {}",
1289 @public(*abs_axis),
1290 @public(mode),
1291 @public(gain)
1292 );
1293 if !get_axis_gain_touchpad(&mut gain as *mut f64, *abs_axis, device_type) {
1294 error!(LOG_LABEL, "{} getAxisGain failed!", @public(*abs_axis));
1295 return RET_ERR;
1296 }
1297 if !mode {
1298 *abs_axis = if *abs_axis >= 0.0 { gain } else { -gain };
1299 }
1300 debug!(
1301 LOG_LABEL,
1302 "output the abs_axis {}", @public(*abs_axis)
1303 );
1304 }
1305 RET_OK
1306 }
1307
1308 #[test]
test_handle_motion_accelerate_normal()1309 fn test_handle_motion_accelerate_normal()
1310 {
1311 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1312 let mut abs_x: f64 = 0.0;
1313 let mut abs_y: f64 = 0.0;
1314 let ret: i32;
1315 unsafe {
1316 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1317 }
1318 assert_eq!(ret, RET_OK);
1319 }
1320
1321 #[test]
test_handle_motion_accelerate_mini_limit()1322 fn test_handle_motion_accelerate_mini_limit()
1323 {
1324 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1325 let mut abs_x: f64 = 0.0;
1326 let mut abs_y: f64 = 0.0;
1327 let ret: i32;
1328 unsafe {
1329 ret = HandleMotionAccelerateMouse(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1330 }
1331 assert_eq!(ret, RET_ERR);
1332 }
1333
1334 #[test]
test_handle_motion_accelerate_capture_mode_false()1335 fn test_handle_motion_accelerate_capture_mode_false()
1336 {
1337 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1338 let mut abs_x: f64 = 0.0;
1339 let mut abs_y: f64 = 0.0;
1340 let ret: i32;
1341 unsafe {
1342 ret = HandleMotionAccelerateMouse(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1343 }
1344 assert_eq!(ret, RET_OK);
1345 assert_eq!(abs_x, 0.0);
1346 assert_eq!(abs_y, 0.0);
1347 }
1348
1349 /* test for touchpad */
1350 #[test]
test_handle_motion_accelerate_normal_touchpad()1351 fn test_handle_motion_accelerate_normal_touchpad()
1352 {
1353 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1354 let mut abs_x: f64 = 0.0;
1355 let mut abs_y: f64 = 0.0;
1356 let ret: i32;
1357 unsafe {
1358 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1359 }
1360 assert_eq!(ret, RET_OK);
1361 }
1362
1363 #[test]
test_handle_motion_accelerate_mini_limit_touchpad()1364 fn test_handle_motion_accelerate_mini_limit_touchpad()
1365 {
1366 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1367 let mut abs_x: f64 = 0.0;
1368 let mut abs_y: f64 = 0.0;
1369 let ret: i32;
1370 unsafe {
1371 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1372 }
1373 assert_eq!(ret, RET_ERR);
1374 }
1375
1376 #[test]
test_handle_motion_accelerate_capture_mode_false_touchpad()1377 fn test_handle_motion_accelerate_capture_mode_false_touchpad()
1378 {
1379 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1380 let mut abs_x: f64 = 0.0;
1381 let mut abs_y: f64 = 0.0;
1382 let ret: i32;
1383 unsafe {
1384 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 0);
1385 }
1386 assert_eq!(ret, RET_OK);
1387 assert_eq!(abs_x, 0.0);
1388 assert_eq!(abs_y, 0.0);
1389 }
1390
1391 /* test for touchpad pc */
1392 #[test]
test_handle_motion_accelerate_capture_pc_offset_false_touchpad()1393 fn test_handle_motion_accelerate_capture_pc_offset_false_touchpad()
1394 {
1395 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1396 let mut abs_x: f64 = 0.0;
1397 let mut abs_y: f64 = 0.0;
1398 let ret: i32;
1399 unsafe {
1400 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1401 }
1402 assert_eq!(ret, RET_ERR);
1403 assert_eq!(abs_x, 0.0);
1404 assert_eq!(abs_y, 0.0);
1405 }
1406
1407 #[test]
test_handle_motion_accelerate_capture_pc_speed_false_touchpad()1408 fn test_handle_motion_accelerate_capture_pc_speed_false_touchpad()
1409 {
1410 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1411 let mut abs_x: f64 = 0.0;
1412 let mut abs_y: f64 = 0.0;
1413 let ret: i32;
1414 unsafe {
1415 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 1);
1416 }
1417 assert_eq!(ret, RET_ERR);
1418 assert_eq!(abs_x, 0.0);
1419 assert_eq!(abs_y, 0.0);
1420 }
1421
1422 #[test]
test_handle_motion_accelerate_capture_pc_mode_false_touchpad()1423 fn test_handle_motion_accelerate_capture_pc_mode_false_touchpad()
1424 {
1425 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1426 let mut abs_x: f64 = 0.0;
1427 let mut abs_y: f64 = 0.0;
1428 let ret: i32;
1429 unsafe {
1430 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1431 }
1432 assert_eq!(ret, RET_OK);
1433 }
1434
1435 #[test]
test_handle_motion_accelerate_capture_pc_nomarl_touchpad()1436 fn test_handle_motion_accelerate_capture_pc_nomarl_touchpad()
1437 {
1438 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1439 let mut abs_x: f64 = 0.0;
1440 let mut abs_y: f64 = 0.0;
1441 let ret: i32;
1442 unsafe {
1443 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1444 }
1445 assert_eq!(ret, RET_OK);
1446 }
1447
1448 #[test]
test_handle_motion_accelerate_capture_pc_offset_exceed_max_touchpad()1449 fn test_handle_motion_accelerate_capture_pc_offset_exceed_max_touchpad()
1450 {
1451 let offset: Offset = Offset{ dx: 82.00002, dy: 82.00004 };
1452 let mut abs_x: f64 = 0.0;
1453 let mut abs_y: f64 = 0.0;
1454 let ret: i32;
1455 unsafe {
1456 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 1);
1457 }
1458 assert_eq!(ret, RET_OK);
1459 assert_eq!(abs_x, 0.0);
1460 assert_eq!(abs_y, 0.0);
1461 }
1462
1463 /* test for touchpad soft_pc_pro */
1464 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_offset_false_touchpad()1465 fn test_handle_motion_accelerate_capture_soft_pc_pro_offset_false_touchpad()
1466 {
1467 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1468 let mut abs_x: f64 = 0.0;
1469 let mut abs_y: f64 = 0.0;
1470 let ret: i32;
1471 unsafe {
1472 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1473 debug!(
1474 LOG_LABEL,
1475 "ret = {}", @public(ret)
1476 );
1477 }
1478 assert_eq!(ret, RET_ERR);
1479 assert_eq!(abs_x, 0.0);
1480 assert_eq!(abs_y, 0.0);
1481 }
1482
1483 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_speed_false_touchpad()1484 fn test_handle_motion_accelerate_capture_soft_pc_pro_speed_false_touchpad()
1485 {
1486 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1487 let mut abs_x: f64 = 0.0;
1488 let mut abs_y: f64 = 0.0;
1489 let ret: i32;
1490 unsafe {
1491 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 2);
1492 }
1493 assert_eq!(ret, RET_ERR);
1494 assert_eq!(abs_x, 0.0);
1495 assert_eq!(abs_y, 0.0);
1496 }
1497
1498 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_mode_false_touchpad()1499 fn test_handle_motion_accelerate_capture_soft_pc_pro_mode_false_touchpad()
1500 {
1501 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1502 let mut abs_x: f64 = 0.0;
1503 let mut abs_y: f64 = 0.0;
1504 let ret: i32;
1505 unsafe {
1506 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1507 }
1508 assert_eq!(ret, RET_OK);
1509 }
1510
1511 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_nomarl_touchpad()1512 fn test_handle_motion_accelerate_capture_soft_pc_pro_nomarl_touchpad()
1513 {
1514 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1515 let mut abs_x: f64 = 0.0;
1516 let mut abs_y: f64 = 0.0;
1517 let ret: i32;
1518 unsafe {
1519 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1520 }
1521 assert_eq!(ret, RET_OK);
1522 }
1523
1524 #[test]
test_handle_motion_accelerate_capture_soft_pc_pro_offset_exceed_max_touchpad()1525 fn test_handle_motion_accelerate_capture_soft_pc_pro_offset_exceed_max_touchpad()
1526 {
1527 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1528 let mut abs_x: f64 = 0.0;
1529 let mut abs_y: f64 = 0.0;
1530 let ret: i32;
1531 unsafe {
1532 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 2);
1533 }
1534 assert_eq!(ret, RET_OK);
1535 assert_eq!(abs_x, 0.0);
1536 assert_eq!(abs_y, 0.0);
1537 }
1538
1539 /* test for touchpad hard_pc_pro */
1540 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_offset_false_touchpad()1541 fn test_handle_motion_accelerate_capture_hard_pc_pro_offset_false_touchpad()
1542 {
1543 let offset: Offset = Offset{ dx: 0.00000001, dy: 0.00000002 };
1544 let mut abs_x: f64 = 0.0;
1545 let mut abs_y: f64 = 0.0;
1546 let ret: i32;
1547 unsafe {
1548 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1549 }
1550 assert_eq!(ret, RET_ERR);
1551 assert_eq!(abs_x, 0.0);
1552 assert_eq!(abs_y, 0.0);
1553 }
1554
1555 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_speed_false_touchpad()1556 fn test_handle_motion_accelerate_capture_hard_pc_pro_speed_false_touchpad()
1557 {
1558 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1559 let mut abs_x: f64 = 0.0;
1560 let mut abs_y: f64 = 0.0;
1561 let ret: i32;
1562 unsafe {
1563 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 0, 3);
1564 }
1565 assert_eq!(ret, RET_ERR);
1566 assert_eq!(abs_x, 0.0);
1567 assert_eq!(abs_y, 0.0);
1568 }
1569
1570 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_mode_false_touchpad()1571 fn test_handle_motion_accelerate_capture_hard_pc_pro_mode_false_touchpad()
1572 {
1573 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1574 let mut abs_x: f64 = 0.0;
1575 let mut abs_y: f64 = 0.0;
1576 let ret: i32;
1577 unsafe {
1578 ret = HandleMotionAccelerateTouchpad(&offset, false, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1579 }
1580 assert_eq!(ret, RET_OK);
1581 }
1582
1583 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_nomarl_touchpad()1584 fn test_handle_motion_accelerate_capture_hard_pc_pro_nomarl_touchpad()
1585 {
1586 let offset: Offset = Offset{ dx: 0.00002, dy: 1.00004 };
1587 let mut abs_x: f64 = 0.0;
1588 let mut abs_y: f64 = 0.0;
1589 let ret: i32;
1590 unsafe {
1591 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1592 }
1593 assert_eq!(ret, RET_OK);
1594 }
1595
1596 #[test]
test_handle_motion_accelerate_capture_hard_pc_pro_offset_exceed_max_touchpad()1597 fn test_handle_motion_accelerate_capture_hard_pc_pro_offset_exceed_max_touchpad()
1598 {
1599 let offset: Offset = Offset{ dx: 160.00002, dy: 160.00004 };
1600 let mut abs_x: f64 = 0.0;
1601 let mut abs_y: f64 = 0.0;
1602 let ret: i32;
1603 unsafe {
1604 ret = HandleMotionAccelerateTouchpad(&offset, true, &mut abs_x as *mut f64, &mut abs_y as *mut f64, 2, 3);
1605 }
1606 assert_eq!(ret, RET_OK);
1607 assert_eq!(abs_x, 0.0);
1608 assert_eq!(abs_y, 0.0);
1609 }
1610 /* test touchpad axis */
1611 #[test]
test_handle_axis_accelerate_normal_touchpad()1612 fn test_handle_axis_accelerate_normal_touchpad()
1613 {
1614 let mut abs_axis: f64 = 19.29931034482759;
1615 let ret: i32;
1616 unsafe {
1617 ret = HandleAxisAccelerateTouchpad(false, &mut abs_axis as *mut f64, 1);
1618 }
1619 assert_eq!(ret, RET_OK);
1620 }
1621
1622 #[test]
test_handle_axis_accelerate_capture_mode_false_touchpad()1623 fn test_handle_axis_accelerate_capture_mode_false_touchpad()
1624 {
1625 let mut abs_axis: f64 = 19.29931034482759;
1626 let ret: i32;
1627 unsafe {
1628 ret = HandleAxisAccelerateTouchpad(true, &mut abs_axis as *mut f64, 1);
1629 }
1630 assert_eq!(ret, RET_OK);
1631 }
1632