Struct BuildCtx 

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

Context threaded through View::build / View::rebuild.

Two responsibilities: allocating unique WidgetIds (it borrows the id counter owned by the render root so ids stay monotonic across passes), and carrying the effective focus chain — whether every link from the root down to the node being built/rebuilt/torn down is focused (see BuildCtx::has_focus).

Implementations

impl<'a> BuildCtx<'a>

pub fn new(next_id: &'a mut u64) -> Self

Create a context borrowing the render root’s id counter.

The focus chain seeds true — “unknown, assume live”. A caller that does not thread the chain therefore keeps the pre-chain behavior (every reconciler under it treats a focused pod as the live one) instead of silently suppressing a release it owed: over-releasing costs the user one tap, while under-releasing strands the shell’s IME surface over a widget that no longer exists and nothing on an idle screen ever corrects it (the same default-to-must-run rule the frame gate follows). The seams that know the real value — RenderRoot::rebuild’s view diff and ComponentWidget’s inner context — set it explicitly with BuildCtx::set_has_focus.

pub fn alloc_id(&mut self) -> WidgetId

Allocate a fresh, unique widget id.

pub fn has_focus(&self) -> bool

Whether the recorded focus path is live all the way from the root to the node currently being built/rebuilt/torn down — the rebuild-pass mirror of PaintCtx::has_focus, composed the same way (self.focused && ctx.has_focus()).

This is what makes a focused ChildPod flag deep inside a blurred branch harmless. A container-routed blur clears the focus link at the nearest common ancestor only, so flags below it legitimately go stale until focus next enters that subtree; a pod under a cleared link sees has_focus() == false here, exactly as it sees false in paint and exactly as focus-routed events never reach it. A reconciler therefore raises mark_focus_orphaned only when ctx.has_focus() && pod.is_focused() — only when the pod losing its identity is the one whose session is actually live.

pub fn set_has_focus(&mut self, has_focus: bool)

Seed the effective focus chain (see BuildCtx::has_focus).

For the two kinds of seam that start a chain rather than descend one: RenderRoot’s view diff, which seeds it from the root’s own session mirror, and a component-style widget that builds an inner BuildCtx over its own id counter (ComponentWidget is the in-crate one) and must carry its outer chain across that boundary. A container descending into a child pod uses BuildCtx::with_focus_link instead — it can only narrow, which is what keeps this an AND-chain.

pub fn with_focus_link<R>( &mut self, link_focused: bool, f: impl FnOnce(&mut Self) -> R, ) -> R

Run f with the focus chain extended by one link, restoring the caller’s chain when it returns.

link_focused is the descended-into pod’s own ChildPod::is_focused flag, so the closure sees self.has_focus() && link_focused: a cleared link anywhere above forces false for the whole subtree below it, and no descent can ever widen the chain. The rebuild-pass counterpart of ChildPod::paint_child’s set_has_focus(self.focused && ctx.has_focus()), in the scoped-closure shape SemanticsCtx::descend_into_pod already uses for the semantics pass.