From a0e54ca238d58accd4aba2fb3e75e541dc302067 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Sun, 5 Nov 2023 14:17:49 +0100
Subject: [PATCH] Add default for `View` trait methods

---
 src/view.rs                          | 99 ++++++++++++++++++++++++----
 src/views/clip.rs                    | 46 ++-----------
 src/views/container.rs               | 60 ++---------------
 src/views/container_box.rs           | 24 ++-----
 src/views/drag_resize_window_area.rs | 60 ++---------------
 src/views/drag_window_area.rs        | 57 ++--------------
 src/views/dyn_container.rs           | 46 ++-----------
 src/views/empty.rs                   | 48 +-------------
 src/views/img.rs                     | 25 -------
 src/views/label.rs                   | 32 ++-------
 src/views/list.rs                    | 92 ++++----------------------
 src/views/rich_text.rs               | 23 +------
 src/views/scroll.rs                  | 24 ++-----
 src/views/stack.rs                   | 84 ++++-------------------
 src/views/static_list.rs             | 93 ++++----------------------
 src/views/svg.rs                     | 29 --------
 src/views/tab.rs                     | 62 +++++------------
 src/views/text_input.rs              | 16 -----
 src/views/virtual_list.rs            | 68 +++----------------
 19 files changed, 188 insertions(+), 800 deletions(-)

diff --git a/src/view.rs b/src/view.rs
index bcb26ff0..066a519a 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -111,6 +111,14 @@ bitflags! {
 pub trait View {
     fn id(&self) -> Id;
 
+    /// This method walk 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.
+    /// 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) {}
+
     fn view_style(&self) -> Option<Style> {
         None
     }
@@ -119,14 +127,50 @@ pub trait View {
         None
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View>;
+    fn child(&self, id: Id) -> Option<&dyn View> {
+        let mut result = None;
+        self.for_each_child(&mut |view| {
+            if view.id() == id {
+                result = Some(view);
+                true
+            } else {
+                false
+            }
+        });
+        result
+    }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View>;
+    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
+        let mut result = None;
+        self.for_each_child_mut(&mut |view| {
+            if view.id() == id {
+                result = Some(view);
+                true
+            } else {
+                false
+            }
+        });
+        result
+    }
 
-    fn children(&self) -> Vec<&dyn View>;
+    fn children(&self) -> Vec<&dyn View> {
+        let mut result = Vec::new();
+        self.for_each_child(&mut |view| {
+            result.push(view);
+            false
+        });
+        result
+    }
 
     /// At the moment, this is used only to build the debug tree.
-    fn children_mut(&mut self) -> Vec<&mut dyn View>;
+    fn children_mut(&mut self) -> Vec<&mut dyn View> {
+        let mut result = Vec::new();
+        self.for_each_child_mut(&mut |view| {
+            result.push(view);
+            false
+        });
+        result
+    }
 
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         core::any::type_name::<Self>().into()
@@ -141,7 +185,9 @@ pub trait View {
     ///
     /// You are in charge of downcasting the state to the expected type and you're required to return
     /// indicating if you'd like a layout or paint pass to be scheduled.
-    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) -> ChangeFlags;
+    fn update(&mut self, _cx: &mut UpdateCx, _state: Box<dyn Any>) -> ChangeFlags {
+        ChangeFlags::empty()
+    }
 
     /// Use this method to style the view's children.
     fn style(&mut self, cx: &mut StyleCx<'_>) {
@@ -152,23 +198,52 @@ pub trait View {
 
     /// Use this method to layout the view's children.
     /// Usually you'll do this by calling `LayoutCx::layout_node`
-    fn layout(&mut self, cx: &mut LayoutCx) -> Node;
+    fn layout(&mut self, cx: &mut LayoutCx) -> Node {
+        cx.layout_node(self.id(), true, |cx| {
+            let mut nodes = Vec::new();
+            self.for_each_child_mut(&mut |child| {
+                nodes.push(cx.layout_view(child));
+                false
+            });
+            nodes
+        })
+    }
 
-    /// You must implement this if your view has children.
-    ///
     /// Responsible for computing the layout of the view's children.
-    fn compute_layout(&mut self, _cx: &mut LayoutCx) -> Option<Rect> {
-        None
+    fn compute_layout(&mut self, cx: &mut LayoutCx) -> Option<Rect> {
+        let mut layout_rect: Option<Rect> = None;
+        self.for_each_child_mut(&mut |child| {
+            let child_layout = cx.compute_view_layout(child);
+            if let Some(rect) = layout_rect {
+                layout_rect = Some(rect.union(child_layout));
+            } else {
+                layout_rect = Some(child_layout);
+            }
+            false
+        });
+        layout_rect
     }
 
     /// Implement this to handle events and to pass them down to children
     ///
     /// 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;
+    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| {
+            handled |= cx.view_event(child, id_path, event.clone());
+            handled
+        });
+        handled
+    }
 
     /// `View`-specific implementation. Will be called in the [`View::paint_main`] entry point method.
     /// Usually you'll call the child `View::paint_main` method. But you might also draw text, adjust the offset, clip or draw text.
-    fn paint(&mut self, cx: &mut PaintCx);
+    fn paint(&mut self, cx: &mut PaintCx) {
+        self.for_each_child_mut(&mut |child| {
+            cx.paint_view(child);
+            false
+        });
+    }
 }
 
 pub(crate) fn paint_bg(
diff --git a/src/views/clip.rs b/src/views/clip.rs
index 4a7f5522..e4ab3aed 100644
--- a/src/views/clip.rs
+++ b/src/views/clip.rs
@@ -1,9 +1,6 @@
 use kurbo::{Rect, Size};
 
-use crate::{
-    id::Id,
-    view::{ChangeFlags, View},
-};
+use crate::{id::Id, view::View};
 
 pub struct Clip {
     id: Id,
@@ -22,42 +19,18 @@ impl View for Clip {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&self.child)
-        } else {
-            None
-        }
-    }
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut self.child)
-        } else {
-            None
-        }
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&self.child]
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut self.child]
+    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 debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Clip".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)])
     }
@@ -66,15 +39,6 @@ impl View for Clip {
         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 paint(&mut self, cx: &mut crate::context::PaintCx) {
         cx.save();
         let style = cx.get_builtin_style(self.id);
diff --git a/src/views/container.rs b/src/views/container.rs
index 42d60c8e..a5ea9699 100644
--- a/src/views/container.rs
+++ b/src/views/container.rs
@@ -1,9 +1,4 @@
-use kurbo::Rect;
-
-use crate::{
-    id::Id,
-    view::{ChangeFlags, View},
-};
+use crate::{id::Id, view::View};
 
 /// A simple wrapper around another View. See [`container`]
 pub struct Container {
@@ -27,60 +22,15 @@ impl View for Container {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&self.child)
-        } else {
-            None
-        }
-    }
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut self.child)
-        } else {
-            None
-        }
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&self.child]
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut self.child]
+    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 debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Container".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 paint(&mut self, cx: &mut crate::context::PaintCx) {
-        cx.paint_view(&mut self.child);
-    }
 }
diff --git a/src/views/container_box.rs b/src/views/container_box.rs
index 4b58efcf..af38da02 100644
--- a/src/views/container_box.rs
+++ b/src/views/container_box.rs
@@ -57,28 +57,12 @@ impl View for ContainerBox {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&*self.child)
-        } else {
-            None
-        }
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut *self.child)
-        } else {
-            None
-        }
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&*self.child]
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut *self.child]
+    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 debug_name(&self) -> std::borrow::Cow<'static, str> {
diff --git a/src/views/drag_resize_window_area.rs b/src/views/drag_resize_window_area.rs
index 2b1c8855..74e5614a 100644
--- a/src/views/drag_resize_window_area.rs
+++ b/src/views/drag_resize_window_area.rs
@@ -1,12 +1,7 @@
-use kurbo::Rect;
 use winit::window::ResizeDirection;
 
 use crate::{
-    action::drag_resize_window,
-    event::{Event, EventListener},
-    id::Id,
-    style::CursorStyle,
-    view::View,
+    action::drag_resize_window, event::EventListener, id::Id, style::CursorStyle, view::View,
 };
 
 use super::Decorators;
@@ -49,56 +44,11 @@ impl View for DragResizeWindowArea {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&self.child)
-        } else {
-            None
-        }
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut self.child)
-        } else {
-            None
-        }
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&self.child]
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut self.child]
-    }
-
-    fn update(
-        &mut self,
-        _cx: &mut crate::context::UpdateCx,
-        _state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
-        crate::view::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: Event,
-    ) -> bool {
-        cx.view_event(&mut self.child, id_path, event)
-    }
-
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        cx.paint_view(&mut self.child);
+    fn for_each_child_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 f80c7f77..91832b25 100644
--- a/src/views/drag_window_area.rs
+++ b/src/views/drag_window_area.rs
@@ -1,8 +1,6 @@
-use kurbo::Rect;
-
 use crate::{
     action::{drag_window, toggle_window_maximized},
-    event::{Event, EventListener},
+    event::EventListener,
     id::Id,
     view::View,
 };
@@ -35,56 +33,11 @@ impl View for DragWindowArea {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&self.child)
-        } else {
-            None
-        }
-    }
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut self.child)
-        } else {
-            None
-        }
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&self.child]
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut self.child]
-    }
-
-    fn update(
-        &mut self,
-        _cx: &mut crate::context::UpdateCx,
-        _state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
-        crate::view::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: Event,
-    ) -> bool {
-        cx.view_event(&mut self.child, id_path, event)
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        cx.paint_view(&mut self.child);
+    fn for_each_child_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 83a87f6e..0e24c78d 100644
--- a/src/views/dyn_container.rs
+++ b/src/views/dyn_container.rs
@@ -1,5 +1,4 @@
 use floem_reactive::{as_child_of_current_scope, create_effect, Scope};
-use kurbo::Rect;
 
 use crate::{
     id::Id,
@@ -93,28 +92,12 @@ impl<T: 'static> View for DynamicContainer<T> {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&*self.child)
-        } else {
-            None
-        }
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut *self.child)
-        } else {
-            None
-        }
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&*self.child]
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut *self.child]
+    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 debug_name(&self) -> std::borrow::Cow<'static, str> {
@@ -138,25 +121,4 @@ impl<T: 'static> View for DynamicContainer<T> {
             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 paint(&mut self, cx: &mut crate::context::PaintCx) {
-        cx.paint_view(&mut self.child);
-    }
 }
diff --git a/src/views/empty.rs b/src/views/empty.rs
index 33efe5a8..6cd1d881 100644
--- a/src/views/empty.rs
+++ b/src/views/empty.rs
@@ -1,7 +1,4 @@
-use crate::{
-    id::Id,
-    view::{ChangeFlags, View},
-};
+use crate::{id::Id, view::View};
 
 pub struct Empty {
     id: Id,
@@ -15,47 +12,4 @@ impl View for Empty {
     fn id(&self) -> Id {
         self.id
     }
-
-    fn child(&self, _id: Id) -> Option<&dyn View> {
-        None
-    }
-
-    fn child_mut(&mut self, _id: Id) -> Option<&mut dyn View> {
-        None
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        Vec::new()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        Vec::new()
-    }
-
-    fn debug_name(&self) -> std::borrow::Cow<'static, str> {
-        "Empty".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, false, |_| Vec::new())
-    }
-
-    fn event(
-        &mut self,
-        _cx: &mut crate::context::EventCx,
-        _id_path: Option<&[Id]>,
-        _event: crate::event::Event,
-    ) -> bool {
-        false
-    }
-
-    fn paint(&mut self, _cx: &mut crate::context::PaintCx) {}
 }
diff --git a/src/views/img.rs b/src/views/img.rs
index 11b1f9f4..1420cdea 100644
--- a/src/views/img.rs
+++ b/src/views/img.rs
@@ -117,22 +117,6 @@ impl View for Img {
         self.id
     }
 
-    fn child(&self, _id: Id) -> Option<&dyn View> {
-        None
-    }
-
-    fn child_mut(&mut self, _id: Id) -> Option<&mut dyn View> {
-        None
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        Vec::new()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        Vec::new()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Img".into()
     }
@@ -181,15 +165,6 @@ impl View for Img {
         })
     }
 
-    fn event(
-        &mut self,
-        _cx: &mut crate::context::EventCx,
-        _id_path: Option<&[Id]>,
-        _event: crate::event::Event,
-    ) -> bool {
-        false
-    }
-
     fn paint(&mut self, cx: &mut crate::context::PaintCx) {
         if let Some(img) = self.img.as_ref() {
             let rect = cx.get_content_rect(self.id);
diff --git a/src/views/label.rs b/src/views/label.rs
index 6593d5cc..ee20e45f 100644
--- a/src/views/label.rs
+++ b/src/views/label.rs
@@ -1,10 +1,14 @@
 use std::{any::Any, fmt::Display};
 
 use crate::{
+    context::UpdateCx,
     cosmic_text::{Attrs, AttrsList, FamilyOwned, TextLayout},
+    id::Id,
     prop_extracter,
+    style::Style,
     style::{FontProps, LineHeight, TextColor, TextOverflow, TextOverflowProp},
     unit::PxPct,
+    view::{ChangeFlags, View},
 };
 use floem_reactive::create_effect;
 use floem_renderer::Renderer;
@@ -12,14 +16,6 @@ use kurbo::{Point, Rect};
 use peniko::Color;
 use taffy::prelude::Node;
 
-use crate::{
-    context::{EventCx, UpdateCx},
-    event::Event,
-    id::Id,
-    style::Style,
-    view::{ChangeFlags, View},
-};
-
 prop_extracter! {
     Extracter {
         color: TextColor,
@@ -108,22 +104,6 @@ impl View for Label {
         self.id
     }
 
-    fn child(&self, _id: Id) -> Option<&dyn View> {
-        None
-    }
-
-    fn child_mut(&mut self, _id: Id) -> Option<&mut dyn View> {
-        None
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        Vec::new()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        Vec::new()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!("Label: {:?}", self.label).into()
     }
@@ -142,10 +122,6 @@ impl View for Label {
         }
     }
 
-    fn event(&mut self, _cx: &mut EventCx, _id_path: Option<&[Id]>, _event: Event) -> bool {
-        false
-    }
-
     fn style(&mut self, cx: &mut crate::context::StyleCx<'_>) {
         if self.font.read(cx) | self.style.read(cx) {
             self.text_layout = None;
diff --git a/src/views/list.rs b/src/views/list.rs
index 2c937981..822a7934 100644
--- a/src/views/list.rs
+++ b/src/views/list.rs
@@ -4,12 +4,11 @@ use std::{
 };
 
 use floem_reactive::{as_child_of_current_scope, create_effect, Scope};
-use kurbo::Rect;
 use rustc_hash::FxHasher;
 use smallvec::SmallVec;
 
 use crate::{
-    context::{AppState, EventCx, UpdateCx},
+    context::{AppState, UpdateCx},
     id::Id,
     view::{view_children_set_parent_id, ChangeFlags, View},
 };
@@ -83,46 +82,22 @@ impl<V: View + 'static, T> View for List<V, T> {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        let child = self
-            .children
-            .iter()
-            .find(|v| v.as_ref().map(|(v, _)| v.id() == id).unwrap_or(false));
-        if let Some(child) = child {
-            child.as_ref().map(|(view, _)| view as &dyn View)
-        } else {
-            None
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for child in self.children.iter().filter_map(|child| child.as_ref()) {
+            if for_each(&child.0) {
+                break;
+            }
         }
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        let child = self
-            .children
-            .iter_mut()
-            .find(|v| v.as_ref().map(|(v, _)| v.id() == id).unwrap_or(false));
-        if let Some(child) = child {
-            child.as_mut().map(|(view, _)| view as &mut dyn View)
-        } else {
-            None
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+        for child in self.children.iter_mut().filter_map(|child| child.as_mut()) {
+            if for_each(&mut child.0) {
+                break;
+            }
         }
     }
 
-    fn children(&self) -> Vec<&dyn View> {
-        self.children
-            .iter()
-            .filter_map(|child| child.as_ref())
-            .map(|child| &child.0 as &dyn View)
-            .collect()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .filter_map(|child| child.as_mut())
-            .map(|child| &mut child.0 as &mut dyn View)
-            .collect()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "List".into()
     }
@@ -146,51 +121,6 @@ impl<V: View + 'static, T> View for List<V, T> {
             ChangeFlags::empty()
         }
     }
-
-    fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
-        cx.layout_node(self.id, true, |cx| {
-            let nodes = self
-                .children
-                .iter_mut()
-                .filter_map(|child| Some(cx.layout_view(&mut child.as_mut()?.0)))
-                .collect::<Vec<_>>();
-            nodes
-        })
-    }
-
-    fn compute_layout(&mut self, cx: &mut crate::context::LayoutCx) -> Option<Rect> {
-        let mut layout_rect = Rect::ZERO;
-        for child in &mut self.children {
-            if let Some((child, _)) = child.as_mut() {
-                layout_rect = layout_rect.union(cx.compute_view_layout(child));
-            }
-        }
-        Some(layout_rect)
-    }
-
-    fn event(
-        &mut self,
-        cx: &mut EventCx,
-        id_path: Option<&[Id]>,
-        event: crate::event::Event,
-    ) -> bool {
-        for child in self.children.iter_mut() {
-            if let Some((child, _)) = child.as_mut() {
-                if cx.view_event(child, id_path, event.clone()) {
-                    return true;
-                }
-            }
-        }
-        false
-    }
-
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        for child in self.children.iter_mut() {
-            if let Some((child, _)) = child.as_mut() {
-                cx.paint_view(child);
-            }
-        }
-    }
 }
 
 #[derive(Debug)]
diff --git a/src/views/rich_text.rs b/src/views/rich_text.rs
index 06b4b27b..29c62251 100644
--- a/src/views/rich_text.rs
+++ b/src/views/rich_text.rs
@@ -6,8 +6,7 @@ use kurbo::{Point, Rect};
 use taffy::prelude::Node;
 
 use crate::{
-    context::{EventCx, UpdateCx},
-    event::Event,
+    context::UpdateCx,
     id::Id,
     style::{Style, TextOverflow},
     unit::PxPct,
@@ -43,22 +42,6 @@ impl View for RichText {
         self.id
     }
 
-    fn child(&self, _id: Id) -> Option<&dyn View> {
-        None
-    }
-
-    fn child_mut(&mut self, _id: Id) -> Option<&mut dyn View> {
-        None
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        Vec::new()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        Vec::new()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!(
             "RichText: {:?}",
@@ -86,10 +69,6 @@ impl View for RichText {
         }
     }
 
-    fn event(&mut self, _cx: &mut EventCx, _id_path: Option<&[Id]>, _event: Event) -> bool {
-        false
-    }
-
     fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
         cx.layout_node(self.id, true, |cx| {
             let size = self.text_layout.size();
diff --git a/src/views/scroll.rs b/src/views/scroll.rs
index 34e92e61..1194d618 100644
--- a/src/views/scroll.rs
+++ b/src/views/scroll.rs
@@ -560,28 +560,12 @@ impl View for Scroll {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        if self.child.id() == id {
-            Some(&self.child)
-        } else {
-            None
-        }
-    }
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        if self.child.id() == id {
-            Some(&mut self.child)
-        } else {
-            None
-        }
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        vec![&self.child]
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for_each(&self.child);
     }
 
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        vec![&mut self.child]
+    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 debug_name(&self) -> std::borrow::Cow<'static, str> {
diff --git a/src/views/stack.rs b/src/views/stack.rs
index 8da8b34f..a9be7b64 100644
--- a/src/views/stack.rs
+++ b/src/views/stack.rs
@@ -1,8 +1,7 @@
-use kurbo::Rect;
 use taffy::style::FlexDirection;
 
 use crate::{
-    context::{EventCx, UpdateCx},
+    context::UpdateCx,
     id::Id,
     style::Style,
     view::{ChangeFlags, View},
@@ -54,32 +53,20 @@ impl View for Stack {
             .map(|direction| Style::new().flex_direction(direction))
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        self.children
-            .iter()
-            .find(|v| v.id() == id)
-            .map(|child| child as &dyn View)
-    }
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .find(|v| v.id() == id)
-            .map(|child| child as &mut dyn View)
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        self.children
-            .iter()
-            .map(|child| child as &dyn View)
-            .collect()
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for child in &self.children {
+            if for_each(child) {
+                break;
+            }
+        }
     }
 
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .map(|child| child as &mut dyn View)
-            .collect()
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+        for child in &mut self.children {
+            if for_each(child) {
+                break;
+            }
+        }
     }
 
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
@@ -99,49 +86,4 @@ impl View for Stack {
             ChangeFlags::empty()
         }
     }
-
-    fn style(&mut self, cx: &mut crate::context::StyleCx) {
-        for child in &mut self.children {
-            cx.style_view(child);
-        }
-    }
-
-    fn event(
-        &mut self,
-        cx: &mut EventCx,
-        id_path: Option<&[Id]>,
-        event: crate::event::Event,
-    ) -> bool {
-        for child in self.children.iter_mut() {
-            if cx.view_event(child, id_path, event.clone()) {
-                return true;
-            }
-        }
-        false
-    }
-
-    fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
-        cx.layout_node(self.id, true, |cx| {
-            let nodes = self
-                .children
-                .iter_mut()
-                .map(|child| cx.layout_view(child))
-                .collect::<Vec<_>>();
-            nodes
-        })
-    }
-
-    fn compute_layout(&mut self, cx: &mut crate::context::LayoutCx) -> Option<Rect> {
-        let mut layout_rect = Rect::ZERO;
-        for child in &mut self.children {
-            layout_rect = layout_rect.union(cx.compute_view_layout(child));
-        }
-        Some(layout_rect)
-    }
-
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        for child in self.children.iter_mut() {
-            cx.paint_view(child);
-        }
-    }
 }
diff --git a/src/views/static_list.rs b/src/views/static_list.rs
index a13ce9e6..98539cb9 100644
--- a/src/views/static_list.rs
+++ b/src/views/static_list.rs
@@ -1,10 +1,4 @@
-use crate::{
-    context::{EventCx, UpdateCx},
-    id::Id,
-    style::Style,
-    view::{ChangeFlags, View},
-};
-use kurbo::Rect;
+use crate::{id::Id, style::Style, view::View};
 use taffy::style::FlexDirection;
 
 pub struct StaticList {
@@ -30,92 +24,27 @@ impl View for StaticList {
         self.id
     }
 
-    fn view_style(&self) -> Option<crate::style::Style> {
-        Some(Style::new().flex_direction(FlexDirection::Column))
-    }
-
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        self.children
-            .iter()
-            .find(|v| v.id() == id)
-            .map(|child| child as &dyn View)
-    }
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .find(|v| v.id() == id)
-            .map(|child| child as &mut dyn View)
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        self.children
-            .iter()
-            .map(|child| child as &dyn View)
-            .collect()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .map(|child| child as &mut dyn View)
-            .collect()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "StaticList".into()
     }
 
-    fn update(
-        &mut self,
-        _cx: &mut UpdateCx,
-        _state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
-        ChangeFlags::empty()
+    fn view_style(&self) -> Option<crate::style::Style> {
+        Some(Style::new().flex_direction(FlexDirection::Column))
     }
 
-    fn style(&mut self, cx: &mut crate::context::StyleCx) {
-        for child in &mut self.children {
-            cx.style_view(child);
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for child in &self.children {
+            if for_each(child) {
+                break;
+            }
         }
     }
 
-    fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
-        cx.layout_node(self.id, true, |cx| {
-            let nodes = self
-                .children
-                .iter_mut()
-                .map(|child| cx.layout_view(child))
-                .collect::<Vec<_>>();
-            nodes
-        })
-    }
-
-    fn compute_layout(&mut self, cx: &mut crate::context::LayoutCx) -> Option<Rect> {
-        let mut layout_rect = Rect::ZERO;
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
         for child in &mut self.children {
-            layout_rect = layout_rect.union(cx.compute_view_layout(child));
-        }
-        Some(layout_rect)
-    }
-
-    fn event(
-        &mut self,
-        cx: &mut EventCx,
-        id_path: Option<&[Id]>,
-        event: crate::event::Event,
-    ) -> bool {
-        for child in self.children.iter_mut() {
-            if cx.view_event(child, id_path, event.clone()) {
-                return true;
+            if for_each(child) {
+                break;
             }
         }
-        false
-    }
-
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        for child in self.children.iter_mut() {
-            cx.paint_view(child);
-        }
     }
 }
diff --git a/src/views/svg.rs b/src/views/svg.rs
index 64eae416..c2b87bad 100644
--- a/src/views/svg.rs
+++ b/src/views/svg.rs
@@ -56,22 +56,6 @@ impl View for Svg {
         self.id
     }
 
-    fn child(&self, _id: Id) -> Option<&dyn View> {
-        None
-    }
-
-    fn child_mut(&mut self, _id: Id) -> Option<&mut dyn View> {
-        None
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        Vec::new()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        Vec::new()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Svg".into()
     }
@@ -97,19 +81,6 @@ impl View for Svg {
         }
     }
 
-    fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
-        cx.layout_node(self.id, false, |_| Vec::new())
-    }
-
-    fn event(
-        &mut self,
-        _cx: &mut crate::context::EventCx,
-        _id_path: Option<&[Id]>,
-        _event: crate::event::Event,
-    ) -> bool {
-        false
-    }
-
     fn paint(&mut self, cx: &mut crate::context::PaintCx) {
         if let Some(tree) = self.svg_tree.as_ref() {
             let hash = self.svg_hash.as_ref().unwrap();
diff --git a/src/views/tab.rs b/src/views/tab.rs
index 0ca6a75a..b5da1f5a 100644
--- a/src/views/tab.rs
+++ b/src/views/tab.rs
@@ -1,12 +1,11 @@
 use std::{hash::Hash, marker::PhantomData};
 
 use floem_reactive::{as_child_of_current_scope, create_effect, Scope};
-use kurbo::Rect;
 use smallvec::SmallVec;
 use taffy::style::Display;
 
 use crate::{
-    context::{EventCx, UpdateCx},
+    context::UpdateCx,
     id::Id,
     style::DisplayProp,
     view::{ChangeFlags, View},
@@ -97,46 +96,22 @@ impl<V: View + 'static, T> View for Tab<V, T> {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        let child = self
-            .children
-            .iter()
-            .find(|v| v.as_ref().map(|(v, _)| v.id() == id).unwrap_or(false));
-        if let Some(child) = child {
-            child.as_ref().map(|(view, _)| view as &dyn View)
-        } else {
-            None
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for child in self.children.iter().filter_map(|child| child.as_ref()) {
+            if for_each(&child.0) {
+                break;
+            }
         }
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        let child = self
-            .children
-            .iter_mut()
-            .find(|v| v.as_ref().map(|(v, _)| v.id() == id).unwrap_or(false));
-        if let Some(child) = child {
-            child.as_mut().map(|(view, _)| view as &mut dyn View)
-        } else {
-            None
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+        for child in self.children.iter_mut().filter_map(|child| child.as_mut()) {
+            if for_each(&mut child.0) {
+                break;
+            }
         }
     }
 
-    fn children(&self) -> Vec<&dyn View> {
-        self.children
-            .iter()
-            .filter_map(|child| child.as_ref())
-            .map(|child| &child.0 as &dyn View)
-            .collect()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .filter_map(|child| child.as_mut())
-            .map(|child| &mut child.0 as &mut dyn View)
-            .collect()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!("Tab: {}", self.active).into()
     }
@@ -172,6 +147,7 @@ impl<V: View + 'static, T> View for Tab<V, T> {
     }
 
     fn layout(&mut self, cx: &mut crate::context::LayoutCx) -> taffy::prelude::Node {
+        // FIXME: This should only layout the selected view.
         cx.layout_node(self.id, true, |cx| {
             let nodes = self
                 .children
@@ -196,15 +172,13 @@ impl<V: View + 'static, T> View for Tab<V, T> {
             nodes
         })
     }
-
+    /*
     fn compute_layout(&mut self, cx: &mut crate::context::LayoutCx) -> Option<Rect> {
-        let mut layout_rect = Rect::ZERO;
-        for child in &mut self.children {
-            if let Some((child, _)) = child.as_mut() {
-                layout_rect = layout_rect.union(cx.compute_view_layout(child));
-            }
+        if let Some(Some((child, _))) = self.children.get_mut(self.active) {
+            Some(cx.compute_view_layout(child))
+        } else {
+            None
         }
-        Some(layout_rect)
     }
 
     fn event(
@@ -224,5 +198,5 @@ impl<V: View + 'static, T> View for Tab<V, T> {
         if let Some(Some((child, _))) = self.children.get_mut(self.active) {
             cx.paint_view(child);
         }
-    }
+    }*/
 }
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index dd0a1ee8..4467e929 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -712,22 +712,6 @@ impl View for TextInput {
         self.id
     }
 
-    fn child(&self, _id: Id) -> Option<&dyn View> {
-        None
-    }
-
-    fn child_mut(&mut self, _id: Id) -> Option<&mut dyn View> {
-        None
-    }
-
-    fn children(&self) -> Vec<&dyn View> {
-        Vec::new()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        Vec::new()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!("TextInput: {:?}", self.buffer.get_untracked()).into()
     }
diff --git a/src/views/virtual_list.rs b/src/views/virtual_list.rs
index 86e39834..a64d0e35 100644
--- a/src/views/virtual_list.rs
+++ b/src/views/virtual_list.rs
@@ -201,46 +201,22 @@ impl<V: View + 'static, T> View for VirtualList<V, T> {
         self.id
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
-        let child = self
-            .children
-            .iter()
-            .find(|v| v.as_ref().map(|(v, _)| v.id() == id).unwrap_or(false));
-        if let Some(child) = child {
-            child.as_ref().map(|(view, _)| view as &dyn View)
-        } else {
-            None
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+        for child in self.children.iter().filter_map(|child| child.as_ref()) {
+            if for_each(&child.0) {
+                break;
+            }
         }
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-        let child = self
-            .children
-            .iter_mut()
-            .find(|v| v.as_ref().map(|(v, _)| v.id() == id).unwrap_or(false));
-        if let Some(child) = child {
-            child.as_mut().map(|(view, _)| view as &mut dyn View)
-        } else {
-            None
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+        for child in self.children.iter_mut().filter_map(|child| child.as_mut()) {
+            if for_each(&mut child.0) {
+                break;
+            }
         }
     }
 
-    fn children(&self) -> Vec<&dyn View> {
-        self.children
-            .iter()
-            .filter_map(|child| child.as_ref())
-            .map(|child| &child.0 as &dyn View)
-            .collect()
-    }
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View> {
-        self.children
-            .iter_mut()
-            .filter_map(|child| child.as_mut())
-            .map(|child| &mut child.0 as &mut dyn View)
-            .collect()
-    }
-
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "VirtualList".into()
     }
@@ -356,30 +332,6 @@ impl<V: View + 'static, T> View for VirtualList<V, T> {
         }
         Some(layout_rect)
     }
-
-    fn event(
-        &mut self,
-        cx: &mut crate::context::EventCx,
-        id_path: Option<&[Id]>,
-        event: crate::event::Event,
-    ) -> bool {
-        for child in self.children.iter_mut() {
-            if let Some((child, _)) = child.as_mut() {
-                if cx.view_event(child, id_path, event.clone()) {
-                    return true;
-                }
-            }
-        }
-        false
-    }
-
-    fn paint(&mut self, cx: &mut crate::context::PaintCx) {
-        for child in &mut self.children {
-            if let Some((child, _)) = child.as_mut() {
-                cx.paint_view(child);
-            }
-        }
-    }
 }
 
 impl<T: Clone> VirtualListVector<T> for im::Vector<T> {