devela 0.28.0

A development substrate of coherence.
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

// devela::ui::event::pointer::pointer
//
//! Defines [`EventMouse`], [`EventPointer`], [`EventPointerKind`].
//

use crate::{_impl_init, EventButton, EventButtonState, EventButtons, KeyMods, f32bits_niche};

/* definitions */

#[doc = crate::_tags!(event interaction)]
/// Represents a basic mouse event.
#[doc = crate::_doc_meta!{
    location("ui/event"),
    test_size_of(EventMouse = 16|128; niche Option),
}]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct EventMouse {
    /// The x-coordinate of the mouse cursor.
    pub x: i32,
    /// The y-coordinate of the mouse cursor.
    pub y: i32,
    /// The mouse button involved in the event.
    pub button: Option<EventButton>,
    /// The state of the mouse button (Pressed, Released, Moved).
    pub state: EventButtonState,
    /// A bitmask of currently pressed buttons.
    pub buttons: EventButtons,
    /// Keyboard modifiers held during the event, when reported by the backend.
    ///
    /// Terminal backends may not report every modifier combination
    /// because some are reserved by the terminal emulator.
    pub mods: KeyMods,
}
_impl_init! {
    Self::new(0, 0, None, EventButtonState::INIT, EventButtons::INIT, KeyMods::INIT) => EventMouse
}
#[rustfmt::skip]
impl EventMouse {
    /// Returns a normalized mouse event.
    pub const fn new(x: i32, y: i32, button: Option<EventButton>,
        state: EventButtonState, buttons: EventButtons, mods: KeyMods) -> Self {
        Self { x, y, button, state, buttons, mods }
    }
}

#[doc = crate::_tags!(event interaction)]
/// Represents a pointer event (mouse, touch, or pen).
#[doc = crate::_doc_meta!{
    location("ui/event"),
    test_size_of(EventPointer = 36|288; niche Option),
}]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct EventPointer {
    /// The type of pointer (mouse, touch, pen).
    pub kind: EventPointerKind,
    /// Unique ID for touch and pen inputs (e.g., multi-touch gestures).
    pub id: u32,
    /// The x-coordinate of the pointer.
    pub x: i32,
    /// The y-coordinate of the pointer.
    pub y: i32,
    /// The delta movement since the last event.
    pub dx: i32,
    ///
    pub dy: i32,
    /// The pressure applied (0.0 to 1.0), applicable for pen/touch.
    pressure: f32bits_niche,
    /// The tilt angle of a stylus (if applicable).
    pub tilt_x: i8,
    /// The tilt of the stylus along the Y-axis (-90° to 90°).
    pub tilt_y: i8,
    /// The rotation of the stylus around its own axis (0° to 359°).
    pub twist: u16,
    /// The button involved.
    pub button: Option<EventButton>,
    /// The state of the pointer (Pressed, Released, Moved).
    pub state: EventButtonState,
    /// A bitmask of currently pressed buttons.
    pub buttons: EventButtons,
    /// Keyboard modifiers held during the event, when reported by the backend.
    ///
    /// Terminal backends may not report every modifier combination
    /// because some are reserved by the terminal emulator.
    pub mods: KeyMods,
    // /// The phase of the pointer (useful for touch events).
    // pub phase: EventPointerPhase,
}
_impl_init! {
    Self::new(EventPointerKind::INIT, 0, 0, 0, 0, 0, f32bits_niche::INIT, 0, 0, 0, None,
    EventButtonState::INIT, EventButtons::INIT, KeyMods::INIT) => EventPointer
}
#[rustfmt::skip]
impl EventPointer {
    /// Returns a normalized pointer event.
    #[allow(clippy::too_many_arguments)]
    pub const fn new(kind: EventPointerKind, id: u32, x: i32, y: i32, dx: i32, dy: i32,
        pressure: f32bits_niche, tilt_x: i8, tilt_y: i8, twist: u16, button: Option<EventButton>,
        state: EventButtonState, buttons: EventButtons, mods: KeyMods) -> Self {
        Self {
            kind, id, x, y, dx, dy, pressure, tilt_x, tilt_y, twist, button, state, buttons, mods
        }
    }
    /// Gets the pressure.
    pub const fn get_pressure(&self) -> f32 {
        self.pressure.as_float()
    }
    /// Sets the pressure.
    pub const fn set_pressure(&mut self, pressure: f32) {
        self.pressure = f32bits_niche::new(pressure);
    }
}

#[doc = crate::_tags!(event interaction)]
/// Enum representing the type of pointer.
#[doc = crate::_doc_meta!{location("ui/event")}]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum EventPointerKind {
    /// A mouse pointer.
    Mouse,
    /// A touch pointer.
    Touch,
    /// A pen pointer.
    Pen,
}
_impl_init! { Self::Mouse => EventPointerKind }

// /// Represents the phase of a pointer (useful for touch events).
// #[doc = crate::_doc_meta!{location("ui/event")}]
// #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
// pub enum EventPointerPhase {
//     /// The pointer has started touching the surface.
//     Start,
//     /// The pointer is moving.
//     Move,
//     /// The pointer was lifted from the surface.
//     End,
//     /// The input was cancelled (e.g., interrupted by system gestures).
//     Cancel,
// }
// _impl_init! { Self::Start => EventPointerPhase }