freya_core/values/
gaps.rs

1use torin::gaps::Gaps;
2
3use crate::parsing::{
4    Parse,
5    ParseError,
6};
7
8impl Parse for Gaps {
9    fn parse(value: &str) -> Result<Self, ParseError> {
10        let mut paddings = Gaps::default();
11
12        if value == "none" {
13            return Ok(paddings);
14        }
15
16        let mut values = value.split_ascii_whitespace();
17
18        match values.clone().count() {
19            // Same in each directions
20            1 => {
21                paddings.fill_all(
22                    values
23                        .next()
24                        .ok_or(ParseError)?
25                        .parse::<f32>()
26                        .map_err(|_| ParseError)?,
27                );
28            }
29            // By vertical and horizontal
30            2 => {
31                // Vertical
32                paddings.fill_vertical(
33                    values
34                        .next()
35                        .ok_or(ParseError)?
36                        .parse::<f32>()
37                        .map_err(|_| ParseError)?,
38                );
39
40                // Horizontal
41                paddings.fill_horizontal(
42                    values
43                        .next()
44                        .ok_or(ParseError)?
45                        .parse::<f32>()
46                        .map_err(|_| ParseError)?,
47                )
48            }
49            // Individual vertical but same horizontal
50            3 => {
51                let top = values
52                    .next()
53                    .ok_or(ParseError)?
54                    .parse::<f32>()
55                    .map_err(|_| ParseError)?;
56                let left_and_right = values
57                    .next()
58                    .ok_or(ParseError)?
59                    .parse::<f32>()
60                    .map_err(|_| ParseError)?;
61                let bottom = values
62                    .next()
63                    .ok_or(ParseError)?
64                    .parse::<f32>()
65                    .map_err(|_| ParseError)?;
66                paddings = Gaps::new(top, left_and_right, bottom, left_and_right);
67            }
68            // Each directions
69            4 => {
70                paddings = Gaps::new(
71                    values
72                        .next()
73                        .ok_or(ParseError)?
74                        .parse::<f32>()
75                        .map_err(|_| ParseError)?,
76                    values
77                        .next()
78                        .ok_or(ParseError)?
79                        .parse::<f32>()
80                        .map_err(|_| ParseError)?,
81                    values
82                        .next()
83                        .ok_or(ParseError)?
84                        .parse::<f32>()
85                        .map_err(|_| ParseError)?,
86                    values
87                        .next()
88                        .ok_or(ParseError)?
89                        .parse::<f32>()
90                        .map_err(|_| ParseError)?,
91                );
92            }
93            _ => {}
94        }
95
96        Ok(paddings)
97    }
98}