Struct GridView 

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

A virtualized 2D tile grid backed by a ListModel<T>.

Implementations

impl<T: 'static> GridView<T>

pub fn new( model: ListModel<T>, delegate: impl Fn(&TileContext<'_, T>) -> Box<dyn Widget> + 'static, ) -> Self

Create a grid backed by a ListModel<T>. The delegate builds the widget for each tile from a TileContext.

pub fn from_source<S: ListDataSource<Item = T>>( source: S, delegate: impl Fn(&TileContext<'_, T>) -> Box<dyn Widget> + 'static, ) -> Self

Create a grid backed by any ListDataSource (large / external data).

pub fn from_source_keyed<S: ListDataSource<Item = T>>( source: S, keyed: KeyedSelectionModel<S::Key>, delegate: impl Fn(&TileContext<'_, T>) -> Box<dyn Widget> + 'static, ) -> Self

where S::Key: ItemKey,

Create a grid backed by any ListDataSource with keyed selection.

The KeyedSelectionModel<S::Key> holds the selected items by the source’s key, not by position, so a selection survives the grid being sorted (by artist, by year), narrowed by a filter, or a lazy source sliding its loaded window: it stays on the same items. Clicks, Ctrl/⌘-clicks, Shift-clicks, the keyboard and the rubber band all write keys. An item the source no longer shows (removed, or filtered out here) leaves the selection, as in ListView.

on_selection_changed still reports indices: the positions the selected keys have when the selection changes. A sort moves them without changing the selection, so it does not fire. The view stays GridView<T>; the index↔key mapping is captured from the concrete source here. Mutually exclusive with selection (the last one set wins).

pub fn enabled(self, enabled: impl Into<Prop<bool>>) -> Self

Enable or disable the whole view. A disabled view greys out and stops accepting focus / selection / keyboard input (arena-gated).

pub fn sizing(self, sizing: impl Into<Prop<GridSizing>>) -> Self

Set the tile sizing / column-count policy.

Accepts a plain GridSizing (static) or a Signal<GridSizing> (reactive). A bound signal is observed at [BindingLevel::Rebuild]: when it changes, build() rebuilds the cached layout strategy and reflows — the internal scroll_y / focused_index / selection are field signals on the same widget instance, so they survive the rebuild (no scroll jump). This is the card-size-slider path; mirrors TabWidget::sizing.

pub fn tile_size(self, width: f32, height: f32) -> Self

Sugar for GridSizing::Fixed — every tile is exactly width × height.

pub fn column_count(self, count: usize, tile_height: f32) -> Self

Sugar for GridSizing::FixedColumnCount — exactly count columns.

pub fn variable_row_heights(self, estimated: f32) -> Self

Switch to variable row heights: each row is sized to its tallest tile (SwiftUI LazyVGrid semantics). estimated seeds rows that haven’t been measured yet; the scroll position is anchored when an estimate is later corrected. Combine with item_height for exact heights.

pub fn item_height(self, f: impl Fn(usize) -> f32 + 'static) -> Self

Supply an exact per-item natural height. Width-independent, so it doesn’t depend on the runtime column count: VariableRowGrid sizes each row to max(item_height(i)) over its items. Implies variable row heights, gives an exact scrollbar, and removes anchoring jitter.

pub fn waterfall(self, estimated: f32) -> Self

Switch to a Pinterest-style waterfall: per-item variable heights flow into the currently-shortest column. Column count comes from the configured sizing; heights are auto-measured (or exact via item_height). estimated seeds unmeasured items.

pub fn column_spacing(self, spacing: f32) -> Self

Horizontal gap between tiles (default 8).

pub fn row_spacing(self, spacing: f32) -> Self

Vertical gap between tile rows (default 8).

pub fn spacing(self, spacing: f32) -> Self

Set both column and row spacing.

pub fn content_inset(self, inset: EdgeInsets) -> Self

Inset from the scroll-content edge to the tiles.

pub fn min_columns(self, count: usize) -> Self

Never fewer than count columns (at least 1).

Bounds the count a GridSizing::Fixed or GridSizing::Adaptive derives from the width; ignored by GridSizing::FixedColumnCount, whose count is already the answer. When the width cannot afford count columns of the sizing’s width, the tiles narrow to share the width — the grid never overflows horizontally. The tile height is kept as the sizing gives it (a card gets narrower, not shorter), so a tile that must hold its aspect ratio sizes its own content from the width it is handed. If min_columns exceeds max_columns, the maximum wins.

pub fn max_columns(self, count: usize) -> Self

Never more than count columns (at least 1), however wide the viewport.

Bounds the count a GridSizing::Fixed or GridSizing::Adaptive derives from the width; ignored by GridSizing::FixedColumnCount. Under Fixed the tiles keep their width and the leftover is placed by column_alignment; under Adaptive they stretch to share the width of the capped count, up to max_width.

pub fn column_alignment(self, alignment: HAlignment) -> Self

Where the block of columns sits in the viewport when it is narrower than the content: [HAlignment::Leading] (the default, the tiles against the leading inset, leftover trailing), Center or Trailing. Leading and trailing swap in a right-to-left layout. Only the columns move: a section header and a detail_row band span the content width. The order of the columns within the block is the same in both directions.

Only a layout that leaves width over has anything to place: a GridSizing::Fixed grid, an Adaptive one with max_width, or any grid capped by max_columns.

pub fn selection(self, sel: SelectionModel) -> Self

Set the index-based selection model (modes None / Single / Multi). It holds positions: for a selection that stays on its items through a sort or a filter, build the grid with from_source_keyed instead.

pub fn on_selection_changed( self, f: impl Fn(&BTreeSet<usize>) + 'static, ) -> Self

Called whenever the selection set changes — including programmatic changes — with the new set of selected indices. For a keyed selection these are the positions its keys have at that moment.

Because it also fires for programmatic changes, it carries no input modifiers and no EventContext; for the modifiers held at the moment of input, use on_tile_activate, which receives one.

pub fn marquee_selection(self, enabled: bool) -> Self

Enable / disable rubber-band marquee selection (default enabled; only active when the selection model is in Multi mode).

pub fn wrap_navigation(self, enabled: bool) -> Self

Whether arrow navigation wraps across row/grid edges (default false).

pub fn tab_traversal(self, traversal: GridTabTraversal) -> Self

How Tab moves out of (or within) the grid (default OutOfGrid).

pub fn show_scrollbar(self, show: bool) -> Self

Suppress the internal scrollbar (mount your own via the signal accessors so it survives rebuilds).

pub fn overscroll_behavior(self, behavior: OverscrollBehavior) -> Self

Scroll-chaining behavior at the boundary (default Chain).

pub fn smooth_scrolling(self, enabled: bool) -> Self

Enable or disable animated wheel scrolling (enabled by default).

pub fn smooth_scroll_duration(self, duration: Duration) -> Self

Duration of the smooth scroll animation (default 150 ms).

pub fn scroll_bar_style(self, style: ScrollBarMode) -> Self

How the scroll bar is displayed (default Permanent). Overlay and Thin float the bar over the content instead of reserving a layout column, mirroring ScrollArea::scroll_bar_style.

pub fn scroll_y_signal(&self) -> &Signal<f32>

The vertical scroll offset signal.

pub fn max_scroll_y_signal(&self) -> &Signal<f32>

The maximum scroll offset signal (content_height - viewport_height).

pub fn viewport_ratio_y_signal(&self) -> &Signal<f32>

The vertical viewport-to-content ratio signal (drives the thumb size).

pub fn detail_visible_span_signal(&self) -> &Signal<Option<Range<f32>>>

The part of the open detail band that is on screen, in band-local coordinates: max(0, scroll_y − band.y) .. min(band.height, scroll_y + viewport_height − band.y), where band.y is the band’s top in the grid’s content. None while no band is open, and while the open band is entirely off screen.

Written by each layout after the scroll offset is clamped, and only when it changes, so an observer is not told of a scroll that leaves the band’s visible part as it was. Meant for a band holding far more than a viewport shows, hundreds of tracks say, that realizes only the rows in the span: a window of rows between two spacers, with no copy of the grid’s placement arithmetic. See the module docs, “A long band”.

pub fn handle(&self) -> GridViewHandle

A GridViewHandle on this grid: scroll it to a tile, or to a tile and its detail band, from outside the widget.

Usable at once and for the grid’s whole life: a request made before the grid is mounted is applied at its first layout, and the handle keeps working through every rebuild. A request is applied by the layout, after it has measured the detail band and settled the scroll anchoring, so one made in the same turn as opening a band lands where the new layout puts the tile. Prefer it to scroll_to_index and ensure_index_visible, which compute the offset when they are called.

pub fn ensure_index_visible(&self, index: usize, anchor: ScrollAnchor)

Bring index into view: nothing when the tile is already fully visible, otherwise a scroll per anchor, as scroll_to_index.

Computed at call time from the last layout’s geometry and clamped to its scroll range. Before the grid has been laid out there is no geometry and this does nothing, and a change of layout made in the same turn (a detail band opened above the tile) is not yet counted. GridViewHandle::ensure_index_visible has neither limit.

pub fn scroll_to_index(&self, index: usize, anchor: ScrollAnchor)

Scroll to index, forcing its position in the viewport per anchor; ScrollAnchor::Auto scrolls the least that shows it.

Computed at call time, with the limits ensure_index_visible documents: it does nothing before the grid’s first layout. GridViewHandle::scroll_to_index has neither limit.

pub fn sections<P: SectionProvider>(self, provider: P) -> Self

Group the flat model into sections, rendering a header above each section’s tile band. Sections compose with the uniform tile layout.

pub fn section_header_delegate( self, f: impl Fn(usize, &str) -> Box<dyn Widget> + 'static, ) -> Self

Custom section-header widget builder (section_index, title). Without it a default bold-text header is used.

pub fn section_header_height(self, height: f32) -> Self

Height of each section header row (default 28).

pub fn pinned_section_headers(self, enabled: bool) -> Self

Keep the current section’s header pinned to the top while scrolling through it (SwiftUI pinnedViews:[.sectionHeaders]).

pub fn a11y_label(self, label: impl Into<String>) -> Self

Accessible label for the grid container.

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

Per-call Tier-3 decoration style override (focus ring, marquee, insertion bar, pinned-header surface). Precedence: this override → theme.style_slots.grid_view → the stock RecipeGridViewStyle.

pub fn empty_view(self, f: impl Fn() -> Box<dyn Widget> + 'static) -> Self

Widget shown when the model is empty.

pub fn loading_view(self, f: impl Fn() -> Box<dyn Widget> + 'static) -> Self

Widget overlaid while is_loading reads true.

pub fn is_loading(self, flag: impl Into<Prop<bool>>) -> Self

Reactive loading flag; when true the loading_view is shown above the grid.

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

Enable intra-grid drag reordering (and keyboard Alt+Arrow). The move is routed through the source’s accept_drop (a built-in ListModel reorders via move_item; an external source applies its own command).

pub fn exportable(self, mode: DragTransferMode) -> Self

where T: Clone,

Make tiles droppable outside this view — on a DropTarget, another data view, or the OS.

A dragged tile (or the whole selection, when the pressed tile is part of a multi-selection) carries clones of its items in a public RowDragData<T>, so a foreign receiver can pull them out with payload.get_typed::<RowDragData<T>>() / DropTarget::on_drop_typed::<RowDragData<T>>() — no serialization. This also makes tiles a drag source even without reorderable.

mode chooses what happens to the origin rows once a foreign target accepts them: DragTransferMode::Move removes them (via the source’s on_drag_out, or on_rows_transferred_out), DragTransferMode::Copy leaves them. A same-view reorder is never a transfer, so mode never affects it. Requires T: Clone.

pub fn export_external( self, f: impl Fn(&[T]) -> Vec<(String, Vec<u8>)> + 'static, ) -> Self

where T: Clone,

Additionally advertise the dragged tiles as MIME data so they can be dropped on a DropZone or exported to another application / window via the OS. f maps the dragged items to (mime_type, bytes) pairs (e.g. text/plain, text/uri-list, an app-specific application/x-…). Implies exportable (defaulting to DragTransferMode::Move if not already set). Requires T: Clone.

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

Override how rows moved out to a foreign target are removed from this view. Receives the dragged rows’ indices (descending-safe) and the live context. Without this, an exportable Move drag removes them through the source’s on_drag_out (works out of the box for a ListModel).

pub fn accept_foreign_rows(self, accept: bool) -> Self

Accept exported rows dropped from a different view or source without writing a custom ListDataSource. Pair with on_rows_received, which is handed the dropped items and the insertion index. (Same-view reorder is reorderable; a custom ListDataSource can still accept foreign drops through its can_accept/accept_drop instead.)

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

Handler for rows accepted via accept_foreign_rows: (items, insertion_index, ctx). Insert them into your model at the index.

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

Accept external drops at a flat insertion index. Returns true when the drop is accepted.

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

Called when a tile is activated (a click per activate_on, or Enter on the focused tile) — the “open / default action”, distinct from selection.

pub fn activate_on(self, mode: ActivateOn) -> Self

Choose single- vs double-click tile activation (default ActivateOn::DoubleClick). Enter activates in either mode.

pub fn tile_context_menu( self, f: impl Fn(usize, Point, &mut EventContext<'_>) -> Option<Box<dyn Widget>> + 'static, ) -> Self

Per-tile context-menu factory: (index, pointer_position, ctx) → optional menu widget.

pub fn type_ahead_label(self, f: impl Fn(usize) -> String + 'static) -> Self

Supply a per-item label for type-ahead navigation (typing letters jumps to the first matching item). Required to enable type-ahead.

pub fn tile_a11y_label(self, f: impl Fn(usize) -> String + 'static) -> Self

Supply a per-item accessible name applied to each tile’s GridCell (Node::label), so a screen reader announces a concise item name in addition to the row/column position. Without it, the cell’s name is left to its contents.

pub fn type_ahead_timeout(self, timeout: Duration) -> Self

Type-ahead reset timeout (default 500 ms; ZERO disables).

pub fn expanded_index(self, expanded: Signal<Option<usize>>) -> Self

The disclosed tile: Some(index) opens a full-width band under the row holding tile index (see detail_row), None closes it. The grid writes it when a tile is activated (not for a tile with nothing to disclose), and follows writes made from outside. Without this the grid keeps its own signal.

pub fn detail_row( self, f: impl Fn(&TileContext<'_, T>) -> Option<Box<dyn Widget>> + 'static, ) -> Self

The content of the detail band: the “album expansion” of a music library, a full-width band opened directly under the row that holds the activated tile.

f receives the disclosed tile’s TileContext, the same one the tile delegate gets, and returns the band’s content, or None when the tile has nothing to disclose. It is also asked when a tile is activated, to learn whether it has anything, and its answer dropped, so it should be cheap and have no side effects. The band pushes the following rows down, and stays under its tile when a resize changes the column count.

With a band, activating a tile (a click per activate_on, or Enter) opens it and scrolls it into view, and activating the open tile closes it; on_tile_activate still fires. A tile with nothing to disclose opens nothing. In a single selection, Enter also selects the tile whose band it opens, unless the application has an activation of its own; a multiple selection is left as it is. Space on the open tile closes it. ↓ from the open tile moves focus to the first focusable control in the band, scrolling it into view, and ↑ from there, when the control does not use it, returns to the tile. A band that closes with focus inside it hands focus back to the grid, on its tile. Arrows between tiles step over the band, and the rubber band selects no band.

The band follows its tile when the tile moves. A source with item keys is followed through a sort or a filter (a reset); a source without them is followed through inserts, removals and moves, and closes the band on a reset. A ListModel’s keys are its positions, which identify no item across a reset, so it counts as a source without keys here, through from_source as through new. The band closes when its tile is removed.

The band is measured height-for-width at the content width, or sized by detail_row_height. It works with the uniform grid, variable_row_heights and sections. A waterfall has no rows to put it under and ignores it. A band that opens, closes or moves above the viewport leaves the visible tiles where they are. Its content is rebuilt when the band moves to another tile, when its own tile’s item arrives from a lazy source, and when the grid’s rows change (an insert, a removal, a move, an update, a reset); a lazy source loading other windows leaves it as it is.

Accessibility: the band is a Role::Group, read after its tile’s row, named after its tile’s tile_a11y_label, or labelled by the tile, or, with the tile outside the realized window, “Details of item N” in the user’s language. A tile carries an expanded state, Expand / Collapse actions and, while open, a controls relation to the band. Without detail_row_when every tile does, one with nothing to disclose included, since knowing otherwise means building its band, and that one stays collapsed. The grid’s row and column counts and the tiles’ positions do not count the band.

pub fn detail_row_when( self, f: impl Fn(&TileContext<'_, T>) -> bool + 'static, ) -> Self

Which tiles have a detail band, answered without building one: f receives the tile’s TileContext, as detail_row does, and returns false for a tile with nothing to disclose.

Such a tile is not a disclosure. Assistive technology hears no expanded state on it and is offered no Expand or Collapse, which it would be otherwise. Activating it opens nothing, detail_row is not asked for it, and expanded_index naming it opens no band.

f is asked as each tile is built: when it comes into the realized window, after a change to the data, and when its selectedness flips. Answer from the item, cheaply and with no side effects, and agree with detail_row: a tile f accepts and detail_row gives nothing for is offered as expandable, and opens nothing. A tile of a lazy source whose item has not arrived is offered until it does. Without detail_row, this does nothing.

pub fn detail_row_height(self, f: impl Fn(usize) -> f32 + 'static) -> Self

The detail band’s height for the tile at index, instead of measuring it. See detail_row.

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

The context-menu key opens the focused tile’s menu, not the grid’s.

A GridView is focusable and its tiles are not — the container owns focus and active_descendant above is what points assistive technology at the current tile. So the dispatcher’s default of “the focused widget” would open the grid’s own menu.

The tile the user means is the roving cursor, else the first selected tile. Only realized tiles have a widget, so a cursor scrolled outside the virtualization window resolves to nothing and the menu falls back to the grid — which is right, since there is no tile on screen for it to be about.

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

Every child but the detail band, which the body pane presents among the tiles, after its own row (GridBodyPane::accessibility_children).

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

Compose child widgets. Called once after the widget is placed in the arena, and again whenever the widget is marked for rebuild — a BindingLevel::Rebuild binding, rebuild_single_widget, or a density switch. A theme or locale switch does not rebuild: set_theme and set_locale mark layout + paint dirty and leave the built subtree standing, so anything derived from the theme or the locale must be read per pass or bound to a signal rather than captured here. 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 as_any(&self) -> Option<&dyn Any>

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 children(&self) -> Vec<WidgetId>

Return the child widget IDs that this widget manages.

fn clips_children(&self) -> bool

Whether this widget clips its children to its bounds.

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 culls_children(&self) -> bool

Whether this widget decides, on every layout pass, which of its children exist at all.

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 accessible_title_node(&self) -> Option<WidgetId>

The widget that paints this one’s title, when it has one.

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_proxy(&self) -> Option<WidgetId>

The descendant whose accessibility node stands for this widget.

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 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 accepts_child_hit(&self, _child: WidgetId, _point: Point) -> bool

Veto a hit on one of this widget’s direct children, per point.

fn hit_outset(&self, _kind: PointerKind, _tokens: &InputTokens) -> EdgeInsets

How far outside its own bounds this widget still absorbs a press, per edge, for the pointer that is asking.

fn hit_slop(&self, _kind: PointerKind, _tokens: &InputTokens) -> Option<HitSlop>

This widget’s own say in the miss-only slop pass, overriding the density default for its node.

fn hit_distance(&self, local_point: Point, bounds: Rect) -> Option<f32>

How far a missed press is from this widget’s actual silhouette, in the widget’s own bounds space.

fn target_regions(&self, _bounds: Rect) -> Vec<TargetRegion>

The interactive sub-regions this widget paints inside its own single node — a scroll bar’s thumb, a slider’s knob, a header cell’s filter affordance.

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).