oxivgl 0.1.1

Safe no_std Rust bindings for LVGL — embedded GUI on ESP32 and host SDL2
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

// SPDX-License-Identifier: MIT OR Apache-2.0
//! Type-safe style selector combining [`Part`](crate::widgets::Part) and
//! [`ObjState`](crate::enums::ObjState) bits.
//!
//! Replaces raw `u32` in all style-related methods.
//!
//! ```ignore
//! use oxivgl::style::Selector;
//! use oxivgl::enums::ObjState;
//! use oxivgl::widgets::Part;
//!
//! btn.add_style(&style, Selector::DEFAULT);
//! btn.add_style(&style, ObjState::PRESSED);
//! slider.add_style(&style, Part::Indicator | ObjState::PRESSED);
//! ```

/// Style selector = [`Part`](crate::widgets::Part) +
/// [`ObjState`](crate::enums::ObjState) bits. Pass to methods like
/// [`Obj::add_style`](crate::widgets::Obj::add_style),
/// [`Obj::radius`](crate::widgets::Obj::radius), etc.
#[derive(Clone, Copy, Debug, Default)]
pub struct Selector(u32);

impl Selector {
    /// Default selector (main part, default state).
    pub const DEFAULT: Self = Self(0);

    /// Raw `u32` value for passing to LVGL FFI.
    pub fn raw(self) -> u32 {
        self.0
    }
}

impl From<crate::widgets::Part> for Selector {
    fn from(p: crate::widgets::Part) -> Self {
        Self(p as u32)
    }
}

impl From<crate::enums::ObjState> for Selector {
    fn from(s: crate::enums::ObjState) -> Self {
        Self(s.0)
    }
}

impl core::ops::BitOr<crate::enums::ObjState> for crate::widgets::Part {
    type Output = Selector;
    fn bitor(self, rhs: crate::enums::ObjState) -> Selector {
        Selector(self as u32 | rhs.0)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{enums::ObjState, widgets::Part};

    #[test]
    fn default_is_zero() {
        assert_eq!(Selector::DEFAULT.raw(), 0);
        assert_eq!(Selector::default().raw(), 0);
    }

    #[test]
    fn from_part() {
        let s: Selector = Part::Indicator.into();
        assert_eq!(s.raw(), Part::Indicator as u32);
    }

    #[test]
    fn from_state() {
        let s: Selector = ObjState::PRESSED.into();
        assert_eq!(s.raw(), ObjState::PRESSED.0);
    }

    #[test]
    fn part_bitor_state() {
        let s = Part::Indicator | ObjState::PRESSED;
        assert_eq!(s.raw(), Part::Indicator as u32 | ObjState::PRESSED.0);
    }
}