cssbox-core 0.1.0

Standalone CSS layout engine — core algorithms
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

//! CSS value types and resolution.

/// A CSS length-percentage value.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LengthPercentage {
    /// An absolute length in pixels.
    Length(f32),
    /// A percentage (0.0 to 1.0 internally, specified as 0-100%).
    Percentage(f32),
}

impl LengthPercentage {
    pub fn resolve(&self, reference: f32) -> f32 {
        match self {
            LengthPercentage::Length(px) => *px,
            LengthPercentage::Percentage(pct) => reference * pct,
        }
    }

    pub fn px(value: f32) -> Self {
        LengthPercentage::Length(value)
    }

    pub fn percent(value: f32) -> Self {
        LengthPercentage::Percentage(value / 100.0)
    }
}

impl Default for LengthPercentage {
    fn default() -> Self {
        LengthPercentage::Length(0.0)
    }
}

/// A CSS length-percentage-auto value.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum LengthPercentageAuto {
    Length(f32),
    Percentage(f32),
    #[default]
    Auto,
}

impl LengthPercentageAuto {
    pub fn resolve(&self, reference: f32) -> Option<f32> {
        match self {
            LengthPercentageAuto::Length(px) => Some(*px),
            LengthPercentageAuto::Percentage(pct) => Some(reference * pct),
            LengthPercentageAuto::Auto => None,
        }
    }

    pub fn resolve_or(&self, reference: f32, default: f32) -> f32 {
        self.resolve(reference).unwrap_or(default)
    }

    pub fn is_auto(&self) -> bool {
        matches!(self, LengthPercentageAuto::Auto)
    }

    pub fn px(value: f32) -> Self {
        LengthPercentageAuto::Length(value)
    }

    pub fn percent(value: f32) -> Self {
        LengthPercentageAuto::Percentage(value / 100.0)
    }
}

/// A CSS dimension that may be `none` (used for max-width/max-height).
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum LengthPercentageNone {
    Length(f32),
    Percentage(f32),
    #[default]
    None,
}

impl LengthPercentageNone {
    pub fn resolve(&self, reference: f32) -> Option<f32> {
        match self {
            LengthPercentageNone::Length(px) => Some(*px),
            LengthPercentageNone::Percentage(pct) => Some(reference * pct),
            LengthPercentageNone::None => None,
        }
    }

    pub fn px(value: f32) -> Self {
        LengthPercentageNone::Length(value)
    }

    pub fn percent(value: f32) -> Self {
        LengthPercentageNone::Percentage(value / 100.0)
    }
}

/// Number or auto (used for z-index, flex-grow, etc.).
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum NumberOrAuto {
    Number(f32),
    #[default]
    Auto,
}

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

    #[test]
    fn test_length_percentage_resolve() {
        let lp = LengthPercentage::px(20.0);
        assert_eq!(lp.resolve(100.0), 20.0);

        let lp = LengthPercentage::percent(50.0);
        assert_eq!(lp.resolve(200.0), 100.0);
    }

    #[test]
    fn test_length_percentage_auto_resolve() {
        let v = LengthPercentageAuto::Auto;
        assert_eq!(v.resolve(100.0), None);

        let v = LengthPercentageAuto::px(30.0);
        assert_eq!(v.resolve(100.0), Some(30.0));

        let v = LengthPercentageAuto::percent(25.0);
        assert_eq!(v.resolve(200.0), Some(50.0));
    }
}