Skip to main content

fc_ui/capabilities/controls/
toggle.rs

1//! Toggle component - Toggle/Switch component with animations and keyboard support.
2
3use crate::capabilities::foundation::theme::use_theme;
4use gpui::{prelude::FluentBuilder as _, *};
5use std::rc::Rc;
6
7actions!(toggle, [ToggleAction]);
8
9#[derive(Copy, Clone, Debug, PartialEq, Eq)]
10pub enum ToggleSize {
11    Sm,
12    Md,
13}
14
15#[derive(Copy, Clone, Debug, PartialEq, Eq)]
16pub enum LabelSide {
17    Left,
18    Right,
19}
20
21#[derive(IntoElement)]
22pub struct Toggle {
23    id: ElementId,
24    base: Stateful<Div>,
25    checked: bool,
26    disabled: bool,
27    label: Option<SharedString>,
28    label_side: LabelSide,
29    on_click: Option<Rc<dyn Fn(&bool, &mut Window, &mut App)>>,
30    size: ToggleSize,
31    style: StyleRefinement,
32}
33
34impl Toggle {
35    pub fn new(id: impl Into<ElementId>) -> Self {
36        let id = id.into();
37        Self {
38            id: id.clone(),
39            base: div().id(id),
40            checked: false,
41            disabled: false,
42            label: None,
43            label_side: LabelSide::Right,
44            on_click: None,
45            size: ToggleSize::Md,
46            style: StyleRefinement::default(),
47        }
48    }
49
50    pub fn checked(mut self, checked: bool) -> Self {
51        self.checked = checked;
52        self
53    }
54
55    pub fn disabled(mut self, disabled: bool) -> Self {
56        self.disabled = disabled;
57        self
58    }
59
60    pub fn label<T: Into<SharedString>>(mut self, label: T) -> Self {
61        self.label = Some(label.into());
62        self
63    }
64
65    pub fn label_side(mut self, side: LabelSide) -> Self {
66        self.label_side = side;
67        self
68    }
69
70    pub fn on_click<F>(mut self, handler: F) -> Self
71    where
72        F: Fn(&bool, &mut Window, &mut App) + 'static,
73    {
74        self.on_click = Some(Rc::new(handler));
75        self
76    }
77
78    pub fn size(mut self, size: ToggleSize) -> Self {
79        self.size = size;
80        self
81    }
82}
83
84impl Styled for Toggle {
85    fn style(&mut self) -> &mut StyleRefinement {
86        &mut self.style
87    }
88}
89
90impl InteractiveElement for Toggle {
91    fn interactivity(&mut self) -> &mut Interactivity {
92        self.base.interactivity()
93    }
94}
95
96impl StatefulInteractiveElement for Toggle {}
97
98impl RenderOnce for Toggle {
99    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
100        let theme = use_theme(cx);
101        let user_style = self.style;
102
103        let (bg_width, bg_height, bar_width, inset) = match self.size {
104            ToggleSize::Sm => (px(28.0), px(16.0), px(12.0), px(2.0)),
105            ToggleSize::Md => (px(36.0), px(20.0), px(16.0), px(2.0)),
106        };
107
108        let checked = self.checked;
109
110        let (bg, toggle_bg) = if self.disabled {
111            let bg_color = if checked {
112                theme.tokens.primary.opacity(0.5)
113            } else {
114                theme.tokens.muted
115            };
116            (bg_color, theme.tokens.background.opacity(0.35))
117        } else if checked {
118            (theme.tokens.primary, theme.tokens.background)
119        } else {
120            (theme.tokens.muted, theme.tokens.background)
121        };
122
123        let radius = bg_height;
124
125        let focus_handle = window
126            .use_keyed_state(self.id.clone(), cx, |_, cx| cx.focus_handle())
127            .read(cx)
128            .clone();
129
130        let is_focused = focus_handle.is_focused(window);
131
132        self.base
133            .when(!self.disabled, |this| {
134                this.track_focus(&focus_handle.tab_index(0).tab_stop(true))
135            })
136            .flex()
137            .items_center()
138            .gap(px(8.0))
139            .when(self.label_side == LabelSide::Left, |this| {
140                this.flex_row_reverse()
141            })
142            .child(
143                div()
144                    .w(bg_width)
145                    .h(bg_height)
146                    .rounded(radius)
147                    .flex()
148                    .items_center()
149                    .bg(bg)
150                    .border_2()
151                    .border_color(gpui::transparent_black())
152                    .when(is_focused && !self.disabled, |this| {
153                        this.border_color(theme.tokens.ring)
154                    })
155                    .cursor(if self.disabled {
156                        CursorStyle::Arrow
157                    } else {
158                        CursorStyle::PointingHand
159                    })
160                    .when(!self.disabled, |this| {
161                        this.hover(|style| {
162                            if checked {
163                                style.bg(theme.tokens.primary.opacity(0.9))
164                            } else {
165                                style.bg(theme.tokens.muted.opacity(0.8))
166                            }
167                        })
168                    })
169                    .child(toggle_thumb(
170                        self.id.clone(),
171                        checked,
172                        toggle_bg,
173                        bg_width,
174                        bar_width,
175                        inset,
176                        radius,
177                        self.disabled,
178                        window,
179                        cx,
180                    )),
181            )
182            .when_some(self.label.clone(), |this, label| {
183                this.child(
184                    div()
185                        .text_size(match self.size {
186                            ToggleSize::Sm => px(13.0),
187                            ToggleSize::Md => px(14.0),
188                        })
189                        .font_family(theme.tokens.font_family.clone())
190                        .text_color(if self.disabled {
191                            theme.tokens.muted_foreground
192                        } else {
193                            theme.tokens.foreground
194                        })
195                        .cursor(if self.disabled {
196                            CursorStyle::Arrow
197                        } else {
198                            CursorStyle::PointingHand
199                        })
200                        .child(label),
201                )
202            })
203            .map(|this| {
204                let mut div = this;
205                div.style().refine(&user_style);
206                div
207            })
208            .when(!self.disabled, |this| {
209                this.when_some(self.on_click.clone(), |this, on_click| {
210                    let on_click_for_key = on_click.clone();
211                    this.on_click(move |_, window, cx| {
212                        let new_checked = !checked;
213                        (on_click)(&new_checked, window, cx);
214                    })
215                    .on_key_down(move |event, window, cx| {
216                        if event.keystroke.key == "space" {
217                            let new_checked = !checked;
218                            (on_click_for_key)(&new_checked, window, cx);
219                            cx.stop_propagation();
220                        }
221                    })
222                })
223            })
224    }
225}
226
227fn toggle_thumb(
228    id: ElementId,
229    checked: bool,
230    color: Hsla,
231    bg_width: Pixels,
232    bar_width: Pixels,
233    inset: Pixels,
234    radius: Pixels,
235    disabled: bool,
236    window: &mut Window,
237    cx: &mut App,
238) -> impl IntoElement {
239    let toggle_state = window.use_keyed_state(id.clone(), cx, |_, _| checked);
240
241    div()
242        .rounded(radius)
243        .bg(color)
244        .shadow_md()
245        .size(bar_width)
246        .relative()
247        .map(|this| {
248            let prev_checked = *toggle_state.read(cx);
249
250            if !disabled && prev_checked != checked {
251                let duration = std::time::Duration::from_millis(150);
252                cx.spawn({
253                    let toggle_state = toggle_state.clone();
254                    async move |cx| {
255                        cx.background_executor().timer(duration).await;
256                        _ = toggle_state.update(cx, |state, _| *state = checked);
257                    }
258                })
259                .detach();
260
261                this.with_animation(
262                    ElementId::NamedInteger("toggle-slide".into(), checked as u64),
263                    Animation::new(duration),
264                    move |this, delta| {
265                        let max_x = bg_width - bar_width - inset * 2.0;
266                        let x = if checked {
267                            inset + max_x * delta
268                        } else {
269                            inset + max_x - max_x * delta
270                        };
271                        this.left(x)
272                    },
273                )
274                .into_any_element()
275            } else {
276                let max_x = bg_width - bar_width - inset * 2.0;
277                let x = if checked { inset + max_x } else { inset };
278                this.left(x).into_any_element()
279            }
280        })
281}