use std::cell::RefCell; use std::collections::HashMap; use std::rc::Rc; use gpui::prelude::FluentBuilder; use gpui::{ AnyElement, App, AppContext as _, Bounds, ClickEvent, Context, Div, ElementId, Global, InteractiveElement as _, IntoElement, KeyDownEvent, MouseButton, ParentElement as _, Pixels, Point, Render, RenderOnce, Role, SharedString, Stateful, StatefulInteractiveElement as _, StyleRefinement, Styled as _, Window, canvas, div, px, relative, }; use gpui_native_core::button::{Button, ButtonVariant}; use gpui_native_core::common::{Sizable as _, v_flex}; use gpui_native_core::popover::Popover; use gpui_native_core::scroll_area::{ScrollArea, ScrollAxes}; use gpui_native_core::spinner::Spinner; use gpui_native_core::tooltip::Tooltip; use gpui_native_icons::IconRole; use gpui_native_theme::{ActiveTheme as _, POPUP_MAX_HEIGHT, Size, TAB_INDICATOR_WIDTH}; use gpui_native_utils::{StyledExt as _, adjacent_selectable}; /// Reports the next selected tab by pointer and keys. type ChangeHandler = Rc; /// Reports the tab's index by its close control. type CloseHandler = Rc; /// Reports a tab moved from one index to another by a drag. type ReorderHandler = Rc; /// Decorates the rendered tab, e.g. to attach a drag payload. type TabWrap = Box) -> AnyElement>; type TabsFn = Box Vec>; /// The open-state reporter of the overflow popover. type OpenHandler = Rc; /// Identifies one strip's measurements across windows. type MeasureKey = (u64, String); /// Shared per-frame state that lets tab canvases read the strip's bounds. type RootBoundsCell = Rc>>>; /// One inline tab's geometry relative to the strip's left edge. #[derive(Clone, Copy, Default)] struct TabMeasure { left: Pixels, width: Pixels, } /// A strip's geometry captured the previous frame. #[derive(Clone, Default)] struct StripMeasure { container_width: Pixels, trigger_width: Option, tabs: HashMap, } /// The capture context handed to inline tabs, only in popover mode. #[derive(Clone)] struct MeasureFrame { key: MeasureKey, root_bounds: RootBoundsCell, } /// Measurements read a frame late, so strips render one frame behind a resize. #[derive(Default)] struct TabsMeasurements { strips: HashMap, } impl Global for TabsMeasurements {} impl TabsMeasurements { fn record_container(&mut self, key: &MeasureKey, width: Pixels) { self.strips.entry(key.clone()).or_default().container_width = width; } fn record_trigger(&mut self, key: &MeasureKey, width: Pixels) { self.strips.entry(key.clone()).or_default().trigger_width = Some(width); } fn record_tab(&mut self, key: &MeasureKey, tab: String, measure: TabMeasure) { self.strips .entry(key.clone()) .or_default() .tabs .insert(tab, measure); } } /// Everything a tab needs to draw and interact, shared across a strip's slots. #[derive(Clone)] struct StripCtx { id: ElementId, selected: usize, variant: TabsVariant, on_change: Option, on_close: Option, on_reorder: Option, focus: gpui::FocusHandle, measure: Option, /// Whether tabs drag onto each other to reorder; requires `on_reorder`. draggable: bool, /// The tab drag gesture's live state, for the drop indicator. drop_at: gpui::Entity, } impl StripCtx { /// The context for tabs drawn inside a popover: no measurement, no dragging. fn for_popover(&self) -> Self { Self { measure: None, draggable: false, ..self.clone() } } } /// The index the tab at `from` occupies once dropped before the tab at `onto`, /// or `None` when the drop is a no-op. fn reorder_target(from: usize, onto: usize) -> Option { match from.cmp(&onto) { std::cmp::Ordering::Equal => None, std::cmp::Ordering::Less => Some(onto - 1), std::cmp::Ordering::Greater => Some(onto), } } /// Displacement before a tab drag locks to an axis: horizontal reorders, /// vertical cancels the reorder, like a browser tab strip. const TAB_DRAG_AXIS_LOCK: Pixels = px(6.0); /// One tab drag gesture's live state. #[derive(Clone, Copy, Default, PartialEq)] struct TabDrop { /// The tab the drag currently hovers, for the drop indicator. onto: Option, /// Where the drag's first move landed, anchoring the axis lock. origin: Option>, /// Whether the gesture locked as a horizontal (`Some(true)`) or vertical /// (`Some(false)`) drag; `None` until it moved [`TAB_DRAG_AXIS_LOCK`]. horizontal: Option, } impl TabDrop { /// Whether the gesture locked as a vertical drag, canceling the reorder. fn canceled(&self) -> bool { self.horizontal == Some(false) } } /// One slot of a strip: a lone tab, or same-kind tabs collapsed into a group chip. enum StripItem { /// A tab outside any two-member kind group, at its original index. Single(usize, Tab), /// Tabs of one kind collapsed into a chip, at the first member's index. Group { kind: SharedString, /// The collapsed tabs with their original indices. members: Vec<(usize, Tab)>, }, } impl StripItem { /// The key the strip's geometry records the item under. fn measure_key(&self, tabs_id: &ElementId) -> String { match self { StripItem::Single(_, tab) => tab.key.to_string(), StripItem::Group { kind, .. } => group_key(tabs_id, kind).to_string(), } } } /// The group chip's identity for one strip and kind. fn group_key(tabs_id: &ElementId, kind: &SharedString) -> ElementId { SharedString::from(format!("{tabs_id}-tabs-group-{kind}")).into() } /// The payload dragged when reordering a tab. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct TabDrag { /// The dragged tab's index into the `tabs` vec. pub index: usize, } /// The floating pill that follows the cursor while a tab is dragged. struct TabDragPreview { label: SharedString, } impl Render for TabDragPreview { fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { let theme = cx.theme(); div() .px_2() .py_1() .rounded(theme.radius.control) .border_1() .border_color(theme.colors.border) .bg(theme.colors.background) .text_size(theme.sizes.medium.text_size) .text_color(theme.colors.foreground) .shadow(theme.elevations.control.shadows()) .child(self.label.clone()) } } /// The visual language of a [`Tabs`] strip. #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] pub enum TabsVariant { #[default] Underline, Pill, } /// One tab of a [`Tabs`] strip. #[must_use] pub struct Tab { /// The stable identity for element state; must survive reordering. key: ElementId, label: SharedString, lead: Option, busy: bool, disabled: bool, closeable: bool, pinned: bool, kind: Option, wrap: Option, } impl Tab { /// Creates a tab shown as `label`, identified by `key`. pub fn new(key: K, label: L) -> Self where K: Into, L: Into, { Self { key: key.into(), label: label.into(), lead: None, busy: false, disabled: false, closeable: false, pinned: false, kind: None, wrap: None, } } /// Sets the leading element, e.g. an icon or an avatar. pub fn lead(mut self, lead: E) -> Self where E: IntoElement + 'static, { self.lead = Some(lead.into_any_element()); self } /// Shows the loading slot. pub fn busy(mut self, busy: bool) -> Self { self.busy = busy; self } /// Renders the tab dimmed; clicks and keyboard skip it. pub fn disabled(mut self, disabled: bool) -> Self { self.disabled = disabled; self } /// Shows a close control that reports the tab through [`Tabs::on_close`]. pub fn closeable(mut self, closeable: bool) -> Self { self.closeable = closeable; self } /// Draws the tab with the active treatment at all times, selected or not. pub fn pinned(mut self, pinned: bool) -> Self { self.pinned = pinned; self } /// Sets the kind the tab belongs to; same-kind tabs collapse into one group. pub fn kind(mut self, kind: K) -> Self where K: Into, { self.kind = Some(kind.into()); self } /// Hands the rendered tab through `wrap`, e.g. to attach a drag payload. pub fn wrap(mut self, wrap: F) -> Self where F: FnOnce(Stateful
) -> AnyElement + 'static, { self.wrap = Some(Box::new(wrap)); self } } // Tab is a data builder, not an element, adopt the combinators explicitly. impl FluentBuilder for Tab {} /// A tab strip. #[derive(IntoElement)] #[must_use] pub struct Tabs { id: ElementId, selected: usize, variant: TabsVariant, overflow_scroll: bool, overflow_popover: bool, overflow_open: bool, draggable: bool, a11y_label: Option, on_change: Option, on_close: Option, on_reorder: Option, on_overflow_open: Option, tabs: Option, style: StyleRefinement, } impl Tabs { /// Creates a strip selecting the first tab. pub fn new(id: I) -> Self where I: Into, { Self { id: id.into(), selected: 0, variant: TabsVariant::default(), overflow_scroll: false, overflow_popover: false, overflow_open: false, draggable: false, a11y_label: None, on_change: None, on_close: None, on_reorder: None, on_overflow_open: None, tabs: None, style: StyleRefinement::default(), } } /// Sets the current selection, as an index into the `tabs` vec — not a tab key. pub fn selected(mut self, selected: usize) -> Self { self.selected = selected; self } /// Sets the strip's visual language. pub fn variant(mut self, variant: TabsVariant) -> Self { self.variant = variant; self } /// Scrolls the strip horizontally when the tabs overflow. pub fn overflow_scroll(mut self, overflow_scroll: bool) -> Self { self.overflow_scroll = overflow_scroll; self } /// Shows a popover of the tabs that do not fit, via a trigger at the strip's end. pub fn overflow_popover(mut self, overflow_popover: bool) -> Self { self.overflow_popover = overflow_popover; self } /// The overflow popover's current open state; read only in [`Self::overflow_popover`] mode. pub fn overflow_open(mut self, overflow_open: bool) -> Self { self.overflow_open = overflow_open; self } /// Lets tabs be dragged onto each other to reorder them. pub fn draggable(mut self, draggable: bool) -> Self { self.draggable = draggable; self } /// Reports the overflow popover's next open state, from its trigger, dismissals, and selection. pub fn on_overflow_open(mut self, handler: F) -> Self where F: Fn(bool, &mut Window, &mut App) + 'static, { self.on_overflow_open = Some(Rc::new(handler)); self } /// Reports the next selected tab, as an index into the `tabs` vec — not a tab key; indices shift on reorder. pub fn on_change(mut self, handler: F) -> Self where F: Fn(usize, &mut Window, &mut App) + 'static, { self.on_change = Some(Rc::new(handler)); self } /// Reports a closed tab, as an index into the `tabs` vec — not a tab key; indices shift on reorder. pub fn on_close(mut self, handler: F) -> Self where F: Fn(usize, &mut Window, &mut App) + 'static, { self.on_close = Some(Rc::new(handler)); self } /// Reports a tab moved by a drag. pub fn on_reorder(mut self, handler: F) -> Self where F: Fn(usize, usize, &mut Window, &mut App) + 'static, { self.on_reorder = Some(Rc::new(handler)); self } /// Sets the tabs; the closure runs during render and must not mutate entities or notify. pub fn tabs(mut self, tabs: F) -> Self where F: Fn(&mut Window, &mut App) -> Vec + 'static, { self.tabs = Some(Box::new(tabs)); self } /// Overrides the accessibility label, which defaults to the id. pub fn accessibility_label(mut self, label: L) -> Self where L: Into, { self.a11y_label = Some(label.into()); self } /// The number of items that fit before the popover trigger, from last frame's geometry. fn inline_count(tabs_id: &ElementId, items: &[StripItem], measure: &StripMeasure) -> usize { let limit = measure.container_width - measure.trigger_width.unwrap_or(Pixels::ZERO); let mut count = 0; for item in items { let Some(entry) = measure.tabs.get(&item.measure_key(tabs_id)) else { return items.len(); }; if entry.left + entry.width > limit { break; } count += 1; } count } fn render_overflow_popover( ctx: &StripCtx, overflow_items: Vec, open: bool, on_overflow_open: Option, ) -> Popover { let id = ctx.id.clone(); let trigger_id = id.clone(); let on_change = ctx.on_change.clone(); let row_change: Option = match (on_change, on_overflow_open.clone()) { (Some(on_change), Some(dismiss)) => Some(Rc::new(move |index, window, cx| { on_change(index, window, cx); dismiss(false, window, cx); })), (None, Some(dismiss)) => Some(Rc::new(move |_, window, cx| { dismiss(false, window, cx); })), (on_change, None) => on_change, }; let row_ctx = StripCtx { on_change: row_change, ..ctx.for_popover() }; Popover::new((id.clone(), "tabs-overflow")) .open(open) .on_change({ let on_overflow_open = on_overflow_open.clone(); move |next, window, cx| { if let Some(on_overflow_open) = &on_overflow_open { on_overflow_open(next, window, cx); } } }) .trigger(move |_, _| { Button::new((trigger_id.clone(), "tabs-overflow-trigger")) .icon(IconRole::More) .variant(ButtonVariant::Ghost) .small() .accessibility_label("More tabs") .on_click({ let on_overflow_open = on_overflow_open.clone(); move |event, window, cx| { // Pointer clicks toggle inside Popover; only the keyboard path lands here. if let ClickEvent::Keyboard(_) = event && let Some(on_overflow_open) = &on_overflow_open { on_overflow_open(!open, window, cx); } } }) .into_any_element() }) .content(move |_, cx| { let rows: Vec = overflow_items .into_iter() .flat_map(|item| match item { StripItem::Single(index, tab) => { vec![tab.render_tab(&row_ctx, cx, index)] } // A group that ran out of room lists its members inline. StripItem::Group { members, .. } => members .into_iter() .map(|(index, tab)| tab.render_tab(&row_ctx, cx, index)) .collect::>(), }) .collect(); ScrollArea::new((id.clone(), "tabs-overflow-list")) .axes(ScrollAxes::Vertical) .max_h(POPUP_MAX_HEIGHT) .child(v_flex().gap_0p5().p_1().children(rows)) .into_any_element() }) } /// Collapses same-kind tabs (two or more) into group chips, keeping strip order. fn group_by_kind(tabs: Vec) -> Vec { let mut counts: HashMap = HashMap::new(); for tab in &tabs { if let Some(kind) = &tab.kind { *counts.entry(kind.clone()).or_default() += 1; } } let mut items: Vec = Vec::new(); let mut group_slots: HashMap = HashMap::new(); for (index, tab) in tabs.into_iter().enumerate() { let grouped_kind = tab .kind .clone() .filter(|kind| counts.get(kind).copied().unwrap_or(0) >= 2); match grouped_kind { Some(kind) => match group_slots.get(&kind).copied() { Some(slot) => { if let StripItem::Group { members, .. } = &mut items[slot] { members.push((index, tab)); } } None => { group_slots.insert(kind.clone(), items.len()); items.push(StripItem::Group { kind, members: vec![(index, tab)], }); } }, None => items.push(StripItem::Single(index, tab)), } } items } /// Renders a group chip labeled with the kind and its member count. fn render_group_tab( ctx: &StripCtx, kind: SharedString, members: Vec<(usize, Tab)>, window: &mut Window, cx: &mut App, ) -> AnyElement { let tabs_id = ctx.id.clone(); let count = members.len(); let selected = members.iter().any(|(index, _)| *index == ctx.selected); // A pinned member keeps the chip in the active treatment, selected or not. let active = selected || members.iter().any(|(_, tab)| tab.pinned); let open = window .use_keyed_state((group_key(&tabs_id, &kind), "open"), cx, |_, _| false) .clone(); let theme = cx.theme(); let metrics = theme.sizes.resolve(Size::default()); let small = theme.sizes.small; let label_color = match ctx.variant { TabsVariant::Underline => { if active { theme.ramps.primary.base } else { theme.colors.foreground } } TabsVariant::Pill => theme.colors.foreground, }; let group_key = group_key(&tabs_id, &kind); let chip = div() .id((group_key.clone(), "group-tab")) .debug_selector({ let tabs_id = tabs_id.clone(); let label = kind.clone(); move || format!("{tabs_id}-group-{label}") }) .flex() .items_center() .gap_2() .cursor_pointer() .role(Role::Tab) .aria_selected(selected) .aria_label(SharedString::from(format!("{kind}, {count} tabs"))) .text_color(label_color) .when(!active, |chip| { chip.hover(|chip| chip.bg(theme.colors.muted)) }) .map(|chip| match ctx.variant { TabsVariant::Underline => chip .px_2() .py_1() .rounded_tl(theme.radius.sm) .rounded_tr(theme.radius.sm) .border_b(TAB_INDICATOR_WIDTH) .border_color(gpui::transparent_black()) .when(active, |chip| chip.border_color(theme.ramps.primary.base)), TabsVariant::Pill => chip .h(small.control_height + metrics.plate_inset * 2.0) .px(metrics.dense_padding_x) .pr(metrics.plate_inset) .rounded(theme.radius.control) .when(active, |chip| { chip.bg(theme.colors.background) .shadow(theme.elevations.control.shadows()) }), }) .child(SharedString::from(format!("{kind} ({count})"))) .when(ctx.variant == TabsVariant::Pill, |chip| { chip.child(div().flex_none().w(metrics.padding_x * 1.5)) }) .when_some(ctx.measure.clone(), |chip, measure| { let key = measure.key.clone(); let root_bounds = measure.root_bounds.clone(); let item_key = group_key.to_string(); chip.child( canvas( move |bounds, _, cx| { let root = root_bounds.borrow(); if let Some(root) = root.as_ref() { cx.default_global::().record_tab( &key, item_key, TabMeasure { left: bounds.origin.x - root.origin.x, width: bounds.size.width, }, ); } }, |_, _, _, _| {}, ) .absolute() .inset_0(), ) }); // Selecting a row also dismisses the popover, mirroring the overflow popover. let row_change: Option = { let open = open.clone(); let on_change = ctx.on_change.clone(); Some(Rc::new(move |index, window, cx| { open.update(cx, |open, cx| { *open = false; cx.notify(); }); if let Some(on_change) = &on_change { on_change(index, window, cx); } })) }; let row_ctx = StripCtx { on_change: row_change, ..ctx.for_popover() }; Popover::new((group_key.clone(), "group-popover")) .open(*open.read(cx)) .on_change({ let open = open.clone(); move |next, _, cx| { open.update(cx, |open, cx| { *open = next; cx.notify(); }); } }) .trigger(move |_, _| chip.into_any_element()) .content(move |_, cx| { let rows: Vec = members .into_iter() .map(|(index, tab)| tab.render_tab(&row_ctx, cx, index)) .collect(); ScrollArea::new((group_key.clone(), "tabs-group-list")) .axes(ScrollAxes::Vertical) .max_h(POPUP_MAX_HEIGHT) .child(v_flex().gap_0p5().p_1().children(rows)) .into_any_element() }) .into_any_element() } } impl gpui::Styled for Tabs { fn style(&mut self) -> &mut StyleRefinement { &mut self.style } } impl RenderOnce for Tabs { fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement { let tabs = match self.tabs { Some(build) => build(window, cx), None => Vec::new(), }; let mut items = Self::group_by_kind(tabs); let selectable: Vec = items .iter() .flat_map(|item| match item { StripItem::Single(index, tab) => (!tab.disabled) .then_some(*index) .into_iter() .collect::>(), StripItem::Group { members, .. } => members .iter() .filter(|(_, tab)| !tab.disabled) .map(|(index, _)| *index) .collect::>(), }) .collect(); let focus = gpui_native_utils::focus_handle(&self.id, window, cx); // Theme reads end here, so the strip's group chips can take `cx` mutably. let (medium_text_size, border_color, shadow_bleed) = { let theme = cx.theme(); let shadow_bleed = match self.variant { TabsVariant::Pill => theme.elevations.control.bleed(), TabsVariant::Underline => Pixels::ZERO, }; ( theme.sizes.medium.text_size, theme.colors.border, shadow_bleed, ) }; let label = self .a11y_label .clone() .unwrap_or_else(|| SharedString::from(self.id.to_string())); let measure_key: MeasureKey = ( window.window_handle().window_id().as_u64(), self.id.to_string(), ); let measure = if self.overflow_popover { cx.try_global::() .and_then(|cache| cache.strips.get(&measure_key).cloned()) } else { None }; let inline_count = measure .as_ref() .map(|measure| Self::inline_count(&self.id, &items, measure)) .unwrap_or(items.len()); let overflow_items = items.split_off(inline_count); let measure_frame = self.overflow_popover.then(|| MeasureFrame { key: measure_key.clone(), root_bounds: Rc::new(RefCell::new(None)), }); let drop_at = window .use_keyed_state((self.id.clone(), "tab-drop"), cx, |_, _| TabDrop::default()) .clone(); let ctx = StripCtx { id: self.id.clone(), selected: self.selected, variant: self.variant, on_change: self.on_change.clone(), on_close: self.on_close.clone(), on_reorder: self.on_reorder.clone(), focus: focus.clone(), measure: measure_frame.clone(), draggable: self.draggable && self.on_reorder.is_some(), drop_at, }; let strip: Vec = items .into_iter() .map(|item| match item { StripItem::Single(index, tab) => tab.render_tab(&ctx, cx, index), StripItem::Group { kind, members } => { Self::render_group_tab(&ctx, kind, members, window, cx) } }) .collect(); let popover = (self.overflow_popover && measure.is_some() && !overflow_items.is_empty()) .then(|| { Self::render_overflow_popover( &ctx, overflow_items, self.overflow_open, self.on_overflow_open.clone(), ) }); div() .id(self.id.clone()) .flex() .text_size(medium_text_size) .refine_style(&self.style) .track_focus(&focus) .focusable() .tab_stop(true) .role(Role::TabList) .aria_label(label) .on_key_down({ let selected = self.selected; let on_change = self.on_change.clone(); move |event: &KeyDownEvent, window, cx| { let target = match event.keystroke.key.as_str() { "right" => adjacent_selectable(&selectable, Some(selected), true), "left" => adjacent_selectable(&selectable, Some(selected), false), "home" => selectable.first().copied(), "end" => selectable.last().copied(), _ => return, }; if let Some(next) = target && next != selected && let Some(on_change) = &on_change { on_change(next, window, cx); } cx.stop_propagation(); } }) .when(ctx.draggable, |root| { root.on_drag_move::({ let drop_at = ctx.drop_at.clone(); move |event, _, cx| { let position = event.event.position; let outside = !event.bounds.contains(&position); drop_at.update(cx, |drop, cx| { let origin = drop.origin.get_or_insert(position); if drop.horizontal.is_none() { let dx = (position.x - origin.x).abs(); let dy = (position.y - origin.y).abs(); if dx.max(dy) > TAB_DRAG_AXIS_LOCK { drop.horizontal = Some(dx >= dy); } } if (outside || drop.canceled()) && drop.onto.is_some() { drop.onto = None; cx.notify(); } }); } }) // A drop over the strip's gaps lands on the last hovered slot. .on_drop::({ let drop_at = ctx.drop_at.clone(); let on_reorder = ctx.on_reorder.clone(); move |drag, window, cx| { let onto = drop_at.read(cx).onto; let canceled = drop_at.read(cx).canceled(); drop_at.update(cx, |drop, cx| { if drop.onto.is_some() { drop.onto = None; cx.notify(); } }); if let (Some(onto), Some(on_reorder)) = (onto, on_reorder.as_ref()) && !canceled && let Some(to) = reorder_target(drag.index, onto) { on_reorder(drag.index, to, window, cx); } } }) }) .map(|root| match self.variant { TabsVariant::Underline => root.gap_1().border_b_1().border_color(border_color), TabsVariant::Pill => root.items_center().gap_1(), }) .map(|root| { if self.overflow_popover { let Some(root_bounds) = measure_frame.map(|frame| frame.root_bounds) else { return root.children(strip); }; let container_canvas = canvas( { let key = measure_key.clone(); move |bounds, _, cx| { cx.default_global::() .record_container(&key, bounds.size.width); *root_bounds.borrow_mut() = Some(bounds); } }, |_, _, _, _| {}, ) .absolute() .inset(shadow_bleed); let trigger_canvas = canvas( { let key = measure_key; move |bounds, _, cx| { cx.default_global::() .record_trigger(&key, bounds.size.width); } }, |_, _, _, _| {}, ) .absolute() .inset_0(); let control = match popover { Some(popover) => div().flex_none().relative().child(popover), None => div().flex_none().relative().child( div().w(measure .as_ref() .and_then(|measure| measure.trigger_width) .unwrap_or(Pixels::ZERO)), ), }; root.min_w_0() .flex_grow(1.0) .overflow_hidden() .p(shadow_bleed) .m(-shadow_bleed) .child(container_canvas) .child( div() .flex_none() .flex() .gap_1() .when(self.variant == TabsVariant::Pill, |row| row.items_center()) .children(strip), ) .child(control.child(trigger_canvas)) } else if self.overflow_scroll { root.min_w_0() .overflow_x_scroll() .p(shadow_bleed) .m(-shadow_bleed) .child( div() .flex_none() .flex() .gap_1() .when(self.variant == TabsVariant::Pill, |row| row.items_center()) .children(strip), ) } else { root.children(strip) } }) } } impl Tab { fn render_tab(mut self, ctx: &StripCtx, cx: &App, index: usize) -> AnyElement { let selected = index == ctx.selected; // A pinned tab always wears the active treatment, selected or not. let active = selected || self.pinned; let theme = cx.theme(); let metrics = theme.sizes.resolve(Size::default()); let small = theme.sizes.small; let label_color = match ctx.variant { TabsVariant::Underline => { if self.disabled { theme.colors.muted_foreground } else if active { theme.ramps.primary.base } else { theme.colors.foreground } } TabsVariant::Pill => { if self.disabled { theme.colors.muted_foreground } else { theme.colors.foreground } } }; let close = (self.closeable && ctx.on_close.is_some() && !self.disabled) .then(|| self.render_tab_close(&ctx.id, index, &ctx.on_close)); let strip_tab = div() .id((self.key.clone(), "tab")) .debug_selector({ let tabs_id = ctx.id.clone(); let label = self.label.clone(); move || format!("{tabs_id}-tab-{}", label) }) .flex() .items_center() .gap_2() .role(Role::Tab) .aria_selected(selected) .text_color(label_color) .line_height(relative(1.0)) .when(!self.disabled && !active, |strip_tab| { strip_tab.hover(|strip_tab| strip_tab.bg(theme.colors.muted)) }) .map(|strip_tab| match ctx.variant { TabsVariant::Underline => strip_tab .px_2() .py_1() .rounded_tl(theme.radius.sm) .rounded_tr(theme.radius.sm) .border_b(TAB_INDICATOR_WIDTH) .border_color(gpui::transparent_black()) .when(active, |strip_tab| { strip_tab.border_color(theme.ramps.primary.base) }), TabsVariant::Pill => strip_tab .h(small.control_height + metrics.plate_inset * 2.0) .px(metrics.dense_padding_x) .pr(metrics.plate_inset) .rounded(theme.radius.control) .when(active, |strip_tab| { strip_tab .bg(theme.colors.background) .shadow(theme.elevations.control.shadows()) }), }) .when_some(self.lead.take(), |strip_tab, lead| strip_tab.child(lead)) .child(div().flex_grow(1.0).child(self.label.clone())) .when(ctx.variant == TabsVariant::Pill, |strip_tab| { strip_tab.child(div().flex_none().w(metrics.padding_x * 1.5)) }) .when(self.busy && !self.disabled, |strip_tab| { strip_tab.child( Spinner::new((self.key.clone(), "tab-busy")) .small() .accessibility_label("Loading"), ) }) .when_some(close, |strip_tab, close| strip_tab.child(close)) .when( { let drop = ctx.drop_at.read(cx); drop.onto == Some(index) && !drop.canceled() }, |strip_tab| { strip_tab.child( div() .absolute() .left_0() .top(TAB_INDICATOR_WIDTH) .bottom(TAB_INDICATOR_WIDTH) .w(TAB_INDICATOR_WIDTH) .rounded(theme.radius.sm) .bg(theme.ramps.primary.base), ) }, ) .when_some(ctx.measure.clone(), |strip_tab, measure| { let key = measure.key.clone(); let root_bounds = measure.root_bounds.clone(); let tab_key = self.key.to_string(); strip_tab.child( canvas( move |bounds, _, cx| { let root = root_bounds.borrow(); if let Some(root) = root.as_ref() { cx.default_global::().record_tab( &key, tab_key, TabMeasure { left: bounds.origin.x - root.origin.x, width: bounds.size.width, }, ); } }, |_, _, _, _| {}, ) .absolute() .inset_0(), ) }) .when(!self.disabled, |strip_tab| { strip_tab.cursor_pointer().on_click({ let selected = ctx.selected; let on_change = ctx.on_change.clone(); let focus = ctx.focus.clone(); move |_, window, cx| { window.focus(&focus, cx); if index != selected && let Some(on_change) = &on_change { on_change(index, window, cx); } } }) }) .when(ctx.draggable && !self.disabled, |strip_tab| { strip_tab .on_mouse_down(MouseButton::Left, { let drop_at = ctx.drop_at.clone(); move |event, _, cx| { cx.stop_propagation(); drop_at.update(cx, |drop, cx| { let fresh = TabDrop { origin: Some(event.position), ..TabDrop::default() }; if *drop != fresh { *drop = fresh; cx.notify(); } }); } }) .on_drag(TabDrag { index }, { let label = self.label.clone(); move |_, _, _, cx| { cx.new(|_| TabDragPreview { label: label.clone(), }) } }) .drag_over::({ let drop_at = ctx.drop_at.clone(); move |style, drag, _, cx| { let drop = *drop_at.read(cx); let hovered = drag.index != index && !drop.canceled(); drop_at.update(cx, |drop, cx| match (hovered, drop.onto) { (true, current) if current != Some(index) => { drop.onto = Some(index); cx.notify(); } (false, Some(_)) => { drop.onto = None; cx.notify(); } _ => {} }); style } }) .on_drop::({ let on_reorder = ctx.on_reorder.clone(); let drop_at = ctx.drop_at.clone(); move |drag, window, cx| { let canceled = drop_at.read(cx).canceled(); drop_at.update(cx, |drop, cx| { if drop.onto.is_some() { drop.onto = None; cx.notify(); } }); let target = (!canceled) .then(|| reorder_target(drag.index, index)) .flatten(); if let (Some(to), Some(on_reorder)) = (target, on_reorder.as_ref()) { on_reorder(drag.index, to, window, cx); } } }) }); match self.wrap { Some(wrap) => wrap(strip_tab), None => strip_tab.into_any_element(), } } fn render_tab_close( &self, tabs_id: &ElementId, index: usize, on_close: &Option, ) -> AnyElement { Button::new((self.key.clone(), "tab-close")) .icon(IconRole::Close) .variant(ButtonVariant::Ghost) .xsmall() .tab_stop(false) .debug_selector({ let tabs_id = tabs_id.clone(); let label = self.label.clone(); move || format!("{tabs_id}-close-{}", label) }) .tooltip(Tooltip::text("Close")) .accessibility_label(SharedString::from(format!("Close {}", self.label))) .on_click({ let on_close = on_close.clone(); move |_, window, cx| { cx.stop_propagation(); if let Some(on_close) = &on_close { on_close(index, window, cx); } } }) .into_any_element() } }