Merge pull request #2226 from iced-rs/overlay-composition-reloaded

Remove `position` from `overlay::Element`

core/src/element.rs

@@ -446,11 +446,12 @@ where
         tree: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
+        translation: Vector,
     ) -> Option<overlay::Element<'b, B, Theme, Renderer>> {
         let mapper = &self.mapper;
 
         self.widget
-            .overlay(tree, layout, renderer)
+            .overlay(tree, layout, renderer, translation)
             .map(move |overlay| overlay.map(mapper))
     }
 }
@@ -596,7 +597,10 @@ where
         state: &'b mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
+        translation: Vector,
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.element.widget.overlay(state, layout, renderer)
+        self.element
+            .widget
+            .overlay(state, layout, renderer, translation)
     }
 }

core/src/overlay.rs

@@ -24,13 +24,7 @@ where
     /// user interface.
     ///
     /// [`Node`]: layout::Node
-    fn layout(
-        &mut self,
-        renderer: &Renderer,
-        bounds: Size,
-        position: Point,
-        translation: Vector,
-    ) -> layout::Node;
+    fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node;
 
     /// Draws the [`Overlay`] using the associated `Renderer`.
     fn draw(
@@ -120,6 +114,7 @@ pub fn from_children<'a, Message, Theme, Renderer>(
     tree: &'a mut Tree,
     layout: Layout<'_>,
     renderer: &Renderer,
+    translation: Vector,
 ) -> Option<Element<'a, Message, Theme, Renderer>>
 where
     Renderer: crate::Renderer,
@@ -129,7 +124,9 @@ where
         .zip(&mut tree.children)
         .zip(layout.children())
         .filter_map(|((child, state), layout)| {
-            child.as_widget_mut().overlay(state, layout, renderer)
+            child
+                .as_widget_mut()
+                .overlay(state, layout, renderer, translation)
         })
         .collect::<Vec<_>>();
 

core/src/overlay/element.rs

@@ -12,8 +12,6 @@ use std::any::Any;
 /// A generic [`Overlay`].
 #[allow(missing_debug_implementations)]
 pub struct Element<'a, Message, Theme, Renderer> {
-    position: Point,
-    translation: Vector,
     overlay: Box<dyn Overlay<Message, Theme, Renderer> + 'a>,
 }
 
@@ -23,26 +21,9 @@ where
 {
     /// Creates a new [`Element`] containing the given [`Overlay`].
     pub fn new(
-        position: Point,
         overlay: Box<dyn Overlay<Message, Theme, Renderer> + 'a>,
     ) -> Self {
-        Self {
-            position,
-            overlay,
-            translation: Vector::ZERO,
-        }
-    }
-
-    /// Returns the position of the [`Element`].
-    pub fn position(&self) -> Point {
-        self.position
-    }
-
-    /// Translates the [`Element`].
-    pub fn translate(mut self, translation: Vector) -> Self {
-        self.position = self.position + translation;
-        self.translation = self.translation + translation;
-        self
+        Self { overlay }
     }
 
     /// Applies a transformation to the produced message of the [`Element`].
@@ -57,8 +38,6 @@ where
         B: 'a,
     {
         Element {
-            position: self.position,
-            translation: self.translation,
             overlay: Box::new(Map::new(self.overlay, f)),
         }
     }
@@ -68,14 +47,8 @@ where
         &mut self,
         renderer: &Renderer,
         bounds: Size,
-        translation: Vector,
     ) -> layout::Node {
-        self.overlay.layout(
-            renderer,
-            bounds,
-            self.position + translation,
-            self.translation + translation,
-        )
+        self.overlay.layout(renderer, bounds)
     }
 
     /// Processes a runtime [`Event`].
@@ -165,14 +138,8 @@ impl<'a, A, B, Theme, Renderer> Overlay<B, Theme, Renderer>
 where
     Renderer: crate::Renderer,
 {
-    fn layout(
-        &mut self,
-        renderer: &Renderer,
-        bounds: Size,
-        position: Point,
-        translation: Vector,
-    ) -> layout::Node {
-        self.content.layout(renderer, bounds, position, translation)
+    fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
+        self.content.layout(renderer, bounds)
     }
 
     fn operate(

core/src/overlay/group.rs

@@ -4,9 +4,7 @@ use crate::mouse;
 use crate::overlay;
 use crate::renderer;
 use crate::widget;
-use crate::{
-    Clipboard, Event, Layout, Overlay, Point, Rectangle, Shell, Size, Vector,
-};
+use crate::{Clipboard, Event, Layout, Overlay, Point, Rectangle, Shell, Size};
 
 /// An [`Overlay`] container that displays multiple overlay [`overlay::Element`]
 /// children.
@@ -44,7 +42,7 @@ where
 
     /// Turns the [`Group`] into an overlay [`overlay::Element`].
     pub fn overlay(self) -> overlay::Element<'a, Message, Theme, Renderer> {
-        overlay::Element::new(Point::ORIGIN, Box::new(self))
+        overlay::Element::new(Box::new(self))
     }
 }
 
@@ -65,18 +63,12 @@ impl<'a, Message, Theme, Renderer> Overlay<Message, Theme, Renderer>
 where
     Renderer: crate::Renderer,
 {
-    fn layout(
-        &mut self,
-        renderer: &Renderer,
-        bounds: Size,
-        _position: Point,
-        translation: Vector,
-    ) -> layout::Node {
+    fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
         layout::Node::with_children(
             bounds,
             self.children
                 .iter_mut()
-                .map(|child| child.layout(renderer, bounds, translation))
+                .map(|child| child.layout(renderer, bounds))
                 .collect(),
         )
     }

core/src/widget.rs

@@ -15,7 +15,7 @@ use crate::layout::{self, Layout};
 use crate::mouse;
 use crate::overlay;
 use crate::renderer;
-use crate::{Clipboard, Length, Rectangle, Shell, Size};
+use crate::{Clipboard, Length, Rectangle, Shell, Size, Vector};
 
 /// A component that displays information and allows interaction.
 ///
@@ -146,6 +146,7 @@ where
         _state: &'a mut Tree,
         _layout: Layout<'_>,
         _renderer: &Renderer,
+        _translation: Vector,
     ) -> Option<overlay::Element<'a, Message, Theme, Renderer>> {
         None
     }

examples/modal/src/main.rs

@@ -346,16 +346,15 @@ mod modal {
             state: &'b mut widget::Tree,
             layout: Layout<'_>,
             _renderer: &Renderer,
+            translation: Vector,
         ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-            Some(overlay::Element::new(
-                layout.position(),
-                Box::new(Overlay {
-                    content: &mut self.modal,
-                    tree: &mut state.children[1],
-                    size: layout.bounds().size(),
-                    on_blur: self.on_blur.clone(),
-                }),
-            ))
+            Some(overlay::Element::new(Box::new(Overlay {
+                position: layout.position() + translation,
+                content: &mut self.modal,
+                tree: &mut state.children[1],
+                size: layout.bounds().size(),
+                on_blur: self.on_blur.clone(),
+            })))
         }
 
         fn mouse_interaction(
@@ -392,6 +391,7 @@ mod modal {
     }
 
     struct Overlay<'a, 'b, Message, Theme, Renderer> {
+        position: Point,
         content: &'b mut Element<'a, Message, Theme, Renderer>,
         tree: &'b mut widget::Tree,
         size: Size,
@@ -409,8 +409,6 @@ mod modal {
             &mut self,
             renderer: &Renderer,
             _bounds: Size,
-            position: Point,
-            _translation: Vector,
         ) -> layout::Node {
             let limits = layout::Limits::new(Size::ZERO, self.size)
                 .width(Length::Fill)
@@ -423,7 +421,7 @@ mod modal {
                 .align(Alignment::Center, Alignment::Center, limits.max());
 
             layout::Node::with_children(self.size, vec![child])
-                .move_to(position)
+                .move_to(self.position)
         }
 
         fn on_event(
@@ -530,6 +528,7 @@ mod modal {
                 self.tree,
                 layout.children().next().unwrap(),
                 renderer,
+                Vector::ZERO,
             )
         }
     }

examples/toast/src/main.rs

@@ -456,6 +456,7 @@ mod toast {
             state: &'b mut Tree,
             layout: Layout<'_>,
             renderer: &Renderer,
+            translation: Vector,
         ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
             let instants = state.state.downcast_mut::<Vec<Option<Instant>>>();
 
@@ -465,19 +466,18 @@ mod toast {
                 &mut content_state[0],
                 layout,
                 renderer,
+                translation,
             );
 
             let toasts = (!self.toasts.is_empty()).then(|| {
-                overlay::Element::new(
-                    layout.bounds().position(),
-                    Box::new(Overlay {
-                        toasts: &mut self.toasts,
-                        state: toasts_state,
-                        instants,
-                        on_close: &self.on_close,
-                        timeout_secs: self.timeout_secs,
-                    }),
-                )
+                overlay::Element::new(Box::new(Overlay {
+                    position: layout.bounds().position() + translation,
+                    toasts: &mut self.toasts,
+                    state: toasts_state,
+                    instants,
+                    on_close: &self.on_close,
+                    timeout_secs: self.timeout_secs,
+                }))
             });
             let overlays =
                 content.into_iter().chain(toasts).collect::<Vec<_>>();
@@ -488,6 +488,7 @@ mod toast {
     }
 
     struct Overlay<'a, 'b, Message> {
+        position: Point,
         toasts: &'b mut [Element<'a, Message>],
         state: &'b mut [Tree],
         instants: &'b mut [Option<Instant>],
@@ -502,8 +503,6 @@ mod toast {
             &mut self,
             renderer: &Renderer,
             bounds: Size,
-            position: Point,
-            _translation: Vector,
         ) -> layout::Node {
             let limits = layout::Limits::new(Size::ZERO, bounds);
 
@@ -519,7 +518,7 @@ mod toast {
                 self.toasts,
                 self.state,
             )
-            .translate(Vector::new(position.x, position.y))
+            .translate(Vector::new(self.position.x, self.position.y))
         }
 
         fn on_event(

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,48 +23,37 @@ 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
     pub fn layout(
         &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`.