Skip to main content

sui_widgets/composites/
navigation.rs

1use crate::DefaultTheme;
2use crate::IconGlyph;
3use crate::composites::forms::{
4    set_focus_animation_target, set_hover_animation_target, set_press_animation_target,
5};
6use crate::composites::indicators::{
7    draw_control_frame, draw_control_shape, draw_focus_ring_frame, inset_rect, measure_text,
8    physical_pixels, rounded_rect_path, semibold_control_text_style, sliding_inset_rect,
9    tab_indicator_rect, tab_panel_transition_translation, tab_state_visuals,
10};
11use crate::composites::popups::AnimatedScalar;
12use crate::composites::status::{
13    SegmentedControlChange, SegmentedControlContextChange, segmented_control_item_id,
14};
15use crate::controls::draw_icon_glyph;
16use crate::text_align::paint_aligned_text;
17use std::sync::Arc;
18use sui_core::Event;
19use sui_core::ImageHandle;
20use sui_core::InvalidationKind;
21use sui_core::KeyState;
22use sui_core::Point;
23use sui_core::PointerButton;
24use sui_core::PointerEventKind;
25use sui_core::Rect;
26use sui_core::SemanticsAction;
27use sui_core::SemanticsNode;
28use sui_core::SemanticsRole;
29use sui_core::SemanticsValue;
30use sui_core::Size;
31use sui_core::Vector;
32use sui_core::WakeEvent;
33use sui_core::WidgetId;
34use sui_layout::Constraints;
35use sui_layout::Padding as Insets;
36use sui_reactive::Observable;
37use sui_runtime::ArrangeCtx;
38use sui_runtime::Command;
39use sui_runtime::EventCtx;
40use sui_runtime::MeasureCtx;
41use sui_runtime::PaintCtx;
42use sui_runtime::REACTIVE_CHANGED;
43use sui_runtime::SemanticsCtx;
44use sui_runtime::Widget;
45use sui_runtime::WidgetChildren;
46use sui_runtime::WidgetPodMutVisitor;
47use sui_runtime::WidgetPodVisitor;
48use sui_scene::ImageSource;
49use sui_text::TextMeasurement;
50use sui_text::TextStyle;
51
52/// One navigation tab, measured and painted as a single optional-icon + label item.
53#[derive(Clone, Debug, PartialEq, Eq)]
54pub struct TabBarItem {
55    pub(super) label: String,
56    pub(super) icon: Option<ImageHandle>,
57}
58
59impl TabBarItem {
60    /// Create a text-only tab item.
61    pub fn new(label: impl Into<String>) -> Self {
62        Self {
63            label: label.into(),
64            icon: None,
65        }
66    }
67
68    /// Add a leading registered image. The image is tinted like the label, and both share one
69    /// centered content box and active indicator.
70    pub fn icon(mut self, icon: ImageHandle) -> Self {
71        self.icon = Some(icon);
72        self
73    }
74
75    /// Visible and accessible label.
76    pub fn label(&self) -> &str {
77        &self.label
78    }
79
80    /// Optional leading glyph.
81    pub fn icon_handle(&self) -> Option<ImageHandle> {
82        self.icon
83    }
84}
85
86impl From<String> for TabBarItem {
87    fn from(label: String) -> Self {
88        Self::new(label)
89    }
90}
91
92impl From<&str> for TabBarItem {
93    fn from(label: &str) -> Self {
94        Self::new(label)
95    }
96}
97
98pub struct TabBar {
99    pub(super) theme: Box<DefaultTheme>,
100    pub(super) theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
101    pub(super) name: String,
102    pub(super) tabs: Vec<TabBarItem>,
103    pub(super) selected: usize,
104    pub(super) selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
105    pub(super) selected_source: Option<Arc<dyn Observable<Option<usize>>>>,
106    pub(super) selection_from: usize,
107    pub(super) selection_animation: AnimatedScalar,
108    pub(super) hovered: Option<usize>,
109    pub(super) hover_visual: Option<usize>,
110    pub(super) pressed: Option<usize>,
111    pub(super) press_visual: Option<usize>,
112    pub(super) hover_animation: AnimatedScalar,
113    pub(super) press_animation: AnimatedScalar,
114    pub(super) focus_animation: AnimatedScalar,
115    pub(super) gap: Option<f32>,
116    pub(super) label_measurements: Vec<TextMeasurement>,
117    pub(super) content_widths: Vec<f32>,
118    pub(super) widths: Vec<f32>,
119    pub(super) on_change: Option<Box<dyn FnMut(usize, String)>>,
120}
121
122impl TabBar {
123    pub fn new(name: impl Into<String>) -> Self {
124        Self {
125            theme: Box::new(DefaultTheme::default()),
126            theme_reader: None,
127            name: name.into(),
128            tabs: Vec::new(),
129            selected: 0,
130            selected_reader: None,
131            selected_source: None,
132            selection_from: 0,
133            selection_animation: AnimatedScalar::new(1.0),
134            hovered: None,
135            hover_visual: None,
136            pressed: None,
137            press_visual: None,
138            hover_animation: AnimatedScalar::new(0.0),
139            press_animation: AnimatedScalar::new(0.0),
140            focus_animation: AnimatedScalar::new(0.0),
141            gap: None,
142            label_measurements: Vec::new(),
143            content_widths: Vec::new(),
144            widths: Vec::new(),
145            on_change: None,
146        }
147    }
148
149    pub fn theme(mut self, theme: DefaultTheme) -> Self {
150        self.theme = Box::new(theme);
151        self.theme_reader = None;
152        self
153    }
154
155    pub fn theme_when<F>(mut self, theme: F) -> Self
156    where
157        F: Fn() -> DefaultTheme + 'static,
158    {
159        self.theme_reader = Some(Box::new(theme));
160        self
161    }
162
163    pub fn tab(mut self, label: impl Into<String>) -> Self {
164        self.tabs.push(TabBarItem::new(label));
165        self
166    }
167
168    pub fn tabs<I, S>(mut self, labels: I) -> Self
169    where
170        I: IntoIterator<Item = S>,
171        S: Into<String>,
172    {
173        self.tabs.extend(labels.into_iter().map(TabBarItem::new));
174        self
175    }
176
177    /// Append one icon-capable tab item.
178    pub fn item(mut self, item: impl Into<TabBarItem>) -> Self {
179        self.tabs.push(item.into());
180        self
181    }
182
183    /// Append icon-capable tab items.
184    pub fn items<I, T>(mut self, items: I) -> Self
185    where
186        I: IntoIterator<Item = T>,
187        T: Into<TabBarItem>,
188    {
189        self.tabs.extend(items.into_iter().map(Into::into));
190        self
191    }
192
193    pub fn selected(mut self, index: usize) -> Self {
194        self.selected = index;
195        self.selected_reader = None;
196        self.selected_source = None;
197        self.selection_from = index;
198        self.selection_animation = AnimatedScalar::new(1.0);
199        self
200    }
201
202    pub fn selected_when<F>(mut self, selected: F) -> Self
203    where
204        F: Fn() -> Option<usize> + 'static,
205    {
206        if let Some(index) = selected() {
207            self.selected = index;
208            self.selection_from = index;
209        }
210        self.selected_reader = Some(Box::new(selected));
211        self.selected_source = None;
212        self
213    }
214
215    /// Bind the selected tab to an observable value without rebuilding the
216    /// retained tab bar.
217    pub fn selected_from<O>(mut self, selected: O) -> Self
218    where
219        O: Observable<Option<usize>> + 'static,
220    {
221        if let Some(index) = selected.get() {
222            self.selected = index;
223            self.selection_from = index;
224        }
225        self.selected_reader = None;
226        self.selected_source = Some(Arc::new(selected));
227        self
228    }
229
230    pub fn gap(mut self, gap: f32) -> Self {
231        self.gap = Some(gap.max(0.0));
232        self
233    }
234
235    pub fn on_change<F>(mut self, on_change: F) -> Self
236    where
237        F: FnMut(usize, String) + 'static,
238    {
239        self.on_change = Some(Box::new(on_change));
240        self
241    }
242
243    pub fn selected_index(&self) -> usize {
244        self.normalized_selected()
245    }
246
247    pub fn current_tab(&self) -> Option<&str> {
248        self.tabs
249            .get(self.normalized_selected())
250            .map(TabBarItem::label)
251    }
252
253    pub(super) fn normalized_selected(&self) -> usize {
254        let selected = self
255            .selected_source
256            .as_ref()
257            .and_then(|source| source.get())
258            .or_else(|| self.selected_reader.as_ref().and_then(|reader| reader()))
259            .unwrap_or(self.selected);
260        if self.tabs.is_empty() {
261            0
262        } else {
263            selected.min(self.tabs.len() - 1)
264        }
265    }
266
267    pub(super) fn activate(&mut self, index: usize, ctx: &mut EventCtx) {
268        if self.tabs.is_empty() {
269            return;
270        }
271
272        let index = index.min(self.tabs.len() - 1);
273        let selected = self.normalized_selected();
274        if selected != index {
275            self.selected = index;
276            if let Some(on_change) = &mut self.on_change {
277                on_change(index, self.tabs[index].label.clone());
278            }
279            let target = self.normalized_selected();
280            self.selected = target;
281            self.start_selection_animation(selected, target, ctx);
282        }
283    }
284
285    pub(super) fn start_selection_animation(&mut self, from: usize, to: usize, ctx: &mut EventCtx) {
286        if self.tabs.is_empty() || from == to {
287            self.selection_from = to;
288            self.selection_animation = AnimatedScalar::new(1.0);
289            return;
290        }
291
292        let theme = self.resolved_theme();
293        self.selection_from = from.min(self.tabs.len() - 1);
294        self.selection_animation = AnimatedScalar::new(0.0);
295        self.selection_animation.set_target_event(
296            1.0,
297            theme.motion.tab_switch_duration(),
298            theme.motion.tab_switch_easing(),
299            ctx,
300        );
301        ctx.request_paint();
302        ctx.request_semantics();
303    }
304
305    pub(super) fn sync_external_selected(&mut self, ctx: &mut EventCtx) {
306        if (self.selected_reader.is_none() && self.selected_source.is_none())
307            || self.tabs.is_empty()
308        {
309            return;
310        }
311
312        if let Some(source) = &self.selected_source {
313            let _ = ctx.observe(source.as_ref(), InvalidationKind::Paint);
314            let _ = ctx.observe(source.as_ref(), InvalidationKind::Semantics);
315        }
316
317        let previous = self.selected.min(self.tabs.len() - 1);
318        let selected = self.normalized_selected();
319        if previous != selected {
320            self.selected = selected;
321            self.start_selection_animation(previous, selected, ctx);
322        }
323    }
324
325    pub(super) fn tab_height(&self) -> f32 {
326        self.resolved_theme().metrics.tab_height
327    }
328
329    pub(super) fn resolved_gap(&self) -> f32 {
330        self.gap
331            .unwrap_or(self.resolved_theme().metrics.tab_gap)
332            .max(0.0)
333    }
334
335    pub(super) fn measured_widths(&self) -> &[f32] {
336        &self.widths
337    }
338
339    pub(super) fn tab_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
340        if index >= self.tabs.len() || self.measured_widths().len() != self.tabs.len() {
341            return None;
342        }
343
344        let gap = self.resolved_gap();
345        let base_total =
346            self.widths.iter().sum::<f32>() + (gap * self.tabs.len().saturating_sub(1) as f32);
347        let extra_per_tab = if bounds.width() > base_total && !self.tabs.is_empty() {
348            (bounds.width() - base_total) / self.tabs.len() as f32
349        } else {
350            0.0
351        };
352
353        let tab_height = self.tab_height().min(bounds.height()).max(0.0);
354        let tab_y = bounds.y() + ((bounds.height() - tab_height) * 0.5).max(0.0);
355        let mut x = bounds.x();
356        for (current, width) in self.widths.iter().enumerate() {
357            let width = *width + extra_per_tab;
358            let rect = Rect::new(x, tab_y, width, tab_height);
359            if current == index {
360                return Some(rect);
361            }
362            x += width + gap;
363        }
364
365        None
366    }
367
368    pub(super) fn tab_content_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
369        let tab = self.tab_rect(bounds, index)?;
370        let width = *self.content_widths.get(index)?;
371        let slot = inset_rect(tab, self.resolved_theme().metrics.tab_padding);
372        let width = width.min(slot.width()).max(0.0);
373        Some(Rect::new(
374            slot.x() + ((slot.width() - width) * 0.5).max(0.0),
375            slot.y(),
376            width,
377            slot.height(),
378        ))
379    }
380
381    pub(super) fn tab_indicator_anchor_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
382        let tab = self.tab_rect(bounds, index)?;
383        if self.tabs.get(index)?.icon.is_some() {
384            let content = self.tab_content_rect(bounds, index)?;
385            Some(Rect::new(
386                content.x(),
387                tab.y(),
388                content.width(),
389                tab.height(),
390            ))
391        } else {
392            let padding = self.resolved_theme().metrics.tab_padding;
393            Some(Rect::new(
394                tab.x() + padding.left,
395                tab.y(),
396                (tab.width() - padding.left - padding.right).max(0.0),
397                tab.height(),
398            ))
399        }
400    }
401
402    pub(super) fn tab_at(&self, bounds: Rect, position: Point) -> Option<usize> {
403        self.tabs.iter().enumerate().find_map(|(index, _)| {
404            self.tab_rect(bounds, index)
405                .filter(|rect| rect.contains(position))
406                .map(|_| index)
407        })
408    }
409
410    pub(super) fn move_selection(&mut self, delta: isize, ctx: &mut EventCtx) {
411        if self.tabs.is_empty() {
412            return;
413        }
414
415        let selected = self.normalized_selected() as isize;
416        let last = self.tabs.len() as isize - 1;
417        let next = (selected + delta).clamp(0, last) as usize;
418        self.activate(next, ctx);
419        self.set_hovered(Some(next), ctx);
420    }
421
422    pub(super) fn advance_animations(&mut self, time: f64) -> bool {
423        let selection_animating = self.selection_animation.advance(time);
424        let hover_animating = self.hover_animation.advance(time);
425        if !hover_animating
426            && self.hovered.is_none()
427            && self.hover_animation.value <= AnimatedScalar::EPSILON
428        {
429            self.hover_visual = None;
430        }
431        let press_animating = self.press_animation.advance(time);
432        if !press_animating
433            && self.pressed.is_none()
434            && self.press_animation.value <= AnimatedScalar::EPSILON
435        {
436            self.press_visual = None;
437        }
438        let focus_animating = self.focus_animation.advance(time);
439        selection_animating | hover_animating | press_animating | focus_animating
440    }
441
442    pub(super) fn resolved_theme(&self) -> DefaultTheme {
443        self.theme_reader
444            .as_ref()
445            .map(|theme| theme())
446            .unwrap_or(*self.theme)
447    }
448
449    pub(super) fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
450        if self.hovered == hovered {
451            return;
452        }
453        let theme = self.resolved_theme();
454        self.hovered = hovered;
455        if let Some(index) = hovered {
456            self.hover_visual = Some(index);
457            self.hover_animation = AnimatedScalar::new(0.0);
458            set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
459        } else if !set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx) {
460            self.hover_visual = None;
461        }
462        ctx.request_paint();
463        ctx.request_semantics();
464    }
465
466    pub(super) fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
467        if self.pressed == pressed {
468            return;
469        }
470        let theme = self.resolved_theme();
471        self.pressed = pressed;
472        if let Some(index) = pressed {
473            self.press_visual = Some(index);
474            self.press_animation = AnimatedScalar::new(0.0);
475            set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
476        } else if !set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx) {
477            self.press_visual = None;
478        }
479        ctx.request_paint();
480        ctx.request_semantics();
481    }
482
483    pub(super) fn hover_amount_for(&self, index: usize) -> f32 {
484        if self.hover_visual == Some(index) {
485            self.hover_animation.value
486        } else {
487            0.0
488        }
489    }
490
491    pub(super) fn press_amount_for(&self, index: usize) -> f32 {
492        if self.press_visual == Some(index) {
493            self.press_animation.value
494        } else {
495            0.0
496        }
497    }
498}
499
500impl Widget for TabBar {
501    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
502        self.sync_external_selected(ctx);
503        match event {
504            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
505                self.set_hovered(self.tab_at(ctx.bounds(), pointer.position), ctx);
506            }
507            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
508                self.set_hovered(None, ctx);
509            }
510            Event::Pointer(pointer)
511                if pointer.kind == PointerEventKind::Down
512                    && pointer.button == Some(PointerButton::Primary) =>
513            {
514                let hovered = self.tab_at(ctx.bounds(), pointer.position);
515                self.set_hovered(hovered, ctx);
516                self.set_pressed(hovered, ctx);
517                ctx.request_focus();
518                ctx.request_pointer_capture(pointer.pointer_id);
519                ctx.set_handled();
520            }
521            Event::Pointer(pointer)
522                if pointer.kind == PointerEventKind::Up
523                    && pointer.button == Some(PointerButton::Primary) =>
524            {
525                let hovered = self.tab_at(ctx.bounds(), pointer.position);
526                if let Some(index) = self
527                    .pressed
528                    .zip(hovered)
529                    .filter(|(left, right)| left == right)
530                    .map(|(index, _)| index)
531                {
532                    self.activate(index, ctx);
533                }
534                self.set_hovered(hovered, ctx);
535                self.set_pressed(None, ctx);
536                ctx.release_pointer_capture(pointer.pointer_id);
537                ctx.set_handled();
538            }
539            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
540                if self.pressed.is_some() {
541                    self.set_pressed(None, ctx);
542                    self.set_hovered(None, ctx);
543                    ctx.release_pointer_capture(pointer.pointer_id);
544                    ctx.set_handled();
545                }
546            }
547            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
548                match key.key.as_str() {
549                    "ArrowLeft" | "ArrowUp" => self.move_selection(-1, ctx),
550                    "ArrowRight" | "ArrowDown" => self.move_selection(1, ctx),
551                    "Home" => self.activate(0, ctx),
552                    "End" if !self.tabs.is_empty() => self.activate(self.tabs.len() - 1, ctx),
553                    _ => return,
554                }
555                ctx.request_paint();
556                ctx.request_semantics();
557                ctx.set_handled();
558            }
559            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
560                if self.advance_animations(*time) {
561                    ctx.request_animation_frame();
562                }
563                ctx.request_paint();
564            }
565            _ => {}
566        }
567    }
568
569    fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
570        if command.is(REACTIVE_CHANGED) && self.selected_source.is_some() {
571            self.sync_external_selected(ctx);
572            ctx.set_handled();
573        }
574    }
575
576    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
577        if let Some(source) = &self.selected_source {
578            let selected = ctx.observe_with(source.as_ref(), InvalidationKind::Paint);
579            let _ = ctx.observe_with(source.as_ref(), InvalidationKind::Semantics);
580            if let Some(selected) = selected {
581                self.selected = selected;
582            }
583        }
584        let theme = self.resolved_theme();
585        let style = theme.text_style(theme.palette.text);
586        let padding = theme.metrics.tab_padding;
587        self.label_measurements = self
588            .tabs
589            .iter()
590            .map(|tab| measure_text(ctx, &tab.label, &style))
591            .collect();
592        let icon_size = theme
593            .metrics
594            .icon_size
595            .min((self.tab_height() - padding.top - padding.bottom).max(0.0));
596        self.content_widths = self
597            .tabs
598            .iter()
599            .zip(self.label_measurements.iter())
600            .map(|(tab, measurement)| {
601                measurement.width
602                    + tab
603                        .icon
604                        .map(|_| icon_size + theme.metrics.icon_label_gap)
605                        .unwrap_or_default()
606            })
607            .collect();
608        self.widths = self
609            .content_widths
610            .iter()
611            .map(|content_width| {
612                (content_width + padding.left + padding.right).max(theme.metrics.tab_min_width)
613            })
614            .collect();
615
616        let gap = self.resolved_gap();
617        let width =
618            self.widths.iter().sum::<f32>() + (gap * self.tabs.len().saturating_sub(1) as f32);
619        constraints.clamp(Size::new(width.max(160.0), self.tab_height()))
620    }
621
622    fn paint(&self, ctx: &mut PaintCtx) {
623        let theme = self.resolved_theme();
624        let palette = theme.palette;
625        let metrics = theme.metrics;
626        let interaction = theme.interaction;
627        let tab_padding = metrics.tab_padding;
628        let label_style = theme.text_style(palette.text_muted);
629        let selected_label_style = theme.text_style(palette.text);
630
631        // Navigation tabs share one flat strip. Selection is communicated by the
632        // animated underline below rather than by a second, raised tile.
633        ctx.fill_rect(ctx.bounds(), palette.control);
634        let divider_height = physical_pixels(ctx, metrics.border_width);
635        ctx.fill_rect(
636            Rect::new(
637                ctx.bounds().x(),
638                ctx.bounds().max_y() - divider_height,
639                ctx.bounds().width(),
640                divider_height,
641            ),
642            palette.border.with_alpha(0.72),
643        );
644
645        let focus_progress = self.focus_animation.value;
646        for (index, tab) in self.tabs.iter().enumerate() {
647            let Some(rect) = self.tab_rect(ctx.bounds(), index) else {
648                continue;
649            };
650            let selected = self.normalized_selected() == index;
651            let hovered = self.hovered == Some(index);
652            let pressed = self.pressed == Some(index);
653            let hover_amount = self.hover_amount_for(index);
654            let press_amount = self.press_amount_for(index);
655
656            // Hover and press remain local to each tab, but the steady selected
657            // state stays flat so it does not compete with the underline.
658            if (hovered
659                || pressed
660                || hover_amount > AnimatedScalar::EPSILON
661                || press_amount > AnimatedScalar::EPSILON)
662                && let Some((background, border)) =
663                    tab_state_visuals(&theme, false, hovered, pressed, hover_amount, press_amount)
664            {
665                draw_control_shape(
666                    ctx,
667                    rect,
668                    metrics.corner_radius,
669                    physical_pixels(ctx, metrics.border_width),
670                    background,
671                    border,
672                );
673            }
674
675            if selected && focus_progress > AnimatedScalar::EPSILON {
676                draw_focus_ring_frame(
677                    ctx,
678                    rect,
679                    metrics.corner_radius,
680                    metrics,
681                    palette
682                        .focus_ring
683                        .with_alpha(palette.focus_ring.alpha * focus_progress),
684                );
685            }
686
687            let text_style = if selected {
688                selected_label_style.clone()
689            } else {
690                label_style.clone()
691            };
692            let text_slot = inset_rect(rect, tab_padding);
693            let pressed_offset = press_amount * interaction.pressed_offset;
694            let Some(content) = self.tab_content_rect(ctx.bounds(), index) else {
695                continue;
696            };
697            let content = content.translate(Vector::new(0.0, pressed_offset));
698            ctx.push_clip_rect(text_slot);
699            let label_slot = if let Some(icon) = tab.icon {
700                let icon_size = metrics.icon_size.min(content.height());
701                let icon_rect = Rect::new(
702                    content.x(),
703                    content.y() + (content.height() - icon_size) * 0.5,
704                    icon_size,
705                    icon_size,
706                );
707                ctx.draw_image_source(
708                    icon_rect,
709                    ImageSource::new(icon).with_tint(text_style.color),
710                );
711                Rect::new(
712                    icon_rect.max_x() + metrics.icon_label_gap,
713                    content.y(),
714                    (content.max_x() - icon_rect.max_x() - metrics.icon_label_gap).max(0.0),
715                    content.height(),
716                )
717            } else {
718                content
719            };
720            paint_aligned_text(
721                ctx,
722                label_slot,
723                &tab.label,
724                &text_style,
725                text_style.line_height,
726                0.0,
727            );
728            ctx.pop_clip();
729        }
730
731        if let Some(accent) = tab_indicator_rect(
732            |index| self.tab_indicator_anchor_rect(ctx.bounds(), index),
733            self.selection_from,
734            self.normalized_selected(),
735            self.selection_animation.value,
736            Insets::ZERO,
737            interaction.active_indicator_thickness,
738        ) {
739            ctx.fill(
740                rounded_rect_path(accent, accent.height() * 0.5),
741                palette.accent,
742            );
743        }
744    }
745
746    fn semantics(&self, ctx: &mut SemanticsCtx) {
747        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::TabBar, ctx.bounds());
748        node.name = Some(self.name.clone());
749        node.value = self
750            .current_tab()
751            .map(|value| SemanticsValue::Text(value.to_string()));
752        node.state.focused = ctx.is_focused();
753        node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
754        ctx.push(node);
755    }
756
757    fn accepts_focus(&self) -> bool {
758        true
759    }
760
761    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
762        let theme = self.resolved_theme();
763        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
764        ctx.request_paint();
765        ctx.request_semantics();
766    }
767}
768
769#[derive(Clone, Copy, Debug, PartialEq, Eq)]
770pub(super) enum BrowserTabHit {
771    Tab(usize),
772    Close(usize),
773}
774
775impl BrowserTabHit {
776    pub(super) fn index(self) -> usize {
777        match self {
778            Self::Tab(index) | Self::Close(index) => index,
779        }
780    }
781}
782
783pub(super) type BrowserTabBarChange = Box<dyn FnMut(usize, String)>;
784pub(super) type BrowserTabBarContextChange = Box<dyn FnMut(usize, String, &mut EventCtx)>;
785
786pub struct BrowserTabBar {
787    pub(super) theme: Box<DefaultTheme>,
788    pub(super) theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
789    pub(super) name: String,
790    pub(super) tabs: Vec<String>,
791    max_tab_width: f32,
792    pub(super) tabs_reader: Option<Box<dyn Fn() -> Vec<String>>>,
793    pub(super) selected: Option<usize>,
794    pub(super) selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
795    pub(super) selection_from: Option<usize>,
796    pub(super) selection_to: Option<usize>,
797    pub(super) selection_animation: AnimatedScalar,
798    pub(super) hovered: Option<BrowserTabHit>,
799    pub(super) hover_visual: Option<BrowserTabHit>,
800    pub(super) pressed: Option<BrowserTabHit>,
801    pub(super) press_visual: Option<BrowserTabHit>,
802    pub(super) hover_animation: AnimatedScalar,
803    pub(super) press_animation: AnimatedScalar,
804    pub(super) focus_animation: AnimatedScalar,
805    pub(super) label_measurements: Vec<TextMeasurement>,
806    pub(super) widths: Vec<f32>,
807    pub(super) on_change: Option<BrowserTabBarChange>,
808    pub(super) on_change_with_ctx: Option<BrowserTabBarContextChange>,
809    pub(super) on_close: Option<BrowserTabBarChange>,
810    pub(super) on_close_with_ctx: Option<BrowserTabBarContextChange>,
811}
812
813impl BrowserTabBar {
814    pub fn new(name: impl Into<String>) -> Self {
815        Self {
816            theme: Box::new(DefaultTheme::default()),
817            theme_reader: None,
818            name: name.into(),
819            tabs: Vec::new(),
820            max_tab_width: f32::INFINITY,
821            tabs_reader: None,
822            selected: None,
823            selected_reader: None,
824            selection_from: None,
825            selection_to: None,
826            selection_animation: AnimatedScalar::new(1.0),
827            hovered: None,
828            hover_visual: None,
829            pressed: None,
830            press_visual: None,
831            hover_animation: AnimatedScalar::new(0.0),
832            press_animation: AnimatedScalar::new(0.0),
833            focus_animation: AnimatedScalar::new(0.0),
834            label_measurements: Vec::new(),
835            widths: Vec::new(),
836            on_change: None,
837            on_change_with_ctx: None,
838            on_close: None,
839            on_close_with_ctx: None,
840        }
841    }
842
843    pub fn theme(mut self, theme: DefaultTheme) -> Self {
844        self.theme = Box::new(theme);
845        self.theme_reader = None;
846        self
847    }
848
849    pub fn theme_when<F>(mut self, theme: F) -> Self
850    where
851        F: Fn() -> DefaultTheme + 'static,
852    {
853        self.theme_reader = Some(Box::new(theme));
854        self
855    }
856
857    pub fn tabs<I, S>(mut self, labels: I) -> Self
858    where
859        I: IntoIterator<Item = S>,
860        S: Into<String>,
861    {
862        self.tabs.extend(labels.into_iter().map(Into::into));
863        self
864    }
865
866    pub fn tabs_when<F>(mut self, tabs: F) -> Self
867    where
868        F: Fn() -> Vec<String> + 'static,
869    {
870        self.tabs_reader = Some(Box::new(tabs));
871        self
872    }
873
874    /// Bound document labels while keeping the close control visible.
875    pub fn max_tab_width(mut self, width: f32) -> Self {
876        self.max_tab_width = width.max(0.0);
877        self
878    }
879
880    /// Selected tab's measured bounds in content coordinates, for a containing viewport.
881    pub fn selected_tab_bounds(&self) -> Option<Rect> {
882        let width = self.widths.iter().sum::<f32>()
883            + self.resolved_theme().metrics.tab_gap * self.tabs.len().saturating_sub(1) as f32;
884        self.tab_rect(
885            Rect::new(0.0, 0.0, width, self.tab_height()),
886            self.normalized_selected()?,
887        )
888    }
889
890    pub fn selected(mut self, index: Option<usize>) -> Self {
891        self.selected = index;
892        self.selection_from = index;
893        self.selection_to = index;
894        self.selection_animation = AnimatedScalar::new(1.0);
895        self
896    }
897
898    pub fn selected_when<F>(mut self, selected: F) -> Self
899    where
900        F: Fn() -> Option<usize> + 'static,
901    {
902        self.selected_reader = Some(Box::new(selected));
903        self
904    }
905
906    pub fn on_change<F>(mut self, on_change: F) -> Self
907    where
908        F: FnMut(usize, String) + 'static,
909    {
910        self.on_change = Some(Box::new(on_change));
911        self
912    }
913
914    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
915    where
916        F: FnMut(usize, String, &mut EventCtx) + 'static,
917    {
918        self.on_change_with_ctx = Some(Box::new(on_change));
919        self
920    }
921
922    pub fn on_close<F>(mut self, on_close: F) -> Self
923    where
924        F: FnMut(usize, String) + 'static,
925    {
926        self.on_close = Some(Box::new(on_close));
927        self
928    }
929
930    pub fn on_close_with_ctx<F>(mut self, on_close: F) -> Self
931    where
932        F: FnMut(usize, String, &mut EventCtx) + 'static,
933    {
934        self.on_close_with_ctx = Some(Box::new(on_close));
935        self
936    }
937
938    pub fn selected_index(&self) -> Option<usize> {
939        self.normalized_selected()
940    }
941
942    pub(super) fn refresh_tabs(&mut self) {
943        if let Some(reader) = &self.tabs_reader {
944            self.tabs = reader();
945        }
946        self.selected = self.resolved_selected_raw();
947        let selected = self.normalized_selected();
948        if self.selection_animation.value >= 1.0 - AnimatedScalar::EPSILON
949            && self.selection_to != selected
950        {
951            self.selection_from = selected;
952            self.selection_to = selected;
953            self.selection_animation = AnimatedScalar::new(1.0);
954        }
955    }
956
957    pub(super) fn resolved_selected_raw(&self) -> Option<usize> {
958        self.selected_reader
959            .as_ref()
960            .map(|reader| reader())
961            .unwrap_or(self.selected)
962    }
963
964    pub(super) fn normalized_selected(&self) -> Option<usize> {
965        let selected = self.resolved_selected_raw()?;
966        (selected < self.tabs.len()).then_some(selected)
967    }
968
969    pub(super) fn activate(&mut self, index: usize, ctx: &mut EventCtx) {
970        self.refresh_tabs();
971        if index >= self.tabs.len() {
972            return;
973        }
974        let from = self.normalized_selected();
975        if from == Some(index) {
976            return;
977        }
978        let label = self.tabs[index].clone();
979        self.selected = Some(index);
980        if let Some(on_change) = &mut self.on_change {
981            on_change(index, label.clone());
982        }
983        if let Some(on_change) = &mut self.on_change_with_ctx {
984            on_change(index, label, ctx);
985        }
986        self.refresh_tabs();
987        self.start_selection_animation(from, self.normalized_selected(), ctx);
988    }
989
990    pub(super) fn close(&mut self, index: usize, ctx: &mut EventCtx) {
991        self.refresh_tabs();
992        if index >= self.tabs.len() {
993            return;
994        }
995        let from = self.normalized_selected();
996        let label = self.tabs[index].clone();
997        if let Some(on_close) = &mut self.on_close {
998            on_close(index, label.clone());
999        }
1000        if let Some(on_close) = &mut self.on_close_with_ctx {
1001            on_close(index, label, ctx);
1002        }
1003        self.refresh_tabs();
1004        self.start_selection_animation(from, self.normalized_selected(), ctx);
1005    }
1006
1007    pub(super) fn start_selection_animation(
1008        &mut self,
1009        from: Option<usize>,
1010        to: Option<usize>,
1011        ctx: &mut EventCtx,
1012    ) {
1013        self.selection_from = from.or(to);
1014        self.selection_to = to;
1015        if from.zip(to).is_some_and(|(from, to)| from != to) {
1016            let theme = self.resolved_theme();
1017            self.selection_animation = AnimatedScalar::new(0.0);
1018            self.selection_animation.set_target_event(
1019                1.0,
1020                theme.motion.tab_switch_duration(),
1021                theme.motion.tab_switch_easing(),
1022                ctx,
1023            );
1024        } else {
1025            self.selection_animation = AnimatedScalar::new(1.0);
1026        }
1027        ctx.request_paint();
1028        ctx.request_semantics();
1029    }
1030
1031    pub(super) fn resolved_theme(&self) -> DefaultTheme {
1032        self.theme_reader
1033            .as_ref()
1034            .map(|theme| theme())
1035            .unwrap_or(*self.theme)
1036    }
1037
1038    pub(super) fn close_size(theme: &DefaultTheme) -> f32 {
1039        (theme.metrics.tab_height * 0.56).clamp(16.0, 20.0)
1040    }
1041
1042    pub(super) fn close_gap(theme: &DefaultTheme) -> f32 {
1043        theme.metrics.icon_label_gap.max(7.0)
1044    }
1045
1046    pub(super) fn tab_height(&self) -> f32 {
1047        self.resolved_theme().metrics.tab_height
1048    }
1049
1050    pub(super) fn measured_widths(&self) -> &[f32] {
1051        &self.widths
1052    }
1053
1054    pub(super) fn tab_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
1055        if index >= self.tabs.len() || self.measured_widths().len() != self.tabs.len() {
1056            return None;
1057        }
1058
1059        let theme = self.resolved_theme();
1060        let gap = theme.metrics.tab_gap;
1061        let tab_height = self.tab_height().min(bounds.height()).max(0.0);
1062        let tab_y = bounds.y() + ((bounds.height() - tab_height) * 0.5).max(0.0);
1063        let mut x = bounds.x();
1064        for (current, measured_width) in self.widths.iter().enumerate() {
1065            let visible_width = (*measured_width).min((bounds.max_x() - x).max(0.0));
1066            let rect = Rect::new(x, tab_y, visible_width, tab_height);
1067            if current == index {
1068                return (visible_width > 0.0).then_some(rect);
1069            }
1070            x += *measured_width + gap;
1071            if x >= bounds.max_x() {
1072                break;
1073            }
1074        }
1075
1076        None
1077    }
1078
1079    pub(super) fn close_rect_for(&self, tab_rect: Rect) -> Rect {
1080        let theme = self.resolved_theme();
1081        let close = Self::close_size(&theme)
1082            .min(tab_rect.width())
1083            .min(tab_rect.height());
1084        Rect::new(
1085            tab_rect.max_x() - close - Self::close_gap(&theme),
1086            tab_rect.y() + ((tab_rect.height() - close) * 0.5),
1087            close,
1088            close,
1089        )
1090    }
1091
1092    pub(super) fn label_rect_for(&self, tab_rect: Rect) -> Rect {
1093        let theme = self.resolved_theme();
1094        let padding = theme.metrics.tab_padding;
1095        let close = self.close_rect_for(tab_rect);
1096        Rect::new(
1097            tab_rect.x() + padding.left,
1098            tab_rect.y() + padding.top,
1099            (close.x() - tab_rect.x() - padding.left - Self::close_gap(&theme)).max(0.0),
1100            (tab_rect.height() - padding.top - padding.bottom).max(0.0),
1101        )
1102    }
1103
1104    pub(super) fn hit_at(&self, bounds: Rect, position: Point) -> Option<BrowserTabHit> {
1105        for index in 0..self.tabs.len() {
1106            let Some(rect) = self.tab_rect(bounds, index) else {
1107                continue;
1108            };
1109            if self.close_rect_for(rect).contains(position) {
1110                return Some(BrowserTabHit::Close(index));
1111            }
1112            if rect.contains(position) {
1113                return Some(BrowserTabHit::Tab(index));
1114            }
1115        }
1116        None
1117    }
1118
1119    pub(super) fn move_selection(&mut self, delta: isize, ctx: &mut EventCtx) {
1120        self.refresh_tabs();
1121        if self.tabs.is_empty() {
1122            return;
1123        }
1124        let selected = self.normalized_selected().unwrap_or(0) as isize;
1125        let last = self.tabs.len() as isize - 1;
1126        let next = (selected + delta).clamp(0, last) as usize;
1127        self.activate(next, ctx);
1128        self.set_hovered(Some(BrowserTabHit::Tab(next)), ctx);
1129    }
1130
1131    pub(super) fn advance_animations(&mut self, time: f64) -> bool {
1132        let selection_animating = self.selection_animation.advance(time);
1133        let hover_animating = self.hover_animation.advance(time);
1134        if !hover_animating
1135            && self.hovered.is_none()
1136            && self.hover_animation.value <= AnimatedScalar::EPSILON
1137        {
1138            self.hover_visual = None;
1139        }
1140        let press_animating = self.press_animation.advance(time);
1141        if !press_animating
1142            && self.pressed.is_none()
1143            && self.press_animation.value <= AnimatedScalar::EPSILON
1144        {
1145            self.press_visual = None;
1146        }
1147        let focus_animating = self.focus_animation.advance(time);
1148        selection_animating | hover_animating | press_animating | focus_animating
1149    }
1150
1151    pub(super) fn set_hovered(&mut self, hovered: Option<BrowserTabHit>, ctx: &mut EventCtx) {
1152        if self.hovered == hovered {
1153            return;
1154        }
1155        let theme = self.resolved_theme();
1156        self.hovered = hovered;
1157        if let Some(hit) = hovered {
1158            self.hover_visual = Some(hit);
1159            self.hover_animation = AnimatedScalar::new(0.0);
1160            set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
1161        } else if !set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx) {
1162            self.hover_visual = None;
1163        }
1164        ctx.request_paint();
1165        ctx.request_semantics();
1166    }
1167
1168    pub(super) fn set_pressed(&mut self, pressed: Option<BrowserTabHit>, ctx: &mut EventCtx) {
1169        if self.pressed == pressed {
1170            return;
1171        }
1172        let theme = self.resolved_theme();
1173        self.pressed = pressed;
1174        if let Some(hit) = pressed {
1175            self.press_visual = Some(hit);
1176            self.press_animation = AnimatedScalar::new(0.0);
1177            set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
1178        } else if !set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx) {
1179            self.press_visual = None;
1180        }
1181        ctx.request_paint();
1182        ctx.request_semantics();
1183    }
1184
1185    pub(super) fn hover_amount_for(&self, index: usize) -> f32 {
1186        if self.hover_visual.is_some_and(|hit| hit.index() == index) {
1187            self.hover_animation.value
1188        } else {
1189            0.0
1190        }
1191    }
1192
1193    pub(super) fn press_amount_for(&self, index: usize) -> f32 {
1194        if self.press_visual.is_some_and(|hit| hit.index() == index) {
1195            self.press_animation.value
1196        } else {
1197            0.0
1198        }
1199    }
1200}
1201
1202impl Widget for BrowserTabBar {
1203    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
1204        self.refresh_tabs();
1205        match event {
1206            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
1207                self.set_hovered(self.hit_at(ctx.bounds(), pointer.position), ctx);
1208            }
1209            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
1210                self.set_hovered(None, ctx);
1211            }
1212            Event::Pointer(pointer)
1213                if pointer.kind == PointerEventKind::Down
1214                    && pointer.button == Some(PointerButton::Primary) =>
1215            {
1216                let hovered = self.hit_at(ctx.bounds(), pointer.position);
1217                self.set_hovered(hovered, ctx);
1218                self.set_pressed(hovered, ctx);
1219                ctx.request_focus();
1220                ctx.request_pointer_capture(pointer.pointer_id);
1221                ctx.set_handled();
1222            }
1223            Event::Pointer(pointer)
1224                if pointer.kind == PointerEventKind::Up
1225                    && pointer.button == Some(PointerButton::Primary) =>
1226            {
1227                let hovered = self.hit_at(ctx.bounds(), pointer.position);
1228                if let Some(hit) = self
1229                    .pressed
1230                    .zip(hovered)
1231                    .filter(|(left, right)| left == right)
1232                    .map(|(hit, _)| hit)
1233                {
1234                    match hit {
1235                        BrowserTabHit::Tab(index) => self.activate(index, ctx),
1236                        BrowserTabHit::Close(index) => self.close(index, ctx),
1237                    }
1238                }
1239                self.set_hovered(hovered, ctx);
1240                self.set_pressed(None, ctx);
1241                ctx.release_pointer_capture(pointer.pointer_id);
1242                ctx.set_handled();
1243            }
1244            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
1245                if self.pressed.is_some() {
1246                    self.set_pressed(None, ctx);
1247                    self.set_hovered(None, ctx);
1248                    ctx.release_pointer_capture(pointer.pointer_id);
1249                    ctx.set_handled();
1250                }
1251            }
1252            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
1253                match key.key.as_str() {
1254                    "ArrowLeft" | "ArrowUp" => self.move_selection(-1, ctx),
1255                    "ArrowRight" | "ArrowDown" => self.move_selection(1, ctx),
1256                    "Home" => self.activate(0, ctx),
1257                    "End" if !self.tabs.is_empty() => self.activate(self.tabs.len() - 1, ctx),
1258                    _ => return,
1259                }
1260                ctx.request_paint();
1261                ctx.request_semantics();
1262                ctx.set_handled();
1263            }
1264            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
1265                if self.advance_animations(*time) {
1266                    ctx.request_animation_frame();
1267                }
1268                ctx.request_paint();
1269            }
1270            _ => {}
1271        }
1272    }
1273
1274    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
1275        self.refresh_tabs();
1276        let theme = self.resolved_theme();
1277        let style = theme.text_style(theme.palette.text);
1278        let padding = theme.metrics.tab_padding;
1279        let close_extent = Self::close_size(&theme) + (Self::close_gap(&theme) * 2.0);
1280        self.label_measurements = self
1281            .tabs
1282            .iter()
1283            .map(|tab| measure_text(ctx, tab, &style))
1284            .collect();
1285        self.widths = self
1286            .label_measurements
1287            .iter()
1288            .map(|measurement| {
1289                (measurement.width + padding.left + padding.right + close_extent)
1290                    .max(theme.metrics.tab_min_width)
1291                    .min(self.max_tab_width.max(theme.metrics.tab_min_width))
1292            })
1293            .collect();
1294
1295        let gap = theme.metrics.tab_gap;
1296        let width =
1297            self.widths.iter().sum::<f32>() + (gap * self.tabs.len().saturating_sub(1) as f32);
1298        constraints.clamp(Size::new(width, self.tab_height()))
1299    }
1300
1301    fn paint(&self, ctx: &mut PaintCtx) {
1302        let theme = self.resolved_theme();
1303        let palette = theme.palette;
1304        let interaction = theme.interaction;
1305        let selected_index = self.normalized_selected();
1306        let focus_progress = self.focus_animation.value;
1307
1308        let clip_outset = physical_pixels(
1309            ctx,
1310            theme.metrics.focus_ring_outset + (theme.metrics.focus_ring_width * 0.5),
1311        );
1312        ctx.push_clip_rect(ctx.bounds().inflate(clip_outset, clip_outset));
1313        for (index, tab) in self.tabs.iter().enumerate() {
1314            let Some(rect) = self.tab_rect(ctx.bounds(), index) else {
1315                continue;
1316            };
1317            let selected = selected_index == Some(index);
1318            let hovered = self.hovered.is_some_and(|hit| hit.index() == index);
1319            let pressed = self.pressed.is_some_and(|hit| hit.index() == index);
1320            let hover_amount = self.hover_amount_for(index);
1321            let press_amount = self.press_amount_for(index);
1322
1323            if let Some((background, border)) = tab_state_visuals(
1324                &theme,
1325                selected,
1326                hovered,
1327                pressed,
1328                hover_amount,
1329                press_amount,
1330            ) {
1331                draw_control_shape(
1332                    ctx,
1333                    rect,
1334                    theme.metrics.corner_radius,
1335                    physical_pixels(ctx, theme.metrics.border_width),
1336                    background,
1337                    border,
1338                );
1339            }
1340
1341            if selected && focus_progress > AnimatedScalar::EPSILON {
1342                draw_focus_ring_frame(
1343                    ctx,
1344                    rect,
1345                    theme.metrics.corner_radius,
1346                    theme.metrics,
1347                    palette
1348                        .focus_ring
1349                        .with_alpha(palette.focus_ring.alpha * focus_progress),
1350                );
1351            }
1352
1353            let text_style = theme.text_style(if selected {
1354                palette.text
1355            } else {
1356                palette.text_muted
1357            });
1358            let text_slot = self.label_rect_for(rect);
1359            let pressed_offset = press_amount * interaction.pressed_offset;
1360            ctx.push_clip_rect(text_slot);
1361            paint_aligned_text(
1362                ctx,
1363                text_slot.translate(Vector::new(0.0, pressed_offset)),
1364                tab,
1365                &text_style,
1366                text_style.line_height,
1367                0.0,
1368            );
1369            ctx.pop_clip();
1370
1371            let close = self.close_rect_for(rect);
1372            let close_hovered = self.hovered == Some(BrowserTabHit::Close(index));
1373            let close_pressed = self.pressed == Some(BrowserTabHit::Close(index));
1374            if close_hovered || close_pressed {
1375                ctx.fill(
1376                    rounded_rect_path(close, theme.metrics.corner_radius.min(5.0)),
1377                    if close_pressed {
1378                        palette.control_active
1379                    } else {
1380                        palette.control_hover
1381                    },
1382                );
1383            }
1384            draw_icon_glyph(
1385                ctx,
1386                IconGlyph::Close,
1387                close.inflate(-3.0, -3.0),
1388                if close_hovered || selected {
1389                    palette.text
1390                } else {
1391                    palette.placeholder
1392                }
1393                .with_alpha(if close_pressed { 0.95 } else { 0.78 }),
1394            );
1395        }
1396
1397        if let Some(selected) = selected_index {
1398            let progress = if self.selection_to == Some(selected) {
1399                self.selection_animation.value
1400            } else {
1401                1.0
1402            };
1403            if let Some(accent) = tab_indicator_rect(
1404                |index| self.tab_rect(ctx.bounds(), index),
1405                self.selection_from.unwrap_or(selected),
1406                selected,
1407                progress,
1408                theme.metrics.tab_padding,
1409                interaction.active_indicator_thickness,
1410            ) {
1411                ctx.fill(
1412                    rounded_rect_path(accent, accent.height() * 0.5),
1413                    palette.accent,
1414                );
1415            }
1416        }
1417        ctx.pop_clip();
1418    }
1419
1420    fn semantics(&self, ctx: &mut SemanticsCtx) {
1421        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::TabBar, ctx.bounds());
1422        node.name = Some(self.name.clone());
1423        node.value = self
1424            .normalized_selected()
1425            .and_then(|index| self.tabs.get(index))
1426            .map(|value| SemanticsValue::Text(value.to_string()));
1427        node.state.focused = ctx.is_focused();
1428        node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
1429        ctx.push(node);
1430
1431        for (index, tab) in self.tabs.iter().enumerate() {
1432            let Some(rect) = self.tab_rect(ctx.bounds(), index) else {
1433                continue;
1434            };
1435            let tab_id = browser_tab_semantics_id(ctx.widget_id(), index);
1436            let mut tab_node = SemanticsNode::new(tab_id, SemanticsRole::Button, rect);
1437            tab_node.parent = Some(ctx.widget_id());
1438            tab_node.name = Some(tab.clone());
1439            tab_node.state.selected = self.normalized_selected() == Some(index);
1440            tab_node.state.hovered = self.hovered.is_some_and(|hit| hit.index() == index);
1441            tab_node.actions = vec![SemanticsAction::Activate, SemanticsAction::Focus];
1442            ctx.push(tab_node);
1443
1444            let mut close_node = SemanticsNode::new(
1445                browser_tab_close_semantics_id(ctx.widget_id(), index),
1446                SemanticsRole::Button,
1447                self.close_rect_for(rect),
1448            );
1449            close_node.parent = Some(tab_id);
1450            close_node.name = Some(format!("Close {tab} tab"));
1451            close_node.state.hovered = self.hovered == Some(BrowserTabHit::Close(index));
1452            close_node.actions = vec![SemanticsAction::Activate, SemanticsAction::Focus];
1453            ctx.push(close_node);
1454        }
1455    }
1456
1457    fn accepts_focus(&self) -> bool {
1458        true
1459    }
1460
1461    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
1462        let theme = self.resolved_theme();
1463        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
1464        ctx.request_paint();
1465        ctx.request_semantics();
1466    }
1467}
1468
1469pub(super) fn browser_tab_semantics_id(parent: WidgetId, index: usize) -> WidgetId {
1470    const TAG: u64 = 3_u64 << 51;
1471    const LOW_MASK: u64 = (1_u64 << 51) - 1;
1472    WidgetId::new(
1473        TAG | (parent
1474            .get()
1475            .wrapping_mul(397)
1476            .wrapping_add(index as u64 + 1)
1477            & LOW_MASK),
1478    )
1479}
1480
1481pub(super) fn browser_tab_close_semantics_id(parent: WidgetId, index: usize) -> WidgetId {
1482    const TAG: u64 = 3_u64 << 51;
1483    const LOW_MASK: u64 = (1_u64 << 51) - 1;
1484    WidgetId::new(
1485        TAG | (parent
1486            .get()
1487            .wrapping_mul(397)
1488            .wrapping_add(10_000 + index as u64)
1489            & LOW_MASK),
1490    )
1491}
1492
1493pub struct SegmentedControl {
1494    pub(super) theme: Box<DefaultTheme>,
1495    pub(super) theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
1496    pub(super) name: String,
1497    pub(super) segments: Vec<SegmentedControlItem>,
1498    pub(super) selected: usize,
1499    pub(super) selected_reader: Option<Box<dyn Fn() -> Option<usize>>>,
1500    pub(super) selection_from: usize,
1501    pub(super) selection_animation: AnimatedScalar,
1502    pub(super) hovered: Option<usize>,
1503    pub(super) hover_visual: Option<usize>,
1504    pub(super) pressed: Option<usize>,
1505    pub(super) press_visual: Option<usize>,
1506    pub(super) hover_animation: AnimatedScalar,
1507    pub(super) press_animation: AnimatedScalar,
1508    pub(super) focus_animation: AnimatedScalar,
1509    pub(super) label_measurements: Vec<TextMeasurement>,
1510    pub(super) on_change: Option<SegmentedControlChange>,
1511    pub(super) on_change_with_ctx: Option<SegmentedControlContextChange>,
1512}
1513
1514pub struct SegmentedControlItem {
1515    pub(super) label: String,
1516    pub(super) semantic_name: Option<String>,
1517    pub(super) description: Option<String>,
1518    pub(super) disabled: bool,
1519}
1520
1521impl SegmentedControlItem {
1522    pub fn new(label: impl Into<String>) -> Self {
1523        Self {
1524            label: label.into(),
1525            semantic_name: None,
1526            description: None,
1527            disabled: false,
1528        }
1529    }
1530
1531    pub fn semantic_name(mut self, name: impl Into<String>) -> Self {
1532        self.semantic_name = Some(name.into());
1533        self
1534    }
1535
1536    pub fn description(mut self, description: impl Into<String>) -> Self {
1537        self.description = Some(description.into());
1538        self
1539    }
1540
1541    pub fn disabled(mut self) -> Self {
1542        self.disabled = true;
1543        self
1544    }
1545
1546    pub fn label(&self) -> &str {
1547        &self.label
1548    }
1549}
1550
1551impl SegmentedControl {
1552    pub fn new(name: impl Into<String>) -> Self {
1553        Self {
1554            theme: Box::new(DefaultTheme::default()),
1555            theme_reader: None,
1556            name: name.into(),
1557            segments: Vec::new(),
1558            selected: 0,
1559            selected_reader: None,
1560            selection_from: 0,
1561            selection_animation: AnimatedScalar::new(1.0),
1562            hovered: None,
1563            hover_visual: None,
1564            pressed: None,
1565            press_visual: None,
1566            hover_animation: AnimatedScalar::new(0.0),
1567            press_animation: AnimatedScalar::new(0.0),
1568            focus_animation: AnimatedScalar::new(0.0),
1569            label_measurements: Vec::new(),
1570            on_change: None,
1571            on_change_with_ctx: None,
1572        }
1573    }
1574
1575    pub fn theme(mut self, theme: DefaultTheme) -> Self {
1576        self.theme = Box::new(theme);
1577        self.theme_reader = None;
1578        self
1579    }
1580
1581    pub fn theme_when<F>(mut self, theme: F) -> Self
1582    where
1583        F: Fn() -> DefaultTheme + 'static,
1584    {
1585        self.theme_reader = Some(Box::new(theme));
1586        self
1587    }
1588
1589    pub fn item(mut self, item: SegmentedControlItem) -> Self {
1590        self.segments.push(item);
1591        self
1592    }
1593
1594    pub fn items<I>(mut self, items: I) -> Self
1595    where
1596        I: IntoIterator<Item = SegmentedControlItem>,
1597    {
1598        self.segments.extend(items);
1599        self
1600    }
1601
1602    pub fn segments<I, S>(mut self, labels: I) -> Self
1603    where
1604        I: IntoIterator<Item = S>,
1605        S: Into<String>,
1606    {
1607        self.segments
1608            .extend(labels.into_iter().map(SegmentedControlItem::new));
1609        self
1610    }
1611
1612    pub fn selected(mut self, index: usize) -> Self {
1613        self.selected = index;
1614        self.selected_reader = None;
1615        self.selection_from = index;
1616        self.selection_animation = AnimatedScalar::new(1.0);
1617        self
1618    }
1619
1620    pub fn selected_when<F>(mut self, selected: F) -> Self
1621    where
1622        F: Fn() -> Option<usize> + 'static,
1623    {
1624        self.selected_reader = Some(Box::new(selected));
1625        self
1626    }
1627
1628    pub fn on_change<F>(mut self, on_change: F) -> Self
1629    where
1630        F: FnMut(usize, String) + 'static,
1631    {
1632        self.on_change = Some(Box::new(on_change));
1633        self
1634    }
1635
1636    pub fn on_change_with_ctx<F>(mut self, on_change: F) -> Self
1637    where
1638        F: FnMut(usize, String, &mut EventCtx) + 'static,
1639    {
1640        self.on_change_with_ctx = Some(Box::new(on_change));
1641        self
1642    }
1643
1644    pub fn selected_index(&self) -> usize {
1645        self.normalized_selected()
1646    }
1647
1648    pub(super) fn normalized_selected(&self) -> usize {
1649        let selected = self
1650            .selected_reader
1651            .as_ref()
1652            .and_then(|reader| reader())
1653            .unwrap_or(self.selected);
1654        if self.segments.is_empty() {
1655            0
1656        } else {
1657            selected.min(self.segments.len() - 1)
1658        }
1659    }
1660
1661    pub(super) fn segment_height(&self) -> f32 {
1662        self.resolved_theme().metrics.tab_height
1663    }
1664
1665    pub(super) fn segment_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
1666        if index >= self.segments.len() {
1667            return None;
1668        }
1669        let count = self.segments.len().max(1);
1670        let width = bounds.width() / count as f32;
1671        let x = bounds.x() + width * index as f32;
1672        let width = if index + 1 == count {
1673            bounds.max_x() - x
1674        } else {
1675            width
1676        };
1677        Some(Rect::new(
1678            x,
1679            bounds.y(),
1680            width.max(0.0),
1681            bounds.height().max(0.0),
1682        ))
1683    }
1684
1685    pub(super) fn segment_at(&self, bounds: Rect, position: Point) -> Option<usize> {
1686        if !bounds.contains(position) || self.segments.is_empty() {
1687            return None;
1688        }
1689        let slot_width = (bounds.width() / self.segments.len() as f32).max(1.0);
1690        let index = ((position.x - bounds.x()) / slot_width).floor() as usize;
1691        Some(index.min(self.segments.len() - 1))
1692    }
1693
1694    pub(super) fn resolved_theme(&self) -> DefaultTheme {
1695        self.theme_reader
1696            .as_ref()
1697            .map(|theme| theme())
1698            .unwrap_or(*self.theme)
1699    }
1700
1701    pub(super) fn activate(&mut self, index: usize, ctx: &mut EventCtx) {
1702        let Some(segment) = self.segments.get(index) else {
1703            return;
1704        };
1705        if segment.disabled {
1706            return;
1707        }
1708
1709        let index = index.min(self.segments.len() - 1);
1710        let selected = self.normalized_selected();
1711        if selected != index {
1712            let theme = self.resolved_theme();
1713            self.selection_from = selected;
1714            self.selected = index;
1715            self.selection_animation = AnimatedScalar::new(0.0);
1716            self.selection_animation.set_target_event(
1717                1.0,
1718                theme.motion.tab_switch_duration(),
1719                theme.motion.tab_switch_easing(),
1720                ctx,
1721            );
1722            let label = self.segments[index].label.clone();
1723            if let Some(on_change) = &mut self.on_change {
1724                on_change(index, label.clone());
1725            }
1726            if let Some(on_change) = &mut self.on_change_with_ctx {
1727                on_change(index, label, ctx);
1728            }
1729        }
1730    }
1731
1732    pub(super) fn move_selection(&mut self, delta: isize, ctx: &mut EventCtx) {
1733        if self.segments.is_empty() {
1734            return;
1735        }
1736        let selected = self.normalized_selected() as isize;
1737        let last = self.segments.len() as isize - 1;
1738        let next = (selected + delta).clamp(0, last) as usize;
1739        self.activate(next, ctx);
1740        self.set_hovered(Some(next), ctx);
1741    }
1742
1743    pub(super) fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
1744        if self.hovered == hovered {
1745            return;
1746        }
1747        let theme = self.resolved_theme();
1748        self.hovered = hovered;
1749        if let Some(index) = hovered {
1750            self.hover_visual = Some(index);
1751            self.hover_animation = AnimatedScalar::new(0.0);
1752            set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
1753        } else if !set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx) {
1754            self.hover_visual = None;
1755        }
1756        ctx.request_paint();
1757        ctx.request_semantics();
1758    }
1759
1760    pub(super) fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
1761        if self.pressed == pressed {
1762            return;
1763        }
1764        let theme = self.resolved_theme();
1765        self.pressed = pressed;
1766        if let Some(index) = pressed {
1767            self.press_visual = Some(index);
1768            self.press_animation = AnimatedScalar::new(0.0);
1769            set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
1770        } else if !set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx) {
1771            self.press_visual = None;
1772        }
1773        ctx.request_paint();
1774        ctx.request_semantics();
1775    }
1776
1777    pub(super) fn hover_amount_for(&self, index: usize) -> f32 {
1778        if self.hover_visual == Some(index) {
1779            self.hover_animation.value
1780        } else {
1781            0.0
1782        }
1783    }
1784
1785    pub(super) fn press_amount_for(&self, index: usize) -> f32 {
1786        if self.press_visual == Some(index) {
1787            self.press_animation.value
1788        } else {
1789            0.0
1790        }
1791    }
1792
1793    pub(super) fn advance_animations(&mut self, time: f64) -> bool {
1794        let selection_animating = self.selection_animation.advance(time);
1795        let hover_animating = self.hover_animation.advance(time);
1796        if !hover_animating
1797            && self.hovered.is_none()
1798            && self.hover_animation.value <= AnimatedScalar::EPSILON
1799        {
1800            self.hover_visual = None;
1801        }
1802        let press_animating = self.press_animation.advance(time);
1803        if !press_animating
1804            && self.pressed.is_none()
1805            && self.press_animation.value <= AnimatedScalar::EPSILON
1806        {
1807            self.press_visual = None;
1808        }
1809        let focus_animating = self.focus_animation.advance(time);
1810        selection_animating | hover_animating | press_animating | focus_animating
1811    }
1812}
1813
1814impl Widget for SegmentedControl {
1815    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
1816        match event {
1817            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
1818                self.set_hovered(self.segment_at(ctx.bounds(), pointer.position), ctx);
1819            }
1820            Event::Pointer(pointer)
1821                if pointer.kind == PointerEventKind::Leave
1822                    || pointer.kind == PointerEventKind::Cancel =>
1823            {
1824                if pointer.kind == PointerEventKind::Cancel && self.pressed.is_some() {
1825                    ctx.release_pointer_capture(pointer.pointer_id);
1826                    ctx.set_handled();
1827                }
1828                self.set_pressed(None, ctx);
1829                self.set_hovered(None, ctx);
1830            }
1831            Event::Pointer(pointer)
1832                if pointer.kind == PointerEventKind::Down
1833                    && pointer.button == Some(PointerButton::Primary) =>
1834            {
1835                let hovered = self.segment_at(ctx.bounds(), pointer.position);
1836                self.set_hovered(hovered, ctx);
1837                self.set_pressed(hovered, ctx);
1838                ctx.request_focus();
1839                ctx.request_pointer_capture(pointer.pointer_id);
1840                ctx.set_handled();
1841            }
1842            Event::Pointer(pointer)
1843                if pointer.kind == PointerEventKind::Up
1844                    && pointer.button == Some(PointerButton::Primary) =>
1845            {
1846                let hovered = self.segment_at(ctx.bounds(), pointer.position);
1847                if let Some(index) = self
1848                    .pressed
1849                    .zip(hovered)
1850                    .filter(|(left, right)| left == right)
1851                    .map(|(index, _)| index)
1852                {
1853                    self.activate(index, ctx);
1854                }
1855                self.set_hovered(hovered, ctx);
1856                self.set_pressed(None, ctx);
1857                ctx.release_pointer_capture(pointer.pointer_id);
1858                ctx.set_handled();
1859            }
1860            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
1861                match key.key.as_str() {
1862                    "ArrowLeft" | "ArrowUp" => self.move_selection(-1, ctx),
1863                    "ArrowRight" | "ArrowDown" => self.move_selection(1, ctx),
1864                    "Home" => self.activate(0, ctx),
1865                    "End" if !self.segments.is_empty() => {
1866                        self.activate(self.segments.len() - 1, ctx)
1867                    }
1868                    _ => return,
1869                }
1870                ctx.request_paint();
1871                ctx.request_semantics();
1872                ctx.set_handled();
1873            }
1874            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
1875                if self.advance_animations(*time) {
1876                    ctx.request_animation_frame();
1877                }
1878                ctx.request_paint();
1879            }
1880            _ => {}
1881        }
1882    }
1883
1884    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
1885        let theme = self.resolved_theme();
1886        let style = semibold_control_text_style(&theme, theme.palette.text);
1887        let padding = theme.metrics.tab_padding;
1888        self.label_measurements = self
1889            .segments
1890            .iter()
1891            .map(|segment| measure_text(ctx, &segment.label, &style))
1892            .collect();
1893        let widest = self
1894            .label_measurements
1895            .iter()
1896            .map(|measurement| measurement.width + padding.left + padding.right)
1897            .fold(theme.metrics.tab_min_width, f32::max);
1898        let width = widest * self.segments.len().max(1) as f32;
1899        constraints.clamp(Size::new(width.max(160.0), self.segment_height()))
1900    }
1901
1902    fn paint(&self, ctx: &mut PaintCtx) {
1903        let theme = self.resolved_theme();
1904        let palette = theme.palette;
1905        let metrics = theme.metrics;
1906        let interaction = theme.interaction;
1907        let padding = metrics.tab_padding;
1908        let label_style = semibold_control_text_style(&theme, palette.text_muted);
1909        let selected_label_style = TextStyle {
1910            color: palette.text,
1911            ..label_style.clone()
1912        };
1913        let radius = metrics.corner_radius;
1914
1915        ctx.fill(rounded_rect_path(ctx.bounds(), radius), palette.control);
1916
1917        let selected_thumb = if !self.segments.is_empty() {
1918            let from = self.selection_from.min(self.segments.len() - 1);
1919            let selected = self.normalized_selected();
1920            let thumb = sliding_inset_rect(
1921                |index| self.segment_rect(ctx.bounds(), index),
1922                from,
1923                selected,
1924                self.selection_animation.value,
1925                Insets::all(2.0),
1926            );
1927            if let Some(thumb) = thumb {
1928                draw_control_shape(
1929                    ctx,
1930                    thumb,
1931                    (thumb.height() * 0.5).min(radius),
1932                    physical_pixels(ctx, metrics.border_width),
1933                    palette.selection,
1934                    palette.selection_border,
1935                );
1936            }
1937            thumb
1938        } else {
1939            None
1940        };
1941
1942        let focus_progress = self.focus_animation.value;
1943        for (index, segment) in self.segments.iter().enumerate() {
1944            let Some(rect) = self.segment_rect(ctx.bounds(), index) else {
1945                continue;
1946            };
1947            let selected = self.normalized_selected() == index;
1948            let hovered = self.hovered == Some(index);
1949            let pressed = self.pressed == Some(index);
1950            let hover_amount = self.hover_amount_for(index);
1951            let press_amount = self.press_amount_for(index);
1952
1953            if !selected
1954                && let Some((background, border)) =
1955                    tab_state_visuals(&theme, false, hovered, pressed, hover_amount, press_amount)
1956            {
1957                draw_control_shape(
1958                    ctx,
1959                    rect.inflate(-1.0, -1.0),
1960                    radius,
1961                    physical_pixels(ctx, metrics.border_width),
1962                    background,
1963                    border,
1964                );
1965            }
1966
1967            if selected && focus_progress > AnimatedScalar::EPSILON {
1968                let focus_bounds = selected_thumb.unwrap_or_else(|| rect.inflate(-2.0, -2.0));
1969                draw_focus_ring_frame(
1970                    ctx,
1971                    focus_bounds,
1972                    (focus_bounds.height() * 0.5).min(radius),
1973                    metrics,
1974                    palette
1975                        .focus_ring
1976                        .with_alpha(palette.focus_ring.alpha * focus_progress),
1977                );
1978            }
1979
1980            let text_style = if selected {
1981                selected_label_style.clone()
1982            } else {
1983                label_style.clone()
1984            };
1985            let text_slot = inset_rect(rect, padding);
1986            let pressed_offset = press_amount * interaction.pressed_offset;
1987            ctx.push_clip_rect(text_slot);
1988            paint_aligned_text(
1989                ctx,
1990                text_slot.translate(Vector::new(0.0, pressed_offset)),
1991                &segment.label,
1992                &text_style,
1993                text_style.line_height,
1994                0.5,
1995            );
1996            ctx.pop_clip();
1997        }
1998    }
1999
2000    fn semantics(&self, ctx: &mut SemanticsCtx) {
2001        let selected = self.normalized_selected();
2002        let value = self
2003            .segments
2004            .get(selected)
2005            .map(|segment| segment.label.clone());
2006        let mut group =
2007            SemanticsNode::new(ctx.widget_id(), SemanticsRole::RadioGroup, ctx.bounds());
2008        group.name = Some(self.name.clone());
2009        group.value = value.map(SemanticsValue::Text);
2010        group.state.focused = ctx.is_focused();
2011        group.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
2012        ctx.push(group);
2013
2014        for (index, segment) in self.segments.iter().enumerate() {
2015            let Some(bounds) = self.segment_rect(ctx.bounds(), index) else {
2016                continue;
2017            };
2018            let mut node = SemanticsNode::new(
2019                segmented_control_item_id(ctx.widget_id(), index),
2020                SemanticsRole::RadioButton,
2021                bounds,
2022            );
2023            node.parent = Some(ctx.widget_id());
2024            node.name = Some(
2025                segment
2026                    .semantic_name
2027                    .clone()
2028                    .unwrap_or_else(|| segment.label.clone()),
2029            );
2030            node.description = segment.description.clone();
2031            node.value = Some(SemanticsValue::Text(segment.label.clone()));
2032            node.actions = if segment.disabled {
2033                Vec::new()
2034            } else {
2035                vec![SemanticsAction::Activate]
2036            };
2037            node.state.disabled = segment.disabled;
2038            node.state.hovered = self.hovered == Some(index);
2039            node.state.selected = selected == index;
2040            node.state.checked = Some(if selected == index {
2041                sui_core::ToggleState::Checked
2042            } else {
2043                sui_core::ToggleState::Unchecked
2044            });
2045            ctx.push(node);
2046        }
2047    }
2048
2049    fn accepts_focus(&self) -> bool {
2050        true
2051    }
2052
2053    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
2054        let theme = self.resolved_theme();
2055        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
2056        ctx.request_paint();
2057        ctx.request_semantics();
2058    }
2059}
2060
2061pub struct Tabs {
2062    pub(super) theme: Box<DefaultTheme>,
2063    pub(super) theme_reader: Option<Box<dyn Fn() -> DefaultTheme>>,
2064    pub(super) name: String,
2065    pub(super) labels: Vec<String>,
2066    pub(super) panels: WidgetChildren,
2067    pub(super) selected: usize,
2068    pub(super) selection_from: usize,
2069    pub(super) selection_animation: AnimatedScalar,
2070    pub(super) hovered: Option<usize>,
2071    pub(super) hover_visual: Option<usize>,
2072    pub(super) pressed: Option<usize>,
2073    pub(super) press_visual: Option<usize>,
2074    pub(super) hover_animation: AnimatedScalar,
2075    pub(super) press_animation: AnimatedScalar,
2076    pub(super) focus_animation: AnimatedScalar,
2077    pub(super) label_measurements: Vec<TextMeasurement>,
2078    pub(super) widths: Vec<f32>,
2079    pub(super) gap: Option<f32>,
2080    pub(super) panel_frame: Rect,
2081    pub(super) on_change: Option<Box<dyn FnMut(usize, String)>>,
2082}
2083
2084impl Tabs {
2085    pub fn new(name: impl Into<String>) -> Self {
2086        Self {
2087            theme: Box::new(DefaultTheme::default()),
2088            theme_reader: None,
2089            name: name.into(),
2090            labels: Vec::new(),
2091            panels: WidgetChildren::new(),
2092            selected: 0,
2093            selection_from: 0,
2094            selection_animation: AnimatedScalar::new(1.0),
2095            hovered: None,
2096            hover_visual: None,
2097            pressed: None,
2098            press_visual: None,
2099            hover_animation: AnimatedScalar::new(0.0),
2100            press_animation: AnimatedScalar::new(0.0),
2101            focus_animation: AnimatedScalar::new(0.0),
2102            label_measurements: Vec::new(),
2103            widths: Vec::new(),
2104            gap: None,
2105            panel_frame: Rect::ZERO,
2106            on_change: None,
2107        }
2108    }
2109
2110    pub fn theme(mut self, theme: DefaultTheme) -> Self {
2111        self.theme = Box::new(theme);
2112        self.theme_reader = None;
2113        self
2114    }
2115
2116    pub fn theme_when<F>(mut self, theme: F) -> Self
2117    where
2118        F: Fn() -> DefaultTheme + 'static,
2119    {
2120        self.theme_reader = Some(Box::new(theme));
2121        self
2122    }
2123
2124    pub fn selected(mut self, index: usize) -> Self {
2125        self.selected = index;
2126        self.selection_from = index;
2127        self.selection_animation = AnimatedScalar::new(1.0);
2128        self
2129    }
2130
2131    pub fn on_change<F>(mut self, on_change: F) -> Self
2132    where
2133        F: FnMut(usize, String) + 'static,
2134    {
2135        self.on_change = Some(Box::new(on_change));
2136        self
2137    }
2138
2139    pub fn tab<W>(mut self, label: impl Into<String>, panel: W) -> Self
2140    where
2141        W: Widget + 'static,
2142    {
2143        self.labels.push(label.into());
2144        self.panels.push(panel);
2145        self
2146    }
2147
2148    pub fn selected_index(&self) -> usize {
2149        self.normalized_selected()
2150    }
2151
2152    pub fn current_tab(&self) -> Option<&str> {
2153        self.labels
2154            .get(self.normalized_selected())
2155            .map(String::as_str)
2156    }
2157
2158    pub(super) fn normalized_selected(&self) -> usize {
2159        if self.labels.is_empty() {
2160            0
2161        } else {
2162            self.selected.min(self.labels.len() - 1)
2163        }
2164    }
2165
2166    pub(super) fn header_height(&self) -> f32 {
2167        self.resolved_theme().metrics.tab_height
2168    }
2169
2170    pub(super) fn resolved_gap(&self) -> f32 {
2171        self.gap
2172            .unwrap_or(self.resolved_theme().metrics.tab_gap)
2173            .max(0.0)
2174    }
2175
2176    pub(super) fn header_rect(&self, bounds: Rect) -> Rect {
2177        Rect::new(bounds.x(), bounds.y(), bounds.width(), self.header_height())
2178    }
2179
2180    pub(super) fn tab_rect(&self, bounds: Rect, index: usize) -> Option<Rect> {
2181        if index >= self.labels.len() || self.widths.len() != self.labels.len() {
2182            return None;
2183        }
2184
2185        let header = self.header_rect(bounds);
2186        let gap = self.resolved_gap();
2187        let base_total =
2188            self.widths.iter().sum::<f32>() + (gap * self.labels.len().saturating_sub(1) as f32);
2189        let extra_per_tab = if header.width() > base_total && !self.labels.is_empty() {
2190            (header.width() - base_total) / self.labels.len() as f32
2191        } else {
2192            0.0
2193        };
2194
2195        let mut x = header.x();
2196        for (current, width) in self.widths.iter().enumerate() {
2197            let rect = Rect::new(x, header.y(), *width + extra_per_tab, header.height());
2198            if current == index {
2199                return Some(rect);
2200            }
2201            x += rect.width() + gap;
2202        }
2203
2204        None
2205    }
2206
2207    pub(super) fn tab_at(&self, bounds: Rect, position: Point) -> Option<usize> {
2208        self.labels.iter().enumerate().find_map(|(index, _)| {
2209            self.tab_rect(bounds, index)
2210                .filter(|rect| rect.contains(position))
2211                .map(|_| index)
2212        })
2213    }
2214
2215    pub(super) fn select(&mut self, index: usize, ctx: &mut EventCtx) {
2216        if self.labels.is_empty() {
2217            return;
2218        }
2219
2220        let index = index.min(self.labels.len() - 1);
2221        if self.selected != index {
2222            let theme = self.resolved_theme();
2223            self.selection_from = self.normalized_selected();
2224            self.selected = index;
2225            self.selection_animation = AnimatedScalar::new(0.0);
2226            self.selection_animation.set_target_event(
2227                1.0,
2228                theme.motion.tab_switch_duration(),
2229                theme.motion.tab_switch_easing(),
2230                ctx,
2231            );
2232            if let Some(on_change) = &mut self.on_change {
2233                on_change(index, self.labels[index].clone());
2234            }
2235        }
2236    }
2237
2238    pub(super) fn move_selection(&mut self, delta: isize, ctx: &mut EventCtx) {
2239        if self.labels.is_empty() {
2240            return;
2241        }
2242
2243        let next = (self.normalized_selected() as isize + delta)
2244            .clamp(0, self.labels.len() as isize - 1) as usize;
2245        self.set_hovered(Some(next), ctx);
2246        self.select(next, ctx);
2247    }
2248
2249    pub(super) fn advance_animations(&mut self, time: f64) -> bool {
2250        let selection_animating = self.selection_animation.advance(time);
2251        let hover_animating = self.hover_animation.advance(time);
2252        if !hover_animating
2253            && self.hovered.is_none()
2254            && self.hover_animation.value <= AnimatedScalar::EPSILON
2255        {
2256            self.hover_visual = None;
2257        }
2258        let press_animating = self.press_animation.advance(time);
2259        if !press_animating
2260            && self.pressed.is_none()
2261            && self.press_animation.value <= AnimatedScalar::EPSILON
2262        {
2263            self.press_visual = None;
2264        }
2265        let focus_animating = self.focus_animation.advance(time);
2266        selection_animating | hover_animating | press_animating | focus_animating
2267    }
2268
2269    pub(super) fn selected_panel(&self) -> Option<&sui_runtime::WidgetPod> {
2270        self.panels.as_slice().get(self.normalized_selected())
2271    }
2272
2273    pub(super) fn selected_panel_mut(&mut self) -> Option<&mut sui_runtime::WidgetPod> {
2274        let index = self.normalized_selected();
2275        self.panels.as_mut_slice().get_mut(index)
2276    }
2277
2278    pub(super) fn resolved_theme(&self) -> DefaultTheme {
2279        self.theme_reader
2280            .as_ref()
2281            .map(|theme| theme())
2282            .unwrap_or(*self.theme)
2283    }
2284
2285    pub(super) fn set_hovered(&mut self, hovered: Option<usize>, ctx: &mut EventCtx) {
2286        if self.hovered == hovered {
2287            return;
2288        }
2289        let theme = self.resolved_theme();
2290        self.hovered = hovered;
2291        if let Some(index) = hovered {
2292            self.hover_visual = Some(index);
2293            self.hover_animation = AnimatedScalar::new(0.0);
2294            set_hover_animation_target(&mut self.hover_animation, 1.0, &theme, ctx);
2295        } else if !set_hover_animation_target(&mut self.hover_animation, 0.0, &theme, ctx) {
2296            self.hover_visual = None;
2297        }
2298        ctx.request_paint();
2299        ctx.request_semantics();
2300    }
2301
2302    pub(super) fn set_pressed(&mut self, pressed: Option<usize>, ctx: &mut EventCtx) {
2303        if self.pressed == pressed {
2304            return;
2305        }
2306        let theme = self.resolved_theme();
2307        self.pressed = pressed;
2308        if let Some(index) = pressed {
2309            self.press_visual = Some(index);
2310            self.press_animation = AnimatedScalar::new(0.0);
2311            set_press_animation_target(&mut self.press_animation, 1.0, &theme, ctx);
2312        } else if !set_press_animation_target(&mut self.press_animation, 0.0, &theme, ctx) {
2313            self.press_visual = None;
2314        }
2315        ctx.request_paint();
2316        ctx.request_semantics();
2317    }
2318
2319    pub(super) fn hover_amount_for(&self, index: usize) -> f32 {
2320        if self.hover_visual == Some(index) {
2321            self.hover_animation.value
2322        } else {
2323            0.0
2324        }
2325    }
2326
2327    pub(super) fn press_amount_for(&self, index: usize) -> f32 {
2328        if self.press_visual == Some(index) {
2329            self.press_animation.value
2330        } else {
2331            0.0
2332        }
2333    }
2334}
2335
2336impl Widget for Tabs {
2337    fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
2338        match event {
2339            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Move => {
2340                self.set_hovered(self.tab_at(ctx.bounds(), pointer.position), ctx);
2341            }
2342            Event::Pointer(_pointer) if matches!(_pointer.kind, PointerEventKind::Leave) => {
2343                self.set_hovered(None, ctx);
2344            }
2345            Event::Pointer(pointer)
2346                if pointer.kind == PointerEventKind::Down
2347                    && pointer.button == Some(PointerButton::Primary)
2348                    && self.header_rect(ctx.bounds()).contains(pointer.position) =>
2349            {
2350                let hovered = self.tab_at(ctx.bounds(), pointer.position);
2351                self.set_hovered(hovered, ctx);
2352                self.set_pressed(hovered, ctx);
2353                ctx.request_focus();
2354                ctx.request_pointer_capture(pointer.pointer_id);
2355                ctx.set_handled();
2356            }
2357            Event::Pointer(pointer)
2358                if pointer.kind == PointerEventKind::Up
2359                    && pointer.button == Some(PointerButton::Primary) =>
2360            {
2361                if self.pressed.is_some() {
2362                    let hovered = self.tab_at(ctx.bounds(), pointer.position);
2363                    if let Some(index) = self
2364                        .pressed
2365                        .zip(hovered)
2366                        .filter(|(left, right)| left == right)
2367                        .map(|(index, _)| index)
2368                    {
2369                        self.select(index, ctx);
2370                        ctx.request_measure();
2371                    }
2372                    self.set_hovered(hovered, ctx);
2373                    self.set_pressed(None, ctx);
2374                    ctx.release_pointer_capture(pointer.pointer_id);
2375                    ctx.set_handled();
2376                }
2377            }
2378            Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
2379                if self.pressed.is_some() {
2380                    self.set_pressed(None, ctx);
2381                    self.set_hovered(None, ctx);
2382                    ctx.release_pointer_capture(pointer.pointer_id);
2383                    ctx.set_handled();
2384                }
2385            }
2386            Event::Keyboard(key) if ctx.is_focused() && key.state == KeyState::Pressed => {
2387                match key.key.as_str() {
2388                    "ArrowLeft" | "ArrowUp" => self.move_selection(-1, ctx),
2389                    "ArrowRight" | "ArrowDown" => self.move_selection(1, ctx),
2390                    "Home" => self.select(0, ctx),
2391                    "End" if !self.labels.is_empty() => self.select(self.labels.len() - 1, ctx),
2392                    _ => return,
2393                }
2394                ctx.request_measure();
2395                ctx.request_paint();
2396                ctx.request_semantics();
2397                ctx.set_handled();
2398            }
2399            Event::Wake(WakeEvent::AnimationFrame { time, .. }) => {
2400                if self.advance_animations(*time) {
2401                    ctx.request_animation_frame();
2402                }
2403                ctx.request_paint();
2404            }
2405            _ => {}
2406        }
2407    }
2408
2409    fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
2410        let theme = self.resolved_theme();
2411        let text_style = theme.text_style(theme.palette.text);
2412        let tab_padding = theme.metrics.tab_padding;
2413        self.label_measurements = self
2414            .labels
2415            .iter()
2416            .map(|label| measure_text(ctx, label, &text_style))
2417            .collect();
2418        self.widths = self
2419            .label_measurements
2420            .iter()
2421            .map(|measurement| {
2422                (measurement.width + tab_padding.left + tab_padding.right)
2423                    .max(theme.metrics.tab_min_width)
2424            })
2425            .collect();
2426
2427        let gap = self.resolved_gap();
2428        let header_width =
2429            self.widths.iter().sum::<f32>() + (gap * self.labels.len().saturating_sub(1) as f32);
2430        let available_width = if constraints.max.width.is_finite() {
2431            constraints.max.width.max(header_width)
2432        } else {
2433            header_width.max(320.0)
2434        };
2435        let header_height = self.header_height();
2436        let padding = theme.metrics.tab_panel_padding;
2437        let panel_gap = theme.metrics.tab_panel_gap;
2438
2439        let panel_constraints = Constraints::new(
2440            Size::ZERO,
2441            Size::new(
2442                (available_width - padding.left - padding.right).max(0.0),
2443                if constraints.max.height.is_finite() {
2444                    (constraints.max.height
2445                        - header_height
2446                        - panel_gap
2447                        - padding.top
2448                        - padding.bottom)
2449                        .max(0.0)
2450                } else {
2451                    f32::INFINITY
2452                },
2453            ),
2454        );
2455
2456        let panel_size = if let Some(panel) = self.selected_panel_mut() {
2457            panel.measure(ctx, panel_constraints)
2458        } else {
2459            Size::new(0.0, theme.metrics.min_height)
2460        };
2461
2462        let content_width = (panel_size.width + padding.left + padding.right).max(available_width);
2463        let content_height = panel_size.height + padding.top + padding.bottom;
2464        self.panel_frame = Rect::new(
2465            0.0,
2466            header_height + panel_gap,
2467            content_width,
2468            content_height,
2469        );
2470
2471        constraints.clamp(Size::new(
2472            content_width,
2473            header_height + panel_gap + content_height,
2474        ))
2475    }
2476
2477    fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
2478        let theme = self.resolved_theme();
2479        let header_height = self.header_height();
2480        let padding = theme.metrics.tab_panel_padding;
2481        let panel_gap = theme.metrics.tab_panel_gap;
2482        if let Some(panel) = self.selected_panel_mut() {
2483            let panel_size = panel.measured_size();
2484            panel.arrange(
2485                ctx,
2486                Rect::new(
2487                    bounds.x() + padding.left,
2488                    bounds.y() + header_height + panel_gap + padding.top,
2489                    panel_size.width,
2490                    panel_size.height,
2491                ),
2492            );
2493        }
2494    }
2495
2496    fn paint(&self, ctx: &mut PaintCtx) {
2497        let theme = self.resolved_theme();
2498        let palette = theme.palette;
2499        let metrics = theme.metrics;
2500        let interaction = theme.interaction;
2501        let tab_padding = metrics.tab_padding;
2502        let header = self.header_rect(ctx.bounds());
2503        let label_style = theme.text_style(palette.text_muted);
2504        let selected_label_style = theme.text_style(palette.text);
2505
2506        ctx.fill(
2507            rounded_rect_path(header, metrics.corner_radius),
2508            palette.control,
2509        );
2510
2511        let focus_progress = self.focus_animation.value;
2512        for (index, label) in self.labels.iter().enumerate() {
2513            let Some(rect) = self.tab_rect(ctx.bounds(), index) else {
2514                continue;
2515            };
2516            let selected = self.normalized_selected() == index;
2517            let hovered = self.hovered == Some(index);
2518            let pressed = self.pressed == Some(index);
2519            let hover_amount = self.hover_amount_for(index);
2520            let press_amount = self.press_amount_for(index);
2521
2522            if let Some((background, border)) = tab_state_visuals(
2523                &theme,
2524                selected,
2525                hovered,
2526                pressed,
2527                hover_amount,
2528                press_amount,
2529            ) {
2530                draw_control_shape(
2531                    ctx,
2532                    rect,
2533                    metrics.corner_radius,
2534                    physical_pixels(ctx, metrics.border_width),
2535                    background,
2536                    border,
2537                );
2538            }
2539
2540            if selected && focus_progress > AnimatedScalar::EPSILON {
2541                draw_focus_ring_frame(
2542                    ctx,
2543                    rect,
2544                    metrics.corner_radius,
2545                    metrics,
2546                    palette
2547                        .focus_ring
2548                        .with_alpha(palette.focus_ring.alpha * focus_progress),
2549                );
2550            }
2551
2552            let text_style = if selected {
2553                selected_label_style.clone()
2554            } else {
2555                label_style.clone()
2556            };
2557            let text_slot = inset_rect(rect, tab_padding);
2558            let pressed_offset = press_amount * interaction.pressed_offset;
2559            ctx.push_clip_rect(text_slot);
2560            paint_aligned_text(
2561                ctx,
2562                text_slot.translate(Vector::new(0.0, pressed_offset)),
2563                label,
2564                &text_style,
2565                text_style.line_height,
2566                0.5,
2567            );
2568            ctx.pop_clip();
2569        }
2570
2571        if let Some(accent) = tab_indicator_rect(
2572            |index| self.tab_rect(ctx.bounds(), index),
2573            self.selection_from,
2574            self.normalized_selected(),
2575            self.selection_animation.value,
2576            tab_padding,
2577            interaction.active_indicator_thickness,
2578        ) {
2579            ctx.fill(
2580                rounded_rect_path(accent, accent.height() * 0.5),
2581                palette.accent,
2582            );
2583        }
2584
2585        let content = self.panel_frame.translate(ctx.bounds().origin.to_vector());
2586        draw_control_frame(
2587            ctx,
2588            content,
2589            metrics.corner_radius + 2.0,
2590            metrics,
2591            palette.surface_raised,
2592            palette.border,
2593            None,
2594        );
2595        if let Some(panel) = self.selected_panel() {
2596            let panel_translation = tab_panel_transition_translation(
2597                self.selection_from,
2598                self.normalized_selected(),
2599                self.selection_animation.value,
2600                metrics,
2601            );
2602            if panel_translation == Vector::ZERO {
2603                panel.paint(ctx);
2604            } else {
2605                ctx.push_clip_rect(content);
2606                ctx.translate(panel_translation);
2607                panel.paint(ctx);
2608                ctx.pop_transform();
2609                ctx.pop_clip();
2610            }
2611        }
2612    }
2613
2614    fn semantics(&self, ctx: &mut SemanticsCtx) {
2615        let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Tabs, ctx.bounds());
2616        node.name = Some(self.name.clone());
2617        node.value = self
2618            .current_tab()
2619            .map(|value| SemanticsValue::Text(value.to_string()));
2620        node.state.focused = ctx.is_focused();
2621        node.actions = vec![SemanticsAction::Focus, SemanticsAction::SetValue];
2622        ctx.push(node);
2623        if let Some(panel) = self.selected_panel() {
2624            panel.semantics(ctx);
2625        }
2626    }
2627
2628    fn accepts_focus(&self) -> bool {
2629        true
2630    }
2631
2632    fn focus_changed(&mut self, ctx: &mut EventCtx, focused: bool) {
2633        let theme = self.resolved_theme();
2634        set_focus_animation_target(&mut self.focus_animation, focused as u8 as f32, &theme, ctx);
2635        ctx.request_paint();
2636        ctx.request_semantics();
2637    }
2638
2639    fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
2640        if let Some(panel) = self.selected_panel() {
2641            visitor.visit(panel);
2642        }
2643    }
2644
2645    fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
2646        if let Some(panel) = self.selected_panel_mut() {
2647            visitor.visit(panel);
2648        }
2649    }
2650}