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

//! Toolbar widget configuration and geometry
//!
//! Provides toolbar configuration and geometry calculation
//! for headless architecture.

use crate::types::{Rect, WidgetState};
use serde::{Deserialize, Serialize};

/// Toolbar orientation
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum ToolbarOrientation {
    #[default]
    Horizontal,
    Vertical,
}

/// Toolbar item configuration
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ToolbarItem {
    /// Button with text
    Button {
        id: String,
        text: Option<String>,
        active: bool,
        disabled: bool,
        min_width: f64,
    },
    /// Visual separator
    Separator,
    /// Flexible spacer
    Spacer,
    /// Label (non-interactive text)
    Label {
        id: String,
        text: String,
    },
}

impl ToolbarItem {
    pub fn button(id: &str, text: &str) -> Self {
        Self::Button {
            id: id.to_string(),
            text: Some(text.to_string()),
            active: false,
            disabled: false,
            min_width: 0.0,
        }
    }

    pub fn id(&self) -> Option<&str> {
        match self {
            Self::Button { id, .. } => Some(id),
            Self::Label { id, .. } => Some(id),
            Self::Separator | Self::Spacer => None,
        }
    }
}

/// Section alignment
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum SectionAlign {
    #[default]
    Start,
    End,
}

/// Toolbar section configuration
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolbarSection {
    pub items: Vec<ToolbarItem>,
    pub show_separator: bool,
    pub align: SectionAlign,
}

impl ToolbarSection {
    pub fn new(items: Vec<ToolbarItem>) -> Self {
        Self {
            items,
            show_separator: false,
            align: SectionAlign::Start,
        }
    }
}

/// Toolbar configuration
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolbarConfig {
    pub sections: Vec<ToolbarSection>,
    pub orientation: ToolbarOrientation,
    pub item_size: f64,
    pub spacing: f64,
    pub padding: f64,
}

impl Default for ToolbarConfig {
    fn default() -> Self {
        Self {
            sections: Vec::new(),
            orientation: ToolbarOrientation::Horizontal,
            item_size: 32.0,
            spacing: 4.0,
            padding: 8.0,
        }
    }
}

/// Toolbar interaction response
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct ToolbarResponse {
    pub clicked: Option<String>,
    pub hovered: Option<String>,
    pub item_geometries: Vec<ToolbarItemGeometry>,
}

/// Geometry and state for a single toolbar item
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolbarItemGeometry {
    pub id: Option<String>,
    pub rect: Rect,
    pub state: WidgetState,
    pub item_type: ToolbarItemType,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ToolbarItemType {
    Button,
    Separator,
    Spacer,
    Label,
}

// TODO: Implement headless toolbar geometry calculation and interaction detection