stack & padding fix sorta, preparing for scroll areas

src/core/pad.rs

@@ -12,8 +12,20 @@ impl Widget for Padded {
 
     fn desired_size(&mut self, ctx: &mut SizeCtx) -> UiVec2 {
         let mut size = ctx.size(&self.inner);
-        size.abs.x += self.padding.left + self.padding.right;
-        size.abs.y += self.padding.top + self.padding.bottom;
+        // TODO: this is currently a hack
+        // the correct solution is that the position is not linear
+        // becauase if you have 0.5 rel + 100 abs, it's linear
+        // until you fill up parent rel (in abs units) and then 1.0 rel (piecewise linear)
+        // so I guess yet another detection system is needed
+        // to determine when abs translated to rel + rel > 1.0
+        // hopefully find a way to get working on gpu so no cpu changing needed
+        // eg by sending size to calculate above and then doing... something?
+        if size.rel.x != 1.0 {
+            size.abs.x += self.padding.left + self.padding.right;
+        }
+        if size.rel.y != 1.0 {
+            size.abs.y += self.padding.top + self.padding.bottom;
+        }
         size
     }
 }

src/core/span.rs

@@ -47,7 +47,7 @@ impl Widget for Span {
         } else {
             UiScalar::new(total.rel, total.abs)
         };
-        let mut max_ortho = UiScalar::default();
+        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));

src/core/stack.rs

@@ -1,19 +1,82 @@
+use std::marker::PhantomData;
+
 use crate::prelude::*;
 
 pub struct Stack {
     pub children: Vec<WidgetId>,
+    pub size: StackSize,
+    pub offset: usize,
 }
 
 impl Widget for Stack {
     fn draw(&mut self, painter: &mut Painter) {
+        for _ in 0..self.offset {
+            painter.layer = painter.next_layer();
+        }
         let base = painter.layer;
         for child in &self.children {
-            if painter.layer == base {
-                painter.layer = painter.child_layer();
+            painter.layer = if painter.layer == base {
+                painter.child_layer()
             } else {
-                painter.layer = painter.next_layer();
-            }
+                painter.next_layer()
+            };
             painter.widget(child);
         }
     }
+
+    fn desired_size(&mut self, ctx: &mut SizeCtx) -> UiVec2 {
+        match self.size {
+            StackSize::Full => UiVec2::MAX_SIZE,
+            StackSize::Child(i) => ctx.size(&self.children[i]),
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub enum StackSize {
+    #[default]
+    Full,
+    Child(usize),
+}
+
+pub struct StackBuilder<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
+    pub children: Wa,
+    pub size: StackSize,
+    pub offset: usize,
+    _pd: PhantomData<Tag>,
+}
+
+impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
+    for StackBuilder<LEN, Wa, Tag>
+{
+    type Output = Stack;
+
+    extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
+        Stack {
+            children: self.children.ui(args.0).arr.to_vec(),
+            offset: self.offset,
+            size: self.size,
+        }
+    }
+}
+
+impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> StackBuilder<LEN, Wa, Tag> {
+    pub fn new(children: Wa) -> Self {
+        Self {
+            children,
+            size: StackSize::default(),
+            offset: 0,
+            _pd: PhantomData,
+        }
+    }
+
+    pub fn stack_size(mut self, size: StackSize) -> Self {
+        self.size = size;
+        self
+    }
+
+    pub fn offset_layer(mut self, offset: usize) -> Self {
+        self.offset = offset;
+        self
+    }
 }

src/core/trait_fns.rs

@@ -44,12 +44,12 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
     }
 }
 
-pub trait CoreWidgetArr<const LEN: usize, Tag> {
+pub trait CoreWidgetArr<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
     fn span(self, dir: Dir, lengths: impl IntoSpanLens<LEN>) -> impl WidgetFn<Span>;
-    fn stack(self) -> impl WidgetFn<Stack>;
+    fn stack(self) -> StackBuilder<LEN, Wa, Tag>;
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> CoreWidgetArr<LEN, Tag> for Wa {
+impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> CoreWidgetArr<LEN, Wa, Tag> for Wa {
     fn span(self, dir: Dir, lengths: impl IntoSpanLens<LEN>) -> impl WidgetFn<Span> {
         let lengths = lengths.into_lens();
         move |ui| Span {
@@ -57,10 +57,8 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> CoreWidgetArr<LEN, Tag>
             dir,
         }
     }
-    fn stack(self) -> impl WidgetFn<Stack> {
-        move |ui| Stack {
-            children: self.ui(ui).arr.to_vec(),
-        }
+    fn stack(self) -> StackBuilder<LEN, Wa, Tag> {
+        StackBuilder::new(self)
     }
 }