Struct TabBar 

pub struct TabBar<T: 'static> { /* private fields */ }

A reactive header strip that pulls its tab list from a data source and writes the active tab into a shared Signal<Option<TabId>>.

Selection is id-based: the bar holds a stable TabId per item (extracted via the id_of closure passed to the constructor) and the public selected_id signal is the source of truth across reorders / removals / locale changes. Internal index-based work (keyboard nav, scroll-to-active, click activation) reads a private selected_index signal that the bar keeps in bidirectional sync with selected_id at build time.

Implementations

impl<T: 'static> TabBar<T>

pub fn horizontal( model: ListModel<T>, delegate: TabDelegate<T>, selected_id: Signal<Option<TabId>>, id_of: impl Fn(usize, &T) -> TabId + 'static, ) -> Self

Construct a horizontal tab bar from a ListModel<T>. Default sizing is TabSizing::Shared.

selected_id is the id-based selection signal — written by the bar on click / keyboard / drag-drop and observable by callers. id_of(index, &item) extracts the stable TabId from each model item.

pub fn horizontal_from_source<S: ListDataSource<Item = T>>( source: S, delegate: TabDelegate<T>, selected_id: Signal<Option<TabId>>, id_of: impl Fn(usize, &T) -> TabId + 'static, ) -> Self

Construct a horizontal tab bar from any ListDataSource. Default sizing is TabSizing::Shared.

pub fn vertical( model: ListModel<T>, delegate: TabDelegate<T>, selected_id: Signal<Option<TabId>>, id_of: impl Fn(usize, &T) -> TabId + 'static, ) -> Self

Construct a vertical tab bar from a ListModel<T>. Tabs stack top-to-bottom as horizontal pills (icon + label + close button arranged left-to-right within each pill). Default sizing is TabSizing::Shared — uniform pill heights.

pub fn vertical_from_source<S: ListDataSource<Item = T>>( source: S, delegate: TabDelegate<T>, selected_id: Signal<Option<TabId>>, id_of: impl Fn(usize, &T) -> TabId + 'static, ) -> Self

Construct a vertical tab bar from any ListDataSource.

pub fn tab_sizing(self, mode: TabSizing) -> Self

Override the per-tab sizing strategy. See TabSizing.

pub fn tab_display(self, mode: TabDisplayMode) -> Self

Choose what every tab shows — icon, label, or both. See TabDisplayMode. Default TabDisplayMode::Auto (render each tab as its TabInfo declares).

pub fn min_tab_width(self, dp: f32) -> Self

Minimum width (in dp) any unpinned tab will be drawn at. Default: DEFAULT_MIN_TAB_WIDTH.

In horizontal orientation this clamps the per-tab width. In vertical orientation every tab is forced to the bar’s cross-axis width, so the same knob defines the bar’s minimum width — the sidebar adapts to the widest piece of bar content (tab labels or a slot widget) and never shrinks below this floor. Vertical pill heights stay at theme.components.tab.editor_tab_height regardless of this knob.

Under TabSizing::Fill a vertical bar takes the width it is offered outright, so this floor no longer applies to it; in a horizontal Fill bar it still does (the tabs overflow into scroll rather than squeeze below it).

pub fn tab_bar_height(self, dp: f32) -> Self

Override the tab-strip cross-axis extent (the strip height for a horizontal bar; the per-tab pill height for a vertical one). None keeps the style’s editor_tab_height. Use for a compact bar.

pub fn max_tab_width(self, dp: f32) -> Self

Maximum width (in dp) any unpinned tab will be drawn at — long labels truncate with an ellipsis at this width. Default: DEFAULT_MAX_TAB_WIDTH.

In horizontal orientation this clamps the per-tab width. In vertical orientation it caps the whole sidebar’s width — see min_tab_width for the symmetric adapt-to-content rule.

TabSizing::Fill ignores this cap in both orientations — filling the bar is the point, and a cap would leave exactly the slack the mode exists to remove.

pub fn tab_spacing(self, dp: f32) -> Self

Override the spacing (in dp) between adjacent tab headers in the row. Default: DEFAULT_TAB_SPACING.

pub fn pinned_tab_width(self, dp: f32) -> Self

Width (in dp) of an icon-only pinned tab. Default: DEFAULT_PINNED_TAB_WIDTH.

pub fn tab_background(self, color: impl Into<ColorProp>) -> Self

All-states shorthand for the per-tab background — every tab (selected, idle, hovered) paints this unless a per-state override below is set. Accepts any Color, SurfaceRole, or Signal<Color> (via ColorProp). Default None = transparent. To tint the bar’s backdrop instead, use bar_background.

pub fn selected_tab_background(self, color: impl Into<ColorProp>) -> Self

Background for the selected tab. Falls back to tab_background, then transparent.

pub fn hover_tab_background(self, color: impl Into<ColorProp>) -> Self

Background for the hovered (non-selected) tab. Falls back to tab_background, then transparent.

pub fn idle_tab_background(self, color: impl Into<ColorProp>) -> Self

Background for idle tabs (not selected, not hovered). Falls back to tab_background, then transparent.

pub fn bar_background(self, color: impl Into<ColorProp>) -> Self

Set the backdrop fill spanning the whole bar strip (behind the headers, slots, and scroll arrows). Independent of the per-tab backgrounds. Accepts any Color, SurfaceRole, or Signal<Color>. Default None = transparent.

pub fn tab_dividers(self) -> Self

Draw a 1 dp divider between consecutive tabs (scrollable and pinned strips). Off by default. See tab_divider_color.

pub fn tab_divider_color(self, color: impl Into<ColorProp>) -> Self

Like tab_dividers, but with an explicit colour. Accepts any Color, [BorderRole], or Signal<Color>. Implies tab_dividers().

pub fn active_indicator(self, position: TabIndicatorPosition) -> Self

Choose which edge the active-tab highlight indicator hugs. Default TabIndicatorPosition::OuterEdge (top for horizontal / leading for vertical); InnerEdge puts it below the label (horizontal) / on the trailing edge (vertical). Honoured by the default RecipeTabStyle; a custom TabStyle may interpret it freely.

pub fn selected_text_role(self, role: TextRole) -> Self

Set the text role used for the label (and matching icon tint) on the selected tab. Default: [TextRole::Primary] — the Int UI editor-strip convention. Override to e.g. [TextRole::Accent] when the strip sits over a tinted surface.

pub fn idle_text_role(self, role: TextRole) -> Self

Set the text role used for the label (and matching icon tint) on idle tabs (not selected, not disabled). Default: [TextRole::Secondary]. Disabled tabs always read as [TextRole::Disabled] regardless of this setting.

pub fn style(self, style: impl TabStyle) -> Self

Override the active TabStyle for every header in this bar. The widget keeps responsibility for the label / icon / close button composition, the optional per-state tab backgrounds, and all input handling; the style only paints the accent indicator and focus ring chrome via make_body. Per-call override > theme slot > built-in RecipeTabStyle default.

pub fn on_pin_toggle( self, f: impl Fn(usize, bool, &mut EventContext<'_>) + 'static, ) -> Self

Install a pin-toggle handler called whenever the user crosses a pinned tab over the unpinned region or vice-versa during a drag. Receives (model_index, new_pinned_flag, ctx). The firing [EventContext] lets the handler confirm the transition via a dialog or route it through an intent before mutating the item; apps decide whether to actually flip the pinned state.

pub fn bar_leading_slot(self, w: impl Widget + 'static) -> Self

Bar-level leading slot — a widget rendered before the headers row (and before any pinned region in later phases).

pub fn bar_leading_slot_id(self, id: WidgetId) -> Self

Bar-level leading slot accepting a pre-registered widget id.

pub fn bar_trailing_slot(self, w: impl Widget + 'static) -> Self

Bar-level trailing slot — a widget rendered after the headers row (and after any overflow dropdown in later phases).

pub fn bar_trailing_slot_id(self, id: WidgetId) -> Self

Bar-level trailing slot accepting a pre-registered widget id.

pub fn separator(self, on: bool) -> Self

Toggle the 1 dp bottom separator the bar paints under the headers. Default: on.

pub fn show_scroll_arrows(self, on: bool) -> Self

Toggle the leading + trailing scroll-arrow buttons. They auto-show when the headers row overflows the bar’s viewport, and click animates the scroll position by one tab-width. Default: on.

pub fn overflow_button(self, mode: TabOverflowButton) -> Self

When the trailing “show all tabs” overflow dropdown appears — a Popover with a MenuList of every tab. Default: TabOverflowButton::Auto (shown only when the headers overflow the viewport). See TabOverflowButton for Always / Never.

pub fn show_overflow_dropdown(self, on: bool) -> Self

Convenience over overflow_button: true maps to TabOverflowButton::Always, false to TabOverflowButton::Never. Prefer overflow_button(TabOverflowButton::Auto) for the default “only when overflowing” behaviour.

pub fn vertical_wheel_scrolls_horizontally(self, on: bool) -> Self

On a horizontal bar, treat a plain vertical-wheel event as a horizontal scroll (Firefox / Chrome convention). Has no effect on vertical or multi-line bars (those still scroll vertically). Default: on.

pub fn shift_wheel_scrolls_horizontally(self, on: bool) -> Self

Shift + vertical wheel forces a horizontal scroll regardless of orientation. Default: on.

pub fn on_close( self, f: impl Fn(usize, &mut EventContext<'_>) + 'static, ) -> Self

Install a close-tab handler called whenever the user clicks a closable tab’s close button, middle-clicks the tab header, or presses Delete on a focused tab. The handler receives the firing [EventContext] so it can open a confirmation dialog (ctx.present_modal(MessageBox::confirm(...))), dispatch an intent, or otherwise route the close request through the framework. To veto the close, do nothing in the handler; to confirm-then-close, run the confirmation flow and only mutate the underlying model on accept.

If unset and the bar is backed by a ListModel<T>, the default behavior is to remove the item at the given index from the model (no confirmation, no ctx needed for that path).

pub fn reorderable(self, on: bool) -> Self

Enable drag-to-reorder. Each tab header becomes a drag source and the bar accepts drops anywhere along the headers row, painting an insertion-line indicator at the would-be position. On drop the bar calls on_reorder — falling back to ListModel::move_item when the bar is backed by a ListModel<T> and no explicit handler is set. Default: off.

pub fn on_reorder( self, f: impl Fn(usize, usize, &mut EventContext<'_>) + 'static, ) -> Self

Install a reorder handler called whenever the user drag-drops a tab to a new position. Receives (from, to, ctx) — from/to are model indices and ctx is the firing [EventContext] so the handler can open a confirmation dialog or dispatch an intent before persisting the move. Implies reorderable(true).

pub fn accept_external_tabs(self, on: bool) -> Self

where T: Clone,

Opt into cross-bar tab transfer. When enabled, this bar’s headers become transfer drag sources (their drag payload carries a clone of the dragged item) and the bar accepts tabs dragged from other TabBar<T>s, painting the same insertion-line indicator as an intra-bar reorder.

Requires T: Clone — the dragged item is cloned into the payload (cheap for handle-like T whose heavy state lives behind an Rc). Default: off.

Pair with on_tab_received (this bar, as a drop target — insert the item into your model) and on_transfer_out (the source bar — remove the tab from your model).

pub fn on_tab_received( self, f: impl Fn(T, usize, &mut EventContext<'_>) + 'static, ) -> Self

where T: Clone,

Install the target-side callback fired when a foreign tab is dropped onto this bar. Receives (item, insertion_index, ctx) — the moved item (taken by value from the drag payload), the model index in this bar where it should land, and the firing context. The app inserts the item into its own model. Implies accept_external_tabs(true).

pub fn on_transfer_out( self, f: impl Fn(TabId, &mut EventContext<'_>) + 'static, ) -> Self

where T: Clone,

Install the source-side callback fired after one of this bar’s tabs has been accepted by a different bar. Receives the transferred tab’s TabId; the app removes it from its own model. Not fired for intra-bar reorders (those go through on_reorder) or rejected / cancelled drags. Implies accept_external_tabs(true).

pub fn on_external_drop( self, f: impl Fn(&DragPayload, usize, &mut EventContext<'_>) -> bool + 'static, ) -> Self

Accept non-tab drops onto the bar — an in-app foreign drag (e.g. a file dragged from a TreeView, carrying app data) or an OS file/text/URL drop. The bar paints the same insertion-line indicator while such a payload hovers, and on drop calls f with the raw [DragPayload], the model insertion index, and the firing context. Return true if accepted — the app inspects the payload (get_typed::<T>() / files() / text() / uris()) and mints whatever it needs (e.g. opens a tab).

Independent of accept_external_tabs: a bar can accept foreign tabs, non-tab payloads, both, or neither. OS drops additionally require the app to have called TeksiloAppBuilder::install_external_dnd().

Note: the hover indicator is optimistic — it shows for any non-tab payload while this handler is installed; f’s return value is authoritative at drop time.

Trait Implementations

impl<T: 'static> Debug for TabBar<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: 'static> Widget for TabBar<T>

fn build(&mut self, ctx: &mut BuildContext<'_>) -> Vec<WidgetId>

Compose child widgets. Called once after the widget is placed in the arena, and again on environment change (theme switch, locale switch). Takes &mut self — store child IDs, signal handles, any state needed later. Returns the list of root child IDs (empty for leaf widgets).

fn layout_response( &self, proposal: SizeProposal, ctx: &LayoutContext<'_>, ) -> LayoutResponse

Respond to the parent’s size proposal with this widget’s wanted size, grow/shrink weights, and compression floor (see [LayoutResponse]).

fn place_children( &self, bounds: Rect, _proposal: SizeProposal, children: &mut [WidgetPlacement], _ctx: &LayoutContext<'_>, )

Position children within the allocated bounds.

fn accessibility(&self, builder: &mut AccessNodeBuilder)

Declare this widget’s accessibility identity.

fn children(&self) -> Vec<WidgetId>

Return the child widget IDs that this widget manages.

fn type_name(&self) -> &'static str

Concrete type name of this widget (e.g. "teksilo_widgets::button::Button"). The default implementation resolves at the impl site via std::any::type_name::<Self>(), so calls through &dyn Widget correctly dispatch to the monomorphized fn for the concrete type — getting the concrete name through the vtable without per-impl boilerplate.

fn cacheable_layout(&self) -> bool

Whether this widget’s layout_response may be memoized by the per-pass layout cache. Defaults to true.

fn paint(&self, _bounds: Rect, _canvas: &mut Canvas, _ctx: &PaintContext<'_>)

Draw the widget’s visual representation.

fn wants_after_paint(&self) -> bool

Whether this widget wants its after_paint hook to fire each frame. Returning false (the default) saves a virtual call per widget per frame for the vast majority of widgets that don’t aggregate descendant geometry.

fn after_paint(&self, _view: &WidgetTreeView<'_>, _ctx: &PaintContext<'_>)

Called once per frame after this widget’s subtree has finished painting. Receives a read-only view of the layout-resolved arena so a parent can read its descendants’ final bounds — e.g. TitleBar aggregates its drag region and control-button rects into a single HitRegions payload for the Windows backend’s WM_NCHITTEST.

fn wants_post_paint(&self) -> bool

Whether this widget wants its post_paint hook to fire each frame. Returning false (the default) saves a virtual call per widget per frame for the vast majority of widgets that don’t draw a foreground over their children.

fn post_paint( &self, _bounds: Rect, _canvas: &mut Canvas, _ctx: &PaintContext<'_>, )

Draw a foreground layer over this widget’s children.

fn wants_descendant_redirects(&self) -> bool

Whether this widget wants the AT walker to consult its a11y_redirect_descendant hook for every descendant during AT tree emission, not just its direct arena children.

fn a11y_redirect_descendant( &self, _self_id: WidgetId, _descendant: WidgetId, ) -> Option<NodeId>

Optional redirection hook for AT-tree placement of a child.

fn accessible_title_hint(&self) -> Option<String>

Suggest an accessible title to an enclosing container that wraps this widget as content — typically a modal / dialog shell that wants to propagate the inner content’s visible title as the shell’s own accessible name.

fn initial_focus_hint(&self) -> Option<WidgetId>

Optional hint that directs initial focus to a specific descendant when this widget is the root of a deferred-built modal surface.

fn accessibility_children(&self) -> Option<Vec<WidgetId>>

Optional override for the child ORDER presented to assistive technology, when it must differ from the paint / z-order child order returned by children.

fn as_any(&self) -> Option<&(dyn Any + 'static)>

Downcast hook. Default implementation returns None; concrete widgets override with Some(self) when they want to expose their concrete type to test-level introspection or reflection. The trait already bounds on std::any::Any so concrete types satisfy the 'static requirement.

fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>

Mutable counterpart of as_any. Default returns None; widgets that want to expose mutable state to tests (e.g. so a test can mutate a Scene inside a SceneView post-layout) override with Some(self). Should follow the same opt-in pattern as as_any: only widgets that opt into & introspection should opt into &mut.

fn clips_children(&self) -> bool

Whether this widget clips its children to its bounds.

fn focus_reveal_rect(&self, _bounds: Rect) -> Option<Rect>

The rectangle (in absolute tree coordinates) that best represents this widget when the framework reveals it into an ancestor scroll area on focus gain. Returning None (the default) reveals the widget’s whole bounds — correct for most controls.

fn hit_shape(&self, _local_point: Point, _bounds: Rect) -> bool

Whether the point lies inside this widget’s actual shape, not just its rectangular bounds. Consulted by hit-testing right after the bounds check: returning false for a point that is inside the bounding box makes the widget transparent to the click there, so it falls through to whatever sibling is painted underneath (the same machinery as a fully pass-through node, but shape-aware).

fn preserves_children_on_rebuild(&self) -> bool

How rebuild_single_widget treats this widget’s existing children when re-running its build().

fn tooltip_has_content(&self) -> bool

Whether this widget, used as tooltip content, currently has anything worth showing.

fn declare_shortcuts(&self) -> Vec<Shortcut>

Declare the rebindable keyboard shortcuts this widget exposes, without installing handlers. The framework calls this at arena insertion time (before build()) and at certain lazy boundaries (e.g. Switcher walks declarations on its not-yet-mounted Pending slots), so settings UIs and the ShortcutRegistry see the keystrokes the moment the owning container mounts — even if build() hasn’t run.

fn take_handler_set(&mut self) -> Option<HandlerSet>

Extract attached handler set from a WidgetWithHandlers wrapper. Called during arena insertion to transfer handlers to the WidgetNode. Default: returns None (no attached handlers).