Struct SubcomposeLayoutNode 

pub struct SubcomposeLayoutNode { /* private fields */ }

Node responsible for orchestrating measure-time subcomposition.

Implementations

impl SubcomposeLayoutNode

pub fn new( modifier: Modifier, measure_policy: Rc<dyn for<'scope> Fn(&mut SubcomposeMeasureScopeImpl<'scope>, Constraints) -> MeasureResult>, ) -> Self

Creates a node with modifier whose children measure_policy subcomposes and measures.

pub fn with_content_type_policy( modifier: Modifier, measure_policy: Rc<dyn for<'scope> Fn(&mut SubcomposeMeasureScopeImpl<'scope>, Constraints) -> MeasureResult>, ) -> Self

Creates a SubcomposeLayoutNode with ContentTypeReusePolicy.

Use this for lazy lists to enable content-type-aware slot reuse. Slots with matching content types can reuse each other’s nodes, improving efficiency when scrolling through items with different types.

pub fn handle(&self) -> SubcomposeLayoutNodeHandle

Returns a cloneable handle that shares this node’s state.

pub fn set_measure_policy( &mut self, policy: Rc<dyn for<'scope> Fn(&mut SubcomposeMeasureScopeImpl<'scope>, Constraints) -> MeasureResult>, )

Replaces the measure policy and invalidates the subcomposition. Does nothing if policy is the same Rc as the current one.

pub fn set_captured_context(&mut self, context: CapturedCompositionContext)

Records the source composition context for measure-time subcomposition. A context under a changed static composition local makes every slot compose again, running every body it holds, as Compose forces a SubcomposeLayout’s children.

pub fn set_density(&mut self, density: Density)

Records the grid the composition provided, re-measuring if it moved.

Mirrors LayoutNode::set_density: SubcomposeLayout captures this at the same composition site that captures the subcomposition context, so the two cannot disagree.

pub fn set_layout_direction(&mut self, direction: LayoutDirection)

Updates relative modifier placement for this node’s composition scope.

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

Replaces the modifier chain and invalidates the layout, draw, pointer input and semantics work that the changed modifier nodes affect.

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

Turns debug logging of the modifier chain on or off.

pub fn modifier(&self) -> Modifier

Returns the modifier that was last set on this node.

pub fn resolved_modifiers(&self) -> ResolvedModifiers

Returns the padding, layout properties and offset that the modifier chain resolved to.

pub fn layout_state(&self) -> LayoutState

Returns a clone of the current layout state.

pub fn set_position(&self, position: Point)

Updates the position of this node. Called during placement. LayoutState::place self-reports actual moves to the scene phase.

pub fn set_measured_size(&self, size: Size)

Updates the measured size of this node. Called during measurement. LayoutState::set_size self-reports actual changes to the scene phase.

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>

Semantics reported by this node’s live modifier chain.

pub fn semantics_reach(&self) -> SemanticsReach

Whether this node’s modifiers make it modal or hidden.

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

Returns the modifier slices snapshot for rendering.

pub fn state(&self) -> Ref<'_, SubcomposeState>

Borrows the subcomposition state that tracks the slots composed for this node.

pub fn state_mut(&self) -> RefMut<'_, SubcomposeState>

Mutably borrows the subcomposition state that tracks the slots composed for this node.

pub fn invalidate_subcomposition(&self)

Invalidates the recompose scopes of all slots and schedules a measure, so the measure policy subcomposes again.

pub fn request_measure_recompose(&self)

Schedules a measure for this node and its ancestors without invalidating the recompose scopes of its slots.

pub fn with_active_children<R>(&self, f: impl FnOnce(&[NodeId]) -> R) -> R

Calls f with the children this node placed in its last layout, in placement order, without copying them. Changes through a node handle during f become visible to the next read; this read keeps its original children.

pub fn mark_needs_measure(&self)

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

pub fn mark_needs_layout_flag(&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 mark_needs_semantics(&self)

Mark this node as needing semantics recomputation.

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)

Clears the pending redraw flag once the node has been drawn.

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 modifier_capabilities(&self) -> NodeCapabilities

Returns the modifier capabilities for this node.

pub fn has_layout_modifier_nodes(&self) -> bool

Returns whether the modifier chain contains layout modifier nodes.

pub fn has_draw_modifier_nodes(&self) -> bool

Returns whether the modifier chain contains draw modifier nodes.

pub fn has_pointer_input_modifier_nodes(&self) -> bool

Returns whether the modifier chain contains pointer input modifier nodes.

pub fn has_semantics_modifier_nodes(&self) -> bool

Returns whether the modifier chain contains semantics modifier nodes.

pub fn has_focus_modifier_nodes(&self) -> bool

Returns whether the modifier chain contains focus modifier nodes.

Trait Implementations

impl Node for SubcomposeLayoutNode

fn mark_descendant_needs_semantics(&self)

One flag serves both: the tree merges a subcompose node on every update, and a descendant’s change leaves its reach as it was.

fn mount(&mut self)

Called once the node has its id, when the composition applies the node’s creation.

fn unmount(&mut self)

Called just before the node is removed from the applier.

fn insert_child(&mut self, child: NodeId) -> bool

Adds child to this node’s child list, returning whether the list actually changed. A node that already holds the child returns false: callers record a structural change from this answer, and a structural change re-lowers the whole subtree, so claiming one for a no-op costs a full rebuild per call.

fn remove_child(&mut self, child: NodeId) -> bool

Removes child from this node’s child list, returning whether the list actually changed. Only this node can answer that: a caller inspecting the child’s parent pointer gets it wrong when the child was reparented while still listed here.

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

Moves the child at the first index to the second index in the child list.

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

Replaces the child list with children, in order.

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

Copies child IDs into the provided scratch buffer without allocating a fresh container for every traversal. A node without children leaves the buffer empty.

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

Copies the ids of the children this node owns, in order, into out. A node whose collect_children_into leaves some children out overrides this to list them all. The default calls collect_children_into.

fn owned_child_index(&self, child: NodeId) -> Option<usize>

Finds a child in the order returned by Node::collect_owned_children_into. Nodes with slice-backed child storage should override this to avoid materializing the whole list for a single lookup.

fn set_node_id(&mut self, id: NodeId)

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

fn on_attached_to_parent(&mut self, parent: NodeId)

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<NodeId>

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_descendant_needs_layout(&self, measure: bool)

Mark that a node below this one needs layout, or measure when measure is set: a layout pass has to visit this node to reach it, while this node’s own measurement may still hold. A node that does not track the difference marks itself dirty.

fn descendant_needs_layout(&self) -> bool

Check if a node below this one needs layout or measure.

fn descendant_needs_measure(&self) -> bool

Check if a node below this one needs measure.

fn mark_needs_semantics(&self)

Mark this node as needing semantics recomputation.

fn needs_semantics(&self) -> bool

Check if this node or a node below it needs semantics recomputation.

fn set_parent_for_bubbling(&mut self, parent: NodeId)

Set parent reference for dirty flag bubbling ONLY. This is a minimal version of on_attached_to_parent that doesn’t trigger registry updates or other side effects. Used during measurement when we need to establish parent connections for bubble_measure_dirty without causing the full attachment lifecycle.

fn layout_dirty(&self) -> bool

Check if a layout pass has to visit this node: the node or a node below it needs layout or measure.

fn is_virtual(&self) -> bool

Whether the node lays out nothing itself and its parent lays out its children, so a change of its own is a change of its parent’s.

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 debug_heap_bytes(&self) -> usize

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