Struct LayoutNode 

pub struct LayoutNode {
    pub modifier: Modifier,
    pub measure_policy: Rc<dyn MeasurePolicy>,
    pub children: Vec<usize>,
    /* private fields */
}

Re-export the UI crate so applications can depend on a single crate.

Fields

modifier: Modifier

measure_policy: Rc<dyn MeasurePolicy>

children: Vec<usize>

The actual children of this node (folded view - includes virtual nodes as-is)

Implementations

impl LayoutNode

pub fn new( modifier: Modifier, measure_policy: Rc<dyn MeasurePolicy>, ) -> LayoutNode

pub fn new_virtual() -> LayoutNode

Create a virtual LayoutNode for subcomposition slot containers. Virtual nodes are transparent - their children are flattened into parent’s children list.

pub fn set_modifier(&mut self, modifier: Modifier)

pub fn set_measure_policy(&mut self, policy: Rc<dyn MeasurePolicy>)

pub fn mark_needs_measure(&self)

Mark this node as needing measure. Also marks it as needing layout.

pub fn mark_needs_layout(&self)

Mark this node as needing layout (but not necessarily measure).

pub fn mark_needs_redraw(&self)

Mark this node as needing redraw without forcing measure/layout.

pub fn needs_measure(&self) -> bool

Check if this node needs measure.

pub fn needs_layout(&self) -> bool

Check if this node needs layout.

pub fn mark_needs_semantics(&self)

Mark this node as needing semantics recomputation.

pub fn needs_semantics(&self) -> bool

Returns true when semantics need to be recomputed.

pub fn needs_redraw(&self) -> bool

Returns true when this node requested a redraw since the last render pass.

pub fn clear_needs_redraw(&self)

pub fn mark_needs_pointer_pass(&self)

Marks this node as needing a fresh pointer-input pass.

pub fn needs_pointer_pass(&self) -> bool

Returns true when pointer-input state needs to be recomputed.

pub fn clear_needs_pointer_pass(&self)

Clears the pointer-input dirty flag after hosts service it.

pub fn mark_needs_focus_sync(&self)

Marks this node as needing a focus synchronization.

pub fn needs_focus_sync(&self) -> bool

Returns true when focus state needs to be synchronized.

pub fn clear_needs_focus_sync(&self)

Clears the focus dirty flag after the focus manager processes it.

pub fn set_node_id(&mut self, id: usize)

Set this node’s ID (called by applier after creation).

pub fn node_id(&self) -> Option<usize>

Get this node’s ID.

pub fn set_parent(&self, parent: usize)

Set this node’s parent (called when node is added as child). Sets both folded_parent (direct) and parent (first non-virtual ancestor for bubbling).

pub fn clear_parent(&self)

Clear this node’s parent (called when node is removed from parent).

pub fn parent(&self) -> Option<usize>

Get this node’s parent for dirty flag bubbling (may skip virtual nodes).

pub fn folded_parent(&self) -> Option<usize>

Get this node’s direct parent (may be a virtual node).

pub fn is_virtual(&self) -> bool

Returns true if this is a virtual node (transparent container for subcomposition).

pub fn resolved_modifiers(&self) -> ResolvedModifiers

pub fn modifier_capabilities(&self) -> NodeCapabilities

pub fn modifier_child_capabilities(&self) -> NodeCapabilities

pub fn set_debug_modifiers(&mut self, enabled: bool)

pub fn debug_modifiers_enabled(&self) -> bool

pub fn modifier_locals_handle(&self) -> Rc<RefCell<ModifierLocalManager>>

pub fn has_layout_modifier_nodes(&self) -> bool

pub fn has_draw_modifier_nodes(&self) -> bool

pub fn has_pointer_input_modifier_nodes(&self) -> bool

pub fn has_semantics_modifier_nodes(&self) -> bool

pub fn has_focus_modifier_nodes(&self) -> bool

pub fn modifier_slices_snapshot(&self) -> Rc<ModifierNodeSlices>

pub fn layout_state(&self) -> LayoutState

Returns a clone of the current layout state.

pub fn measured_size(&self) -> Size

Returns the measured size of this node.

pub fn position(&self) -> Point

Returns the position of this node relative to its parent.

pub fn is_placed(&self) -> bool

Returns true if this node has been placed in the current layout pass.

pub fn set_measured_size(&self, size: Size)

Updates the measured size of this node. Called during measurement.

pub fn set_position(&self, position: Point)

Updates the position of this node. Called during placement.

pub fn set_measurement_constraints(&self, constraints: Constraints)

Records the constraints used for measurement. Used for relayout optimization.

pub fn set_content_offset(&self, offset: Point)

Records the content offset (e.g. from padding).

pub fn clear_placed(&self)

Clears the is_placed flag. Called at the start of a layout pass.

pub fn semantics_configuration(&self) -> Option<SemanticsConfiguration>

pub fn with_text_field_modifier_mut<R>( &mut self, f: impl FnMut(&mut TextFieldModifierNode) -> R, ) -> Option<R>

Access the text field modifier node (if present) with a mutable callback.

This is used for keyboard event dispatch to text fields. Returns None if no text field modifier is found in the chain.

pub fn layout_state_handle(&self) -> Rc<RefCell<LayoutState>>

Returns a handle to the shared layout state. Used by layout system to update state without borrowing the Applier.

Trait Implementations

impl Clone for LayoutNode

fn clone(&self) -> LayoutNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for LayoutNode

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Node for LayoutNode

fn set_parent_for_bubbling(&mut self, parent: usize)

Minimal parent setter for dirty flag bubbling. Only sets the parent Cell without triggering registry updates. This is used during SubcomposeLayout measurement where we need parent pointers for bubble_measure_dirty but don’t want full attachment side effects.

fn mount(&mut self)

fn unmount(&mut self)

fn set_node_id(&mut self, id: usize)

Called after the node is created to record its own ID. Useful for nodes that need to store their ID for later operations.

fn insert_child(&mut self, child: usize)

fn remove_child(&mut self, child: usize)

fn move_child(&mut self, from: usize, to: usize)

fn update_children(&mut self, children: &[usize])

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

fn collect_children_into(&self, out: &mut SmallVec<[usize; 8]>)

Copies child IDs into the provided scratch buffer without allocating a fresh container for every traversal.

fn on_attached_to_parent(&mut self, parent: usize)

Called when this node is attached to a parent. Nodes with parent tracking should set their parent reference here.

fn on_removed_from_parent(&mut self)

Called when this node is removed from its parent. Nodes with parent tracking should clear their parent reference here.

fn parent(&self) -> Option<usize>

Get this node’s parent ID (for nodes that track parents). Returns None if node has no parent or doesn’t track parents.

fn mark_needs_layout(&self)

Mark this node as needing layout (for nodes with dirty flags). Called during bubbling to propagate dirtiness up the tree.

fn needs_layout(&self) -> bool

Check if this node needs layout (for nodes with dirty flags).

fn mark_needs_measure(&self)

Mark this node as needing measure (size may have changed). Called during bubbling when children are added/removed.

fn needs_measure(&self) -> bool

Check if this node needs measure (for nodes with dirty flags).

fn mark_needs_semantics(&self)

Mark this node as needing semantics recomputation.

fn needs_semantics(&self) -> bool

Check if this node needs semantics recomputation.

fn recycle_key(&self) -> Option<TypeId>

Returns a recycle pool key when this node supports shell reuse.

fn recycle_pool_limit(&self) -> Option<usize>

Bounds how many recyclable shells of this node type should be retained.

fn prepare_for_recycle(&mut self)

Clears live attachments before the node shell enters a recycle pool.

fn rehouse_for_recycle(&self) -> Option<Box<dyn Node>>

Optionally provides a compact replacement box for this recycled shell.

fn rehouse_for_live_compaction(&mut self) -> Option<Box<dyn Node>>

Optionally moves a live node onto a fresh box during applier compaction.

fn update(&mut self)

fn debug_heap_bytes(&self) -> usize

Returns the node-owned heap retained beyond the node’s own box allocation.