Remove `position` from `overlay::Element`

2 files changed, 37 insertions, 46 deletions

diff --git a/runtime/src/overlay/nested.rs b/runtime/src/overlay/nested.rs
index 60e2eb87..ddb9532b 100644
--- a/runtime/src/overlay/nested.rs
+++ b/runtime/src/overlay/nested.rs
@@ -4,9 +4,7 @@ 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, Vector,
-};
+use crate::core::{Clipboard, Event, Layout, Point, Rectangle, Shell, Size};
 
 /// An overlay container that displays nested overlays
 #[allow(missing_debug_implementations)]
@@ -25,11 +23,6 @@ where
         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.
     ///
     /// [`Node`]: layout::Node
@@ -37,36 +30,30 @@ where
         &mut self,
         renderer: &Renderer,
         bounds: Size,
-        _position: Point,
-        translation: Vector,
     ) -> layout::Node {
         fn recurse<Message, Theme, Renderer>(
             element: &mut overlay::Element<'_, Message, Theme, Renderer>,
             renderer: &Renderer,
             bounds: Size,
-            translation: Vector,
         ) -> layout::Node
         where
             Renderer: renderer::Renderer,
         {
-            let node = element.layout(renderer, bounds, translation);
+            let node = element.layout(renderer, bounds);
 
             if let Some(mut nested) =
                 element.overlay(Layout::new(&node), renderer)
             {
                 layout::Node::with_children(
                     node.size(),
-                    vec![
-                        node,
-                        recurse(&mut nested, renderer, bounds, translation),
-                    ],
+                    vec![node, recurse(&mut nested, renderer, bounds)],
                 )
             } else {
                 layout::Node::with_children(node.size(), vec![node])
             }
         }
 
-        recurse(&mut self.overlay, renderer, bounds, translation)
+        recurse(&mut self.overlay, renderer, bounds)
     }
 
     /// Draws the [`Nested`] overlay using the associated `Renderer`.
diff --git a/runtime/src/user_interface.rs b/runtime/src/user_interface.rs
index 054d56b7..08431ced 100644
--- a/runtime/src/user_interface.rs
+++ b/runtime/src/user_interface.rs
@@ -5,9 +5,7 @@ use crate::core::mouse;
 use crate::core::renderer;
 use crate::core::widget;
 use crate::core::window;
-use crate::core::{
-    Clipboard, Element, Layout, Point, Rectangle, Shell, Size, Vector,
-};
+use crate::core::{Clipboard, Element, Layout, Rectangle, Shell, Size, Vector};
 use crate::overlay;
 
 /// A set of interactive graphical elements with a specific [`Layout`].
@@ -193,7 +191,12 @@ where
         let mut manual_overlay = ManuallyDrop::new(
             self.root
                 .as_widget_mut()
-                .overlay(&mut self.state, Layout::new(&self.base), renderer)
+                .overlay(
+                    &mut self.state,
+                    Layout::new(&self.base),
+                    renderer,
+                    Vector::ZERO,
+                )
                 .map(overlay::Nested::new),
         );
 
@@ -201,8 +204,7 @@ where
             let bounds = self.bounds;
 
             let mut overlay = manual_overlay.as_mut().unwrap();
-            let mut layout =
-                overlay.layout(renderer, bounds, Point::ORIGIN, Vector::ZERO);
+            let mut layout = overlay.layout(renderer, bounds);
             let mut event_statuses = Vec::new();
 
             for event in events.iter().cloned() {
@@ -245,6 +247,7 @@ where
                                 &mut self.state,
                                 Layout::new(&self.base),
                                 renderer,
+                                Vector::ZERO,
                             )
                             .map(overlay::Nested::new),
                     );
@@ -256,12 +259,7 @@ where
                     overlay = manual_overlay.as_mut().unwrap();
 
                     shell.revalidate_layout(|| {
-                        layout = overlay.layout(
-                            renderer,
-                            bounds,
-                            Point::ORIGIN,
-                            Vector::ZERO,
-                        );
+                        layout = overlay.layout(renderer, bounds);
                     });
                 }
 
@@ -451,17 +449,18 @@ where
         let base_cursor = if let Some(mut overlay) = self
             .root
             .as_widget_mut()
-            .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .overlay(
+                &mut self.state,
+                Layout::new(&self.base),
+                renderer,
+                Vector::ZERO,
+            )
             .map(overlay::Nested::new)
         {
-            let overlay_layout = self.overlay.take().unwrap_or_else(|| {
-                overlay.layout(
-                    renderer,
-                    self.bounds,
-                    Point::ORIGIN,
-                    Vector::ZERO,
-                )
-            });
+            let overlay_layout = self
+                .overlay
+                .take()
+                .unwrap_or_else(|| overlay.layout(renderer, self.bounds));
 
             let cursor = if cursor
                 .position()
@@ -520,7 +519,12 @@ where
             .as_ref()
             .and_then(|layout| {
                 root.as_widget_mut()
-                    .overlay(&mut self.state, Layout::new(base), renderer)
+                    .overlay(
+                        &mut self.state,
+                        Layout::new(base),
+                        renderer,
+                        Vector::ZERO,
+                    )
                     .map(overlay::Nested::new)
                     .map(|mut overlay| {
                         let overlay_interaction = overlay.mouse_interaction(
@@ -574,16 +578,16 @@ where
         if let Some(mut overlay) = self
             .root
             .as_widget_mut()
-            .overlay(&mut self.state, Layout::new(&self.base), renderer)
+            .overlay(
+                &mut self.state,
+                Layout::new(&self.base),
+                renderer,
+                Vector::ZERO,
+            )
             .map(overlay::Nested::new)
         {
             if self.overlay.is_none() {
-                self.overlay = Some(overlay.layout(
-                    renderer,
-                    self.bounds,
-                    Point::ORIGIN,
-                    Vector::ZERO,
-                ));
+                self.overlay = Some(overlay.layout(renderer, self.bounds));
             }
 
             overlay.operate(