Don't let hidden views contribute to the parent's rect

src/context.rs

@@ -284,10 +284,10 @@
 
     /// This removes a view from the app state.
     pub fn remove_view(&mut self, view: &mut dyn View) {
         view.for_each_child_mut(&mut |child| {
             self.remove_view(child);
             false
         });
         let id = view.id();
         let view_state = self.view_state(id);
         if let Some(action) = view_state.cleanup_listener.as_ref() {
@@ -1121,12 +1121,12 @@
         // Propagate style requests to children if needed.
         if view_state.request_style_recursive {
             view_state.request_style_recursive = false;
             view.for_each_child(&mut |child| {
                 let state = self.app_state_mut().view_state(child.id());
                 state.request_style_recursive = true;
                 state.request_style = true;
                 false
             });
         }
 
         self.app_state
@@ -1326,18 +1326,16 @@
     /// - invoking any attached context::ResizeListeners
     ///
     /// Returns the bounding rect that encompasses this view and its children
-    pub fn compute_view_layout(&mut self, view: &mut dyn View) -> Rect {
+    pub fn compute_view_layout(&mut self, view: &mut dyn View) -> Option<Rect> {
         let id = view.id();
         if self.app_state().is_hidden(id) {
-            return Rect::ZERO;
+            self.app_state_mut().view_state(id).layout_rect = Rect::ZERO;
+            return None;
         }
 
         self.save();
 
-        let layout = self
-            .app_state()
-            .get_layout(id)
-            .unwrap_or(taffy::layout::Layout::new());
+        let layout = self.app_state().get_layout(id).unwrap();
         let origin = Point::new(layout.location.x as f64, layout.location.y as f64);
         let parent_viewport = self.viewport.map(|rect| {
             rect.with_origin(Point::new(
@@ -1401,7 +1399,7 @@
 
         self.restore();
 
-        layout_rect
+        Some(layout_rect)
     }
 
     pub(crate) fn get_resize_listener(&mut self, id: Id) -> Option<&mut ResizeListener> {

src/view.rs

@@ -121,11 +121,11 @@
 
     /// 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
@@ -180,10 +180,10 @@
 
     /// Use this method to style the view's children.
     fn style(&mut self, cx: &mut StyleCx<'_>) {
         self.for_each_child_mut(&mut |child| {
             cx.style_view(child);
             false
         });
     }
 
     /// Use this method to layout the view's children.
@@ -201,17 +201,7 @@
 
     /// Responsible for computing the layout of the view's children.
     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
+        default_compute_layout(self, cx)
     }
 
     /// Implement this to handle events and to pass them down to children
@@ -219,7 +209,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_rev_mut(&mut |child| {
             handled |= cx.view_event(child, id_path, event.clone());
             handled
         });
@@ -236,6 +226,23 @@
     }
 }
 
+/// Computes the layout of the view's children, if any.
+pub fn default_compute_layout<V: View + ?Sized>(view: &mut V, cx: &mut LayoutCx) -> Option<Rect> {
+    let mut layout_rect: Option<Rect> = None;
+    view.for_each_child_mut(&mut |child| {
+        let child_layout = cx.compute_view_layout(child);
+        if let Some(child_layout) = child_layout {
+            if let Some(rect) = layout_rect {
+                layout_rect = Some(rect.union(child_layout));
+            } else {
+                layout_rect = Some(child_layout);
+            }
+        }
+        false
+    });
+    layout_rect
+}
+
 pub(crate) fn paint_bg(
     cx: &mut PaintCx,
     computed_style: &Style,
@@ -361,14 +368,14 @@
     }
 }
 
 pub(crate) fn view_children(view: &dyn View) -> Vec<&dyn View> {
     let mut result = Vec::new();
     view.for_each_child(&mut |view| {
         result.push(view);
         false
     });
     result
 }
 
 /// Tab navigation finds the next or previous view with the `keyboard_navigatable` status in the tree.
 #[allow(dead_code)]
@@ -398,15 +405,15 @@
     println!("Tab to {new_focus:?}");
 }
 
 fn view_filtered_children<'a>(view: &'a dyn View, id_path: &[Id]) -> Vec<&'a dyn View> {
     let id = id_path[0];
     let id_path = &id_path[1..];
 
     if id == view.id() {
         if id_path.is_empty() {
             view_children(view)
         } else if let Some(child) = view.child(id_path[0]) {
             view_filtered_children(child, id_path)
         } else {
             Vec::new()
         }
@@ -422,7 +429,7 @@
     println!("id is {id:?}");
     println!("id path is {:?}", id_path.0);
 
     let children = view_filtered_children(root_view, &id_path.0);
 
     println!(
         "children is {:?}",
@@ -468,7 +475,7 @@
         if id_path.len() == 1 {
             println!("id is {id:?} id_path is {:?}", id_path);
             let child_id = id_path[0];
             let children = view_children(view);
             let pos = children.iter().position(|v| v.id() == child_id);
             if let Some(pos) = pos {
                 if children.len() > 1 && pos < children.len() - 1 {
@@ -513,7 +520,7 @@
 
         if id_path.len() == 1 {
             let child_id = id_path[0];
             let children = view_children(view);
             let pos = children.iter().position(|v| v.id() == child_id);
             if let Some(pos) = pos {
                 if pos > 0 {
@@ -532,16 +539,16 @@
 
 pub(crate) fn view_children_set_parent_id(view: &dyn View) {
     let parent_id = view.id();
     view.for_each_child(&mut |child| {
         child.id().set_parent(parent_id);
         view_children_set_parent_id(child);
         false
     });
 }
 
 fn view_nested_last_child(view: &dyn View) -> &dyn View {
     let mut last_child = view;
     while let Some(new_last_child) = view_children(last_child).pop() {
         last_child = new_last_child;
     }
     last_child
@@ -561,7 +568,7 @@
         }
         println!("{:?} {}", current_view.id(), &current_view.debug_name());
 
         let mut children = view_children(current_view);
         if let Some(last_child) = children.pop() {
             views.push((last_child, [active_lines.as_slice(), &[false]].concat()));
         }
@@ -580,20 +587,20 @@
         (**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

@@ -1,4 +1,4 @@
-use kurbo::{Rect, Size};
+use kurbo::Size;
 
 use crate::{id::Id, view::View};
 
@@ -27,25 +27,17 @@
         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()
     }
 
-    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 paint(&mut self, cx: &mut crate::context::PaintCx) {
         cx.save();
         let style = cx.get_builtin_style(self.id);

src/views/virtual_list.rs

@@ -8,7 +8,7 @@
 use crate::{
     context::LayoutCx,
     id::Id,
-    view::{ChangeFlags, View},
+    view::{self, ChangeFlags, View},
 };
 
 use super::{apply_diff, diff, Diff, DiffOpAdd, FxIndexSet, HashRun};
@@ -217,21 +217,21 @@
         }
     }
 
     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()
@@ -340,13 +340,7 @@
             self.set_viewport.set(viewport);
         }
 
-        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)
+        view::default_compute_layout(self, cx)
     }
 }