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.
-    ///
-    /// `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<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
-    /// answer is a fraction of, as it is for [`Self::widget_at`].
+    /// has that holds for that box.
     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.