Struct ProgressiveLayoutContext 

pub struct ProgressiveLayoutContext<'a> {
    pub children: &'a [&'a dyn LayoutView],
    pub entries: Vec<ProgressiveChild>,
    pub spacing: f32,
    pub alignment: Alignment,
    pub distribution: Distribution,
    pub bounds: Rect,
    pub completed: usize,
    pub fallback_applied: bool,
}

Opt-in wrapper that breaks a single layout pass into incremental batches.

Contract

Saves partially computed layouts inside LayoutCache so the main UI thread does not stall for deep trees.

Fields

children: &'a [&'a dyn LayoutView]

entries: Vec<ProgressiveChild>

spacing: f32

alignment: Alignment

distribution: Distribution

bounds: Rect

completed: usize

fallback_applied: bool

Implementations

impl<'a> ProgressiveLayoutContext<'a>

pub fn new( bounds: Rect, subviews: &'a [&'a dyn LayoutView], spacing: f32, alignment: Alignment, distribution: Distribution, ) -> Self

Create a new progressive layout context for the given subviews.

pub fn layout_next_batch(&mut self, batch_size: usize) -> bool

Layout up to batch_size additional children.

pub fn layout_next_batch_with_cache( &mut self, batch_size: usize, cache: &mut LayoutCache, ) -> (bool, Vec<Rect>)

Variant of layout_next_batch that integrates with a persistent cache.

pub fn is_complete(&self) -> bool

Returns true when every child has been laid out or fallback has been applied.

pub fn progress(&self) -> (usize, usize)

Returns (completed, total) progress counts.

pub fn apply_remaining_fallback(&mut self, cache: &mut LayoutCache) -> Vec<Rect>

Apply fallback positioning to all children that have not yet been laid out.

pub fn take_rects(self) -> Vec<Rect>

Consume the context and return the final Vec<Rect> for all children in order.