nitron 0.1.1

Create native UIs in Rust
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

/// A spacial unit in one dimension.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Dim {
    /// The default in most cases
    Auto,
    /// Raw display pixels
    Px(f32),
    /// Backend specific sizing unit
    Pt(f32),
    /// Percent
    Pct(f32),
    /// Percent of the viewport height
    ///
    /// Vh(1) = Px(108) on a 1080 height viewport
    Vh(f32),
    /// Percent of the viewport width
    ///
    /// Vw(1) = Px(192) on a 1920 width viewport
    Vw(f32),
}

impl Dim {
    pub(crate) fn compute_taffy_dimension(
        self,
        pt_size: f32,
        vp_width: f32,
        vp_height: f32,
    ) -> taffy::Dimension {
        match self {
            Dim::Auto => taffy::Dimension::auto(),
            Dim::Px(px) => taffy::Dimension::length(px),
            Dim::Pt(pt) => taffy::Dimension::length(pt * pt_size),
            Dim::Pct(pct) => taffy::Dimension::percent(pct * 0.01),
            Dim::Vh(vh) => taffy::Dimension::length(vh * vp_height * 0.01),
            Dim::Vw(vw) => taffy::Dimension::length(vw * vp_width * 0.01),
        }
    }

    pub(crate) fn compute_taffy_length_percentage_auto(
        self,
        pt_size: f32,
        vp_width: f32,
        vp_height: f32,
    ) -> taffy::LengthPercentageAuto {
        match self {
            Dim::Auto => taffy::LengthPercentageAuto::auto(),
            Dim::Px(px) => taffy::LengthPercentageAuto::length(px),
            Dim::Pt(pt) => taffy::LengthPercentageAuto::length(pt * pt_size),
            Dim::Pct(pct) => taffy::LengthPercentageAuto::percent(pct * 0.01),
            Dim::Vh(vh) => taffy::LengthPercentageAuto::length(vh * vp_height * 0.01),
            Dim::Vw(vw) => taffy::LengthPercentageAuto::length(vw * vp_width * 0.01),
        }
    }

    pub(crate) fn compute_taffy_length_percentage(
        self,
        pt_size: f32,
        vp_width: f32,
        vp_height: f32,
    ) -> taffy::LengthPercentage {
        match self {
            Dim::Auto => taffy::LengthPercentage::length(0.0),
            Dim::Px(px) => taffy::LengthPercentage::length(px),
            Dim::Pt(pt) => taffy::LengthPercentage::length(pt * pt_size),
            Dim::Pct(pct) => taffy::LengthPercentage::percent(pct * 0.01),
            Dim::Vh(vh) => taffy::LengthPercentage::length(vh * vp_height * 0.01),
            Dim::Vw(vw) => taffy::LengthPercentage::length(vw * vp_width * 0.01),
        }
    }
}

/// How far to push out a boundary.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Margin {
    pub left: Dim,
    pub right: Dim,
    pub top: Dim,
    pub bottom: Dim,
}

impl Margin {
    #[inline(always)]
    pub const fn new() -> Self {
        Margin {
            left: Dim::Px(0.0),
            right: Dim::Px(0.0),
            top: Dim::Px(0.0),
            bottom: Dim::Px(0.0),
        }
    }

    #[inline(always)]
    pub const fn l(mut self, l: Dim) -> Self {
        self.left = l;
        self
    }

    #[inline(always)]
    pub const fn r(mut self, r: Dim) -> Self {
        self.right = r;
        self
    }

    #[inline(always)]
    pub const fn t(mut self, t: Dim) -> Self {
        self.top = t;
        self
    }

    #[inline(always)]
    pub const fn b(mut self, b: Dim) -> Self {
        self.bottom = b;
        self
    }

    #[inline(always)]
    pub const fn x(mut self, x: Dim) -> Self {
        self.left = x;
        self.right = x;
        self
    }

    #[inline(always)]
    pub const fn y(mut self, y: Dim) -> Self {
        self.top = y;
        self.bottom = y;
        self
    }
}

impl Default for Margin {
    fn default() -> Self {
        Self::new()
    }
}

// For the Lord gives wisdom; from his mouth come knowledge and understanding. - Proverbs 2:6