stack & padding fix sorta, preparing for scroll areas

src/layout/layer.rs

@@ -27,6 +27,8 @@ enum Ptr {
 /// is that realistically desired?
 pub struct Layers {
     vec: Vec<LayerNode>,
+    /// index of last layer at top level (start at first = 0)
+    last: usize,
 }
 
 /// TODO: this can be replaced with Primitives itself atm
@@ -45,6 +47,7 @@ impl Layers {
     pub fn new() -> Layers {
         Self {
             vec: vec![LayerNode::head()],
+            last: 0,
         }
     }
 
@@ -73,7 +76,7 @@ impl Layers {
         match self.vec[i_new].next {
             Ptr::Next(i) => self.vec[i].prev = Ptr::Next(i_new),
             Ptr::Parent(i) => self.vec[i].child.as_mut().unwrap().tail = i_new,
-            Ptr::None => (),
+            Ptr::None => self.last = i_new,
         }
         i_new
     }
@@ -95,11 +98,15 @@ impl Layers {
     }
 
     pub fn iter_mut(&mut self) -> LayerIteratorMut<'_> {
-        LayerIteratorMut::new(&mut self.vec)
+        LayerIteratorMut::new(&mut self.vec, self.last)
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (usize, &Layer)> {
+        self.indices().map(|i| (i, &self.vec[i].data))
     }
 
     pub fn indices(&self) -> LayerIndexIterator<'_> {
-        LayerIndexIterator::new(&self.vec)
+        LayerIndexIterator::new(&self.vec, self.last)
     }
 
     pub fn write<P: Primitive>(
@@ -179,9 +186,9 @@ impl<'a> DoubleEndedIterator for LayerIteratorMut<'a> {
 }
 
 impl<'a> LayerIteratorMut<'a> {
-    fn new(vec: &'a mut Vec<LayerNode>) -> Self {
+    fn new(vec: &'a mut Vec<LayerNode>, last: usize) -> Self {
         Self {
-            inner: LayerIndexIterator::new(vec),
+            inner: LayerIndexIterator::new(vec, last),
         }
     }
 }
@@ -203,7 +210,10 @@ impl<'a> Iterator for LayerIndexIterator<'a> {
         } else if let Ptr::Next(i) = node.next {
             Some(i)
         } else if let Ptr::Parent(i) = node.next {
-            let node = &self.vec[i];
+            let mut node = &self.vec[i];
+            while let Ptr::Parent(i) = node.next {
+                node = &self.vec[i];
+            }
             if let Ptr::Next(i) = node.next {
                 Some(i)
             } else {
@@ -243,8 +253,8 @@ impl<'a> DoubleEndedIterator for LayerIndexIterator<'a> {
 }
 
 impl<'a> LayerIndexIterator<'a> {
-    fn new(vec: &'a Vec<LayerNode>) -> Self {
-        let mut last = 0;
+    fn new(vec: &'a Vec<LayerNode>, last: usize) -> Self {
+        let mut last = last;
         while let Some(c) = vec[last].child {
             last = c.tail;
         }