Struct WidgetPlacement 

#[non_exhaustive]
pub struct WidgetPlacement {
    pub id: WidgetId,
    pub origin: Point,
    pub size: Size,
    pub dormant: bool,
}

Placement of a child widget during layout.

#[non_exhaustive]: a parent reads and writes the fields of the slice it is handed, and never builds one — so the attribute costs a place_children implementation nothing, and it is what makes the next field addition a non-event rather than the breaking change dormant was. Use WidgetPlacement::new where one genuinely has to be constructed.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: WidgetId

origin: Point

size: Size

dormant: bool

Park this child dormant for as long as the flag stays set.

Only read for a parent whose Widget::culls_children returns true, and only such a parent is handed its dormant children here at all — every other widget still sees its active children and nothing else, so setting this without opting in does nothing.

A dormant child leaves paint, the layout recursion, the accessibility tree and the Tab ring, and keeps every piece of its state — focus, text, animations — for when it comes back. Clearing the flag wakes it in the same pass, so a container that culls by viewport shows no hole on the frame a camera jumps.

Arrives pre-set to the child’s current state, so a parent that ignores the field changes nothing.

This is a heavier decision than collapsing size to zero, and the two are worth layering rather than merging: zero size costs the child its geometry, dormancy costs it its existence. Parking what the user is interacting with clears focus and cancels pointers — see LayoutContext::for_each_interaction_ancestor.

Implementations

impl WidgetPlacement

pub fn new(id: WidgetId, origin: Point, size: Size) -> Self

A placement at origin sized size, awake.

The framework fills the slice a parent is handed; this is for the cases that stand outside a layout pass — a test driving place_children directly, or a widget assembling placements of its own.

Trait Implementations

impl Clone for WidgetPlacement

fn clone(&self) -> WidgetPlacement

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for WidgetPlacement

impl Debug for WidgetPlacement

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

Formats the value using the given formatter.