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