gpuikit 0.9.0

A UI toolkit for GPUI applications
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

//! Breadcrumb component for gpuikit

use crate::layout::h_stack;
use crate::theme::{ActiveTheme, Themeable};
use gpui::{
    App, ClickEvent, ElementId, InteractiveElement, IntoElement, MouseButton, ParentElement,
    RenderOnce, SharedString, StatefulInteractiveElement, Styled, Window, div, prelude::*, rems,
};

/// A single breadcrumb item
pub struct BreadcrumbItem {
    label: SharedString,
    on_click: Option<Box<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static>>,
}

impl BreadcrumbItem {
    pub fn new(label: impl Into<SharedString>) -> Self {
        Self {
            label: label.into(),
            on_click: None,
        }
    }

    pub fn on_click(
        mut self,
        handler: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static,
    ) -> Self {
        self.on_click = Some(Box::new(handler));
        self
    }
}

/// Separator style for breadcrumbs
#[derive(Clone, Copy, Default)]
pub enum BreadcrumbSeparator {
    #[default]
    Slash,
    Chevron,
    Arrow,
    Dot,
}

impl BreadcrumbSeparator {
    fn as_str(&self) -> &'static str {
        match self {
            BreadcrumbSeparator::Slash => "/",
            BreadcrumbSeparator::Chevron => "›",
            BreadcrumbSeparator::Arrow => "→",
            BreadcrumbSeparator::Dot => "•",
        }
    }
}

/// A breadcrumb navigation component
#[derive(IntoElement)]
pub struct Breadcrumb {
    id: ElementId,
    items: Vec<BreadcrumbItem>,
    separator: BreadcrumbSeparator,
}

impl Breadcrumb {
    pub fn new(id: impl Into<ElementId>) -> Self {
        Self {
            id: id.into(),
            items: Vec::new(),
            separator: BreadcrumbSeparator::default(),
        }
    }

    pub fn item(mut self, item: BreadcrumbItem) -> Self {
        self.items.push(item);
        self
    }

    pub fn items(mut self, items: impl IntoIterator<Item = BreadcrumbItem>) -> Self {
        self.items.extend(items);
        self
    }

    pub fn separator(mut self, separator: BreadcrumbSeparator) -> Self {
        self.separator = separator;
        self
    }
}

impl RenderOnce for Breadcrumb {
    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
        let theme = cx.theme();
        let separator_str = self.separator.as_str();
        let item_count = self.items.len();

        h_stack()
            .id(self.id)
            .gap(rems(0.375))
            .items_center()
            .text_sm()
            .children(
                self.items
                    .into_iter()
                    .enumerate()
                    .flat_map(|(index, item)| {
                        let is_last = index == item_count - 1;
                        let is_clickable = item.on_click.is_some();

                        let item_element = div()
                            .id(ElementId::NamedInteger(
                                "breadcrumb-item".into(),
                                index as u64,
                            ))
                            .text_color(if is_last {
                                theme.fg()
                            } else {
                                theme.fg_muted()
                            })
                            .when(is_clickable && !is_last, |this| {
                                this.cursor_pointer()
                                    .hover(|style| style.text_color(theme.fg()))
                            })
                            .when(!is_clickable || is_last, |this| this.cursor_default())
                            .when_some(item.on_click.filter(|_| !is_last), |this, handler| {
                                this.on_mouse_down(MouseButton::Left, |_, window, _| {
                                    window.prevent_default()
                                })
                                .on_click(
                                    move |event, window, cx| {
                                        handler(event, window, cx);
                                    },
                                )
                            })
                            .child(item.label);

                        let separator_element = if !is_last {
                            Some(
                                div()
                                    .text_color(theme.fg_muted())
                                    .flex_none()
                                    .child(separator_str),
                            )
                        } else {
                            None
                        };

                        std::iter::once(item_element.into_any_element())
                            .chain(separator_element.map(|s| s.into_any_element()))
                    }),
            )
    }
}

/// Convenience function to create a breadcrumb
pub fn breadcrumb(id: impl Into<ElementId>) -> Breadcrumb {
    Breadcrumb::new(id)
}

/// Convenience function to create a breadcrumb item
pub fn breadcrumb_item(label: impl Into<SharedString>) -> BreadcrumbItem {
    BreadcrumbItem::new(label)
}