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

@@ -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
+            let base_cursor = if manual_overlay
-                .as_ref()
+                .as_mut()
-                .filter(|overlay| {
+                .and_then(|overlay| {
-                    cursor
+                    cursor.position().map(|cursor_position| {
-                        .position()
+                        overlay.is_over(
-                        .map(|cursor_position| {
+                            Layout::new(&layout),
-                            overlay.is_over(
+                            renderer,
-                                Layout::new(&layout),
+                            cursor_position,
-                                renderer,
+                        )
-                                cursor_position,
+                    })
-                            )
-                        })
-                        .unwrap_or_default()
                 })
-                .map(|_| mouse::Cursor::Unavailable)
+                .unwrap_or_default()
-                .unwrap_or(cursor);
+            {
+                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,

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::{
+use crate::core::{Clipboard, Event, Layout, Point, Rectangle, Shell, Size};
-    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>,
+    overlay: overlay::Element<'a, Message, Renderer>,
 }
 
-impl<'a, Message, Renderer> Nested<'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(
+    /// Creates a nested overlay from the provided [`overlay::Element`]
-        &self,
+    pub fn new(element: overlay::Element<'a, Message, Renderer>) -> Self {
+        Self { overlay: element }
+    }
+
+    pub fn layout(
+        &mut self,
         renderer: &Renderer,
         bounds: Size,
         position: Point,
@@ -77,13 +55,11 @@ where
             }
         }
 
-        self.overlay.with_element_mut(|element| {
+        recurse(&mut self.overlay, renderer, bounds, position)
-            recurse(element, renderer, bounds, position)
-        })
     }
 
-    fn draw(
+    pub fn draw(
-        &self,
+        &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(&mut self.overlay, layout, renderer, theme, style, cursor);
-            recurse(element, 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(
+    pub fn mouse_interaction(
-        &self,
+        &mut self,
         layout: Layout<'_>,
         cursor: mouse::Cursor,
         viewport: &Rectangle,
@@ -293,15 +267,12 @@ where
             )
         }
 
-        self.overlay
+        recurse(&mut self.overlay, layout, cursor, viewport, renderer)
-            .with_element_mut(|element| {
-                recurse(element, layout, cursor, viewport, renderer)
-            })
             .unwrap_or_default()
     }
 
-    fn is_over(
+    pub fn is_over(
-        &self,
+        &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
         cursor_position: Point,
@@ -339,16 +310,6 @@ where
             }
         }
 
-        self.overlay.with_element_mut(|element| {
+        recurse(&mut self.overlay, layout, renderer, cursor_position)
-            recurse(element, layout, renderer, cursor_position)
-        })
-    }
-
-    fn overlay<'b>(
-        &'b mut self,
-        _layout: Layout<'_>,
-        _renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Renderer>> {
-        None
     }
 }