From 1c80051d575cea865683df3106cdee9059e05f91 Mon Sep 17 00:00:00 2001 From: iris-ai <4+iris-ai@noreply.localhost> Date: Thu, 17 Sep 2026 04:32:07 -0400 Subject: [PATCH] WIP: a report is a fraction of the parent's box, like a rule Removes the `reports_of` argument and the composition in `in_parent_frame`. Not landed: it makes `Pad` claim 220 px where its child draws 190, because the child is still drawn in the inset box while its report is read against the outer one. Consistency needs `Padding::region` to move the child's box in rather than shrink it, which makes every pad around a filling child overflow -- Bryan's call. --- core/src/ui/painter.rs | 60 +++++++++++------------------------ src/widget/position/scroll.rs | 5 ++- src/widget/position/span.rs | 19 ++++------- src/widget/position/stack.rs | 2 +- 4 files changed, 28 insertions(+), 58 deletions(-) diff --git a/core/src/ui/painter.rs b/core/src/ui/painter.rs index 6d19417..8428537 100644 --- a/core/src/ui/painter.rs +++ b/core/src/ui/painter.rs @@ -139,30 +139,20 @@ impl<'a> Painter<'a> { id: &'s StrongWidget, region: UiRegion, ) -> DrawResult<'s, 'a, W> { - self.widget_at(id, region, region.size(), [false; 2]) + self.widget_at(id, region, [false; 2]) } - /// Draws a widget in `region`, saying what the answer means. - /// - /// `reports_of` is what a fraction the child reports is a fraction of, as - /// lengths of this widget's own box. It is the box the child was given - /// wherever that box is the child's whole area -- a pad's inset, a stack - /// child, a scroll's content -- and a span passes its own extent along - /// the row instead: it offers each child the room left from its cursor, - /// because a text has to wrap at the width actually there, while - /// `rel(0.5)` still means half the span wherever the child sits in it. - /// - /// A `decided` axis is one where this box was chosen from the widget's - /// own answer. On those the answer is not placed inside the box again: it - /// already is the box, and a fraction taken of it a second time would - /// shrink it twice. A container uses that where it hands back exactly - /// what a child asked for -- a span placing a child at the length it - /// reported, a scroll giving its content the content's own length. + /// Draws a widget in a box this widget chose from the widget's own + /// answer along the `decided` axes. On those the answer is not placed + /// inside the box again: it already is the box, and a fraction the + /// widget reported, taken of this box a second time, would shrink it + /// twice. A container uses this where it hands back exactly what a child + /// asked for -- a span placing a child at the length it reported, a + /// scroll giving its content the content's own length. pub fn widget_at<'s, W: ?Sized>( &'s mut self, id: &'s StrongWidget, region: UiRegion, - reports_of: UiVec2, decided: [bool; 2], ) -> DrawResult<'s, 'a, W> { let region_node = self.rsc.widgets().is_region_node(id.id()); @@ -232,10 +222,18 @@ impl<'a> Painter<'a> { for (axis, under) in AXES.into_iter().zip(self.under.iter_mut()) { *under = under.and(holds[axis as usize].through(local.axis(axis).len())); } + // The answer as it was given. A fraction in it is a fraction of this + // widget's box, which is the same thing a rule beside the child + // means and the same thing for every box this widget hands out: a + // span offers each child the room left from its cursor, because a + // text has to wrap at the width actually there, and `rel(0.5)` is + // still half the span. Padding is outside what it pads for the same + // reason -- inset the fraction and a child's `rel` would mean the + // inner box while its `px` meant the outer one. DrawResult { child: id, painter: self, - size: in_parent_frame(size, reports_of, declared), + size, } } @@ -269,14 +267,12 @@ impl<'a> Painter<'a> { /// A child's length in the box it is about to be offered, if it can be /// had without drawing it: from its hint, or from a drawing it already - /// has that holds for that box. `reports_of` is what a fraction in the - /// answer is a fraction of, as it is for [`Self::widget_at`]. + /// has that holds for that box. pub fn known_len( &mut self, child: &StrongWidget, axis: Axis, region: UiRegion, - reports_of: UiVec2, ) -> Option { let declared = self.declared_lens(child); let align = self.rsc.widgets().alignment(child.id()); @@ -302,7 +298,7 @@ impl<'a> Painter<'a> { for (axis, under) in AXES.into_iter().zip(self.under.iter_mut()) { *under = under.and(holds[axis as usize].through(local.axis(axis).len())); } - Some(in_parent_frame(size, reports_of, declared).axis(axis)) + Some(size.axis(axis)) } /// Whether this is the first box a child is asked about in during a draw @@ -521,24 +517,6 @@ impl PrimitiveLike for &TextureHandle { } } -/// A child's answer as lengths of the parent's own box. A widget reports a -/// fraction, and `reports_of` is the length that fraction is of: the box the -/// child was given wherever that is the child's whole area, and the parent's -/// own extent wherever the box is a positional remainder, as a span's is -/// after an earlier child. Pixels come through untouched either way, being -/// that many pixels wherever they end up. A declared axis is already the -/// parent's: it resolved the rule in its own box, and the rule is what the -/// report says. -fn in_parent_frame(size: Size, reports_of: UiVec2, declared: [Option; 2]) -> Size { - let mut size = size; - for (axis, declared) in AXES.into_iter().zip(declared) { - if declared.is_none() { - *size.axis_mut(axis) = size.axis(axis).within_len(reports_of.axis(axis)); - } - } - size -} - /// What a widget declares a length of its box to be. `leftover` is not one: a /// share of what is left over is only a length to the widget dividing one, /// so it passes up in the size instead. diff --git a/src/widget/position/scroll.rs b/src/widget/position/scroll.rs index 199ff70..f0d02c3 100644 --- a/src/widget/position/scroll.rs +++ b/src/widget/position/scroll.rs @@ -14,8 +14,7 @@ impl Widget for Scroll { let container_len = painter.px_len(self.axis); // Draw in the whole container only when its scrolling-axis length is // not already known, then draw it at the scrolled offset. - let whole = UiRegion::FULL; - let answer_len = match painter.known_len(&self.inner, self.axis, whole, whole.size()) { + let answer_len = match painter.known_len(&self.inner, self.axis, UiRegion::FULL) { Some(len) => len, None => painter.widget(&self.inner).size().axis(self.axis), }; @@ -64,7 +63,7 @@ impl Widget for Scroll { region = region.offset(offset); region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len); } - painter.widget_at(&self.inner, region, region.size(), [true; 2]); + painter.widget_at(&self.inner, region, [true; 2]); // What it occupies is its box, on both axes: it clips its content to // that box, so it can neither take less of one nor honestly ask for // more. The content's length is what it scrolls through, not what it diff --git a/src/widget/position/span.rs b/src/widget/position/span.rs index f2d338e..f5c5bd8 100644 --- a/src/widget/position/span.rs +++ b/src/widget/position/span.rs @@ -21,14 +21,12 @@ impl Widget for Span { } let region = UiRegion::from_axis(axis, span, UiSpan::FULL); // Offered the room left from the cursor, because a text has to - // wrap at the width actually there, but reporting a fraction of - // the whole row: `rel(0.5)` is half the span whatever else is in - // it and wherever this child sits among them. - let len = match painter.known_len(child, axis, region, UiVec2::FULL_SIZE) { + // wrap at the width actually there, while what it reports is a + // fraction of the whole row: `rel(0.5)` is half the span + // whatever else is in it and wherever this child sits. + let len = match painter.known_len(child, axis, region) { Some(len) => len, - None => painter - .widget_at(child, region, UiVec2::FULL_SIZE, [false; 2]) - .len(axis), + None => painter.widget_at(child, region, [false; 2]).len(axis), }; cursor.px += len.px + self.gap; cursor.rel += len.rel; @@ -128,12 +126,7 @@ impl Widget for Span { // Along the row this box is the child's own answer, so the answer // is not placed in it again; across it the child sits where its // alignment says. - let placed = painter.widget_at( - child, - region, - UiVec2::FULL_SIZE, - [axis == Axis::X, axis == Axis::Y], - ); + let placed = painter.widget_at(child, region, [axis == Axis::X, axis == Axis::Y]); if shrinks { let used = placed.len(!axis); // Choosing between a fixed and a relative length from the diff --git a/src/widget/position/stack.rs b/src/widget/position/stack.rs index 2fd06e5..5183d91 100644 --- a/src/widget/position/stack.rs +++ b/src/widget/position/stack.rs @@ -35,7 +35,7 @@ impl Widget for Stack { // child is handed a box that owes nothing to its own answer, and // where it sits in one bigger than itself is its own business. match sizing == Some(i) { - true => painter.widget_at(child, region, region.size(), [true; 2]), + true => painter.widget_at(child, region, [true; 2]), false => painter.widget_within(child, region), }; }