freya_core/values/
shadow.rs

1use torin::scaled::Scaled;
2
3use super::Fill;
4use crate::parsing::{
5    ExtSplit,
6    Parse,
7    ParseError,
8};
9
10#[derive(Default, Clone, Debug, PartialEq)]
11pub enum ShadowPosition {
12    #[default]
13    Normal,
14    Inset,
15}
16
17#[derive(Default, Clone, Debug, PartialEq)]
18pub struct Shadow {
19    pub position: ShadowPosition,
20    pub x: f32,
21    pub y: f32,
22    pub blur: f32,
23    pub spread: f32,
24    pub fill: Fill,
25}
26
27impl Parse for Shadow {
28    fn parse(value: &str) -> Result<Self, ParseError> {
29        let mut shadow_values = value.split_ascii_whitespace_excluding_group('(', ')');
30        let mut shadow = Shadow::default();
31
32        let first = shadow_values.next().ok_or(ParseError)?;
33
34        if first == "inset" {
35            shadow.position = ShadowPosition::Inset;
36            shadow.x = shadow_values
37                .next()
38                .ok_or(ParseError)?
39                .parse::<f32>()
40                .map_err(|_| ParseError)?;
41        } else {
42            shadow.x = first.parse::<f32>().map_err(|_| ParseError)?;
43        }
44
45        shadow.y = shadow_values
46            .next()
47            .ok_or(ParseError)?
48            .parse::<f32>()
49            .map_err(|_| ParseError)?;
50        shadow.blur = shadow_values
51            .next()
52            .ok_or(ParseError)?
53            .parse::<f32>()
54            .map_err(|_| ParseError)?;
55
56        let spread_or_fill = shadow_values.next().ok_or(ParseError)?;
57
58        let mut already_filled = false;
59        if let Ok(spread) = spread_or_fill.parse::<f32>() {
60            shadow.spread = spread;
61        } else {
62            already_filled = true;
63            shadow.fill = Fill::parse(spread_or_fill).map_err(|_| ParseError)?;
64        }
65
66        if let Some(fill) = shadow_values.next() {
67            if !already_filled {
68                shadow.fill = Fill::parse(fill).map_err(|_| ParseError)?
69            } else {
70                return Err(ParseError);
71            }
72        }
73
74        Ok(shadow)
75    }
76}
77
78impl Scaled for Shadow {
79    fn scale(&mut self, scale_factor: f32) {
80        self.x *= scale_factor;
81        self.y *= scale_factor;
82        self.spread *= scale_factor;
83        self.blur *= scale_factor;
84    }
85}