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#[derive(Clone, Debug, PartialEq, Eq)]
61pub struct TabBarItem {
62 pub(super) label: String,
63 pub(super) icon: Option<ImageHandle>,
64}
65
66impl TabBarItem {
67 pub fn new(label: impl Into<String>) -> Self {
69 Self {
70 label: label.into(),
71 icon: None,
72 }
73 }
74
75 pub fn icon(mut self, icon: ImageHandle) -> Self {
78 self.icon = Some(icon);
79 self
80 }
81
82 pub fn label(&self) -> &str {
84 &self.label
85 }
86
87 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 pub fn enabled(mut self, enabled: bool) -> Self {
178 self.enabled.set(enabled);
179 self
180 }
181
182 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 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 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 pub fn item(mut self, item: impl Into<TabBarItem>) -> Self {
232 self.tabs.push(item.into());
233 self
234 }
235
236 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 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 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 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 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 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 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 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#[derive(Debug, Clone)]
845pub(super) struct ClosingTab {
846 index: usize,
848 label: String,
849 width: f32,
850 presence: Motion<f32>,
851 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 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 pub fn max_tab_width(mut self, width: f32) -> Self {
952 self.max_tab_width = width.max(0.0);
953 self
954 }
955
956 pub fn text_overflow(mut self, text_overflow: TextOverflow) -> Self {
959 self.text_overflow = text_overflow;
960 self
961 }
962
963 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 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 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 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 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 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 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
1613fn 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
1651fn 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 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 pub fn text_overflow(mut self, text_overflow: TextOverflow) -> Self {
1800 self.text_overflow = text_overflow;
1801 self
1802 }
1803
1804 pub fn enabled(mut self, enabled: bool) -> Self {
1808 self.enabled.set(enabled);
1809 self
1810 }
1811
1812 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 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 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 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 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 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 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 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 pub fn enabled(mut self, enabled: bool) -> Self {
2433 self.enabled.set(enabled);
2434 self
2435 }
2436
2437 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 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 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 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 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 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 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 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 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 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 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}