tabs: add overflow popover for tabs that do not fit
This commit is contained in:
@@ -26,6 +26,8 @@ sidebar = [
|
||||
tabs = [
|
||||
"dep:gpui-native-core",
|
||||
"gpui-native-core/button",
|
||||
"gpui-native-core/popover",
|
||||
"gpui-native-core/scroll_area",
|
||||
"gpui-native-core/spinner",
|
||||
"gpui-native-core/tooltip",
|
||||
]
|
||||
|
||||
+321
-16
@@ -1,17 +1,21 @@
|
||||
use std::cell::RefCell;
|
||||
use std::collections::HashMap;
|
||||
use std::rc::Rc;
|
||||
|
||||
use gpui::prelude::FluentBuilder;
|
||||
use gpui::{
|
||||
AnyElement, App, Div, ElementId, InteractiveElement as _, IntoElement, KeyDownEvent,
|
||||
ParentElement as _, RenderOnce, Role, SharedString, Stateful, StatefulInteractiveElement as _,
|
||||
Styled as _, Window, div,
|
||||
AnyElement, App, Bounds, ClickEvent, Div, ElementId, Global, InteractiveElement as _,
|
||||
IntoElement, KeyDownEvent, ParentElement as _, Pixels, RenderOnce, Role, SharedString,
|
||||
Stateful, StatefulInteractiveElement as _, Styled as _, Window, canvas, div,
|
||||
};
|
||||
use gpui_native_core::button::{Button, ButtonVariant};
|
||||
use gpui_native_core::common::Sizable as _;
|
||||
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 _, Size};
|
||||
use gpui_native_theme::{ActiveTheme as _, POPUP_MAX_HEIGHT, Size};
|
||||
use gpui_native_utils::adjacent_selectable;
|
||||
|
||||
/// The change reporter, fired with the next selected tab by pointer and keys.
|
||||
@@ -21,6 +25,59 @@ type CloseHandler = Rc<dyn Fn(usize, &mut Window, &mut App)>;
|
||||
/// Decorates the rendered tab, e.g. to attach a drag payload.
|
||||
type TabWrap = Box<dyn FnOnce(Stateful<Div>) -> AnyElement>;
|
||||
type TabsFn = Box<dyn Fn(&mut Window, &mut App) -> Vec<Tab>>;
|
||||
/// The open-state reporter of the overflow popover.
|
||||
type OpenHandler = Rc<dyn Fn(bool, &mut Window, &mut App)>;
|
||||
/// 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<RefCell<Option<Bounds<Pixels>>>>;
|
||||
|
||||
/// 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<Pixels>,
|
||||
tabs: HashMap<String, TabMeasure>,
|
||||
}
|
||||
|
||||
/// The capture context handed to inline tabs, only in popover mode.
|
||||
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<MeasureKey, StripMeasure>,
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
/// The visual language of a [`Tabs`] strip.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
@@ -109,9 +166,12 @@ pub struct Tabs {
|
||||
selected: usize,
|
||||
variant: TabsVariant,
|
||||
overflow_scroll: bool,
|
||||
overflow_popover: bool,
|
||||
overflow_open: bool,
|
||||
a11y_label: Option<SharedString>,
|
||||
on_change: Option<ChangeHandler>,
|
||||
on_close: Option<CloseHandler>,
|
||||
on_overflow_open: Option<OpenHandler>,
|
||||
tabs: Option<TabsFn>,
|
||||
}
|
||||
|
||||
@@ -126,9 +186,12 @@ impl Tabs {
|
||||
selected: 0,
|
||||
variant: TabsVariant::default(),
|
||||
overflow_scroll: false,
|
||||
overflow_popover: false,
|
||||
overflow_open: false,
|
||||
a11y_label: None,
|
||||
on_change: None,
|
||||
on_close: None,
|
||||
on_overflow_open: None,
|
||||
tabs: None,
|
||||
}
|
||||
}
|
||||
@@ -151,6 +214,27 @@ impl Tabs {
|
||||
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
|
||||
}
|
||||
|
||||
/// Reports the overflow popover's next open state, from its trigger, dismissals, and selection.
|
||||
pub fn on_overflow_open<F>(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<F>(mut self, handler: F) -> Self
|
||||
where
|
||||
@@ -186,11 +270,110 @@ impl Tabs {
|
||||
self.a11y_label = Some(label.into());
|
||||
self
|
||||
}
|
||||
|
||||
/// The number of tabs that fit before the popover trigger, from last frame's geometry.
|
||||
fn inline_count(tabs: &[Tab], measure: &StripMeasure) -> usize {
|
||||
let limit = measure.container_width - measure.trigger_width.unwrap_or(Pixels::ZERO);
|
||||
let mut count = 0;
|
||||
for tab in tabs {
|
||||
let Some(entry) = measure.tabs.get(&tab.key.to_string()) else {
|
||||
return tabs.len();
|
||||
};
|
||||
if entry.left + entry.width > limit {
|
||||
break;
|
||||
}
|
||||
count += 1;
|
||||
}
|
||||
count
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn render_overflow_popover(
|
||||
id: &ElementId,
|
||||
overflow_tabs: Vec<Tab>,
|
||||
inline_count: usize,
|
||||
selected_index: usize,
|
||||
variant: TabsVariant,
|
||||
open: bool,
|
||||
on_change: Option<ChangeHandler>,
|
||||
on_close: Option<CloseHandler>,
|
||||
on_overflow_open: Option<OpenHandler>,
|
||||
focus: gpui::FocusHandle,
|
||||
) -> Popover {
|
||||
let id = id.clone();
|
||||
let trigger_id = id.clone();
|
||||
|
||||
let row_change: Option<ChangeHandler> = 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,
|
||||
};
|
||||
|
||||
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<AnyElement> = overflow_tabs
|
||||
.into_iter()
|
||||
.zip(inline_count..)
|
||||
.map(|(tab, index)| {
|
||||
tab.render_tab(
|
||||
&id,
|
||||
cx,
|
||||
index,
|
||||
selected_index,
|
||||
variant,
|
||||
&row_change,
|
||||
&on_close,
|
||||
&focus,
|
||||
None,
|
||||
)
|
||||
})
|
||||
.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()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl RenderOnce for Tabs {
|
||||
fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
|
||||
let tabs = match self.tabs {
|
||||
let mut tabs = match self.tabs {
|
||||
Some(build) => build(window, cx),
|
||||
None => Vec::new(),
|
||||
};
|
||||
@@ -210,6 +393,29 @@ impl RenderOnce for Tabs {
|
||||
.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::<TabsMeasurements>()
|
||||
.and_then(|cache| cache.strips.get(&measure_key).cloned())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let inline_count = measure
|
||||
.as_ref()
|
||||
.map(|measure| Self::inline_count(&tabs, measure))
|
||||
.unwrap_or(tabs.len());
|
||||
let overflow_tabs = tabs.split_off(inline_count);
|
||||
|
||||
let measure_frame = self.overflow_popover.then(|| MeasureFrame {
|
||||
key: measure_key.clone(),
|
||||
root_bounds: Rc::new(RefCell::new(None)),
|
||||
});
|
||||
|
||||
let strip: Vec<AnyElement> = tabs
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
@@ -223,10 +429,27 @@ impl RenderOnce for Tabs {
|
||||
&self.on_change,
|
||||
&self.on_close,
|
||||
&focus,
|
||||
measure_frame.as_ref(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
let popover = (self.overflow_popover && measure.is_some() && !overflow_tabs.is_empty())
|
||||
.then(|| {
|
||||
Self::render_overflow_popover(
|
||||
&self.id,
|
||||
overflow_tabs,
|
||||
inline_count,
|
||||
self.selected,
|
||||
self.variant,
|
||||
self.overflow_open,
|
||||
self.on_change.clone(),
|
||||
self.on_close.clone(),
|
||||
self.on_overflow_open.clone(),
|
||||
focus.clone(),
|
||||
)
|
||||
});
|
||||
|
||||
div()
|
||||
.id(self.id.clone())
|
||||
.flex()
|
||||
@@ -262,16 +485,72 @@ impl RenderOnce for Tabs {
|
||||
}
|
||||
TabsVariant::Pill => root.items_center().gap_1(),
|
||||
})
|
||||
.map(|root| match self.overflow_scroll {
|
||||
true => root.min_w_0().overflow_x_scroll().child(
|
||||
div()
|
||||
.flex_none()
|
||||
.flex()
|
||||
.gap_1()
|
||||
.when(self.variant == TabsVariant::Pill, |row| row.items_center())
|
||||
.children(strip),
|
||||
),
|
||||
false => root.children(strip),
|
||||
.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::<TabsMeasurements>()
|
||||
.record_container(&key, bounds.size.width);
|
||||
*root_bounds.borrow_mut() = Some(bounds);
|
||||
}
|
||||
},
|
||||
|_, _, _, _| {},
|
||||
)
|
||||
.absolute()
|
||||
.inset_0();
|
||||
let trigger_canvas = canvas(
|
||||
{
|
||||
let key = measure_key;
|
||||
move |bounds, _, cx| {
|
||||
cx.default_global::<TabsMeasurements>()
|
||||
.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()
|
||||
.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().child(
|
||||
div()
|
||||
.flex_none()
|
||||
.flex()
|
||||
.gap_1()
|
||||
.when(self.variant == TabsVariant::Pill, |row| row.items_center())
|
||||
.children(strip),
|
||||
)
|
||||
} else {
|
||||
root.children(strip)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -288,6 +567,7 @@ impl Tab {
|
||||
on_change: &Option<ChangeHandler>,
|
||||
on_close: &Option<CloseHandler>,
|
||||
focus: &gpui::FocusHandle,
|
||||
measure: Option<&MeasureFrame>,
|
||||
) -> AnyElement {
|
||||
let selected = index == selected_index;
|
||||
|
||||
@@ -368,6 +648,31 @@ impl Tab {
|
||||
)
|
||||
})
|
||||
.when_some(close, |strip_tab, close| strip_tab.child(close))
|
||||
.when_some(measure, |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::<TabsMeasurements>().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 on_change = on_change.clone();
|
||||
|
||||
Reference in New Issue
Block a user