fluix 0.1.24

Rust UI components for GPUI
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

// Theme system for Fluix components

use gpui::*;

/// Component size variants
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ComponentSize {
    XSmall,
    Small,
    Medium,
    Large,
    XLarge,
}

impl ComponentSize {
    /// Get pixel size for the variant
    pub fn px(&self) -> f32 {
        match self {
            ComponentSize::XSmall => 20.0,
            ComponentSize::Small => 28.0,
            ComponentSize::Medium => 36.0,
            ComponentSize::Large => 44.0,
            ComponentSize::XLarge => 52.0,
        }
    }

    /// Get font size for the variant
    pub fn font_size(&self) -> Pixels {
        match self {
            ComponentSize::XSmall => px(11.0),
            ComponentSize::Small => px(13.0),
            ComponentSize::Medium => px(14.0),
            ComponentSize::Large => px(16.0),
            ComponentSize::XLarge => px(18.0),
        }
    }

    /// Get padding for the variant
    pub fn padding(&self) -> (Pixels, Pixels) {
        match self {
            ComponentSize::XSmall => (px(4.0), px(8.0)),
            ComponentSize::Small => (px(6.0), px(12.0)),
            ComponentSize::Medium => (px(8.0), px(16.0)),
            ComponentSize::Large => (px(10.0), px(20.0)),
            ComponentSize::XLarge => (px(12.0), px(24.0)),
        }
    }

    /// Get minimum width for buttons
    pub fn min_width(&self) -> Pixels {
        match self {
            ComponentSize::XSmall => px(60.0),
            ComponentSize::Small => px(72.0),
            ComponentSize::Medium => px(88.0),
            ComponentSize::Large => px(104.0),
            ComponentSize::XLarge => px(120.0),
        }
    }
}

/// Color palette for the theme
#[derive(Debug, Clone)]
pub struct ColorPalette {
    // Primary colors
    pub primary: Rgba,
    pub primary_hover: Rgba,
    pub primary_active: Rgba,
    
    // Secondary colors
    pub secondary: Rgba,
    pub secondary_hover: Rgba,
    pub secondary_active: Rgba,
    
    // Neutral colors
    pub text: Rgba,
    pub text_secondary: Rgba,
    pub text_disabled: Rgba,
    
    // Background colors
    pub background: Rgba,
    pub background_secondary: Rgba,
    pub background_hover: Rgba,
    
    // Border colors
    pub border: Rgba,
    pub border_focus: Rgba,
    pub border_error: Rgba,
    
    // State colors
    pub success: Rgba,
    pub warning: Rgba,
    pub error: Rgba,
    pub info: Rgba,
}

impl Default for ColorPalette {
    fn default() -> Self {
        Self {
            // Primary colors (purple palette)
            primary: rgb(0x696FC7),
            primary_hover: rgb(0xA7AAE1),
            primary_active: rgb(0x5A5FB0),
            
            // Secondary colors (gray palette)
            secondary: rgb(0x666666),
            secondary_hover: rgb(0x888888),
            secondary_active: rgb(0x555555),
            
            // Neutral colors
            text: rgb(0x333333),
            text_secondary: rgb(0x666666),
            text_disabled: rgb(0x999999),
            
            // Background colors
            background: rgb(0xFFFFFF),
            background_secondary: rgb(0xF5F5F5),
            background_hover: rgb(0xF0F0F0),
            
            // Border colors
            border: rgb(0xE0E0E0),
            border_focus: rgb(0x696FC7),
            border_error: rgb(0xE74C3C),
            
            // State colors
            success: rgb(0x27AE60),
            warning: rgb(0xF39C12),
            error: rgb(0xE74C3C),
            info: rgb(0x3498DB),
        }
    }
}

/// Spacing system
pub struct Spacing;

impl Spacing {
    pub const XXXS: f32 = 2.0;
    pub const XXS: f32 = 4.0;
    pub const XS: f32 = 6.0;
    pub const SM: f32 = 8.0;
    pub const MD: f32 = 12.0;
    pub const LG: f32 = 16.0;
    pub const XL: f32 = 20.0;
    pub const XXL: f32 = 24.0;
    pub const XXXL: f32 = 32.0;
}

/// Border radius values
pub struct BorderRadius;

impl BorderRadius {
    pub const NONE: f32 = 0.0;
    pub const SM: f32 = 4.0;
    pub const MD: f32 = 6.0;
    pub const LG: f32 = 8.0;
    pub const XL: f32 = 12.0;
    pub const FULL: f32 = 9999.0;
}

/// Main theme configuration
#[derive(Debug, Clone)]
pub struct Theme {
    pub colors: ColorPalette,
}

impl Default for Theme {
    fn default() -> Self {
        Self {
            colors: ColorPalette::default(),
        }
    }
}

impl Theme {
    /// Create a new theme
    pub fn new() -> Self {
        Self::default()
    }
    
    /// Create a custom theme with specific colors
    pub fn custom(colors: ColorPalette) -> Self {
        Self { colors }
    }
}