Struct ProgressiveLayoutContext 

pub struct ProgressiveLayoutContext<'a> { /* private fields */ }

Opt-in wrapper that breaks a single synchronous layout pass into incremental batches so the UI thread is not blocked for large child lists.

ProgressiveLayoutContext stores the list of children, tracks which ones have been processed, and exposes layout_next_batch to advance layout by batch_size children at a time. Partial results are persisted through LayoutCache so that subsequent frames can pick up where the previous frame left off.

Typical usage:

let mut ctx = ProgressiveLayoutContext::new(bounds, &subviews, spacing, alignment, distribution);
while !ctx.is_complete() {
    ctx.layout_next_batch(8);
}
let rects = ctx.take_rects();

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.

No layout work is performed in the constructor; call layout_next_batch to advance.

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

Layout up to batch_size additional children.

Returns true when all children have been laid out (i.e. the context is complete). Returns false when there are still pending children.

Already-laid-out children are skipped on subsequent calls so it is safe to call this method multiple times with any batch size.

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

Variant of layout_next_batch that accepts a LayoutCache for integration with the persistent cache. When cache is Some, the method reads and writes size/rect entries so that partial results survive across frames.

Returns (is_complete, Vec<Rect>) where the rect vector contains the newly-computed rects for the children processed in this batch.

pub fn is_complete(&self) -> bool

Returns true when every child has been laid out OR fallback has been applied to remaining children.

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. Fallback rects are estimated from the child’s cached previous rect (if available in cache.previous_rects) or from a simple grid-based estimate within self.bounds.

After calling this method is_complete() returns true.

Returns the fallback rects that were assigned (one per remaining child).

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

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