ing prefix gives off bad vibes

src/core/position/span.rs

@@ -0,0 +1,131 @@
+use crate::prelude::*;
+
+pub struct Span {
+    pub children: Vec<(WidgetId, SpanLen)>,
+    pub dir: Dir,
+}
+
+impl Widget for Span {
+    fn draw(&mut self, painter: &mut Painter) {
+        let total = self.setup(&mut painter.size_ctx());
+        let mut start = UiScalar::rel_min();
+        for (child, length) in &self.children {
+            let mut child_region = UiRegion::full();
+            let mut axis = child_region.axis_mut(self.dir.axis);
+            axis.top_left.set(start);
+            match *length {
+                SpanLen::Fixed(offset) => {
+                    start.abs += offset;
+                }
+                SpanLen::Ratio(ratio) => {
+                    let offset = UiScalar::new(total.rel, total.abs);
+                    let rel_end = UiScalar::from_anchor(ratio / total.ratio);
+                    start = rel_end.within(start, (UiScalar::rel_max() + start) - offset);
+                }
+                SpanLen::Relative(rel) => {
+                    start.rel += rel;
+                }
+                SpanLen::Sized(size) => {
+                    let size_axis = size.axis(self.dir.axis);
+                    start.abs += size_axis.abs;
+                    start.rel += size_axis.rel;
+                }
+            }
+            axis.bot_right.set(start);
+            if self.dir.sign == Sign::Neg {
+                child_region.flip(self.dir.axis);
+            }
+            painter.widget_within(child, child_region);
+        }
+    }
+
+    fn desired_size(&mut self, ctx: &mut SizeCtx) -> UiVec2 {
+        let total = self.setup(ctx);
+        let axis = self.dir.axis;
+        let dir_len = if total.ratio != 0.0 {
+            UiScalar::rel_max()
+        } else {
+            UiScalar::new(total.rel, total.abs)
+        };
+        let mut max_ortho = UiScalar::ZERO;
+        for (child, _) in &self.children {
+            let size = ctx.size(child);
+            max_ortho = max_ortho.max(size.axis(!self.dir.axis));
+        }
+        UiVec2::from_axis(axis, dir_len, max_ortho)
+    }
+}
+
+#[derive(Default)]
+pub struct SpanLenSums {
+    pub abs: f32,
+    pub ratio: f32,
+    pub rel: f32,
+}
+
+impl Span {
+    pub fn empty(dir: Dir) -> Self {
+        Self {
+            children: Vec::new(),
+            dir,
+        }
+    }
+
+    fn setup(&mut self, ctx: &mut SizeCtx) -> SpanLenSums {
+        self.children
+            .iter_mut()
+            .fold(SpanLenSums::default(), |mut s, (id, l)| {
+                match l {
+                    SpanLen::Fixed(v) => s.abs += *v,
+                    SpanLen::Ratio(v) => s.ratio += *v,
+                    SpanLen::Relative(v) => s.rel += *v,
+                    SpanLen::Sized(v) => {
+                        let size = ctx.size(id);
+                        let len = size.axis(self.dir.axis);
+                        *v = size;
+                        s.abs += len.abs;
+                        s.rel += len.rel;
+                    }
+                }
+                s
+            })
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum SpanLen {
+    /// exact (non dynamic) size
+    Fixed(f32),
+    /// relative to remaining free space and other ratios
+    /// eg. 1 and 2 would take up 1/3 and 2/3 of the remaining space (after others)
+    Ratio(f32),
+    /// relative to the total space (of the entire span)
+    /// eg. 0.5 means 1/2 of the total space
+    Relative(f32),
+    /// size determined by the child widget itself
+    /// the value is not used externally, I just don't wanna make a duplicate enum
+    /// there are util functions instead so
+    Sized(UiVec2),
+}
+
+pub fn fixed<N: UiNum>(x: N) -> SpanLen {
+    SpanLen::Fixed(x.to_f32())
+}
+
+pub fn ratio<N: UiNum>(x: N) -> SpanLen {
+    SpanLen::Ratio(x.to_f32())
+}
+
+pub fn relative<N: UiNum>(x: N) -> SpanLen {
+    SpanLen::Relative(x.to_f32())
+}
+
+pub fn sized() -> SpanLen {
+    SpanLen::Sized(UiVec2::default())
+}
+
+impl<N: UiNum> From<N> for SpanLen {
+    fn from(value: N) -> Self {
+        Self::Ratio(value.to_f32())
+    }
+}