Use layout with children for nesting

1 files changed, 71 insertions, 59 deletions

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index 44f64c61..c495bb28 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -9,7 +9,6 @@ use crate::core::{
 };
 
 use std::cell::RefCell;
-use std::iter::Peekable;
 
 /// An [`Overlay`] container that displays nested overlays
 #[allow(missing_debug_implementations)]
@@ -55,7 +54,7 @@ where
             renderer: &Renderer,
             bounds: Size,
             position: Point,
-        ) -> Vec<layout::Node>
+        ) -> layout::Node
         where
             Renderer: renderer::Renderer,
         {
@@ -63,23 +62,23 @@ where
 
             let node = element.layout(renderer, bounds, translation);
 
-            if let Some(mut overlay) =
+            if let Some(mut nested) =
                 element.overlay(Layout::new(&node), renderer)
             {
-                vec![node]
-                    .into_iter()
-                    .chain(recurse(&mut overlay, renderer, bounds, position))
-                    .collect()
+                layout::Node::with_children(
+                    node.size(),
+                    vec![
+                        node,
+                        recurse(&mut nested, renderer, bounds, position),
+                    ],
+                )
             } else {
-                vec![node]
+                layout::Node::with_children(node.size(), vec![node])
             }
         }
 
         self.overlay.with_element_mut(|element| {
-            layout::Node::with_children(
-                bounds,
-                recurse(element, renderer, bounds, position),
-            )
+            recurse(element, renderer, bounds, position)
         })
     }
 
@@ -91,9 +90,9 @@ where
         layout: Layout<'_>,
         cursor: mouse::Cursor,
     ) {
-        fn recurse<'a, Message, Renderer>(
+        fn recurse<Message, Renderer>(
             element: &mut overlay::Element<'_, Message, Renderer>,
-            mut layouts: Peekable<impl Iterator<Item = Layout<'a>>>,
+            layout: Layout<'_>,
             renderer: &mut Renderer,
             theme: &<Renderer as renderer::Renderer>::Theme,
             style: &renderer::Style,
@@ -101,18 +100,21 @@ where
         ) where
             Renderer: renderer::Renderer,
         {
+            let mut layouts = layout.children();
+
             if let Some(layout) = layouts.next() {
+                let nested_layout = layouts.next();
+
                 let is_over = cursor
                     .position()
-                    .and_then(|cursor_position| {
-                        layouts.peek().and_then(|nested_layout| {
-                            element.overlay(layout, renderer).map(|overlay| {
-                                overlay.is_over(
-                                    *nested_layout,
-                                    renderer,
-                                    cursor_position,
-                                )
-                            })
+                    .zip(nested_layout)
+                    .and_then(|(cursor_position, nested_layout)| {
+                        element.overlay(layout, renderer).map(|nested| {
+                            nested.is_over(
+                                nested_layout,
+                                renderer,
+                                cursor_position,
+                            )
                         })
                     })
                     .unwrap_or_default();
@@ -131,10 +133,12 @@ where
                     );
                 });
 
-                if let Some(mut overlay) = element.overlay(layout, renderer) {
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(nested_layout)
+                {
                     recurse(
-                        &mut overlay,
-                        layouts,
+                        &mut nested,
+                        nested_layout,
                         renderer,
                         theme,
                         style,
@@ -145,9 +149,7 @@ where
         }
 
         self.overlay.with_element_mut(|element| {
-            let layouts = layout.children().peekable();
-
-            recurse(element, layouts, renderer, theme, style, cursor);
+            recurse(element, layout, renderer, theme, style, cursor);
         })
     }
 
@@ -157,26 +159,28 @@ where
         renderer: &Renderer,
         operation: &mut dyn widget::Operation<Message>,
     ) {
-        fn recurse<'a, Message, Renderer>(
+        fn recurse<Message, Renderer>(
             element: &mut overlay::Element<'_, Message, Renderer>,
-            mut layouts: impl Iterator<Item = Layout<'a>>,
+            layout: Layout<'_>,
             renderer: &Renderer,
             operation: &mut dyn widget::Operation<Message>,
         ) where
             Renderer: renderer::Renderer,
         {
+            let mut layouts = layout.children();
+
             if let Some(layout) = layouts.next() {
                 element.operate(layout, renderer, operation);
 
-                if let Some(mut overlay) = element.overlay(layout, renderer) {
-                    recurse(&mut overlay, layouts, renderer, operation);
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
+                {
+                    recurse(&mut nested, nested_layout, renderer, operation);
                 }
             }
         }
 
-        let layouts = layout.children();
-
-        recurse(self.overlay.0.get_mut(), layouts, renderer, operation)
+        recurse(self.overlay.0.get_mut(), layout, renderer, operation)
     }
 
     fn on_event(
@@ -188,9 +192,9 @@ where
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
     ) -> event::Status {
-        fn recurse<'a, Message, Renderer>(
+        fn recurse<Message, Renderer>(
             element: &mut overlay::Element<'_, Message, Renderer>,
-            mut layouts: impl Iterator<Item = Layout<'a>>,
+            layout: Layout<'_>,
             event: Event,
             cursor: mouse::Cursor,
             renderer: &Renderer,
@@ -200,13 +204,15 @@ where
         where
             Renderer: renderer::Renderer,
         {
+            let mut layouts = layout.children();
+
             if let Some(layout) = layouts.next() {
-                let status = if let Some(mut overlay) =
-                    element.overlay(layout, renderer)
+                let status = if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
                 {
                     recurse(
-                        &mut overlay,
-                        layouts,
+                        &mut nested,
+                        nested_layout,
                         event.clone(),
                         cursor,
                         renderer,
@@ -229,11 +235,9 @@ where
             }
         }
 
-        let layouts = layout.children();
-
         recurse(
             self.overlay.0.get_mut(),
-            layouts,
+            layout,
             event,
             cursor,
             renderer,
@@ -249,9 +253,9 @@ where
         viewport: &Rectangle,
         renderer: &Renderer,
     ) -> mouse::Interaction {
-        fn recurse<'a, Message, Renderer>(
+        fn recurse<Message, Renderer>(
             element: &mut overlay::Element<'_, Message, Renderer>,
-            mut layouts: impl Iterator<Item = Layout<'a>>,
+            layout: Layout<'_>,
             cursor: mouse::Cursor,
             viewport: &Rectangle,
             renderer: &Renderer,
@@ -259,6 +263,8 @@ where
         where
             Renderer: renderer::Renderer,
         {
+            let mut layouts = layout.children();
+
             let layout = layouts.next()?;
             let cursor_position = cursor.position()?;
 
@@ -269,10 +275,11 @@ where
             Some(
                 element
                     .overlay(layout, renderer)
-                    .and_then(|mut overlay| {
+                    .zip(layouts.next())
+                    .and_then(|(mut overlay, layout)| {
                         recurse(
                             &mut overlay,
-                            layouts,
+                            layout,
                             cursor,
                             viewport,
                             renderer,
@@ -288,9 +295,7 @@ where
 
         self.overlay
             .with_element_mut(|element| {
-                let layouts = layout.children();
-
-                recurse(element, layouts, cursor, viewport, renderer)
+                recurse(element, layout, cursor, viewport, renderer)
             })
             .unwrap_or_default()
     }
@@ -301,22 +306,31 @@ where
         renderer: &Renderer,
         cursor_position: Point,
     ) -> bool {
-        fn recurse<'a, Message, Renderer>(
+        fn recurse<Message, Renderer>(
             element: &mut overlay::Element<'_, Message, Renderer>,
-            mut layouts: impl Iterator<Item = Layout<'a>>,
+            layout: Layout<'_>,
             renderer: &Renderer,
             cursor_position: Point,
         ) -> bool
         where
             Renderer: renderer::Renderer,
         {
+            let mut layouts = layout.children();
+
             if let Some(layout) = layouts.next() {
                 if element.is_over(layout, renderer, cursor_position) {
                     return true;
                 }
 
-                if let Some(mut overlay) = element.overlay(layout, renderer) {
-                    recurse(&mut overlay, layouts, renderer, cursor_position)
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
+                {
+                    recurse(
+                        &mut nested,
+                        nested_layout,
+                        renderer,
+                        cursor_position,
+                    )
                 } else {
                     false
                 }
@@ -326,9 +340,7 @@ where
         }
 
         self.overlay.with_element_mut(|element| {
-            let layouts = layout.children();
-
-            recurse(element, layouts, renderer, cursor_position)
+            recurse(element, layout, renderer, cursor_position)
         })
     }