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