icee 0.1.0-alpha0.2

A CSS-like style system for the iced ui framework.
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
138
139
140
141
142

mod button;
mod container;

use std::collections::BTreeMap;
use std::sync::Arc;

use serde::Deserialize;
use serde::Serialize;

use iced::Background;
use iced::Color;

#[derive(Debug, Serialize, Deserialize, Default, Clone)]
#[serde(untagged)]
pub enum RuleLength {
    Float(f32),
    UnsignedInteger(u32),
    String(String),
    #[default]
    None,
}

#[derive(Debug, Serialize, Deserialize, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum RuleState {
    Active,
    #[default]
    Any,
}

#[derive(Debug, Serialize, Deserialize, Default, Clone)]
pub struct Rule {
    #[serde(default)]
    pub id: Option<String>,
    #[serde(default)]
    pub widget: Option<String>,
    #[serde(default)]
    pub state: RuleState,
    #[serde(default)]
    pub color: Option<String>,
    #[serde(default)]
    pub background_color: Option<String>,
    #[serde(default)]
    pub border_radius: Option<RuleLength>,
    #[serde(default)]
    pub width: RuleLength,
    #[serde(default)]
    pub height: RuleLength,
}

#[derive(Debug, Clone)]
pub struct Rules {
    pub rules: Arc<BTreeMap<RuleState, Rule>>,
}

impl Rules {
    pub fn any(&self) -> &Rule {
        self.rules
            .get(&RuleState::Any)
            .expect("Failed to find any rule!")
    }

    pub fn active(&self) -> Option<&Rule> {
        self.rules.get(&RuleState::Active)
    }
}

impl Rule {
    pub fn width(&self) -> Option<iced::Length> {
        Some(match &self.width {
            RuleLength::UnsignedInteger(integer) => iced::Length::Fixed(*integer as f32),
            RuleLength::Float(float) => iced::Length::Fixed(*float),
            RuleLength::String(string) => iced::Length::Fixed(string.parse().unwrap()),
            RuleLength::None => return None,
        })
    }

    pub fn height(&self) -> Option<iced::Length> {
        Some(match &self.height {
            RuleLength::UnsignedInteger(integer) => iced::Length::Fixed(*integer as f32),
            RuleLength::Float(float) => iced::Length::Fixed(*float),
            RuleLength::String(string) => iced::Length::Fixed(string.parse().unwrap()),
            RuleLength::None => return None,
        })
    }

    pub fn border_radius(&self) -> Option<iced::border::Radius> {
        self.border_radius.as_ref().and_then(|border_radius| {
            Some(match border_radius {
                RuleLength::UnsignedInteger(integer) => iced::border::Radius::from(*integer as f32),
                RuleLength::Float(float) => iced::border::Radius::from(*float),
                RuleLength::String(string) => {
                    iced::border::Radius::from(string.parse::<f32>().unwrap())
                }
                RuleLength::None => return None,
            })
        })
    }

    #[inline(always)]
    pub fn merge(&mut self, rule: &Rule) {
        self.color = rule.color.clone().or(self.color.take());
        self.background_color = rule
            .background_color
            .clone()
            .or(self.background_color.take());
        self.border_radius = rule.border_radius.clone().or(self.border_radius.take());
        self.width = rule.width.clone();
        self.height = rule.height.clone();
    }
}

pub(super) fn parse_color(color: &str) -> Option<Color> {
    if color.is_empty() {
        return None;
    }

    if let Ok(color) = csscolorparser::parse(color) {
        let (r, g, b, a) = color.to_linear_rgba();

        Some(Color::from_linear_rgba(
            r as f32, g as f32, b as f32, a as f32,
        ))
    } else {
        None
    }
}

pub(super) fn parse_background_color(background_color: &str) -> Option<Background> {
    if background_color.is_empty() {
        return None;
    }

    if let Ok(color) = csscolorparser::parse(background_color) {
        let (r, g, b, a) = color.to_linear_rgba();

        Some(Background::Color(Color::from_linear_rgba(
            r as f32, g as f32, b as f32, a as f32,
        )))
    } else {
        None
    }
}