Struct Stack 

pub struct Stack { /* private fields */ }

Stacks children on top of each other.

Paint order: first child is drawn first (furthest back). The last child appears on top. Hit testing also follows paint order (reverse).

Children added with add are stretched to fill the stack’s area (the classic behaviour). Children added with add_aligned are laid out at their natural size and positioned within the stack using their own h_anchor / v_anchor (plus margin) — like a floating overlay panel. Because an aligned child’s bounds only cover the panel itself, pointer events outside it fall through to the stretched layer(s) beneath, so an aligned control panel doesn’t block interaction with a full-bleed background child.

Implementations

impl Stack

pub fn new() -> Self

pub fn add(self, child: Box<dyn Widget>) -> Self

Add a child stretched to fill the stack’s full area.

pub fn add_aligned(self, child: Box<dyn Widget>) -> Self

Add a floating child laid out at its natural size and positioned by its h_anchor / v_anchor (respecting margin). Points outside the child fall through to lower layers.

pub fn with_margin(self, m: Insets) -> Self

pub fn with_h_anchor(self, h: HAnchor) -> Self

pub fn with_v_anchor(self, v: VAnchor) -> Self

pub fn with_min_size(self, s: Size) -> Self

pub fn with_max_size(self, s: Size) -> Self

Trait Implementations

impl Default for Stack

fn default() -> Self

Returns the “default value” for a type.

impl Widget for Stack

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

A static name for this widget type, used by the inspector. Default: “Widget”.

fn bounds(&self) -> Rect

Bounding rectangle in parent-local Y-up coordinates.

fn set_bounds(&mut self, b: Rect)

Set the bounding rectangle. Called by the parent during layout.

fn children(&self) -> &[Box<dyn Widget>]

Immutable access to child widgets.

fn children_mut(&mut self) -> &mut Vec<Box<dyn Widget>>

Mutable access to child widgets (required for event dispatch + layout).

fn margin(&self) -> Insets

Outer margin around this widget in logical units.

fn widget_base(&self) -> Option<&WidgetBase>

Direct read access to the widget’s embedded WidgetBase.

fn widget_base_mut(&mut self) -> Option<&mut WidgetBase>

Mutable counterpart of widget_base.

fn h_anchor(&self) -> HAnchor

Horizontal anchor: how this widget sizes/positions itself horizontally within the slot the parent assigns. Default: HAnchor::FIT (take natural content width).

fn v_anchor(&self) -> VAnchor

Vertical anchor: how this widget sizes/positions itself vertically within the slot the parent assigns. Default: VAnchor::FIT (take natural content height).

fn min_size(&self) -> Size

Minimum size constraint (logical units).

fn max_size(&self) -> Size

Maximum size constraint (logical units).

fn layout(&mut self, available: Size) -> Size

Compute desired size given available space, and update internal layout.

fn paint(&mut self, _ctx: &mut dyn DrawCtx)

Paint this widget’s own content into ctx.

fn on_event(&mut self, _: &Event) -> EventResult

Handle an event. The event’s positions are already in local Y-up coordinates. Return EventResult::Consumed to stop bubbling.

fn hit_test(&self, local_pos: Point) -> bool

Return true if local_pos (in this widget’s local coordinates) falls inside this widget’s interactive area. Default: axis-aligned rect test.

fn claims_pointer_exclusively(&self, _local_pos: Point) -> bool

When true, hit_test_subtree stops recursing into this widget’s children and returns this widget as the hit target. Used for floating overlays (e.g. a scrollbar painted above its content) that must claim the pointer before children that happen to share the same pixels. Default: false.

fn hit_test_global_overlay(&self, _local_pos: Point) -> bool

Return true when local_pos hits an app-level overlay owned by this widget. Unlike normal hit testing, ancestors may be missed because the overlay is painted outside their bounds.

fn has_active_modal(&self) -> bool

Whether this widget currently owns an app-modal interaction layer.

fn on_unconsumed_key( &mut self, _key: &Key, _modifiers: Modifiers, ) -> EventResult

Handle a key that was not consumed by the focused widget path.

fn is_focusable(&self) -> bool

Whether this widget can receive keyboard focus. Default: false.

fn focus_id(&self) -> Option<FocusId>

Stable identifier for the programmatic focus channel (crate::focus::request_focus).

fn id(&self) -> Option<&str>

Optional human-readable identifier for this widget instance.

fn is_visible(&self) -> bool

Return false to suppress painting this widget and all its children. The widget’s own paint() will not be called. Default: true.

fn properties(&self) -> Vec<(&'static str, String)>

Return type-specific properties for the inspector properties pane.

fn accepts_text_input(&self) -> bool

true when this widget accepts free-form character input (typing arbitrary letters, numbers, punctuation). Used by the on-screen software keyboard (crate::widgets::on_screen_keyboard) to decide whether to slide up when this widget gains focus.

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

Current text contents of this widget if it is text-bearing. Used by the on-screen software keyboard to apply the sentence-start auto-capitalize heuristic: an empty field (or one ending in ., !, ?, newline) opens the keyboard with Shift active.

fn text_input_mode(&self) -> KeyboardInputMode

Preferred keyboard input mode for this widget — used by the on-screen software keyboard to pick the initial layer when this widget gains focus. Default is KeyboardInputMode::Text; numeric fields override to Numeric so the digit pad slides up instead of the letter row.

fn try_scroll_to_lift(&mut self, _amount: f64) -> f64

Try to lift this widget’s visible content upward by amount pixels. Used by the on-screen-keyboard auto-scroll so a focused text field doesn’t end up hidden behind the keyboard panel: the App walks UP the focus path and asks each ancestor to absorb some of the deficit.

fn set_label_color(&mut self, _color: Color)

If this widget is text-bearing (e.g. Label), update its foreground colour. Default is a no-op. Composite widgets call this on their children to retint labels without rebuilding them — used by Button when toggling between active (white text on accent) and inactive (theme text on subtle bg) appearances.

fn set_label_text(&mut self, _text: &str)

If this widget is text-bearing (e.g. Label), update its displayed text. Default is a no-op. Composite widgets that own a Label child use this to push live values (e.g. an FPS counter) into the child without bypassing the standard backbuffered glyph cache — calling this on a Label only invalidates the cache when the text actually changed.

fn as_reflect(&self) -> Option<&dyn Reflect>

Opt-in reflection accessor for the inspector’s typed property editors.

fn as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Mutable counterpart of as_reflect. Used by the inspector to write edits back into the live widget.

fn has_backbuffer(&self) -> bool

Whether this widget renders into its own offscreen buffer before compositing into the parent.

fn compositing_layer(&mut self) -> Option<CompositingLayer>

Request that this widget subtree be painted into a transient transparent compositing layer before being blended into its parent.

fn backbuffer_spec(&mut self) -> BackbufferSpec

Unified widget-owned backbuffer request.

fn backbuffer_state_mut(&mut self) -> Option<&mut BackbufferState>

Mutable retained backbuffer state for widgets that request a BackbufferSpec other than BackbufferKind::None.

fn mark_dirty(&mut self)

Mark this widget’s own retained surface dirty, if it owns one.

fn backbuffer_cache_mut(&mut self) -> Option<&mut BackbufferCache>

Opt into per-widget CPU bitmap caching with a dirty flag.

fn backbuffer_mode(&self) -> BackbufferMode

Storage format for this widget’s backbuffer. Ignored unless [backbuffer_cache_mut] returns Some. Default BackbufferMode::Rgba — correct for any widget. Opt into BackbufferMode::LcdCoverage only when the widget paints opaque content covering its full bounds.

fn contributes_children_to_inspector(&self) -> bool

Whether the inspector should recurse into this widget’s children.

fn show_in_inspector(&self) -> bool

Return false to hide this widget (and its subtree) from the inspector node snapshot entirely. Intended for zero-size utility widgets such as layout-time watchers / tickers / invisible composers — they bloat the inspector tree without providing user-relevant information and, at scale, can make the inspector’s per-frame tree rebuild expensive.

fn lcd_preference(&self) -> Option<bool>

Per-widget LCD subpixel preference for backbuffered text rendering.

fn paint_overlay(&mut self, _ctx: &mut dyn DrawCtx)

Paint decorations that must appear on top of all children.

fn finish_paint(&mut self, _ctx: &mut dyn DrawCtx)

Called after paint, child painting, and optional overlay painting.

fn paint_global_overlay(&mut self, _ctx: &mut dyn DrawCtx)

Paint app-level overlays after the entire widget tree has been painted.

fn clip_children_rect(&self) -> Option<(f64, f64, f64, f64)>

Return a clip rectangle (in local coordinates) that constrains all child painting. paint_subtree applies this clip before recursing into children, then restores the previous clip state afterward. The clip does not affect paint_overlay, which runs after the clip is removed.

fn inspector_child_transform(&self) -> TransAffine

Affine transform applied between this widget and its children during inspector traversal. Mirrors what paint() does — e.g. a widget that pushes pan/zoom in paint() and pops it in finish_paint() makes the framework recurse into its children with pan/zoom active, so collect_inspector_nodes must apply the same transform when accumulating descendant screen bounds. Without this hook the inspector hover overlay lands at the un-transformed canvas position when the widget sits inside a panning/zooming container.

fn padding(&self) -> Insets

Inner padding — space the widget reserves between its own bounds and its child layout area. Only container widgets carry padding; leaf widgets default to Insets::ZERO.

fn enforce_integer_bounds(&self) -> bool

Whether paint_subtree should snap this widget’s incoming translation to the physical pixel grid.

fn measure_min_height(&self, _available_w: f64) -> f64

Report the minimum height this widget needs to fully render its content when given the supplied available_w for width.

fn take_raise_request(&mut self) -> bool

Container widgets (notably crate::widgets::Stack) call this on each child at the start of layout(). A widget that returns true is moved to the END of its parent’s child list — painted last, i.e. raised to the top of the z-order. take_ semantics: the call is also expected to clear the request so the child doesn’t keep getting raised every frame.

fn needs_draw(&self) -> bool

Return true if this widget, or any visible descendant, has an ongoing draw need that should keep the host drawing.

fn next_draw_deadline(&self) -> Option<Instant>

Return the earliest wall-clock instant at which this widget (or any visible descendant) wants the next draw. None = no scheduled wake. The host loop turns a Some(t) into ControlFlow::WaitUntil(t) so e.g. a cursor blink fires without continuous polling.