From 55dc3b5619392f4a20389255708c61082b3d4c1a Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 14:31:38 -0800
Subject: Introduce internal `overlay::Nested` for `UserInterface`

---
 runtime/src/user_interface.rs         |  71 +++++----
 runtime/src/user_interface/overlay.rs | 288 ++++++++++++++++++++++++++++++++++
 2 files changed, 332 insertions(+), 27 deletions(-)
 create mode 100644 runtime/src/user_interface/overlay.rs

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface.rs b/runtime/src/user_interface.rs
index 68ff6158..8ae0363a 100644
--- a/runtime/src/user_interface.rs
+++ b/runtime/src/user_interface.rs
@@ -1,12 +1,14 @@
 //! Implement your own event loop to drive a user interface.
+mod overlay;
+
 use crate::core::event::{self, Event};
 use crate::core::layout;
 use crate::core::mouse;
 use crate::core::renderer;
 use crate::core::widget;
 use crate::core::window;
-use crate::core::{Clipboard, Rectangle, Size, Vector};
-use crate::core::{Element, Layout, Shell};
+use crate::core::{Clipboard, Point, Rectangle, Size};
+use crate::core::{Element, Layout, Overlay, Shell};
 
 /// A set of interactive graphical elements with a specific [`Layout`].
 ///
@@ -185,18 +187,18 @@ where
         let mut outdated = false;
         let mut redraw_request = None;
 
-        let mut manual_overlay =
-            ManuallyDrop::new(self.root.as_widget_mut().overlay(
-                &mut self.state,
-                Layout::new(&self.base),
-                renderer,
-            ));
+        let mut manual_overlay = ManuallyDrop::new(
+            self.root
+                .as_widget_mut()
+                .overlay(&mut self.state, Layout::new(&self.base), renderer)
+                .map(overlay::Nested::new),
+        );
 
         let (base_cursor, overlay_statuses) = if manual_overlay.is_some() {
             let bounds = self.bounds;
 
             let mut overlay = manual_overlay.as_mut().unwrap();
-            let mut layout = overlay.layout(renderer, bounds, Vector::ZERO);
+            let mut layout = overlay.layout(renderer, bounds, Point::ORIGIN);
             let mut event_statuses = Vec::new();
 
             for event in events.iter().cloned() {
@@ -231,12 +233,16 @@ where
                         &layout::Limits::new(Size::ZERO, self.bounds),
                     );
 
-                    manual_overlay =
-                        ManuallyDrop::new(self.root.as_widget_mut().overlay(
-                            &mut self.state,
-                            Layout::new(&self.base),
-                            renderer,
-                        ));
+                    manual_overlay = ManuallyDrop::new(
+                        self.root
+                            .as_widget_mut()
+                            .overlay(
+                                &mut self.state,
+                                Layout::new(&self.base),
+                                renderer,
+                            )
+                            .map(overlay::Nested::new),
+                    );
 
                     if manual_overlay.is_none() {
                         break;
@@ -245,7 +251,8 @@ where
                     overlay = manual_overlay.as_mut().unwrap();
 
                     shell.revalidate_layout(|| {
-                        layout = overlay.layout(renderer, bounds, Vector::ZERO);
+                        layout =
+                            overlay.layout(renderer, bounds, Point::ORIGIN);
                     });
                 }
 
@@ -260,8 +267,11 @@ where
                     cursor
                         .position()
                         .map(|cursor_position| {
-                            overlay
-                                .is_over(Layout::new(&layout), cursor_position)
+                            overlay.is_over(
+                                Layout::new(&layout),
+                                renderer,
+                                cursor_position,
+                            )
                         })
                         .unwrap_or_default()
                 })
@@ -428,16 +438,20 @@ where
             .root
             .as_widget_mut()
             .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .map(overlay::Nested::new)
         {
             let overlay_layout = self.overlay.take().unwrap_or_else(|| {
-                overlay.layout(renderer, self.bounds, Vector::ZERO)
+                overlay.layout(renderer, self.bounds, Point::ORIGIN)
             });
 
             let cursor = if cursor
                 .position()
                 .map(|cursor_position| {
-                    overlay
-                        .is_over(Layout::new(&overlay_layout), cursor_position)
+                    overlay.is_over(
+                        Layout::new(&overlay_layout),
+                        renderer,
+                        cursor_position,
+                    )
                 })
                 .unwrap_or_default()
             {
@@ -488,6 +502,7 @@ where
             .and_then(|layout| {
                 root.as_widget_mut()
                     .overlay(&mut self.state, Layout::new(base), renderer)
+                    .map(overlay::Nested::new)
                     .map(|overlay| {
                         let overlay_interaction = overlay.mouse_interaction(
                             Layout::new(layout),
@@ -513,6 +528,7 @@ where
                             .map(|cursor_position| {
                                 overlay.is_over(
                                     Layout::new(layout),
+                                    renderer,
                                     cursor_position,
                                 )
                             })
@@ -540,14 +556,15 @@ where
             operation,
         );
 
-        if let Some(mut overlay) = self.root.as_widget_mut().overlay(
-            &mut self.state,
-            Layout::new(&self.base),
-            renderer,
-        ) {
+        if let Some(mut overlay) = self
+            .root
+            .as_widget_mut()
+            .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .map(overlay::Nested::new)
+        {
             if self.overlay.is_none() {
                 self.overlay =
-                    Some(overlay.layout(renderer, self.bounds, Vector::ZERO));
+                    Some(overlay.layout(renderer, self.bounds, Point::ORIGIN));
             }
 
             overlay.operate(
diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
new file mode 100644
index 00000000..6dfed153
--- /dev/null
+++ b/runtime/src/user_interface/overlay.rs
@@ -0,0 +1,288 @@
+use crate::core::event;
+use crate::core::layout;
+use crate::core::mouse;
+use crate::core::overlay;
+use crate::core::renderer;
+use crate::core::widget;
+use crate::core::{
+    Clipboard, Event, Layout, Overlay, Point, Rectangle, Shell, Size,
+};
+
+use std::cell::RefCell;
+
+/// An [`Overlay`] container that displays nested overlays
+#[allow(missing_debug_implementations)]
+pub struct Nested<'a, Message, Renderer> {
+    overlay: Inner<'a, Message, Renderer>,
+}
+
+impl<'a, Message, Renderer> Nested<'a, Message, Renderer> {
+    /// Creates a nested overlay from the provided [`overlay::Element`]
+    pub fn new(element: overlay::Element<'a, Message, Renderer>) -> Self {
+        Self {
+            overlay: Inner(RefCell::new(element)),
+        }
+    }
+}
+
+struct Inner<'a, Message, Renderer>(
+    RefCell<overlay::Element<'a, Message, Renderer>>,
+);
+
+impl<'a, Message, Renderer> Inner<'a, Message, Renderer> {
+    fn with_element_mut<T>(
+        &self,
+        mut f: impl FnMut(&mut overlay::Element<'_, Message, Renderer>) -> T,
+    ) -> T {
+        (f)(&mut self.0.borrow_mut())
+    }
+}
+
+impl<'a, Message, Renderer> Overlay<Message, Renderer>
+    for Nested<'a, Message, Renderer>
+where
+    Renderer: renderer::Renderer,
+{
+    fn layout(
+        &self,
+        renderer: &Renderer,
+        bounds: Size,
+        position: Point,
+    ) -> layout::Node {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            renderer: &Renderer,
+            bounds: Size,
+            position: Point,
+        ) -> Vec<layout::Node>
+        where
+            Renderer: renderer::Renderer,
+        {
+            let translation = position - Point::ORIGIN;
+
+            let node = element.layout(renderer, bounds, translation);
+
+            if let Some(mut overlay) =
+                element.overlay(Layout::new(&node), renderer)
+            {
+                vec![node]
+                    .into_iter()
+                    .chain(recurse(&mut overlay, renderer, bounds, position))
+                    .collect()
+            } else {
+                vec![node]
+            }
+        }
+
+        self.overlay.with_element_mut(|element| {
+            layout::Node::with_children(
+                bounds,
+                recurse(element, renderer, bounds, position),
+            )
+        })
+    }
+
+    fn draw(
+        &self,
+        renderer: &mut Renderer,
+        theme: &<Renderer as renderer::Renderer>::Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+    ) {
+        fn recurse<'a, Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            mut layouts: impl Iterator<Item = Layout<'a>>,
+            renderer: &mut Renderer,
+            theme: &<Renderer as renderer::Renderer>::Theme,
+            style: &renderer::Style,
+            cursor: mouse::Cursor,
+        ) where
+            Renderer: renderer::Renderer,
+        {
+            let layout = layouts.next().unwrap();
+
+            element.draw(renderer, theme, style, layout, cursor);
+
+            if let Some(mut overlay) = element.overlay(layout, renderer) {
+                recurse(&mut overlay, layouts, renderer, theme, style, cursor);
+            }
+        }
+
+        self.overlay.with_element_mut(|element| {
+            let layouts = layout.children();
+
+            recurse(element, layouts, renderer, theme, style, cursor);
+        })
+    }
+
+    fn operate(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn widget::Operation<Message>,
+    ) {
+        fn recurse<'a, Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            mut layouts: impl Iterator<Item = Layout<'a>>,
+            renderer: &Renderer,
+            operation: &mut dyn widget::Operation<Message>,
+        ) where
+            Renderer: renderer::Renderer,
+        {
+            let layout = layouts.next().unwrap();
+
+            element.operate(layout, renderer, operation);
+
+            if let Some(mut overlay) = element.overlay(layout, renderer) {
+                recurse(&mut overlay, layouts, renderer, operation);
+            }
+        }
+
+        let layouts = layout.children();
+
+        recurse(self.overlay.0.get_mut(), layouts, renderer, operation)
+    }
+
+    fn on_event(
+        &mut self,
+        event: Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+    ) -> event::Status {
+        fn recurse<'a, Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            mut layouts: impl Iterator<Item = Layout<'a>>,
+            event: Event,
+            cursor: mouse::Cursor,
+            renderer: &Renderer,
+            clipboard: &mut dyn Clipboard,
+            shell: &mut Shell<'_, Message>,
+        ) -> event::Status
+        where
+            Renderer: renderer::Renderer,
+        {
+            let layout = layouts.next().unwrap();
+
+            let status =
+                if let Some(mut overlay) = element.overlay(layout, renderer) {
+                    recurse(
+                        &mut overlay,
+                        layouts,
+                        event.clone(),
+                        cursor,
+                        renderer,
+                        clipboard,
+                        shell,
+                    )
+                } else {
+                    event::Status::Ignored
+                };
+
+            if matches!(status, event::Status::Ignored) {
+                element
+                    .on_event(event, layout, cursor, renderer, clipboard, shell)
+            } else {
+                status
+            }
+        }
+
+        let layouts = layout.children();
+
+        recurse(
+            self.overlay.0.get_mut(),
+            layouts,
+            event,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+        )
+    }
+
+    fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &Renderer,
+    ) -> mouse::Interaction {
+        fn recurse<'a, Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            mut layouts: impl Iterator<Item = Layout<'a>>,
+            cursor: mouse::Cursor,
+            viewport: &Rectangle,
+            renderer: &Renderer,
+        ) -> mouse::Interaction
+        where
+            Renderer: renderer::Renderer,
+        {
+            let layout = layouts.next().unwrap();
+
+            let interaction =
+                if let Some(mut overlay) = element.overlay(layout, renderer) {
+                    recurse(&mut overlay, layouts, cursor, viewport, renderer)
+                } else {
+                    mouse::Interaction::default()
+                };
+
+            element
+                .mouse_interaction(layout, cursor, viewport, renderer)
+                .max(interaction)
+        }
+
+        self.overlay.with_element_mut(|element| {
+            let layouts = layout.children();
+
+            recurse(element, layouts, cursor, viewport, renderer)
+        })
+    }
+
+    fn is_over(
+        &self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        cursor_position: Point,
+    ) -> bool {
+        fn recurse<'a, Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            mut layouts: impl Iterator<Item = Layout<'a>>,
+            renderer: &Renderer,
+            cursor_position: Point,
+        ) -> bool
+        where
+            Renderer: renderer::Renderer,
+        {
+            let layout = layouts.next().unwrap();
+
+            let is_over = element.is_over(layout, renderer, cursor_position);
+
+            if is_over {
+                return true;
+            }
+
+            if let Some(mut overlay) = element.overlay(layout, renderer) {
+                recurse(&mut overlay, layouts, renderer, cursor_position)
+            } else {
+                false
+            }
+        }
+
+        self.overlay.with_element_mut(|element| {
+            let layouts = layout.children();
+
+            recurse(element, layouts, renderer, cursor_position)
+        })
+    }
+
+    fn overlay<'b>(
+        &'b mut self,
+        _layout: Layout<'_>,
+        _renderer: &Renderer,
+    ) -> Option<overlay::Element<'b, Message, Renderer>> {
+        None
+    }
+}
-- 
cgit 


From f44d4292838f0eaa3fca3ce074977082bb2a6be9 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 13:49:25 -0800
Subject: Render nested in layer

---
 runtime/src/user_interface/overlay.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index 6dfed153..590cc49f 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -102,7 +102,9 @@ where
         {
             let layout = layouts.next().unwrap();
 
-            element.draw(renderer, theme, style, layout, cursor);
+            renderer.with_layer(layout.bounds(), |renderer| {
+                element.draw(renderer, theme, style, layout, cursor);
+            });
 
             if let Some(mut overlay) = element.overlay(layout, renderer) {
                 recurse(&mut overlay, layouts, renderer, theme, style, cursor);
-- 
cgit 


From 1ce047cdb3bb210a8a949794d3db88b3a029df81 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 13:53:22 -0800
Subject: Prioritize mouse interaction of deepest `Overlay`

---
 runtime/src/user_interface/overlay.rs | 30 +++++++++++++++++++++---------
 1 file changed, 21 insertions(+), 9 deletions(-)

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index 590cc49f..f80d1914 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -224,16 +224,28 @@ where
         {
             let layout = layouts.next().unwrap();
 
-            let interaction =
-                if let Some(mut overlay) = element.overlay(layout, renderer) {
-                    recurse(&mut overlay, layouts, cursor, viewport, renderer)
-                } else {
-                    mouse::Interaction::default()
-                };
+            if let Some(cursor_position) = cursor.position() {
+                match element.overlay(layout, renderer) {
+                    Some(mut overlay)
+                        if overlay.is_over(
+                            layout,
+                            renderer,
+                            cursor_position,
+                        ) =>
+                    {
+                        return recurse(
+                            &mut overlay,
+                            layouts,
+                            cursor,
+                            viewport,
+                            renderer,
+                        );
+                    }
+                    _ => {}
+                }
+            }
 
-            element
-                .mouse_interaction(layout, cursor, viewport, renderer)
-                .max(interaction)
+            element.mouse_interaction(layout, cursor, viewport, renderer)
         }
 
         self.overlay.with_element_mut(|element| {
-- 
cgit 


From d4bb7c0b24e3bf7939bdecf2f3e1e0dba67587fc Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 15:06:44 -0800
Subject: Remove unwraps in `overlay::Nested` and fix `mouse_interaction`

---
 runtime/src/user_interface/overlay.rs | 120 +++++++++++++++++++---------------
 1 file changed, 69 insertions(+), 51 deletions(-)

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index f80d1914..332eb32d 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -100,14 +100,25 @@ where
         ) where
             Renderer: renderer::Renderer,
         {
-            let layout = layouts.next().unwrap();
+            if let Some(layout) = layouts.next() {
+                renderer.with_layer(layout.bounds(), |renderer| {
+                    element.draw(renderer, theme, style, layout, cursor);
+                });
 
-            renderer.with_layer(layout.bounds(), |renderer| {
-                element.draw(renderer, theme, style, layout, cursor);
-            });
+                renderer.with_layer(layout.bounds(), |renderer| {
+                    element.draw(renderer, theme, style, layout, cursor);
+                });
 
-            if let Some(mut overlay) = element.overlay(layout, renderer) {
-                recurse(&mut overlay, layouts, renderer, theme, style, cursor);
+                if let Some(mut overlay) = element.overlay(layout, renderer) {
+                    recurse(
+                        &mut overlay,
+                        layouts,
+                        renderer,
+                        theme,
+                        style,
+                        cursor,
+                    );
+                }
             }
         }
 
@@ -132,12 +143,12 @@ where
         ) where
             Renderer: renderer::Renderer,
         {
-            let layout = layouts.next().unwrap();
+            if let Some(layout) = layouts.next() {
+                element.operate(layout, renderer, operation);
 
-            element.operate(layout, renderer, operation);
-
-            if let Some(mut overlay) = element.overlay(layout, renderer) {
-                recurse(&mut overlay, layouts, renderer, operation);
+                if let Some(mut overlay) = element.overlay(layout, renderer) {
+                    recurse(&mut overlay, layouts, renderer, operation);
+                }
             }
         }
 
@@ -167,10 +178,10 @@ where
         where
             Renderer: renderer::Renderer,
         {
-            let layout = layouts.next().unwrap();
-
-            let status =
-                if let Some(mut overlay) = element.overlay(layout, renderer) {
+            if let Some(layout) = layouts.next() {
+                let status = if let Some(mut overlay) =
+                    element.overlay(layout, renderer)
+                {
                     recurse(
                         &mut overlay,
                         layouts,
@@ -184,11 +195,15 @@ where
                     event::Status::Ignored
                 };
 
-            if matches!(status, event::Status::Ignored) {
-                element
-                    .on_event(event, layout, cursor, renderer, clipboard, shell)
+                if matches!(status, event::Status::Ignored) {
+                    element.on_event(
+                        event, layout, cursor, renderer, clipboard, shell,
+                    )
+                } else {
+                    status
+                }
             } else {
-                status
+                event::Status::Ignored
             }
         }
 
@@ -218,41 +233,44 @@ where
             cursor: mouse::Cursor,
             viewport: &Rectangle,
             renderer: &Renderer,
-        ) -> mouse::Interaction
+        ) -> Option<mouse::Interaction>
         where
             Renderer: renderer::Renderer,
         {
-            let layout = layouts.next().unwrap();
+            let layout = layouts.next()?;
+            let cursor_position = cursor.position()?;
 
-            if let Some(cursor_position) = cursor.position() {
-                match element.overlay(layout, renderer) {
-                    Some(mut overlay)
-                        if overlay.is_over(
-                            layout,
-                            renderer,
-                            cursor_position,
-                        ) =>
-                    {
-                        return recurse(
+            if !element.is_over(layout, renderer, cursor_position) {
+                return None;
+            }
+
+            Some(
+                element
+                    .overlay(layout, renderer)
+                    .and_then(|mut overlay| {
+                        recurse(
                             &mut overlay,
                             layouts,
                             cursor,
                             viewport,
                             renderer,
-                        );
-                    }
-                    _ => {}
-                }
-            }
-
-            element.mouse_interaction(layout, cursor, viewport, renderer)
+                        )
+                    })
+                    .unwrap_or_else(|| {
+                        element.mouse_interaction(
+                            layout, cursor, viewport, renderer,
+                        )
+                    }),
+            )
         }
 
-        self.overlay.with_element_mut(|element| {
-            let layouts = layout.children();
+        self.overlay
+            .with_element_mut(|element| {
+                let layouts = layout.children();
 
-            recurse(element, layouts, cursor, viewport, renderer)
-        })
+                recurse(element, layouts, cursor, viewport, renderer)
+            })
+            .unwrap_or_default()
     }
 
     fn is_over(
@@ -270,16 +288,16 @@ where
         where
             Renderer: renderer::Renderer,
         {
-            let layout = layouts.next().unwrap();
-
-            let is_over = element.is_over(layout, renderer, cursor_position);
-
-            if is_over {
-                return true;
-            }
+            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 overlay) = element.overlay(layout, renderer) {
+                    recurse(&mut overlay, layouts, renderer, cursor_position)
+                } else {
+                    false
+                }
             } else {
                 false
             }
-- 
cgit 


From 12c623f35bea0b76bae5e2eeb7d46390b8b9f0e4 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 15:58:07 -0800
Subject: Cursor availability by layer

---
 runtime/src/user_interface/overlay.rs | 34 ++++++++++++++++++++++++++++------
 1 file changed, 28 insertions(+), 6 deletions(-)

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index 332eb32d..44f64c61 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -9,6 +9,7 @@ use crate::core::{
 };
 
 use std::cell::RefCell;
+use std::iter::Peekable;
 
 /// An [`Overlay`] container that displays nested overlays
 #[allow(missing_debug_implementations)]
@@ -92,7 +93,7 @@ where
     ) {
         fn recurse<'a, Message, Renderer>(
             element: &mut overlay::Element<'_, Message, Renderer>,
-            mut layouts: impl Iterator<Item = Layout<'a>>,
+            mut layouts: Peekable<impl Iterator<Item = Layout<'a>>>,
             renderer: &mut Renderer,
             theme: &<Renderer as renderer::Renderer>::Theme,
             style: &renderer::Style,
@@ -101,12 +102,33 @@ where
             Renderer: renderer::Renderer,
         {
             if let Some(layout) = layouts.next() {
-                renderer.with_layer(layout.bounds(), |renderer| {
-                    element.draw(renderer, theme, style, layout, cursor);
-                });
+                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,
+                                )
+                            })
+                        })
+                    })
+                    .unwrap_or_default();
 
                 renderer.with_layer(layout.bounds(), |renderer| {
-                    element.draw(renderer, theme, style, layout, cursor);
+                    element.draw(
+                        renderer,
+                        theme,
+                        style,
+                        layout,
+                        if is_over {
+                            mouse::Cursor::Unavailable
+                        } else {
+                            cursor
+                        },
+                    );
                 });
 
                 if let Some(mut overlay) = element.overlay(layout, renderer) {
@@ -123,7 +145,7 @@ where
         }
 
         self.overlay.with_element_mut(|element| {
-            let layouts = layout.children();
+            let layouts = layout.children().peekable();
 
             recurse(element, layouts, renderer, theme, style, cursor);
         })
-- 
cgit 


From 3e6f6eedcb51150b8a599530021cebdc629fddd2 Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 16:08:05 -0800
Subject: Use layout with children for nesting

---
 runtime/src/user_interface/overlay.rs | 130 +++++++++++++++++++---------------
 1 file changed, 71 insertions(+), 59 deletions(-)

(limited to 'runtime/src')

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)
         })
     }
 
-- 
cgit 


From 83140d6049c165020c2afc1db303b2556e40488e Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 19:03:52 -0800
Subject: Remove interior mutability

Nested doesn't need to implement Overlay trait, it can be be used
mutably in user interface so we don't need interior mutability.
---
 runtime/src/user_interface.rs         | 37 +++++++--------
 runtime/src/user_interface/overlay.rs | 85 ++++++++++-------------------------
 2 files changed, 42 insertions(+), 80 deletions(-)

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface.rs b/runtime/src/user_interface.rs
index 8ae0363a..1d55970e 100644
--- a/runtime/src/user_interface.rs
+++ b/runtime/src/user_interface.rs
@@ -8,7 +8,7 @@ use crate::core::renderer;
 use crate::core::widget;
 use crate::core::window;
 use crate::core::{Clipboard, Point, Rectangle, Size};
-use crate::core::{Element, Layout, Overlay, Shell};
+use crate::core::{Element, Layout, Shell};
 
 /// A set of interactive graphical elements with a specific [`Layout`].
 ///
@@ -261,22 +261,23 @@ where
                 }
             }
 
-            let base_cursor = manual_overlay
-                .as_ref()
-                .filter(|overlay| {
-                    cursor
-                        .position()
-                        .map(|cursor_position| {
-                            overlay.is_over(
-                                Layout::new(&layout),
-                                renderer,
-                                cursor_position,
-                            )
-                        })
-                        .unwrap_or_default()
+            let base_cursor = if manual_overlay
+                .as_mut()
+                .and_then(|overlay| {
+                    cursor.position().map(|cursor_position| {
+                        overlay.is_over(
+                            Layout::new(&layout),
+                            renderer,
+                            cursor_position,
+                        )
+                    })
                 })
-                .map(|_| mouse::Cursor::Unavailable)
-                .unwrap_or(cursor);
+                .unwrap_or_default()
+            {
+                mouse::Cursor::Unavailable
+            } else {
+                cursor
+            };
 
             self.overlay = Some(layout);
 
@@ -434,7 +435,7 @@ where
 
         let viewport = Rectangle::with_size(self.bounds);
 
-        let base_cursor = if let Some(overlay) = self
+        let base_cursor = if let Some(mut overlay) = self
             .root
             .as_widget_mut()
             .overlay(&mut self.state, Layout::new(&self.base), renderer)
@@ -503,7 +504,7 @@ where
                 root.as_widget_mut()
                     .overlay(&mut self.state, Layout::new(base), renderer)
                     .map(overlay::Nested::new)
-                    .map(|overlay| {
+                    .map(|mut overlay| {
                         let overlay_interaction = overlay.mouse_interaction(
                             Layout::new(layout),
                             cursor,
diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index c495bb28..24ddb649 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -4,47 +4,25 @@ use crate::core::mouse;
 use crate::core::overlay;
 use crate::core::renderer;
 use crate::core::widget;
-use crate::core::{
-    Clipboard, Event, Layout, Overlay, Point, Rectangle, Shell, Size,
-};
-
-use std::cell::RefCell;
+use crate::core::{Clipboard, Event, Layout, Point, Rectangle, Shell, Size};
 
 /// An [`Overlay`] container that displays nested overlays
 #[allow(missing_debug_implementations)]
 pub struct Nested<'a, Message, Renderer> {
-    overlay: Inner<'a, Message, Renderer>,
+    overlay: overlay::Element<'a, Message, Renderer>,
 }
 
-impl<'a, Message, Renderer> Nested<'a, Message, Renderer> {
+impl<'a, Message, Renderer> Nested<'a, Message, Renderer>
+where
+    Renderer: renderer::Renderer,
+{
     /// Creates a nested overlay from the provided [`overlay::Element`]
     pub fn new(element: overlay::Element<'a, Message, Renderer>) -> Self {
-        Self {
-            overlay: Inner(RefCell::new(element)),
-        }
+        Self { overlay: element }
     }
-}
-
-struct Inner<'a, Message, Renderer>(
-    RefCell<overlay::Element<'a, Message, Renderer>>,
-);
-
-impl<'a, Message, Renderer> Inner<'a, Message, Renderer> {
-    fn with_element_mut<T>(
-        &self,
-        mut f: impl FnMut(&mut overlay::Element<'_, Message, Renderer>) -> T,
-    ) -> T {
-        (f)(&mut self.0.borrow_mut())
-    }
-}
 
-impl<'a, Message, Renderer> Overlay<Message, Renderer>
-    for Nested<'a, Message, Renderer>
-where
-    Renderer: renderer::Renderer,
-{
-    fn layout(
-        &self,
+    pub fn layout(
+        &mut self,
         renderer: &Renderer,
         bounds: Size,
         position: Point,
@@ -77,13 +55,11 @@ where
             }
         }
 
-        self.overlay.with_element_mut(|element| {
-            recurse(element, renderer, bounds, position)
-        })
+        recurse(&mut self.overlay, renderer, bounds, position)
     }
 
-    fn draw(
-        &self,
+    pub fn draw(
+        &mut self,
         renderer: &mut Renderer,
         theme: &<Renderer as renderer::Renderer>::Theme,
         style: &renderer::Style,
@@ -148,12 +124,10 @@ where
             }
         }
 
-        self.overlay.with_element_mut(|element| {
-            recurse(element, layout, renderer, theme, style, cursor);
-        })
+        recurse(&mut self.overlay, layout, renderer, theme, style, cursor);
     }
 
-    fn operate(
+    pub fn operate(
         &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
@@ -180,10 +154,10 @@ where
             }
         }
 
-        recurse(self.overlay.0.get_mut(), layout, renderer, operation)
+        recurse(&mut self.overlay, layout, renderer, operation)
     }
 
-    fn on_event(
+    pub fn on_event(
         &mut self,
         event: Event,
         layout: Layout<'_>,
@@ -236,7 +210,7 @@ where
         }
 
         recurse(
-            self.overlay.0.get_mut(),
+            &mut self.overlay,
             layout,
             event,
             cursor,
@@ -246,8 +220,8 @@ where
         )
     }
 
-    fn mouse_interaction(
-        &self,
+    pub fn mouse_interaction(
+        &mut self,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         viewport: &Rectangle,
@@ -293,15 +267,12 @@ where
             )
         }
 
-        self.overlay
-            .with_element_mut(|element| {
-                recurse(element, layout, cursor, viewport, renderer)
-            })
+        recurse(&mut self.overlay, layout, cursor, viewport, renderer)
             .unwrap_or_default()
     }
 
-    fn is_over(
-        &self,
+    pub fn is_over(
+        &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
         cursor_position: Point,
@@ -339,16 +310,6 @@ where
             }
         }
 
-        self.overlay.with_element_mut(|element| {
-            recurse(element, layout, renderer, cursor_position)
-        })
-    }
-
-    fn overlay<'b>(
-        &'b mut self,
-        _layout: Layout<'_>,
-        _renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Renderer>> {
-        None
+        recurse(&mut self.overlay, layout, renderer, cursor_position)
     }
 }
-- 
cgit 


From 4de6ee6fa18be5b8fa511bffe93bbec2c5811bfc Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sat, 18 Feb 2023 19:11:50 -0800
Subject: Cursor availability during on_event

---
 runtime/src/user_interface/overlay.rs | 73 ++++++++++++++++++++++++-----------
 1 file changed, 50 insertions(+), 23 deletions(-)

(limited to 'runtime/src')

diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
index 24ddb649..1211d55b 100644
--- a/runtime/src/user_interface/overlay.rs
+++ b/runtime/src/user_interface/overlay.rs
@@ -174,42 +174,67 @@ where
             renderer: &Renderer,
             clipboard: &mut dyn Clipboard,
             shell: &mut Shell<'_, Message>,
-        ) -> event::Status
+        ) -> (event::Status, bool)
         where
             Renderer: renderer::Renderer,
         {
             let mut layouts = layout.children();
 
             if let Some(layout) = layouts.next() {
-                let status = if let Some((mut nested, nested_layout)) =
-                    element.overlay(layout, renderer).zip(layouts.next())
-                {
-                    recurse(
-                        &mut nested,
-                        nested_layout,
-                        event.clone(),
-                        cursor,
-                        renderer,
-                        clipboard,
-                        shell,
-                    )
-                } else {
-                    event::Status::Ignored
-                };
+                let (nested_status, nested_is_over) =
+                    if let Some((mut nested, nested_layout)) =
+                        element.overlay(layout, renderer).zip(layouts.next())
+                    {
+                        recurse(
+                            &mut nested,
+                            nested_layout,
+                            event.clone(),
+                            cursor,
+                            renderer,
+                            clipboard,
+                            shell,
+                        )
+                    } else {
+                        (event::Status::Ignored, false)
+                    };
 
-                if matches!(status, event::Status::Ignored) {
-                    element.on_event(
-                        event, layout, cursor, renderer, clipboard, shell,
+                if matches!(nested_status, event::Status::Ignored) {
+                    let is_over = nested_is_over
+                        || cursor
+                            .position()
+                            .map(|cursor_position| {
+                                element.is_over(
+                                    layout,
+                                    renderer,
+                                    cursor_position,
+                                )
+                            })
+                            .unwrap_or_default();
+
+                    (
+                        element.on_event(
+                            event,
+                            layout,
+                            if nested_is_over {
+                                mouse::Cursor::Unavailable
+                            } else {
+                                cursor
+                            },
+                            renderer,
+                            clipboard,
+                            shell,
+                        ),
+                        is_over,
                     )
                 } else {
-                    status
+                    (nested_status, nested_is_over)
                 }
             } else {
-                event::Status::Ignored
+                (event::Status::Ignored, false)
             }
         }
 
-        recurse(
+        let (status, _) = recurse(
             &mut self.overlay,
             layout,
             event,
@@ -217,7 +242,9 @@ where
             renderer,
             clipboard,
             shell,
-        )
+        );
+
+        status
     }
 
     pub fn mouse_interaction(
-- 
cgit 


From b0205e03d8e4794850e55e8c4bf83a40dd41aa9d Mon Sep 17 00:00:00 2001
From: Cory Forsstrom <cforsstrom18@gmail.com>
Date: Sun, 19 Feb 2023 17:43:13 -0800
Subject: Use nested for lazy widgets

---
 runtime/src/lib.rs                    |   1 +
 runtime/src/overlay.rs                |   4 +
 runtime/src/overlay/nested.rs         | 353 ++++++++++++++++++++++++++++++++++
 runtime/src/user_interface.rs         |   6 +-
 runtime/src/user_interface/overlay.rs | 342 --------------------------------
 5 files changed, 360 insertions(+), 346 deletions(-)
 create mode 100644 runtime/src/overlay.rs
 create mode 100644 runtime/src/overlay/nested.rs
 delete mode 100644 runtime/src/user_interface/overlay.rs

(limited to 'runtime/src')

diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 50abf7b2..4bbf9687 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -47,6 +47,7 @@ pub mod clipboard;
 pub mod command;
 pub mod font;
 pub mod keyboard;
+pub mod overlay;
 pub mod program;
 pub mod system;
 pub mod user_interface;
diff --git a/runtime/src/overlay.rs b/runtime/src/overlay.rs
new file mode 100644
index 00000000..03390980
--- /dev/null
+++ b/runtime/src/overlay.rs
@@ -0,0 +1,4 @@
+//! Overlays for user interfaces.
+mod nested;
+
+pub use nested::Nested;
diff --git a/runtime/src/overlay/nested.rs b/runtime/src/overlay/nested.rs
new file mode 100644
index 00000000..5c5fafde
--- /dev/null
+++ b/runtime/src/overlay/nested.rs
@@ -0,0 +1,353 @@
+use crate::core::event;
+use crate::core::layout;
+use crate::core::mouse;
+use crate::core::overlay;
+use crate::core::renderer;
+use crate::core::widget;
+use crate::core::{Clipboard, Event, Layout, Point, Rectangle, Shell, Size};
+
+/// An [`Overlay`] container that displays nested overlays
+#[allow(missing_debug_implementations)]
+pub struct Nested<'a, Message, Renderer> {
+    overlay: overlay::Element<'a, Message, Renderer>,
+}
+
+impl<'a, Message, Renderer> Nested<'a, Message, Renderer>
+where
+    Renderer: renderer::Renderer,
+{
+    /// Creates a nested overlay from the provided [`overlay::Element`]
+    pub fn new(element: overlay::Element<'a, Message, Renderer>) -> Self {
+        Self { overlay: element }
+    }
+
+    /// Returns the position of the [`Nested`] overlay.
+    pub fn position(&self) -> Point {
+        self.overlay.position()
+    }
+
+    /// Returns the layout [`Node`] of the [`Nested`] overlay.
+    pub fn layout(
+        &mut self,
+        renderer: &Renderer,
+        bounds: Size,
+        position: Point,
+    ) -> layout::Node {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            renderer: &Renderer,
+            bounds: Size,
+            position: Point,
+        ) -> layout::Node
+        where
+            Renderer: renderer::Renderer,
+        {
+            let translation = position - element.position();
+
+            let node = element.layout(renderer, bounds, translation);
+
+            if let Some(mut nested) =
+                element.overlay(Layout::new(&node), renderer)
+            {
+                layout::Node::with_children(
+                    node.size(),
+                    vec![
+                        node,
+                        recurse(&mut nested, renderer, bounds, position),
+                    ],
+                )
+            } else {
+                layout::Node::with_children(node.size(), vec![node])
+            }
+        }
+
+        recurse(&mut self.overlay, renderer, bounds, position)
+    }
+
+    /// Draws the [`Nested`] overlay using the associated `Renderer`.
+    pub fn draw(
+        &mut self,
+        renderer: &mut Renderer,
+        theme: &<Renderer as renderer::Renderer>::Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+    ) {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            renderer: &mut Renderer,
+            theme: &<Renderer as renderer::Renderer>::Theme,
+            style: &renderer::Style,
+            cursor: mouse::Cursor,
+        ) 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()
+                    .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();
+
+                renderer.with_layer(layout.bounds(), |renderer| {
+                    element.draw(
+                        renderer,
+                        theme,
+                        style,
+                        layout,
+                        if is_over {
+                            mouse::Cursor::Unavailable
+                        } else {
+                            cursor
+                        },
+                    );
+                });
+
+                if let Some((mut nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(nested_layout)
+                {
+                    recurse(
+                        &mut nested,
+                        nested_layout,
+                        renderer,
+                        theme,
+                        style,
+                        cursor,
+                    );
+                }
+            }
+        }
+
+        recurse(&mut self.overlay, layout, renderer, theme, style, cursor);
+    }
+
+    /// Applies a [`widget::Operation`] to the [`Nested`] overlay.
+    pub fn operate(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        operation: &mut dyn widget::Operation<Message>,
+    ) {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            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 nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
+                {
+                    recurse(&mut nested, nested_layout, renderer, operation);
+                }
+            }
+        }
+
+        recurse(&mut self.overlay, layout, renderer, operation)
+    }
+
+    /// Processes a runtime [`Event`].
+    pub fn on_event(
+        &mut self,
+        event: Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &Renderer,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+    ) -> event::Status {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            event: Event,
+            cursor: mouse::Cursor,
+            renderer: &Renderer,
+            clipboard: &mut dyn Clipboard,
+            shell: &mut Shell<'_, Message>,
+        ) -> (event::Status, bool)
+        where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            if let Some(layout) = layouts.next() {
+                let (nested_status, nested_is_over) =
+                    if let Some((mut nested, nested_layout)) =
+                        element.overlay(layout, renderer).zip(layouts.next())
+                    {
+                        recurse(
+                            &mut nested,
+                            nested_layout,
+                            event.clone(),
+                            cursor,
+                            renderer,
+                            clipboard,
+                            shell,
+                        )
+                    } else {
+                        (event::Status::Ignored, false)
+                    };
+
+                if matches!(nested_status, event::Status::Ignored) {
+                    let is_over = nested_is_over
+                        || cursor
+                            .position()
+                            .map(|cursor_position| {
+                                element.is_over(
+                                    layout,
+                                    renderer,
+                                    cursor_position,
+                                )
+                            })
+                            .unwrap_or_default();
+
+                    (
+                        element.on_event(
+                            event,
+                            layout,
+                            if nested_is_over {
+                                mouse::Cursor::Unavailable
+                            } else {
+                                cursor
+                            },
+                            renderer,
+                            clipboard,
+                            shell,
+                        ),
+                        is_over,
+                    )
+                } else {
+                    (nested_status, nested_is_over)
+                }
+            } else {
+                (event::Status::Ignored, false)
+            }
+        }
+
+        let (status, _) = recurse(
+            &mut self.overlay,
+            layout,
+            event,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+        );
+
+        status
+    }
+
+    /// Returns the current [`mouse::Interaction`] of the [`Nested`] overlay.
+    pub fn mouse_interaction(
+        &mut self,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &Renderer,
+    ) -> mouse::Interaction {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            layout: Layout<'_>,
+            cursor: mouse::Cursor,
+            viewport: &Rectangle,
+            renderer: &Renderer,
+        ) -> Option<mouse::Interaction>
+        where
+            Renderer: renderer::Renderer,
+        {
+            let mut layouts = layout.children();
+
+            let layout = layouts.next()?;
+            let cursor_position = cursor.position()?;
+
+            if !element.is_over(layout, renderer, cursor_position) {
+                return None;
+            }
+
+            Some(
+                element
+                    .overlay(layout, renderer)
+                    .zip(layouts.next())
+                    .and_then(|(mut overlay, layout)| {
+                        recurse(
+                            &mut overlay,
+                            layout,
+                            cursor,
+                            viewport,
+                            renderer,
+                        )
+                    })
+                    .unwrap_or_else(|| {
+                        element.mouse_interaction(
+                            layout, cursor, viewport, renderer,
+                        )
+                    }),
+            )
+        }
+
+        recurse(&mut self.overlay, layout, cursor, viewport, renderer)
+            .unwrap_or_default()
+    }
+
+    /// Returns true if the cursor is over the [`Nested`] overlay.
+    pub fn is_over(
+        &mut self,
+        layout: Layout<'_>,
+        renderer: &Renderer,
+        cursor_position: Point,
+    ) -> bool {
+        fn recurse<Message, Renderer>(
+            element: &mut overlay::Element<'_, Message, Renderer>,
+            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 nested, nested_layout)) =
+                    element.overlay(layout, renderer).zip(layouts.next())
+                {
+                    recurse(
+                        &mut nested,
+                        nested_layout,
+                        renderer,
+                        cursor_position,
+                    )
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        }
+
+        recurse(&mut self.overlay, layout, renderer, cursor_position)
+    }
+}
diff --git a/runtime/src/user_interface.rs b/runtime/src/user_interface.rs
index 1d55970e..619423fd 100644
--- a/runtime/src/user_interface.rs
+++ b/runtime/src/user_interface.rs
@@ -1,14 +1,12 @@
 //! Implement your own event loop to drive a user interface.
-mod overlay;
-
 use crate::core::event::{self, Event};
 use crate::core::layout;
 use crate::core::mouse;
 use crate::core::renderer;
 use crate::core::widget;
 use crate::core::window;
-use crate::core::{Clipboard, Point, Rectangle, Size};
-use crate::core::{Element, Layout, Shell};
+use crate::core::{Clipboard, Element, Layout, Point, Rectangle, Shell, Size};
+use crate::overlay;
 
 /// A set of interactive graphical elements with a specific [`Layout`].
 ///
diff --git a/runtime/src/user_interface/overlay.rs b/runtime/src/user_interface/overlay.rs
deleted file mode 100644
index 1211d55b..00000000
--- a/runtime/src/user_interface/overlay.rs
+++ /dev/null
@@ -1,342 +0,0 @@
-use crate::core::event;
-use crate::core::layout;
-use crate::core::mouse;
-use crate::core::overlay;
-use crate::core::renderer;
-use crate::core::widget;
-use crate::core::{Clipboard, Event, Layout, Point, Rectangle, Shell, Size};
-
-/// An [`Overlay`] container that displays nested overlays
-#[allow(missing_debug_implementations)]
-pub struct Nested<'a, Message, Renderer> {
-    overlay: overlay::Element<'a, Message, Renderer>,
-}
-
-impl<'a, Message, Renderer> Nested<'a, Message, Renderer>
-where
-    Renderer: renderer::Renderer,
-{
-    /// Creates a nested overlay from the provided [`overlay::Element`]
-    pub fn new(element: overlay::Element<'a, Message, Renderer>) -> Self {
-        Self { overlay: element }
-    }
-
-    pub fn layout(
-        &mut self,
-        renderer: &Renderer,
-        bounds: Size,
-        position: Point,
-    ) -> layout::Node {
-        fn recurse<Message, Renderer>(
-            element: &mut overlay::Element<'_, Message, Renderer>,
-            renderer: &Renderer,
-            bounds: Size,
-            position: Point,
-        ) -> layout::Node
-        where
-            Renderer: renderer::Renderer,
-        {
-            let translation = position - Point::ORIGIN;
-
-            let node = element.layout(renderer, bounds, translation);
-
-            if let Some(mut nested) =
-                element.overlay(Layout::new(&node), renderer)
-            {
-                layout::Node::with_children(
-                    node.size(),
-                    vec![
-                        node,
-                        recurse(&mut nested, renderer, bounds, position),
-                    ],
-                )
-            } else {
-                layout::Node::with_children(node.size(), vec![node])
-            }
-        }
-
-        recurse(&mut self.overlay, renderer, bounds, position)
-    }
-
-    pub fn draw(
-        &mut self,
-        renderer: &mut Renderer,
-        theme: &<Renderer as renderer::Renderer>::Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-    ) {
-        fn recurse<Message, Renderer>(
-            element: &mut overlay::Element<'_, Message, Renderer>,
-            layout: Layout<'_>,
-            renderer: &mut Renderer,
-            theme: &<Renderer as renderer::Renderer>::Theme,
-            style: &renderer::Style,
-            cursor: mouse::Cursor,
-        ) 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()
-                    .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();
-
-                renderer.with_layer(layout.bounds(), |renderer| {
-                    element.draw(
-                        renderer,
-                        theme,
-                        style,
-                        layout,
-                        if is_over {
-                            mouse::Cursor::Unavailable
-                        } else {
-                            cursor
-                        },
-                    );
-                });
-
-                if let Some((mut nested, nested_layout)) =
-                    element.overlay(layout, renderer).zip(nested_layout)
-                {
-                    recurse(
-                        &mut nested,
-                        nested_layout,
-                        renderer,
-                        theme,
-                        style,
-                        cursor,
-                    );
-                }
-            }
-        }
-
-        recurse(&mut self.overlay, layout, renderer, theme, style, cursor);
-    }
-
-    pub fn operate(
-        &mut self,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn widget::Operation<Message>,
-    ) {
-        fn recurse<Message, Renderer>(
-            element: &mut overlay::Element<'_, Message, Renderer>,
-            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 nested, nested_layout)) =
-                    element.overlay(layout, renderer).zip(layouts.next())
-                {
-                    recurse(&mut nested, nested_layout, renderer, operation);
-                }
-            }
-        }
-
-        recurse(&mut self.overlay, layout, renderer, operation)
-    }
-
-    pub fn on_event(
-        &mut self,
-        event: Event,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-    ) -> event::Status {
-        fn recurse<Message, Renderer>(
-            element: &mut overlay::Element<'_, Message, Renderer>,
-            layout: Layout<'_>,
-            event: Event,
-            cursor: mouse::Cursor,
-            renderer: &Renderer,
-            clipboard: &mut dyn Clipboard,
-            shell: &mut Shell<'_, Message>,
-        ) -> (event::Status, bool)
-        where
-            Renderer: renderer::Renderer,
-        {
-            let mut layouts = layout.children();
-
-            if let Some(layout) = layouts.next() {
-                let (nested_status, nested_is_over) =
-                    if let Some((mut nested, nested_layout)) =
-                        element.overlay(layout, renderer).zip(layouts.next())
-                    {
-                        recurse(
-                            &mut nested,
-                            nested_layout,
-                            event.clone(),
-                            cursor,
-                            renderer,
-                            clipboard,
-                            shell,
-                        )
-                    } else {
-                        (event::Status::Ignored, false)
-                    };
-
-                if matches!(nested_status, event::Status::Ignored) {
-                    let is_over = nested_is_over
-                        || cursor
-                            .position()
-                            .map(|cursor_position| {
-                                element.is_over(
-                                    layout,
-                                    renderer,
-                                    cursor_position,
-                                )
-                            })
-                            .unwrap_or_default();
-
-                    (
-                        element.on_event(
-                            event,
-                            layout,
-                            if nested_is_over {
-                                mouse::Cursor::Unavailable
-                            } else {
-                                cursor
-                            },
-                            renderer,
-                            clipboard,
-                            shell,
-                        ),
-                        is_over,
-                    )
-                } else {
-                    (nested_status, nested_is_over)
-                }
-            } else {
-                (event::Status::Ignored, false)
-            }
-        }
-
-        let (status, _) = recurse(
-            &mut self.overlay,
-            layout,
-            event,
-            cursor,
-            renderer,
-            clipboard,
-            shell,
-        );
-
-        status
-    }
-
-    pub fn mouse_interaction(
-        &mut self,
-        layout: Layout<'_>,
-        cursor: mouse::Cursor,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        fn recurse<Message, Renderer>(
-            element: &mut overlay::Element<'_, Message, Renderer>,
-            layout: Layout<'_>,
-            cursor: mouse::Cursor,
-            viewport: &Rectangle,
-            renderer: &Renderer,
-        ) -> Option<mouse::Interaction>
-        where
-            Renderer: renderer::Renderer,
-        {
-            let mut layouts = layout.children();
-
-            let layout = layouts.next()?;
-            let cursor_position = cursor.position()?;
-
-            if !element.is_over(layout, renderer, cursor_position) {
-                return None;
-            }
-
-            Some(
-                element
-                    .overlay(layout, renderer)
-                    .zip(layouts.next())
-                    .and_then(|(mut overlay, layout)| {
-                        recurse(
-                            &mut overlay,
-                            layout,
-                            cursor,
-                            viewport,
-                            renderer,
-                        )
-                    })
-                    .unwrap_or_else(|| {
-                        element.mouse_interaction(
-                            layout, cursor, viewport, renderer,
-                        )
-                    }),
-            )
-        }
-
-        recurse(&mut self.overlay, layout, cursor, viewport, renderer)
-            .unwrap_or_default()
-    }
-
-    pub fn is_over(
-        &mut self,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        cursor_position: Point,
-    ) -> bool {
-        fn recurse<Message, Renderer>(
-            element: &mut overlay::Element<'_, Message, Renderer>,
-            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 nested, nested_layout)) =
-                    element.overlay(layout, renderer).zip(layouts.next())
-                {
-                    recurse(
-                        &mut nested,
-                        nested_layout,
-                        renderer,
-                        cursor_position,
-                    )
-                } else {
-                    false
-                }
-            } else {
-                false
-            }
-        }
-
-        recurse(&mut self.overlay, layout, renderer, cursor_position)
-    }
-}
-- 
cgit 


From 9803b276ad087846dfc3bb349113c5799ce00141 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Wed, 14 Jun 2023 11:27:42 +0200
Subject: Fix cursor availability in `overlay::Nested::draw`

---
 runtime/src/overlay/nested.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'runtime/src')

diff --git a/runtime/src/overlay/nested.rs b/runtime/src/overlay/nested.rs
index 5c5fafde..cd258ab6 100644
--- a/runtime/src/overlay/nested.rs
+++ b/runtime/src/overlay/nested.rs
@@ -94,7 +94,7 @@ where
                     .and_then(|(cursor_position, nested_layout)| {
                         element.overlay(layout, renderer).map(|nested| {
                             nested.is_over(
-                                nested_layout,
+                                nested_layout.children().next().unwrap(),
                                 renderer,
                                 cursor_position,
                             )
-- 
cgit