Skip to main content

sui_widgets/composites/
navigation.rs

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