uzor 1.0.20

Core UI engine — geometry, interaction, input state
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! macOS input theme

use super::super::colors::{AppearanceMode, WidgetState, palette};

/// macOS input theme
#[derive(Debug, Clone)]
#[derive(Default)]
pub struct InputTheme {
    pub appearance: AppearanceMode,
}

impl InputTheme {
    pub fn new(appearance: AppearanceMode) -> Self {
        Self { appearance }
    }

    /// Background color based on state
    pub fn bg_color(&self, _state: WidgetState) -> &'static str {
        let pal = palette(self.appearance);
        pal.control_background
    }

    /// Text color based on state
    pub fn text_color(&self, state: WidgetState) -> &'static str {
        let pal = palette(self.appearance);

        if state == WidgetState::Disabled {
            pal.disabled_control_text
        } else {
            pal.control_text
        }
    }

    /// Placeholder text color
    pub fn placeholder_color(&self) -> &'static str {
        let pal = palette(self.appearance);
        pal.placeholder_text
    }

    /// Border color based on state
    pub fn border_color(&self, state: WidgetState) -> &'static str {
        let pal = palette(self.appearance);

        match state {
            WidgetState::Focused => pal.system_blue,
            WidgetState::Disabled => {
                match self.appearance {
                    AppearanceMode::Light => "#E0E0E0FF",
                    AppearanceMode::Dark => "#3A3A3AFF",
                    _ => pal.separator,
                }
            }
            _ => {
                match self.appearance {
                    AppearanceMode::Light => "#C7C7C7FF",
                    AppearanceMode::Dark => "#545458FF",
                    _ => pal.separator,
                }
            }
        }
    }

    /// Focus outline color (3px blue ring)
    pub fn focus_outline_color(&self) -> &'static str {
        let pal = palette(self.appearance);
        pal.system_blue
    }

    /// Border radius
    pub fn border_radius(&self) -> f64 {
        5.0
    }

    /// Border width
    pub fn border_width(&self) -> f64 {
        1.0
    }

    /// Focus outline width
    pub fn focus_outline_width(&self) -> f64 {
        3.0
    }

    /// Focus outline offset
    pub fn focus_outline_offset(&self) -> f64 {
        2.0
    }

    /// Padding (horizontal, vertical)
    pub fn padding(&self) -> (f64, f64) {
        (6.0, 4.0)
    }

    /// Height for single-line input
    pub fn height(&self) -> f64 {
        22.0
    }

    /// Opacity for disabled state
    pub fn disabled_opacity(&self) -> f64 {
        0.6
    }
}


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

    #[test]
    fn test_input_theme_default() {
        let theme = InputTheme::default();
        assert_eq!(theme.appearance, AppearanceMode::default());
    }

    #[test]
    fn test_input_theme_padding() {
        let theme = InputTheme::default();
        let (h, v) = theme.padding();
        assert_eq!(h, 6.0);
        assert_eq!(v, 4.0);
    }

    #[test]
    fn test_input_theme_border_radius() {
        let theme = InputTheme::default();
        assert_eq!(theme.border_radius(), 5.0);
    }

    #[test]
    fn test_input_theme_height() {
        let theme = InputTheme::default();
        assert_eq!(theme.height(), 22.0);
    }

    #[test]
    fn test_input_focus_outline_width() {
        let theme = InputTheme::default();
        assert_eq!(theme.focus_outline_width(), 3.0);
    }

    #[test]
    fn test_input_border_color_changes_on_focus() {
        let theme = InputTheme::new(AppearanceMode::Light);
        let normal_border = theme.border_color(WidgetState::Normal);
        let focus_border = theme.border_color(WidgetState::Focused);
        assert_ne!(normal_border, focus_border);
    }

    #[test]
    fn test_input_disabled_opacity() {
        let theme = InputTheme::default();
        assert_eq!(theme.disabled_opacity(), 0.6);
    }

    #[test]
    fn test_input_placeholder_color() {
        let theme = InputTheme::default();
        let placeholder = theme.placeholder_color();
        assert!(!placeholder.is_empty());
    }
}