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

@@ -139,30 +139,20 @@ impl<'a> Painter<'a> {
         id: &'s StrongWidget<W>,
         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.
+    /// 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
-    /// `reports_of` is what a fraction the child reports is a fraction of, as
+    /// inside the box again: it already is the box, and a fraction the
-    /// lengths of this widget's own box. It is the box the child was given
+    /// widget reported, taken of this box a second time, would shrink it
-    /// wherever that box is the child's whole area -- a pad's inset, a stack
+    /// twice. A container uses this where it hands back exactly what a child
-    /// child, a scroll's content -- and a span passes its own extent along
+    /// asked for -- a span placing a child at the length it reported, a
-    /// the row instead: it offers each child the room left from its cursor,
+    /// scroll giving its content the content's own length.
-    /// 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.
     pub fn widget_at<'s, W: ?Sized>(
         &'s mut self,
         id: &'s StrongWidget<W>,
         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
+    /// has that holds for that box.
-    /// answer is a fraction of, as it is for [`Self::widget_at`].
     pub fn known_len<W: ?Sized>(
         &mut self,
         child: &StrongWidget<W>,
         axis: Axis,
         region: UiRegion,
-        reports_of: UiVec2,
     ) -> Option<LayoutLen> {
         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<LayoutLen>; 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.

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, UiRegion::FULL) {
-        let answer_len = match painter.known_len(&self.inner, self.axis, whole, whole.size()) {
             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

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
+            // wrap at the width actually there, while what it reports is a
-            // the whole row: `rel(0.5)` is half the span whatever else is in
+            // fraction of the whole row: `rel(0.5)` is half the span
-            // it and wherever this child sits among them.
+            // whatever else is in it and wherever this child sits.
-            let len = match painter.known_len(child, axis, region, UiVec2::FULL_SIZE) {
+            let len = match painter.known_len(child, axis, region) {
                 Some(len) => len,
-                None => painter
+                None => painter.widget_at(child, region, [false; 2]).len(axis),
-                    .widget_at(child, region, UiVec2::FULL_SIZE, [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(
+            let placed = painter.widget_at(child, region, [axis == Axis::X, axis == Axis::Y]);
-                child,
-                region,
-                UiVec2::FULL_SIZE,
-                [axis == Axis::X, axis == Axis::Y],
-            );
             if shrinks {
                 let used = placed.len(!axis);
                 // Choosing between a fixed and a relative length from the

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),
             };
         }