From 51c20071adef0800ff077b05140e1e79d597fdc9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Mon, 6 Nov 2023 08:36:28 +0100
Subject: [PATCH] Add `View::for_each_child_rev_mut` and handle events front to
 back

---
 src/view.rs                          | 29 +++++++++++++++++--
 src/views/clip.rs                    |  7 +++++
 src/views/container.rs               |  7 +++++
 src/views/container_box.rs           | 43 ++++++----------------------
 src/views/drag_resize_window_area.rs |  7 +++++
 src/views/drag_window_area.rs        |  7 +++++
 src/views/dyn_container.rs           |  7 +++++
 src/views/list.rs                    | 16 +++++++++++
 src/views/scroll.rs                  |  7 +++++
 src/views/stack.rs                   | 11 +++++++
 src/views/static_list.rs             | 11 +++++++
 src/views/tab.rs                     | 43 +++++++++++-----------------
 src/views/virtual_list.rs            | 16 +++++++++++
 13 files changed, 146 insertions(+), 65 deletions(-)

diff --git a/src/view.rs b/src/view.rs
index 066a519a..5f7453cf 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -111,14 +111,22 @@ bitflags! {
 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 @@ pub trait View {
     /// 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 @@ impl View for Box<dyn View> {
         (**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()
     }
diff --git a/src/views/clip.rs b/src/views/clip.rs
index e4ab3aed..43ba40a5 100644
--- a/src/views/clip.rs
+++ b/src/views/clip.rs
@@ -27,6 +27,13 @@ impl View for Clip {
         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()
     }
diff --git a/src/views/container.rs b/src/views/container.rs
index a5ea9699..9215273f 100644
--- a/src/views/container.rs
+++ b/src/views/container.rs
@@ -30,6 +30,13 @@ impl View for Container {
         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()
     }
diff --git a/src/views/container_box.rs b/src/views/container_box.rs
index af38da02..627b0f74 100644
--- a/src/views/container_box.rs
+++ b/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 @@ impl View for ContainerBox {
         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()
     }
 }
diff --git a/src/views/drag_resize_window_area.rs b/src/views/drag_resize_window_area.rs
index 74e5614a..55d8ccd6 100644
--- a/src/views/drag_resize_window_area.rs
+++ b/src/views/drag_resize_window_area.rs
@@ -51,4 +51,11 @@ impl View for DragResizeWindowArea {
     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);
+    }
 }
diff --git a/src/views/drag_window_area.rs b/src/views/drag_window_area.rs
index 91832b25..329a7576 100644
--- a/src/views/drag_window_area.rs
+++ b/src/views/drag_window_area.rs
@@ -40,4 +40,11 @@ impl View for DragWindowArea {
     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);
+    }
 }
diff --git a/src/views/dyn_container.rs b/src/views/dyn_container.rs
index 0e24c78d..2b9e0859 100644
--- a/src/views/dyn_container.rs
+++ b/src/views/dyn_container.rs
@@ -100,6 +100,13 @@ impl<T: 'static> View for DynamicContainer<T> {
         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()
     }
diff --git a/src/views/list.rs b/src/views/list.rs
index 822a7934..b5611b86 100644
--- a/src/views/list.rs
+++ b/src/views/list.rs
@@ -98,6 +98,22 @@ impl<V: View + 'static, T> View for List<V, T> {
         }
     }
 
+    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()
     }
diff --git a/src/views/scroll.rs b/src/views/scroll.rs
index 1194d618..191af628 100644
--- a/src/views/scroll.rs
+++ b/src/views/scroll.rs
@@ -568,6 +568,13 @@ impl View for Scroll {
         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()
     }
diff --git a/src/views/stack.rs b/src/views/stack.rs
index a9be7b64..fe780bc7 100644
--- a/src/views/stack.rs
+++ b/src/views/stack.rs
@@ -69,6 +69,17 @@ impl View for Stack {
         }
     }
 
+    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(),
diff --git a/src/views/static_list.rs b/src/views/static_list.rs
index 98539cb9..91766496 100644
--- a/src/views/static_list.rs
+++ b/src/views/static_list.rs
@@ -47,4 +47,15 @@ impl View for StaticList {
             }
         }
     }
+
+    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;
+            }
+        }
+    }
 }
diff --git a/src/views/tab.rs b/src/views/tab.rs
index b5da1f5a..2ff86ef3 100644
--- a/src/views/tab.rs
+++ b/src/views/tab.rs
@@ -112,6 +112,22 @@ impl<V: View + 'static, T> View for Tab<V, T> {
         }
     }
 
+    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 @@ impl<V: View + 'static, T> View for Tab<V, T> {
             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);
-        }
-    }*/
 }
diff --git a/src/views/virtual_list.rs b/src/views/virtual_list.rs
index a64d0e35..a18221ac 100644
--- a/src/views/virtual_list.rs
+++ b/src/views/virtual_list.rs
@@ -217,6 +217,22 @@ impl<V: View + 'static, T> View for VirtualList<V, T> {
         }
     }
 
+    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()
     }