argui-core 0.1.0

Geometry, color, identifiers and shared primitives for Argui
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
146
147
148

use crate::{Modifiers, Point};

/// Platform-independent timing and distance thresholds for pointer gestures.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PointerSettings {
    multi_click_interval: std::time::Duration,
    multi_click_distance: f32,
    long_press_interval: std::time::Duration,
    touch_slop: f32,
}

impl Default for PointerSettings {
    fn default() -> Self {
        Self {
            multi_click_interval: std::time::Duration::from_millis(500),
            multi_click_distance: 5.0,
            long_press_interval: std::time::Duration::from_millis(500),
            touch_slop: 10.0,
        }
    }
}

impl PointerSettings {
    #[must_use]
    pub fn multi_click(mut self, interval: std::time::Duration, distance: f32) -> Self {
        assert!(distance.is_finite() && distance >= 0.0);
        self.multi_click_interval = interval;
        self.multi_click_distance = distance;
        self
    }

    #[must_use]
    pub fn long_press(mut self, interval: std::time::Duration, touch_slop: f32) -> Self {
        assert!(touch_slop.is_finite() && touch_slop >= 0.0);
        self.long_press_interval = interval;
        self.touch_slop = touch_slop;
        self
    }

    #[must_use]
    pub const fn multi_click_interval(self) -> std::time::Duration {
        self.multi_click_interval
    }

    #[must_use]
    pub const fn multi_click_distance(self) -> f32 {
        self.multi_click_distance
    }

    #[must_use]
    pub const fn long_press_interval(self) -> std::time::Duration {
        self.long_press_interval
    }

    #[must_use]
    pub const fn touch_slop(self) -> f32 {
        self.touch_slop
    }
}

/// Device-independent wheel data. Line deltas remain distinct until a scroll
/// container applies its configured logical line size.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ScrollDelta {
    Lines(Point),
    Pixels(Point),
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct PointerId(u64);

impl PointerId {
    pub const MOUSE: Self = Self(0);

    #[must_use]
    pub const fn new(value: u64) -> Self {
        Self(value)
    }

    #[must_use]
    pub const fn get(self) -> u64 {
        self.0
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PointerKind {
    Mouse,
    Touch,
    Pen,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PointerPhase {
    Entered,
    Moved,
    Pressed,
    Released,
    Left,
    Cancelled,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PointerButton {
    Primary,
    Secondary,
    Middle,
    Back,
    Forward,
    Other(u16),
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PointerEvent {
    pub id: PointerId,
    pub kind: PointerKind,
    pub phase: PointerPhase,
    pub position: Point,
    pub button: Option<PointerButton>,
    pub buttons: u16,
    pub pressure: Option<f32>,
    pub primary: bool,
    pub modifiers: Modifiers,
    pub timestamp: std::time::Duration,
}

impl PointerEvent {
    #[must_use]
    pub const fn mouse(phase: PointerPhase, position: Point) -> Self {
        Self {
            id: PointerId::MOUSE,
            kind: PointerKind::Mouse,
            phase,
            position,
            button: None,
            buttons: 0,
            pressure: None,
            primary: true,
            modifiers: Modifiers {
                shift: false,
                control: false,
                alt: false,
                super_key: false,
            },
            timestamp: std::time::Duration::ZERO,
        }
    }
}