One argument says where a child goes and what its fractions are of

`Place` was a product written as a sum -- a `Part` and a fill flag -- and
`Part` named three operations the geometry already had, under words that did
not match them. `Of` was `UiSpan::within`, `From` was `UiSpan::shift`, and
`Sized` was `placement`'s own body with the length given rather than
reported. Both enums are gone.

`PlaceDescAxis` says one axis, named after the operation it performs:
`within`, `shifted`, `sized`, and `WHOLE`. What is optional is a builder --
`fills` and `rel_base` -- so a caller writes only what it decided, and the
rel base it does not write follows the constructor: a span composed into the
caller's box narrows it, a span along a cursor does not, a decided length is
it. That was the one rule a caller could get wrong with nothing failing.

`PlaceDesc` says both axes with named fields, so `axis`, `axis_mut` and
`from_axis` work the way they do on every other pair here, and the joint
work -- resolving a region, reading the fill flags -- is written once rather
than per axis. `widget_at` and `place_at` take `impl Into<PlaceDesc>`, so a
wrapper passes a `UiRegion` and says nothing else. `widget_within` and
`ActiveData::narrow_rel_base` are deleted; `asked` and `placed` carry the
rel base their ask stated.

Cold layout is byte-identical to `84dad21`.

core/src/ui/place.rs

@@ -1,70 +1,242 @@
-use crate::{AxisAlign, Len, PrimitiveHandle, UiRegion, UiSpan};
+use crate::{Axis, AxisAlign, Len, PrimitiveHandle, RegionAlign, UiRegion, UiSpan};
 
-/// A child's region along one axis, said as a part of the region the widget
-/// saying it was given.
+/// How a child's region along one axis comes from the region of the widget
+/// asking, and what its fractions are of.
+///
+/// The three ways of saying a region are the three the geometry already has:
+/// a span composed into the caller's box, a span shifted to where that box
+/// starts, and a length placed in it by alignment. Which one is meant cannot
+/// be read off the numbers, since two of them take the same span and apply
+/// it differently, so it is said here.
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Part {
-    /// Window lengths from where the box starts, which is what a container
-    /// dividing room among its children speaks: a child's report is a window
-    /// length, so the cursor that sums those reports is one too. A moved box
-    /// re-places every child by re-adding its start, exactly. A fraction
-    /// here is a fraction of the window and not of the box -- the whole of a
-    /// box is [`Self::WHOLE`], not a `rel(1.0)` span.
-    From(UiSpan),
-    /// A part of the box in its own coordinates, which is what a container
-    /// that insets one speaks: taking eleven pixels off the end needs no
-    /// length, where saying the same thing in window lengths would make the
-    /// container read its own box -- and a box chosen from its own answer
-    /// then feeds back into the answer.
-    Of(UiSpan),
-    /// A box of this length, wherever in the parent's box the child's own
-    /// alignment puts it, and that same length as its rel base. Unlike `From`,
-    /// it is a length decided from above rather than a place along a
-    /// container's cursor -- what a stack's sizing child decides for the
-    /// rest.
+pub struct PlaceDescAxis {
+    span: PlaceSpan,
+    fills: bool,
+    rel_base: RelBase,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum PlaceSpan {
+    Within(UiSpan),
+    Shifted(UiSpan),
     Sized(Len),
 }
 
-impl Part {
-    /// The whole of the box. Not a variant of its own: it composes and
-    /// inverts through the same expressions every other `Of` does.
-    pub const WHOLE: Self = Self::Of(UiSpan::FULL);
+/// What a child's fractions are of, where the caller has not named a length.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum RelBase {
+    /// The caller's own, unchanged.
+    Inherit,
+    /// The caller's own, narrowed the way the region is.
+    WithRegion,
+    /// This length of the window.
+    Len(Len),
+}
+
+impl PlaceDescAxis {
+    /// The whole of the caller's box.
+    pub const WHOLE: Self = Self::within(UiSpan::FULL);
+
+    /// `span` composed into the caller's own box, so it moves and scales
+    /// with it: [`UiSpan::within`], which is what a container that insets
+    /// one speaks. Taking eleven pixels off the end needs no length, where
+    /// saying the same thing in window lengths would make the container read
+    /// its own box -- and a box chosen from its own answer then feeds back
+    /// into the answer.
+    ///
+    /// The child's rel base is narrowed the same way, so padding takes its
+    /// pixels off both and `rel(1)` under it fills the caller rather than
+    /// overflowing it.
+    pub const fn within(span: UiSpan) -> Self {
+        Self {
+            span: PlaceSpan::Within(span),
+            fills: false,
+            rel_base: RelBase::WithRegion,
+        }
+    }
+
+    /// `span` shifted to where the caller's own box starts: window lengths
+    /// along a cursor, which is what a container dividing room among its
+    /// children speaks. A child's report is a window length, so the cursor
+    /// that sums those reports is one too, and a moved box re-places every
+    /// child by re-adding its start, exactly.
+    ///
+    /// The child's rel base passes through: how far along the cursor a child
+    /// sits says nothing about what a fraction under it is of.
+    pub const fn shifted(span: UiSpan) -> Self {
+        Self {
+            span: PlaceSpan::Shifted(span),
+            fills: false,
+            rel_base: RelBase::Inherit,
+        }
+    }
+
+    /// A box this long, placed in the caller's own by the child's alignment:
+    /// the rule that places an answer, with the length given from above
+    /// rather than reported. What a stack's sizing child decides for the
+    /// rest. It is the child's rel base too.
+    pub const fn sized(len: Len) -> Self {
+        Self {
+            span: PlaceSpan::Sized(len),
+            fills: false,
+            rel_base: RelBase::Len(len),
+        }
+    }
+
+    /// This region is the child's placement: its answer is not placed inside
+    /// it again. A container uses it where it hands back exactly what the
+    /// child asked for -- a row placing a child at the length it reported.
+    pub const fn fills(mut self) -> Self {
+        self.fills = true;
+        self
+    }
+
+    /// What the child's fractions are of, as a length of the window: a
+    /// resolved share, or a box a sibling's answer decided.
+    pub const fn rel_base(mut self, len: Len) -> Self {
+        self.rel_base = RelBase::Len(len);
+        self
+    }
+
+    /// Whether the region is the placement outright, rather than a box the
+    /// answer is placed inside.
+    pub(crate) const fn does_fill(self) -> bool {
+        self.fills
+    }
 
     /// Where it lands in the coordinates `own` is in.
     pub(crate) fn of(self, own: UiSpan, align: AxisAlign) -> UiSpan {
-        match self {
-            Self::From(span) => UiSpan::new(own.start + span.start, own.start + span.end),
-            Self::Of(span) => span.within(&own),
-            Self::Sized(len) => {
+        match self.span {
+            PlaceSpan::Within(span) => span.within(&own),
+            PlaceSpan::Shifted(mut span) => {
+                span.shift(own.start);
+                span
+            }
+            PlaceSpan::Sized(len) => {
                 let start = own.start + (own.len() - len).scale(align.rel());
                 UiSpan::new(start, start + len)
             }
         }
     }
-}
 
-/// A child's region along one axis, and what becomes of its placement in
-/// that region once it has answered.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Place {
-    /// The placement is the child's answer, aligned inside the region by the
-    /// child's alignment.
-    Within(Part),
-    /// The region is the placement; the answer is not placed inside it again.
-    Fill(Part),
-}
-
-impl Place {
-    pub(crate) fn part(self) -> Part {
-        match self {
-            Self::Within(part) | Self::Fill(part) => part,
+    /// The child's rel base, where this says one outright. `None` forwards
+    /// the caller's own, and [`RelBase::WithRegion`] is resolved by whoever
+    /// can read that rel base, so it does not reach here.
+    pub(crate) const fn stated_rel_base(self) -> Option<Len> {
+        match self.rel_base {
+            RelBase::Len(len) => Some(len),
+            _ => None,
         }
     }
 
-    /// Whether the region is the placement outright, rather than a box the
-    /// answer is placed inside.
-    pub(crate) fn fills(self) -> bool {
-        matches!(self, Self::Fill(_))
+    /// The length this narrows the caller's rel base by, where it does.
+    /// `None` leaves that rel base alone, and reading it is then a
+    /// dependency the caller does not take.
+    pub(crate) const fn narrows_rel_base(self) -> Option<UiSpan> {
+        match (self.rel_base, self.span) {
+            (RelBase::WithRegion, PlaceSpan::Within(span)) => Some(span),
+            _ => None,
+        }
+    }
+
+    /// The span it composes into the caller's box, where that is what it
+    /// does: the one case whose validity maps back through the part.
+    pub(crate) const fn within_span(self) -> Option<UiSpan> {
+        match self.span {
+            PlaceSpan::Within(span) => Some(span),
+            _ => None,
+        }
+    }
+
+    /// Whether the caller decided this length rather than a place along its
+    /// own box, which is what stops its length reaching the child at all.
+    pub(crate) const fn is_sized(self) -> bool {
+        matches!(self.span, PlaceSpan::Sized(_))
+    }
+
+    /// The same, with its rel base stated outright.
+    pub(crate) const fn with_rel_base(mut self, len: Option<Len>) -> Self {
+        self.rel_base = match len {
+            Some(len) => RelBase::Len(len),
+            None => RelBase::Inherit,
+        };
+        self
+    }
+}
+
+/// Where a child is asked, on both axes. A [`UiRegion`] converts into the
+/// common case: that box of the caller's own, the answer placed inside it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct PlaceDesc {
+    pub x: PlaceDescAxis,
+    pub y: PlaceDescAxis,
+}
+
+impl PlaceDesc {
+    /// The whole of the caller's box, on both axes.
+    pub const WHOLE: Self = Self::splat(PlaceDescAxis::WHOLE);
+
+    pub const fn new(x: PlaceDescAxis, y: PlaceDescAxis) -> Self {
+        Self { x, y }
+    }
+
+    /// The same on both axes.
+    pub const fn splat(place: PlaceDescAxis) -> Self {
+        Self { x: place, y: place }
+    }
+
+    /// `aligned` on `axis` and `ortho` on the other, which is how a
+    /// container that divides one axis says what it is doing.
+    pub fn from_axis(axis: Axis, aligned: PlaceDescAxis, ortho: PlaceDescAxis) -> Self {
+        match axis {
+            Axis::X => Self::new(aligned, ortho),
+            Axis::Y => Self::new(ortho, aligned),
+        }
+    }
+
+    pub const fn axis(&self, axis: Axis) -> &PlaceDescAxis {
+        match axis {
+            Axis::X => &self.x,
+            Axis::Y => &self.y,
+        }
+    }
+
+    pub const fn axis_mut(&mut self, axis: Axis) -> &mut PlaceDescAxis {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
+    /// Both regions are the child's placement. See [`PlaceDescAxis::fills`].
+    pub const fn fills(self) -> Self {
+        Self::new(self.x.fills(), self.y.fills())
+    }
+
+    /// The child's rel base on one axis. See [`PlaceDescAxis::rel_base`].
+    pub const fn rel_base(mut self, axis: Axis, len: Len) -> Self {
+        *self.axis_mut(axis) = self.axis(axis).rel_base(len);
+        self
+    }
+
+    /// The box each axis names, in the coordinates `own` is in.
+    pub(crate) fn of(self, own: UiRegion, align: RegionAlign) -> UiRegion {
+        UiRegion::new(self.x.of(own.x, align.x), self.y.of(own.y, align.y))
+    }
+}
+
+impl From<UiRegion> for PlaceDesc {
+    fn from(region: UiRegion) -> Self {
+        Self::new(
+            PlaceDescAxis::within(region.x),
+            PlaceDescAxis::within(region.y),
+        )
+    }
+}
+
+impl From<PlaceDescAxis> for PlaceDesc {
+    fn from(place: PlaceDescAxis) -> Self {
+        Self::splat(place)
     }
 }