sequoia-style 0.1.5

Sequoia GUI framework — styles and themes
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

use sequoia_core::Color;

#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct DragValueStyle {
    pub text: Option<Color>,
    pub line: Option<Color>,
    pub line_width: Option<f32>,
    pub line_full: Option<bool>,
    pub background: Option<Color>,
    pub hover_background: Option<Color>,
    pub pressed_background: Option<Color>,
    pub border: Option<Color>,
    pub border_width: Option<f32>,
    pub radius: Option<f32>,
    pub padding: Option<(f32, f32)>,
    pub font_size: Option<f32>,
    pub font_weight: Option<u16>,
}

impl DragValueStyle {
    pub const fn new() -> Self {
        Self {
            text: None,
            line: None,
            line_width: None,
            line_full: None,
            background: None,
            hover_background: None,
            pressed_background: None,
            border: None,
            border_width: None,
            radius: None,
            padding: None,
            font_size: None,
            font_weight: None,
        }
    }

    pub const fn text(mut self, color: Color) -> Self {
        self.text = Some(color);
        self
    }

    pub const fn line(mut self, color: Color) -> Self {
        self.line = Some(color);
        self
    }

    pub const fn line_width(mut self, width: f32) -> Self {
        self.line_width = Some(width);
        self
    }

    pub const fn line_full(mut self, full: bool) -> Self {
        self.line_full = Some(full);
        self
    }

    pub const fn background(mut self, color: Color) -> Self {
        self.background = Some(color);
        self
    }

    pub const fn hover_background(mut self, color: Color) -> Self {
        self.hover_background = Some(color);
        self
    }

    pub const fn pressed_background(mut self, color: Color) -> Self {
        self.pressed_background = Some(color);
        self
    }

    pub const fn border_color(mut self, color: Color) -> Self {
        self.border = Some(color);
        self
    }

    pub const fn border_width(mut self, width: f32) -> Self {
        self.border_width = Some(width);
        self
    }

    pub const fn border(mut self, width: f32, color: Color) -> Self {
        self.border_width = Some(width);
        self.border = Some(color);
        self
    }

    pub const fn radius(mut self, radius: f32) -> Self {
        self.radius = Some(radius);
        self
    }

    pub const fn padding_xy(mut self, pad_x: f32, pad_y: f32) -> Self {
        self.padding = Some((pad_x, pad_y));
        self
    }

    pub const fn font_size(mut self, size: f32) -> Self {
        self.font_size = Some(size);
        self
    }

    pub const fn font_weight(mut self, weight: u16) -> Self {
        self.font_weight = Some(weight);
        self
    }
}

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

    #[test]
    fn const_composition_keeps_base() {
        const CUSTOM: DragValueStyle = DragValueStyle::new().font_size(12.0);
        assert_eq!(CUSTOM.font_size, Some(12.0));
        assert_eq!(CUSTOM.text, None);
    }

    #[test]
    fn surface_builders_set_all_fields() {
        const CUSTOM: DragValueStyle = DragValueStyle::new()
            .background(Color::RED)
            .hover_background(Color::GREEN)
            .pressed_background(Color::BLUE)
            .border(1.0, Color::WHITE)
            .radius(4.0)
            .padding_xy(3.0, 2.0)
            .line_full(true);
        assert_eq!(CUSTOM.background, Some(Color::RED));
        assert_eq!(CUSTOM.hover_background, Some(Color::GREEN));
        assert_eq!(CUSTOM.pressed_background, Some(Color::BLUE));
        assert_eq!(CUSTOM.border_width, Some(1.0));
        assert_eq!(CUSTOM.border, Some(Color::WHITE));
        assert_eq!(CUSTOM.radius, Some(4.0));
        assert_eq!(CUSTOM.padding, Some((3.0, 2.0)));
        assert_eq!(CUSTOM.line_full, Some(true));
    }
}