openlogi-hook 0.8.7

OS-level mouse-event hook for OpenLogi. macOS via CGEventTap; Linux via evdev+uinput; Windows via WH_MOUSE_LL.
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

//! Core Graphics supplies front-to-back window rectangles in global points.

use crate::{CursorPosition, PointerTarget};

pub(crate) struct Window {
    pub x: f64,
    pub y: f64,
    pub width: f64,
    pub height: f64,
    pub target: PointerTarget,
}

/// A malformed row is not evidence that the space behind it is desktop.
pub(crate) fn hit_test(
    point: CursorPosition,
    windows: impl IntoIterator<Item = Option<Window>>,
) -> PointerTarget {
    for window in windows {
        let Some(window) = window else {
            return PointerTarget::Unavailable;
        };
        if point.x >= window.x
            && point.y >= window.y
            && point.x < window.x + window.width
            && point.y < window.y + window.height
        {
            return window.target;
        }
    }
    PointerTarget::Unavailable
}

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

    fn window(x: f64, y: f64, width: f64, height: f64, target: PointerTarget) -> Window {
        Window {
            x,
            y,
            width,
            height,
            target,
        }
    }

    #[test]
    fn pointer_hit_test_preserves_z_order_and_negative_display_coordinates() {
        let front = PointerTarget::Window {
            process_id: 41,
            window_id: 7,
        };
        let back = PointerTarget::Window {
            process_id: 41,
            window_id: 9,
        };
        assert_eq!(
            hit_test(
                CursorPosition { x: -70.0, y: 31.0 },
                [
                    Some(window(-90.0, 30.0, 40.0, 80.0, front)),
                    Some(window(-100.0, 0.0, 100.0, 120.0, back)),
                ]
            ),
            front
        );
        // The right edge belongs to the adjacent surface, not the front window.
        assert_eq!(
            hit_test(
                CursorPosition { x: -50.0, y: 31.0 },
                [
                    Some(window(-90.0, 30.0, 40.0, 80.0, front)),
                    Some(window(-100.0, 0.0, 100.0, 120.0, back)),
                ]
            ),
            back
        );
    }

    #[test]
    fn pointer_hit_test_requires_positive_desktop_evidence_and_respects_obstacles() {
        let point = CursorPosition { x: 13.0, y: 27.0 };
        assert_eq!(hit_test(point, []), PointerTarget::Unavailable);
        assert_eq!(
            hit_test(
                point,
                [
                    None,
                    Some(window(0.0, 0.0, 50.0, 50.0, PointerTarget::Desktop))
                ]
            ),
            PointerTarget::Unavailable
        );
        assert_eq!(
            hit_test(
                point,
                [Some(window(0.0, 0.0, 50.0, 50.0, PointerTarget::Desktop))]
            ),
            PointerTarget::Desktop
        );
        assert_eq!(
            hit_test(
                point,
                [
                    Some(window(10.0, 20.0, 8.0, 12.0, PointerTarget::Unavailable)),
                    Some(window(0.0, 0.0, 50.0, 50.0, PointerTarget::Desktop))
                ]
            ),
            PointerTarget::Unavailable
        );
    }
}