make layer iter reversible

src/core/sense.rs

@@ -141,14 +141,8 @@ impl<Ctx: UiCtx + 'static> SensorModule<Ctx> {
         let mut layers = std::mem::take(&mut ctx.ui().layers);
         let mut module = std::mem::take(ctx.ui().modules.get_mut::<Self>());
 
-        // TODO: temp, need to actually make reverse
+        for (i, _) in layers.iter_mut().rev() {
-        let mut layer_idxs = Vec::new();
+            let Some(list) = module.active.get_mut(&i) else {
-        for (i, _) in layers.iter_mut() {
-            layer_idxs.push(i);
-        }
-
-        for l in &layer_idxs {
-            let Some(list) = module.active.get_mut(l) else {
                 continue;
             };
             let mut ran = false;

src/layout/layer.rs

@@ -7,21 +7,24 @@ use crate::{
 };
 
 struct LayerNode {
-    next: Next,
+    next: Ptr,
-    child: Option<usize>,
+    prev: Ptr,
+    child: Option<Child>,
     data: Layer,
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
-enum Next {
+enum Ptr {
     /// continue on same level
-    Same(usize),
+    Next(usize),
     /// go back to parent
     Parent(usize),
     /// end
     None,
 }
 
+/// TODO: currently this does not ever free layers
+/// is that realistically desired?
 pub struct Layers {
     vec: Vec<LayerNode>,
 }
@@ -32,6 +35,12 @@ pub struct Layer {
     pub primitives: Primitives,
 }
 
+#[derive(Clone, Copy)]
+struct Child {
+    head: usize,
+    tail: usize,
+}
+
 impl Layers {
     pub fn new() -> Layers {
         Self {
@@ -51,26 +60,48 @@ impl Layers {
     }
 
     pub fn next(&mut self, i: usize) -> usize {
-        if let Next::Same(i) = self.vec[i].next {
+        if let Ptr::Next(i) = self.vec[i].next {
             return i;
         }
-        let i_next = self.push(LayerNode::new(Layer::default(), self.vec[i].next));
+        let i_new = self.push(LayerNode::new(
-        self.vec[i].next = Next::Same(i_next);
+            Layer::default(),
-        i_next
+            self.vec[i].next,
+            Ptr::Next(i),
+        ));
+        self.vec[i].next = Ptr::Next(i_new);
+        self.vec[i_new].prev = Ptr::Next(i);
+        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 => (),
+        }
+        i_new
     }
 
     pub fn child(&mut self, i: usize) -> usize {
-        if let Some(i) = self.vec[i].child {
+        if let Some(c) = self.vec[i].child {
-            return i;
+            return c.head;
         }
-        let i_next = self.push(LayerNode::new(Layer::default(), Next::Parent(i)));
+        let i_child = self.push(LayerNode::new(
-        self.vec[i].child = Some(i_next);
+            Layer::default(),
-        i_next
+            Ptr::Parent(i),
+            Ptr::Parent(i),
+        ));
+        self.vec[i].child = Some(Child {
+            head: i_child,
+            tail: i_child,
+        });
+        i_child
     }
 
     pub fn iter_mut(&mut self) -> LayerIteratorMut<'_> {
+        let mut last = 0;
+        while let Some(c) = self.vec[last].child {
+            last = c.tail;
+        }
         LayerIteratorMut {
             next: Some(0),
+            next_back: Some(last),
             vec: &mut self.vec,
         }
     }
@@ -111,21 +142,23 @@ impl IndexMut<usize> for Layers {
 }
 
 impl LayerNode {
-    pub fn new(data: Layer, next: Next) -> Self {
+    pub fn new(data: Layer, next: Ptr, prev: Ptr) -> Self {
         Self {
             next,
+            prev,
             child: None,
             data,
         }
     }
 
     pub fn head() -> Self {
-        Self::new(Layer::default(), Next::None)
+        Self::new(Layer::default(), Ptr::None, Ptr::None)
     }
 }
 
 pub struct LayerIteratorMut<'a> {
     next: Option<usize>,
+    next_back: Option<usize>,
     vec: &'a mut Vec<LayerNode>,
 }
 
@@ -133,16 +166,16 @@ impl<'a> Iterator for LayerIteratorMut<'a> {
     type Item = (usize, &'a mut Layer);
 
     fn next(&mut self) -> Option<Self::Item> {
-        // chat are we cooked? (if it's not set up correctly this could be catastrophic)
         let ret_i = self.next?;
+        // chat are we cooked? (if it's not set up correctly this could be catastrophic)
         let node: &mut LayerNode = unsafe { std::mem::transmute(&mut self.vec[ret_i]) };
-        self.next = if let Some(i) = node.child {
+        self.next = if let Some(c) = node.child {
+            Some(c.head)
+        } else if let Ptr::Next(i) = node.next {
             Some(i)
-        } else if let Next::Same(i) = node.next {
+        } else if let Ptr::Parent(i) = node.next {
-            Some(i)
-        } else if let Next::Parent(i) = node.next {
             let node = &self.vec[i];
-            if let Next::Same(i) = node.next {
+            if let Ptr::Next(i) = node.next {
                 Some(i)
             } else {
                 None
@@ -150,6 +183,32 @@ impl<'a> Iterator for LayerIteratorMut<'a> {
         } else {
             None
         };
+        if self.next_back.unwrap() == ret_i {
+            self.next = None;
+            self.next_back = None;
+        }
+        Some((ret_i, &mut node.data))
+    }
+}
+
+impl<'a> DoubleEndedIterator for LayerIteratorMut<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let ret_i = self.next_back?;
+        let node: &mut LayerNode = unsafe { std::mem::transmute(&mut self.vec[ret_i]) };
+        self.next_back = if let Ptr::Next(mut i) = node.prev {
+            while let Some(c) = self.vec[i].child {
+                i = c.tail
+            }
+            Some(i)
+        } else if let Ptr::Parent(i) = node.prev {
+            Some(i)
+        } else {
+            None
+        };
+        if self.next.unwrap() == ret_i {
+            self.next = None;
+            self.next_back = None;
+        }
         Some((ret_i, &mut node.data))
     }
 }