kobo-core 0.4.0

Kobo e-reader device SDK: device database, sysfs/ioctl, rendering, audio pipeline, trait surface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Nayeem Bin Ahsan
//! Touch->display transform + gesture predicates.
//!
//! The transform uses per-device flags from `DeviceConfig`:
//! - `touch_switch_xy`: swap X and Y axes
//! - `touch_mirrored_x`: mirror the horizontal axis
//! - `touch_mirrored_y`: mirror the vertical axis

pub const SWIPE_MIN_DX: f32 = 80.0;
pub const SWIPE_MAX_MS: u128 = 500;
pub const DOUBLE_TAP_MAX_PRESS_MS: u128 = 300;
pub const DOUBLE_TAP_WINDOW_MS: u128 = 400;

/// Per-device touch configuration.
#[derive(Clone, Copy)]
pub struct TouchConfig {
    pub switch_xy: bool,
    pub mirrored_x: bool,
    pub mirrored_y: bool,
    pub raw_x_max: i32,
    pub raw_y_max: i32,
    pub screen_w: i32,
    pub screen_h: i32,
}

/// Raw evdev -> display-space transform.
pub fn to_display(rx: i32, ry: i32, cfg: &TouchConfig) -> (f32, f32) {
    let (mut x, mut y) = if cfg.switch_xy { (ry, rx) } else { (rx, ry) };

    if cfg.mirrored_x {
        let max = if cfg.switch_xy {
            cfg.raw_y_max
        } else {
            cfg.raw_x_max
        };
        x = max - x;
    }
    if cfg.mirrored_y {
        let max = if cfg.switch_xy {
            cfg.raw_x_max
        } else {
            cfg.raw_y_max
        };
        y = max - y;
    }

    (x as f32, y as f32)
}

#[allow(dead_code)]
pub fn is_swipe(swipe_dx: f32, swipe_dy: f32, dt_ms: u128) -> bool {
    swipe_dx.abs() > SWIPE_MIN_DX && dt_ms < SWIPE_MAX_MS && swipe_dx.abs() > swipe_dy.abs()
}

pub fn is_double_tap(dt_ms: u128, since_prev_tap_ms: u128) -> bool {
    dt_ms < DOUBLE_TAP_MAX_PRESS_MS && since_prev_tap_ms < DOUBLE_TAP_WINDOW_MS
}

#[cfg(test)]
mod tests {
    use super::*;

    // Libra Colour cyttsp5_mt: switch_xy=true, mirrored_x=true
    fn libra_cfg() -> TouchConfig {
        TouchConfig {
            switch_xy: true,
            mirrored_x: true,
            mirrored_y: false,
            raw_x_max: 1447,
            raw_y_max: 1071,
            screen_w: 1072,
            screen_h: 1448,
        }
    }

    // Standard touch panel: no swap, no mirror
    fn plain_cfg() -> TouchConfig {
        TouchConfig {
            switch_xy: false,
            mirrored_x: false,
            mirrored_y: false,
            raw_x_max: 1071,
            raw_y_max: 1447,
            screen_w: 1072,
            screen_h: 1448,
        }
    }

    #[test]
    fn libra_left_edge_maps_small_x() {
        let cfg = libra_cfg();
        let (dx, _) = to_display(736, 1035, &cfg);
        assert!(
            dx < 100.0,
            "left-edge tap must map to small display_x, got {dx}"
        );
    }

    #[test]
    fn libra_right_edge_maps_large_x() {
        let cfg = libra_cfg();
        let (dx, _) = to_display(693, 36, &cfg);
        assert!(
            dx > 970.0,
            "right-edge tap must map to large display_x, got {dx}"
        );
    }

    #[test]
    fn plain_passes_through() {
        let cfg = plain_cfg();
        let (dx, dy) = to_display(100, 200, &cfg);
        assert_eq!(dx, 100.0);
        assert_eq!(dy, 200.0);
    }

    #[test]
    fn plain_mirrored_x() {
        let mut cfg = plain_cfg();
        cfg.mirrored_x = true;
        let (dx, _) = to_display(0, 0, &cfg);
        assert_eq!(dx, cfg.raw_x_max as f32);
    }

    #[test]
    fn is_swipe_detects_fast_horizontal_flick() {
        assert!(is_swipe(200.0, 5.0, 120));
        assert!(is_swipe(-250.0, 40.0, 200));
    }

    #[test]
    fn is_swipe_rejects_small_or_slow_or_vertical() {
        assert!(!is_swipe(20.0, 5.0, 300));
        assert!(!is_swipe(200.0, 5.0, 600));
        assert!(!is_swipe(100.0, 300.0, 100));
    }

    #[test]
    fn is_double_tap_within_window() {
        assert!(is_double_tap(150, 200));
        assert!(!is_double_tap(400, 200));
        assert!(!is_double_tap(150, 500));
    }
}