Add View::for_each_child_rev_mut and handle events front to back

src/view.rs

@@ -111,14 +111,22 @@
 pub trait View {
     fn id(&self) -> Id;
 
-    /// This method walk over children and must be implemented if the view has any children.
+    /// This method walks over children and must be implemented if the view has any children.
     /// It should return children back to front and should stop if `_for_each` returns `true`.
     fn for_each_child<'a>(&'a self, _for_each: &mut dyn FnMut(&'a dyn View) -> bool) {}
 
-    /// This method walk over children and must be implemented if the view has any children.
+    /// This method walks over children and must be implemented if the view has any children.
     /// It should return children back to front and should stop if `_for_each` returns `true`.
     fn for_each_child_mut<'a>(&'a mut self, _for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {}
 
+    /// This method walks over children and must be implemented if the view has any children.
+    /// It should return children front to back and should stop if `_for_each` returns `true`.
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        _for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+    }
+
     fn view_style(&self) -> Option<Style> {
         None
     }
@@ -229,7 +237,7 @@
     /// Return true to stop the event from propagating to other views
     fn event(&mut self, cx: &mut EventCx, id_path: Option<&[Id]>, event: Event) -> bool {
         let mut handled = false;
-        self.for_each_child_mut(&mut |child| {
+        self.for_each_child_rev_mut(&mut |child| {
             handled |= cx.view_event(child, id_path, event.clone());
             handled
         });
@@ -580,6 +588,21 @@
         (**self).id()
     }
 
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        (**self).for_each_child(for_each)
+    }
+
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+        (**self).for_each_child_mut(for_each)
+    }
+
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        (**self).for_each_child_rev_mut(for_each)
+    }
+
     fn view_style(&self) -> Option<Style> {
         (**self).view_style()
     }

src/views/clip.rs

@@ -27,6 +27,13 @@
         for_each(&mut self.child);
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Clip".into()
     }

src/views/container.rs

@@ -30,6 +30,13 @@
         for_each(&mut self.child);
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Container".into()
     }

src/views/container_box.rs

@@ -1,9 +1,4 @@
-use kurbo::Rect;
-
-use crate::{
-    id::Id,
-    view::{ChangeFlags, View},
-};
+use crate::{id::Id, view::View};
 
 /// A wrapper around any type that implements View. See [`container_box`]
 pub struct ContainerBox {
@@ -65,36 +60,14 @@
         for_each(&mut self.child);
     }
 
-    fn debug_name(&self) -> std::borrow::Cow<'static, str> {
-        "ContainerBox".into()
-    }
-
-    fn update(
-        &mut self,
-        _cx: &mut crate::context::UpdateCx,
-        _state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
-        ChangeFlags::empty()
-    }
-
-    fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
-        cx.layout_node(self.id, true, |cx| vec![cx.layout_view(&mut self.child)])
-    }
-
-    fn compute_layout(&mut self, cx: &mut crate::context::LayoutCx) -> Option<Rect> {
-        Some(cx.compute_view_layout(&mut self.child))
-    }
-
-    fn event(
-        &mut self,
-        cx: &mut crate::context::EventCx,
-        id_path: Option<&[Id]>,
-        event: crate::event::Event,
-    ) -> bool {
-        cx.view_event(&mut self.child, id_path, event)
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
     }
 
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        cx.paint_view(&mut self.child);
+    fn debug_name(&self) -> std::borrow::Cow<'static, str> {
+        "ContainerBox".into()
     }
 }

src/views/drag_resize_window_area.rs

@@ -51,4 +51,11 @@
     fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
         for_each(&mut self.child);
     }
+
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
+    }
 }

src/views/drag_window_area.rs

@@ -40,4 +40,11 @@
     fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
         for_each(&mut self.child);
     }
+
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
+    }
 }

src/views/dyn_container.rs

@@ -100,6 +100,13 @@
         for_each(&mut self.child);
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "DynamicContainer".into()
     }

src/views/list.rs

@@ -98,6 +98,22 @@
         }
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for child in self
+            .children
+            .iter_mut()
+            .rev()
+            .filter_map(|child| child.as_mut())
+        {
+            if for_each(&mut child.0) {
+                break;
+            }
+        }
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "List".into()
     }

src/views/scroll.rs

@@ -568,6 +568,13 @@
         for_each(&mut self.child);
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for_each(&mut self.child);
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Scroll".into()
     }

src/views/stack.rs

@@ -69,6 +69,17 @@
         }
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for child in self.children.iter_mut().rev() {
+            if for_each(child) {
+                break;
+            }
+        }
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         match self.direction {
             Some(FlexDirection::Column) => "Vertical Stack".into(),

src/views/static_list.rs

@@ -47,4 +47,15 @@
             }
         }
     }
+
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for child in &mut self.children.iter_mut().rev() {
+            if for_each(child) {
+                break;
+            }
+        }
+    }
 }

src/views/tab.rs

@@ -112,6 +112,22 @@
         }
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for child in self
+            .children
+            .iter_mut()
+            .rev()
+            .filter_map(|child| child.as_mut())
+        {
+            if for_each(&mut child.0) {
+                break;
+            }
+        }
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!("Tab: {}", self.active).into()
     }
@@ -172,31 +188,4 @@
             nodes
         })
     }
-    /*
-    fn compute_layout(&mut self, cx: &mut crate::context::LayoutCx) -> Option<Rect> {
-        if let Some(Some((child, _))) = self.children.get_mut(self.active) {
-            Some(cx.compute_view_layout(child))
-        } else {
-            None
-        }
-    }
-
-    fn event(
-        &mut self,
-        cx: &mut EventCx,
-        id_path: Option<&[Id]>,
-        event: crate::event::Event,
-    ) -> bool {
-        if let Some(Some((child, _))) = self.children.get_mut(self.active) {
-            cx.view_event(child, id_path, event)
-        } else {
-            false
-        }
-    }
-
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        if let Some(Some((child, _))) = self.children.get_mut(self.active) {
-            cx.paint_view(child);
-        }
-    }*/
 }

src/views/virtual_list.rs

@@ -217,6 +217,22 @@
         }
     }
 
+    fn for_each_child_rev_mut<'a>(
+        &'a mut self,
+        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+    ) {
+        for child in self
+            .children
+            .iter_mut()
+            .rev()
+            .filter_map(|child| child.as_mut())
+        {
+            if for_each(&mut child.0) {
+                break;
+            }
+        }
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "VirtualList".into()
     }