iris-ai/iris
1
0 Fork 0
forked from iris/iris
Code Pull Requests Activity

Ask each child once and place its answer by re-expression

Browse Source 
A widget draws in the box it is asked in and its answer is placed inside
that box by re-expressing the drawing; nothing is drawn again in a box an
answer chose. The offer machinery, whose job was to tell a measuring draw
from a placing one, goes with the placing draw. A span measures each child
from its cursor and moves fixed children to their slots with place_at; a
share child is asked once more in its decided slot with its frame narrowed
to it. A stack asks non-sizing children in the box its sizing child
decided. A scroll asks its content once and moves it to the scrolled
offset. A local redraw asks the retained question again and puts the
answer back where the parent placed it.

A symbolic length a child pinned composes through Part::Of exactly where
the part is the whole box less pixels, and pins the parent's own length
otherwise; dropping it let a pad reuse a drawing across a narrowed frame
of the same pixel length (shrinker seeds 60, 248 and 384 at depth 5).

Suite 114/114 including the two decided-box pins, fast oracle 11/11,
shrinker 400 seeds at depth 5 over all fifteen cases.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
iris-aiandClaude Fable 5.1 committed 2026-09-18 18:20:57 -04:00
1 parent 4328eac756
commit 3091fb86df
12 files changed
+353 -354
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

core/src/layout_diagnostics.rs
-4
View File
@@ -32,7 +32,6 @@ pub(crate) enum Counter {
SizeReads,
HintHits,
HintMisses,
RetainedSizeHits,
ReuseAttempts,
ReuseExact,
ReuseMoved,
@@ -42,7 +41,6 @@ pub(crate) enum Counter {
ReuseOutside,
ReuseWrongLayer,
ReuseWrongNode,
PlaceRedraws,
QueuePops,
DepthReads,
LocalRedraws,
@@ -70,7 +68,6 @@ impl Counter {
"draw-result size reads",
"hint hits",
"hint misses",
"retained size hits",
"reuse attempts",
"reuse exact",
"reuse moved",
@@ -80,7 +77,6 @@ impl Counter {
"reuse: outside what it holds for",
"reuse: another layer",
"reuse: region-node choice changed",
"placed by redrawing",
"redraw queue pops",
"depth reads",
"local redraws",
core/src/ui/active.rs
+16 -11
View File
@@ -1,6 +1,6 @@
use crate::{
LayerId, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, Place, RegionAlign, RetainedPrimitive, Size,
TextureHandle, UiRegion, WidgetId,
LayerId, LayoutHolds, LayoutLen, Len, MaskIdx, MoveIdx, Place, RegionAlign, RetainedPrimitive,
Size, TextureHandle, UiRegion, WidgetId,
};
/// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -20,17 +20,22 @@ pub struct ActiveData {
/// length. Its length is the same on every ask, which is what
/// a local redraw relies on to ask its parent's own question again.
pub frame: UiRegion,
/// What of its parent's extent the drawing was given, and what it was
/// given at the parent's first ask of it -- the question a cold layout
/// asks. A part is a length from the extent's start, so an extent that
/// moved re-places every child by re-adding that start.
/// The length its frame was narrowed to on each axis, as a length of
/// its parent's frame: a declared rule, or a box its parent decided for
/// it. `None` forwards the parent's frame whole. Kept as a length rather
/// than a position so that every placement puts the frame back in the
/// part it is given.
pub narrow: [Option<Len>; 2],
/// Where its drawing was put, as a part of its parent's box, and where
/// it was asked. The two differ where a container asks in one place and
/// places the answer in another -- a row measures from its cursor and
/// puts the child in its slot. A part is a length from the box's start,
/// so a box that moved re-places every child by re-adding that start.
pub place: [Place; 2],
pub offer_place: [Place; 2],
/// The box that ask gave it, in its frame's coordinates. Kept rather
/// than worked out again from where its parent's own box is now: a
/// parent drawn again in the box its own answer chose gives its children
/// boxes it never measured anything in, and the measurement this widget
/// answered is the one its parent's layout was built on.
/// The box it was asked in, in its frame's coordinates: the box its
/// drawing was made in and the one its contract is about. Its drawing
/// is placed elsewhere by re-expression, never by asking again there.
pub offer_part: UiRegion,
/// The measured answer and its dependencies. A hint-only dependency or
/// a widget first encountered during placement has no measurement yet.
core/src/ui/painter.rs
+101 -94
View File
@@ -1,14 +1,14 @@
#[cfg(feature = "layout-diagnostics")]
use crate::layout_diagnostics::{self as diag, Counter};
use crate::{
Axis, Holds, LayoutHolds, LayoutLen, Len, Part, Place, Px, PxVec2, RegionAlign, RenderedText,
RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
Axis, Holds, LayoutHolds, LayoutLen, Len, Part, Place, Px, PxVec2, RegionAlign, Rel,
RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData,
TextureHandle, UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
render::{
GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
TexturePrimitive,
},
ui::render_state::DrawInfo,
ui::render_state::{DrawInfo, Placing},
};
const AXES: [Axis; 2] = [Axis::X, Axis::Y];
@@ -44,13 +44,6 @@ pub struct Painter<'a> {
/// Only children whose answers were read constrain this widget's answer.
pub(super) answer_under: LayoutHolds,
pub(super) children: Vec<WidgetId>,
/// The children asked about so far, so the first place each was asked in
/// is the one recorded as its offer.
pub(super) offered: Vec<WidgetId>,
/// Whether this draw is at the place its parent first asked about, which
/// makes the questions it asks the ones a cold layout asks and their
/// answers the ones to keep.
pub(super) at_offer: bool,
/// The children whose size this widget read while drawing.
pub(super) size_deps: Vec<WidgetId>,
/// What this draw itself read of its frame in pixels, per axis: every
@@ -58,8 +51,9 @@ pub struct Painter<'a> {
pub(super) frame_own: [Holds; 2],
/// The same for its own box.
pub(super) extent_own: [Holds; 2],
/// Dependencies of every child drawing, including unmeasured overlays.
pub(super) under: LayoutHolds,
/// What each child's drawing depends on. Asking a child again replaces
/// its drawing, so it replaces this too rather than narrowing it.
pub(super) under: Vec<(WidgetId, LayoutHolds)>,
/// The movable region this widget's primitives are positioned through:
/// its own when opted in, otherwise the nearest ancestor's.
pub(super) move_idx: MoveIdx,
@@ -151,37 +145,40 @@ impl<'a> Painter<'a> {
/// one child wants, and what every transparent container passes for the
/// frame.
pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
self.widget_at(id, UiRegion::FULL, [Place::Within(Part::All); 2])
self.widget_at(id, [None; 2], [Place::Within(Part::All); 2])
}
/// Draws a child, saying what its fractions are of and where its drawing
/// goes.
/// Asks a child, saying what its fractions are of and where it is asked.
///
/// `frame` is that reference, in this widget's own frame coordinates:
/// [`UiRegion::FULL`] forwards this widget's frame, which is what a
/// container that only divides room passes, so a fraction under it means
/// the same wherever it sits and however deeply it is nested. Narrowing
/// it is for what is decided from above, and a declared length narrows
/// it here.
/// `narrow` is a length this widget decided for the child's frame, per
/// axis, as a length of this widget's own frame: a resolved share, or a
/// box a sibling's answer decided. `None` forwards this widget's frame,
/// which is what a container that only divides room passes, so a
/// fraction under it means the same wherever it sits and however deeply
/// it is nested. A declared length narrows the frame here whatever the
/// caller says. A narrowed frame is placed in the part by the child's
/// alignment and is the box the child is asked in.
///
/// `place` is where the drawing goes, per axis, as a part of this
/// widget's extent: see [`Place`]. A narrowed frame is its own extent,
/// since the narrowing is what said where the drawing goes.
/// `place` is where the child is asked, per axis, as a part of this
/// widget's box: see [`Place`]. The child draws once, in that box, and
/// its answer is placed inside it by re-expressing the drawing. Nothing
/// is drawn again in a box an answer chose; a container that puts the
/// answer somewhere else says so with [`Self::place_at`].
pub fn widget_at<'s, W: ?Sized>(
&'s mut self,
id: &'s StrongWidget<W>,
frame: UiRegion,
narrow: [Option<Len>; 2],
place: [Place; 2],
) -> DrawResult<'s, 'a, W> {
let region_node = self.rsc.widgets().is_region_node(id.id());
let declared = self.declared_lens(id);
let align = self.rsc.widgets().alignment(id.id());
let (local, extent) = frame_and_extent(
frame,
part_of(self.extent, place),
narrowed_by(declared, frame),
align,
);
let declared_narrow = narrowed_by(declared);
let narrow = [
declared_narrow[0].or(narrow[0]),
declared_narrow[1].or(narrow[1]),
];
let (local, extent) = frame_and_extent(part_of(self.extent, place), narrow, align);
let within = match local == UiRegion::FULL {
true => self.frame,
false => local.within(&self.frame),
@@ -195,19 +192,7 @@ impl<'a> Painter<'a> {
if !self.children.contains(&id.id()) {
self.children.push(id.id());
}
let first_ask = self.offer(id.id());
let offer_place = if first_ask {
place
} else {
self.state
.active
.get(&id.id())
.map_or(place, |a| a.offer_place)
};
let px = local.size().to_px(self.px);
// The answer and what it holds for, both about the place asked in.
// The child's record may say something else once its drawing has been
// placed: a drawing made again in its placed box holds for that box.
let (size, answer_holds, holds) = self.state.draw_inner(
id.id(),
DrawInfo {
@@ -221,14 +206,20 @@ impl<'a> Painter<'a> {
frame_abs: within,
part: extent,
place,
offer_place,
offer_place: place,
narrow,
px,
},
None,
self.rsc,
);
let compose = |holds| in_parent(holds, local, extent, place, declared);
self.under = self.under.and(compose(holds));
let own = self.extent;
let compose = |holds| in_parent(holds, local, extent, place, narrow, own);
let holds = compose(holds);
match self.under.iter_mut().find(|(child, _)| *child == id.id()) {
Some((_, kept)) => *kept = holds,
None => self.under.push((id.id(), holds)),
}
DrawResult {
child: id,
painter: self,
@@ -242,9 +233,37 @@ impl<'a> Painter<'a> {
/// this frame; what it answered is still something this widget asked.
pub fn undraw<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
self.children.retain(|child| *child != id.id());
self.under.retain(|(child, _)| *child != id.id());
self.state.undraw_rec(id.id(), self.rsc);
}
/// Puts a child asked about in this draw somewhere else in this
/// widget's box: its answer, placed in this part instead. The drawing
/// is re-expressed there rather than made again -- what a row does once
/// it knows every slot, having measured each child from its cursor.
pub fn place_at<W: ?Sized>(&mut self, id: &StrongWidget<W>, place: [Place; 2]) {
debug_assert!(
self.children.contains(&id.id()),
"'{}' placed a child it did not ask about in this draw",
self.label()
);
let at = self.placing();
self.state.place_in(id.id(), &at, place, self.rsc);
}
/// This widget as the thing its children are placed within.
fn placing(&self) -> Placing {
Placing {
id: self.id,
extent: self.extent,
local: self.frame,
px: self.px,
depth: self.depth,
move_idx: self.move_idx,
mask: self.mask,
}
}
/// What a widget's rules declare its lengths to be, which whoever draws
/// it resolves into its frame. Reading them depends on nothing -- the box
/// that comes of them is kept on the child, and `redraw` compares it
@@ -281,19 +300,6 @@ impl<'a> Painter<'a> {
}
}
/// Whether this is the first box a child is asked about in during a draw
/// that is itself the one its parent measured -- the question a cold
/// layout asks, whose answer is the one to keep. A drawing made again in
/// a box chosen from an answer asks about that box instead, and what it
/// hears back is not a measurement of anything.
fn offer(&mut self, child: WidgetId) -> bool {
if !self.at_offer || self.offered.contains(&child) {
return false;
}
self.offered.push(child);
true
}
fn depend_on<W: ?Sized>(&mut self, child: &StrongWidget<W>) {
if !self.size_deps.contains(&child.id()) {
self.size_deps.push(child.id());
@@ -537,19 +543,21 @@ impl PrimitiveLike for &TextureHandle {
/// reach it as one length, so what it holds for maps back through that
/// length exactly -- and where the box it was given is this widget's own,
/// what it says about that box is what this widget can say about its own.
/// `own` is this widget's own box, for a pin that cannot be said exactly.
pub(crate) fn in_parent(
holds: LayoutHolds,
frame: UiRegion,
extent: UiRegion,
place: [Place; 2],
declared: [Option<LayoutLen>; 2],
narrow: [Option<Len>; 2],
own: UiRegion,
) -> LayoutHolds {
let mut result = LayoutHolds::ANY;
for axis in AXES {
let n = axis as usize;
let frame_len = frame.axis(axis).len();
result.frame[n] = holds.frame[n].through(frame_len);
match (place[n].part(), declared[n]) {
match (place[n].part(), narrow[n]) {
// Its box is this widget's own, or a part of it in that box's
// own lengths: so what it holds for is a range on this widget's
// own box, which is what lets that box move without a redraw. A
@@ -561,13 +569,22 @@ pub(crate) fn in_parent(
}
// Its box is a part of this widget's own box, in that box's own
// lengths, so what it holds for maps back through that part into
// a range on this widget's box.
// a range on this widget's box. A length it pinned is this
// widget's length less the part's pixels where the part is the
// whole of the box less pixels, which is the one shape that
// inverts exactly; any other part pins this widget's own length.
(Part::Of(span), None) => {
result.extent[n] = holds.extent[n].through(span.len());
let part_len = span.len();
result.extent[n] = holds.extent[n].through(part_len);
result.extent_len[n] = holds.extent_len[n].map(|pinned| match part_len.rel {
Rel::ONE => pinned - Len::from_parts(Rel::ZERO, part_len.px),
_ => own.axis(axis).len(),
});
}
// Its box is a part of this widget's frame: a length of the
// frame is all that reaches it, so what it holds for is a range
// on the frame and none of it on this widget's own box.
// Its box is a part of this widget's frame, or a length of it
// decided here: a length of the frame is all that reaches it,
// so what it holds for is a range on the frame and none of it
// on this widget's own box.
_ => {
result.frame[n] = result.frame[n].and(
holds.extent[n]
@@ -670,44 +687,34 @@ pub(crate) fn part_of(extent: UiRegion, place: [Place; 2]) -> UiRegion {
/// The length a rule gives a child's frame, per axis: a fraction in it is a
/// fraction of the frame the child was given, which is the one length the
/// rule can mean.
pub(crate) fn narrowed_by(declared: [Option<LayoutLen>; 2], frame: UiRegion) -> [Option<Len>; 2] {
AXES.map(|axis| {
declared[axis as usize]
.map(|len| Len::from_parts(len.rel, len.px).within_len(frame.axis(axis).len()))
})
pub(crate) fn narrowed_by(declared: [Option<LayoutLen>; 2]) -> [Option<Len>; 2] {
declared.map(|declared| declared.map(|len| Len::from_parts(len.rel, len.px)))
}
/// The frame a child is asked in and the box its drawing goes in, both in
/// the coordinates of the widget asking.
/// The frame a child is asked in and the box it is asked in, both in the
/// coordinates of the widget asking.
///
/// `frame` is what the caller said the child's fractions are of, and `part`
/// what of the caller's own box the drawing takes. `narrow` is the length a
/// declared rule gives the frame, which makes the frame the box the drawing
/// goes in -- a rule is what decided where it goes, and there is nothing
/// left to place inside it. A caller that narrowed the frame itself said the
/// same thing.
/// `part` is what of the caller's own box the child is given. `narrow` is a
/// length decided for the child's frame -- a rule, a share, a box a sibling
/// decided -- which makes the frame the box the child is asked in: that
/// length is what decided where it goes, placed in the part by the child's
/// alignment. Where nothing narrowed it, the frame is the caller's own and
/// the part is the box.
///
/// The length is the caller's to supply so that a widget asked again gets
/// the frame it already has rather than a second resolution of its rule.
/// A length rather than a position, so that a child placed again is put back
/// in whatever part it is given rather than where it first was.
pub(crate) fn frame_and_extent(
mut frame: UiRegion,
part: UiRegion,
narrow: [Option<Len>; 2],
align: RegionAlign,
) -> (UiRegion, UiRegion) {
let mut frame = UiRegion::FULL;
let mut extent = part;
for (axis, narrow) in AXES.into_iter().zip(narrow) {
let span = frame.axis_mut(axis);
let narrowed = match narrow {
Some(len) => {
let slot = part.axis(axis);
let start = slot.start + (slot.len() - len).scale(align.axis(axis).rel());
*span = UiSpan::new(start, start + len);
true
}
None => *span != UiSpan::FULL,
};
if narrowed {
if let Some(len) = narrow {
let slot = part.axis(axis);
let start = slot.start + (slot.len() - len).scale(align.axis(axis).rel());
*frame.axis_mut(axis) = UiSpan::new(start, start + len);
*extent.axis_mut(axis) = UiSpan::FULL;
}
}
core/src/ui/render_state.rs
+164 -196
View File
@@ -2,8 +2,8 @@
use crate::layout_diagnostics::{self as diag, Counter, ReuseOutcome, TimerKind};
use crate::ui::painter::{declared_lens, frame_and_extent, narrowed_by, part_of, placed_extent};
use crate::{
ActiveData, Axis, DrawLayers, Holds, IdLike, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, Moves,
Painter, Part, PixelRegion, Place, PxVec2, Size, StrongWidget, UiRegion, UiRsc, Weight,
ActiveData, Axis, DrawLayers, Holds, IdLike, LayoutHolds, LayoutLen, Len, MaskIdx, MoveIdx,
Moves, Painter, Part, PixelRegion, Place, PxVec2, Size, StrongWidget, UiRegion, UiRsc, Weight,
WidgetId, Widgets,
util::{HashMap, Vec2},
};
@@ -26,14 +26,18 @@ pub(super) struct DrawInfo {
/// That frame composed into `parent_move`'s coordinates, which is what
/// the widget's own drawing is written within.
pub frame_abs: UiRegion,
/// The box the drawing is given, in the frame's own coordinates: the
/// The box the widget is asked in, in the frame's own coordinates: the
/// part of the parent's own box that `place` names, before the widget's
/// answer is placed inside it.
pub part: UiRegion,
/// What of the parent's extent the drawing was given, and what it was
/// given at the parent's first ask of it. See [`Place`].
/// Where the widget is put, and where it was asked, as parts of the
/// parent's box. See [`Place`]. The two are one ask's place until the
/// parent places the answer somewhere else.
pub place: [Place; 2],
pub offer_place: [Place; 2],
/// The length the frame was narrowed to on each axis, as a length of
/// the parent's frame, where anything narrowed it.
pub narrow: [Option<Len>; 2],
/// The frame in pixels: one multiply from the parent's own, which is
/// where every pixel length in layout comes from.
pub px: PxVec2,
@@ -45,34 +49,20 @@ impl DrawInfo {
fn fill(&self) -> [bool; 2] {
self.place.map(Place::fills)
}
/// Whether this ask is the one the widget's answer is kept from: the
/// same widget in the place its parent measured it by, however this draw
/// came about.
///
/// **Open.** A place is a length from where the asking widget's own box
/// starts, so two drawings of that widget -- one in the box its parent
/// measured it in, one in the box its own answer chose -- ask their
/// children in the same places and different boxes, and this cannot tell
/// them apart. Shrinker seeds 2 (`repaint`) and 108 (`reorder`) at depth
/// 5 are where that shows.
fn offer(&self) -> bool {
self.place == self.offer_place
}
}
/// What a widget's children are placed in: its own box, the coordinates its
/// drawing is in, and what else one ask of a child is decided from.
struct Placing {
id: WidgetId,
extent: UiRegion,
pub(super) struct Placing {
pub id: WidgetId,
pub extent: UiRegion,
/// The widget's frame in the coordinates its children compose within:
/// `FULL` where it is a region node, since its box is that node.
local: UiRegion,
px: PxVec2,
depth: usize,
move_idx: MoveIdx,
mask: MaskIdx,
pub local: UiRegion,
pub px: PxVec2,
pub depth: usize,
pub move_idx: MoveIdx,
pub mask: MaskIdx,
}
pub struct UiRenderState {
@@ -137,8 +127,7 @@ impl UiRenderState {
let px = active.frame.size().to_px(size);
// Nothing above the root chose anything, so the box it was first
// asked about is the whole of its frame.
let offer = part_of(UiRegion::FULL, active.offer_place);
active.answers_at(px, offer) && active.holds.contains(px, active.extent)
active.answers_at(px, active.offer_part) && active.holds.contains(px, active.offer_part)
});
if !stands {
widgets.needs_redraw.insert(root);
@@ -164,6 +153,7 @@ impl UiRenderState {
part: UiRegion::FULL,
place: [Place::Within(Part::All); 2],
offer_place: [Place::Within(Part::All); 2],
narrow: [None; 2],
px,
}
}
@@ -219,14 +209,8 @@ impl UiRenderState {
/// The root's frame: the window, narrowed by the root's own rules. Its
/// extent is that frame, since nothing above it chose anything else.
fn root_region(id: WidgetId, widgets: &Widgets) -> UiRegion {
let narrow = narrowed_by(declared_lens(widgets, id), UiRegion::FULL);
frame_and_extent(
UiRegion::FULL,
UiRegion::FULL,
narrow,
widgets.alignment(id),
)
.0
let narrow = narrowed_by(declared_lens(widgets, id));
frame_and_extent(UiRegion::FULL, narrow, widgets.alignment(id)).0
}
pub(super) fn draw_inner(
@@ -243,71 +227,50 @@ impl UiRenderState {
diag::draw_request(id, info.parent, frame, info.px, info.region_node);
}
let align = rsc.widgets().alignment(id);
let declared = declared_lens(rsc.widgets(), id);
// Nothing this widget measured can be dirty while it draws: layout is
// one bottom-up walk, so anything deeper has settled or deferred to
// its own parent, and a deferred one leaves that parent marked.
let stale = rsc.widgets().needs_redraw.contains(&id);
let retained = match stale {
true => None,
false => self
.retained_answer(id, part, info)
.or_else(|| self.try_reuse(id, frame, part, info, rsc)),
};
let answer = retained.unwrap_or_else(|| {
// The widget draws once, in the box it is asked in, and its answer
// is placed inside that box by re-expressing the drawing. The box the
// answer chose is never a question: nothing is drawn again in it, so
// an answer is kept only with the drawing that gave it, and both
// have to hold for the box asked about.
let reused = (!stale)
.then(|| self.retained_answer(id, part, info))
.flatten()
.and_then(|answer| {
let extent = placed_extent(part, answer.0, declared, info.fill(), align);
self.try_reuse(id, frame, part, extent, info, rsc)
.map(|()| answer)
});
let answer = reused.unwrap_or_else(|| {
if old.is_none() {
old = self.remove(id, false, rsc);
}
self.draw_at(id, part, info, old.take(), rsc)
let answer = self.draw_at(id, part, info, old.take(), rsc);
// Where the drawing goes: the part its parent gave it, with the
// answer placed inside that part on any axis the parent left
// open.
let extent = placed_extent(part, answer.0, declared, info.fill(), align);
if extent != part {
self.reposition(id, frame, extent, info, rsc);
}
answer
});
// Where the drawing goes, in the frame's own coordinates: the part
// its parent gave it, with the answer placed inside that part on any
// axis the parent left open. The frame itself does not change, so
// nothing under it resolves a fraction a second time.
//
// From the answer it gave when its parent measured it, and not from
// what a placing evaluation reported: placing a drawing by what it
// said in the box its own answer chose would move the box out from
// under it.
let measured = match info.offer() {
true => answer.0,
false => self.active[&id].measured().unwrap_or(answer.0),
};
let extent = placed_extent(
part,
measured,
declared_lens(rsc.widgets(), id),
info.fill(),
align,
);
self.place(id, extent, info, rsc);
// On axes the parent filled, measurement and drawing share an extent.
// Otherwise the answer fixes the final extent as a function of the
// frame, so pull that drawing's validity back through it.
let drawing_holds = self.active[&id].holds;
let mut settled = answer;
for axis in AXES {
let n = axis as usize;
settled.1.frame[n] = settled.1.frame[n].and(drawing_holds.frame[n]);
if info.fill()[n] {
settled.1.extent[n] = settled.1.extent[n].and(drawing_holds.extent[n]);
} else {
settled.1.frame[n] = settled.1.frame[n]
.and(drawing_holds.extent[n].through(extent.axis(axis).len()));
}
}
let active = self.active.get_mut(&id).unwrap();
// Whoever asked owns how the boxes were reached: the frame it stated,
// and what of its own box it gave the drawing. A local redraw asks
// the same question again from these.
// and what of its own box it asked in. A local redraw asks the same
// question again from these.
active.frame_abs = frame;
active.frame = info.frame;
if info.offer() {
active.answer = Some(answer);
active.offer_place = info.offer_place;
active.offer_part = part;
}
active.narrow = info.narrow;
active.answer = Some(answer);
active.offer_place = info.offer_place;
active.offer_part = part;
active.place = info.place;
active.own_align = align;
// A subtree can be reused whole under a different parent -- same box,
@@ -322,21 +285,7 @@ impl UiRenderState {
{
old_parent.children.retain(|child| *child != id);
}
(answer.0, answer.1, settled.1)
}
/// Recompose retained geometry when the evaluation still holds at this extent.
fn place(&mut self, id: WidgetId, extent: UiRegion, info: DrawInfo, rsc: &mut dyn UiRsc) {
if self
.try_reuse(id, info.frame_abs, extent, info, rsc)
.is_some()
{
return;
}
#[cfg(feature = "layout-diagnostics")]
diag::bump(Counter::PlaceRedraws);
let old = self.remove(id, false, rsc);
self.draw_at(id, extent, info, old, rsc);
(answer.0, answer.1, drawing_holds)
}
/// Calls a widget's `draw` and keeps what it drew in `extent` of `frame`.
@@ -361,15 +310,9 @@ impl UiRenderState {
// Reusing its index sooner could make an old parent look current.
false => (info.parent_move, frame, self.slots.remove(&id)),
};
let (old_children, old_answer, old_offer_part) = match old {
Some(old) => (old.children, old.answer, Some(old.offer_part)),
None => (Vec::new(), None, None),
};
let old_children = old.map_or_else(Vec::new, |old| old.children);
rsc.widgets_mut().needs_redraw.remove(&id);
// Only evaluation at the original offer establishes the children's
// offers. A placing evaluation must not overwrite that question.
let px = info.px;
let at_offer = info.offer();
let mut painter = Painter {
state: self,
@@ -385,11 +328,9 @@ impl UiRenderState {
primitives: Vec::new(),
mask_region: None,
children: Vec::new(),
offered: Vec::new(),
at_offer,
size_deps: Vec::new(),
frame_own: [Holds::ANY; 2],
under: LayoutHolds::ANY,
under: Vec::new(),
extent_own: [Holds::ANY; 2],
answer_under: LayoutHolds::ANY,
depth: info.depth,
@@ -422,8 +363,6 @@ impl UiRenderState {
extent_len,
answer_under,
children,
offered: _,
at_offer: _,
size_deps,
frame_own,
under,
@@ -471,7 +410,9 @@ impl UiRenderState {
extent_len,
};
let answer_holds = own_holds.and(answer_under);
let holds = answer_holds.and(under);
let holds = under
.into_iter()
.fold(answer_holds, |holds, (_, child)| holds.and(child));
debug_assert!(
holds.contains(px, extent),
"'{}' ({id:?}) drew in {px:?}, outside the ranges it reported: {holds:?}",
@@ -496,6 +437,7 @@ impl UiRenderState {
part: UiRegion::FULL,
place: [Place::Within(Part::All); 2],
offer_place: [Place::Within(Part::All); 2],
narrow: [None; 2],
px,
},
rsc,
@@ -509,11 +451,12 @@ impl UiRenderState {
frame_abs: frame,
extent,
frame: info.frame,
narrow: info.narrow,
place: info.place,
offer_place: info.offer_place,
offer_part: old_offer_part.unwrap_or(extent),
// Whoever asked writes the answer, if this was the asking.
answer: old_answer,
offer_part: extent,
// Whoever asked writes the answer.
answer: None,
size,
holds,
drawn: true,
@@ -598,16 +541,17 @@ impl UiRenderState {
active.frame.size().to_px(parent_px)
}
/// Reuses the actual drawing in a new box if its retained contract holds
/// there. Answers retained from a different ask are handled separately.
/// Keeps the retained drawing if its contract holds for `part`, the box
/// asked about, and puts it at `extent`, where the answer places it.
fn try_reuse(
&mut self,
id: WidgetId,
frame: UiRegion,
part: UiRegion,
extent: UiRegion,
info: DrawInfo,
rsc: &mut dyn UiRsc,
) -> Option<(Size, LayoutHolds)> {
) -> Option<()> {
#[cfg(feature = "layout-diagnostics")]
diag::bump(Counter::ReuseAttempts);
if rsc.widgets().needs_redraw.contains(&id) {
@@ -656,7 +600,7 @@ impl UiRenderState {
// In pixels, because the frame is a fraction of its parent's and
// that may be what changed -- an unchanged fraction of a box half the
// size is half the widget.
if !active.holds.contains(info.px, extent) {
if !active.holds.contains(info.px, part) {
#[cfg(feature = "layout-diagnostics")]
{
// Which of the three said no, so a frame that redraws more
@@ -665,14 +609,13 @@ impl UiRenderState {
let holds = active.holds;
for axis in AXES {
let n = axis as usize;
if holds.extent_len[n].is_some_and(|pinned| pinned != extent.axis(axis).len()) {
if holds.extent_len[n].is_some_and(|pinned| pinned != part.axis(axis).len()) {
diag::bump(Counter::OutsidePinnedLen);
}
if !holds.frame[n].contains(info.px.axis(axis)) {
diag::bump(Counter::OutsideFrame);
}
if !holds.extent[n].contains(extent.axis(axis).len().to_px(info.px.axis(axis)))
{
if !holds.extent[n].contains(part.axis(axis).len().to_px(info.px.axis(axis))) {
diag::bump(Counter::OutsideExtent);
}
}
@@ -681,9 +624,31 @@ impl UiRenderState {
}
return None;
}
self.relocate(id, frame, extent, info, rsc);
Some(())
}
/// Puts a retained drawing where its parent now has it, without drawing:
/// a moved frame recomposes the subtree or rewrites its node, and a box
/// of another length re-expresses everything inside it.
fn relocate(
&mut self,
id: WidgetId,
frame: UiRegion,
extent: UiRegion,
info: DrawInfo,
rsc: &mut dyn UiRsc,
) {
let active = &self.active[&id];
debug_assert!(
!rsc.widgets().needs_redraw.contains(&id),
"'{}' ({id:?}) placed while marked to draw",
rsc.widgets().label(id)
);
let has_region_node = active.move_idx != active.parent_move;
let extent_moved = active.extent != extent;
let moved = active.frame_abs != frame;
let (answer, slot) = ((active.size, active.holds), active.move_idx);
let slot = active.move_idx;
if moved {
if has_region_node {
self.moves.set(slot, frame);
@@ -719,20 +684,31 @@ impl UiRenderState {
},
);
}
Some(answer)
}
/// Places one child of `at.id` in the box that widget's own box gives
/// it: its part of the extent, with its answer placed inside that part
/// where the ask left the axis open.
/// Places one child of `at.id` where that widget's own box now has it.
fn place_child(&mut self, child: WidgetId, at: &Placing, rsc: &mut dyn UiRsc) {
let place = self.active[&child].place;
self.place_in(child, at, place, rsc);
}
/// Puts a child of `at.id` in `place` of that widget's box: its answer
/// placed inside that part where the place leaves the axis open, the
/// drawing re-expressed there.
pub(super) fn place_in(
&mut self,
child: WidgetId,
at: &Placing,
place: [Place; 2],
rsc: &mut dyn UiRsc,
) {
let active = &self.active[&child];
let (frame, part) = Self::re_ask(active, at.extent, active.place);
let (frame, part) = Self::re_ask(active, at.extent, place);
let extent = placed_extent(
part,
active.measured().unwrap_or(active.size),
active.declared,
active.place.map(Place::fills),
place.map(Place::fills),
active.own_align,
);
let info = DrawInfo {
@@ -745,34 +721,24 @@ impl UiRenderState {
frame,
frame_abs: frame.within(&at.local),
part,
place: active.place,
place,
offer_place: active.offer_place,
narrow: active.narrow,
px: frame.size().to_px(at.px),
};
self.place(child, extent, info, rsc);
self.relocate(child, info.frame_abs, extent, info, rsc);
}
/// The frame and the box a widget being asked again is given, from what
/// it already has and where its parent's box is now. A frame's length is
/// the same on every ask, so a declared length is put back where it sits
/// in the part rather than resolved from its rule a second time.
/// The frame and the box a widget is given at `place` of its parent's
/// box, from what it already has. A frame's length is the same on every
/// ask, so a narrowed frame is put back where it sits in the part rather
/// than resolved a second time.
fn re_ask(
active: &ActiveData,
parent_extent: UiRegion,
parent_box: UiRegion,
place: [Place; 2],
) -> (UiRegion, UiRegion) {
let narrow = AXES.map(|axis| {
let n = axis as usize;
active.declared[n]
.is_some()
.then(|| active.frame.axis(axis).len())
});
frame_and_extent(
active.frame,
part_of(parent_extent, place),
narrow,
active.own_align,
)
frame_and_extent(part_of(parent_box, place), active.narrow, active.own_align)
}
/// Re-places everything inside a widget whose own box moved. Every child
@@ -943,6 +909,7 @@ impl UiRenderState {
frame_abs: UiRegion::FULL,
extent: UiRegion::FULL,
frame: UiRegion::FULL,
narrow: [None; 2],
place: [Place::Within(Part::All); 2],
offer_place: [Place::Within(Part::All); 2],
offer_part: UiRegion::FULL,
@@ -1178,12 +1145,20 @@ impl UiRenderState {
return true;
};
let px = self.asked_px(id);
let (was_answer, was_holds) = (active.answer, active.holds);
// The boxes its parent gave it, then and now: its frame is the same
// on every ask, so the question its parent asked is the one this
// asks again -- there is no box here that could be its parent's to
// choose instead.
let parent_extent = self.active[&parent].extent;
let (was_answer, was_holds, was_place) = (active.answer, active.holds, active.place);
// The question its parent asked, asked again: the same place of the
// box the parent was asked in, which is the box the parent's own
// draw ran in and what its children's parts are of. Where the
// parent's answer put its own drawing is not a question anybody
// asked, and nothing is asked in it here either.
let asked = self.placing_of(parent, self.active[&parent].offer_part);
let (frame, part) = Self::re_ask(active, asked.extent, active.offer_place);
debug_assert_eq!(
frame.size(),
active.frame.size(),
"'{}' ({id:?}) asked again in a frame of another length",
rsc.widgets().label(id)
);
let info = DrawInfo {
layer: active.layer,
parent: active.parent,
@@ -1191,51 +1166,19 @@ impl UiRenderState {
parent_move: active.parent_move,
region_node: rsc.widgets().is_region_node(id),
mask: active.parent_mask,
frame: active.frame,
frame_abs: active.frame_abs,
part: Self::re_ask(active, parent_extent, active.place).1,
place: active.place,
frame,
frame_abs: frame.within(&asked.local),
part,
place: active.offer_place,
offer_place: active.offer_place,
narrow: active.narrow,
px,
};
// The ask that measured it, asked again: the box it was measured in
// as its parent left it, rather than where that ask's place resolves
// to now -- a parent drawn again in the box its own answer chose
// gives its children boxes it never measured anything in.
let offered = DrawInfo {
place: info.offer_place,
part: active.offer_part,
..info
};
#[cfg(feature = "layout-diagnostics")]
diag::bump(Counter::LocalRedraws);
// Asked again in the box its parent gave it, which is the question
// its parent asked only while that box is as long as the one it was
// measured in. Any other box is a different question, so the parent
// asks it, with the mark left on. Lengths and not whole boxes: what
// a drawing depends on is its lengths, so the same lengths elsewhere
// is one question.
//
// The frame is the same on every ask now, so this is about the box
// the drawing goes in alone. Removing it -- asking the measuring
// question here and placing the answer afterwards -- is what the
// transparent-frames plan asks for next, and it does not hold yet:
// seeds 104 (`align`) and 210 (`reorder`) at depth 5 settle
// differently warm and cold without it.
if info.part.size() != offered.part.size() {
self.mark(id, rsc.widgets_mut());
self.mark(parent, rsc.widgets_mut());
return false;
}
let old = self.remove(id, false, rsc);
// The original measurement is refreshed before the assigned slot is
// restored: its lengths may differ even though the frame is
// unchanged.
let answer = self.draw_inner(id, offered, old, rsc);
if info.place != info.offer_place || info.part != offered.part {
self.draw_inner(id, info, None, rsc);
}
let answer = self.draw_inner(id, info, old, rsc);
let active = self.active.get_mut(&id).unwrap();
// A wider contract does not invalidate the guarantee the parent kept.
// Retain that guarantee so widening and narrowing back do not churn it.
@@ -1257,9 +1200,34 @@ impl UiRenderState {
diag::bump(Counter::ReaderEdges);
}
self.mark(parent, rsc.widgets_mut());
} else {
// The answer stands, so where the parent put it stands: the
// fresh drawing goes back there -- the same place, of the box
// the parent's answer chose rather than the one it was asked in.
let at = self.placing_of(parent, self.active[&parent].extent);
self.place_in(id, &at, was_place, rsc);
}
true
}
/// A drawn widget as the thing its children are placed within, with
/// `extent` as the box their parts are of: the box it was asked in for
/// asking one of them again, the box its answer chose for placing one.
fn placing_of(&self, id: WidgetId, extent: UiRegion) -> Placing {
let active = &self.active[&id];
Placing {
id,
extent,
local: match active.move_idx != active.parent_move {
true => UiRegion::FULL,
false => active.frame_abs,
},
px: self.asked_px(id),
depth: active.depth,
move_idx: active.move_idx,
mask: active.mask,
}
}
}
/// Whether what a widget reports along `axis` is inside the box it drew in.