Struct FlexColumn 

pub struct FlexColumn {
    pub gap: f64,
    pub inner_padding: Insets,
    pub background: Color,
    pub use_panel_bg: bool,
    pub fit_width: bool,
    pub top_anchor: bool,
    /* private fields */
}

Stacks children top-to-bottom (first child = visually topmost).

Fields

gap: f64

inner_padding: Insets

background: Color

use_panel_bg: bool

When true, paint background using ctx.visuals().panel_fill regardless of the stored background colour.

fit_width: bool

When true, layout reports the column’s natural content width (max over children, + horizontal padding) instead of the full available.width. Used by auto-sized ancestors that want the column to shrink-to-content rather than stretch. Off by default for backward compatibility.

top_anchor: bool

When true, children are anchored to the TOP of the column’s inner area, with any extra height appearing as whitespace at the BOTTOM. Off by default — legacy callers (e.g. ScrollView content) rely on the natural-anchored layout where children occupy the BOTTOM of their slot when oversized.

Implementations

impl FlexColumn

pub fn new() -> Self

pub fn with_gap(self, gap: f64) -> Self

pub fn with_padding(self, p: f64) -> Self

pub fn with_inner_padding(self, p: Insets) -> Self

pub fn with_background(self, c: Color) -> Self

pub fn with_panel_bg(self) -> Self

Use ctx.visuals().panel_fill as background instead of the stored color.

pub fn with_fit_width(self, fit: bool) -> Self

Opt into content-fit width — layout reports the widest child’s natural width (+ horizontal padding) instead of the full available width. Required when this column is the content of an auto-sized Window; without it, wrapped Labels claim the full available width and the window grows to the canvas. Matches egui’s per-column shrink-to-content option.

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

Anchor children to the TOP of the inner area rather than the bottom of the natural content extent. Default is bottom (the classic Y-up “natural-anchored” placement) so callers like ScrollView whose layout pass uses available.height ≈ ∞ keep working — they need cursor_y to be derived from natural extent, not from the supplied (huge) available. Opt in for containers placed inside a Resize widget or other oversized slot where you want the visible content to start at the top of the frame and any extra space to appear below.

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

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

Add a fixed-size child (flex = 0).

pub fn add_flex(self, child: Box<dyn Widget>, flex: f64) -> Self

Add a flex child that expands proportionally.

pub fn push(&mut self, child: Box<dyn Widget>, flex: f64)

Push a child directly (for use without builder chaining).

Trait Implementations

impl Default for FlexColumn

fn default() -> Self

Returns the “default value” for a type.

impl Widget for FlexColumn

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

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

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.