Introduce Renderer argument to mouse_interaction and on_event

graphics/src/widget/canvas.rs

@@ -193,6 +193,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer<B>,
     ) -> mouse::Interaction {
         let bounds = layout.bounds();
         let cursor = Cursor::from_window_position(cursor_position);

lazy/src/component.rs

@@ -214,15 +214,22 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         self.with_element(|element| {
-            element.mouse_interaction(layout, cursor_position, viewport)
+            element.mouse_interaction(
+                layout,
+                cursor_position,
+                viewport,
+                renderer,
+            )
         })
     }
 
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         let has_overlay = self
             .state
@@ -236,7 +243,9 @@ where
                     CacheBuilder {
                         element,
                         message: PhantomData,
-                        overlay_builder: |element| element.overlay(layout),
+                        overlay_builder: |element| {
+                            element.overlay(layout, renderer)
+                        },
                     }
                     .build(),
                 );
@@ -331,9 +340,15 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         self.with_overlay_maybe(|overlay| {
-            overlay.mouse_interaction(layout, cursor_position, viewport)
+            overlay.mouse_interaction(
+                layout,
+                cursor_position,
+                viewport,
+                renderer,
+            )
         })
         .unwrap_or_default()
     }
@@ -397,7 +412,7 @@ where
                                 element: state.view(),
                                 message: PhantomData,
                                 overlay_builder: |element| {
-                                    element.overlay(layout)
+                                    element.overlay(layout, renderer)
                                 },
                             }
                             .build(),

native/src/element.rs

@@ -259,9 +259,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.widget
+        self.widget.mouse_interaction(
-            .mouse_interaction(layout, cursor_position, viewport)
+            layout,
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     /// Computes the _layout_ hash of the [`Element`].
@@ -273,8 +278,9 @@ where
     pub fn overlay<'b>(
         &'b mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'b, Message, Renderer>> {
-        self.widget.overlay(layout)
+        self.widget.overlay(layout, renderer)
     }
 }
 
@@ -363,9 +369,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.widget
+        self.widget.mouse_interaction(
-            .mouse_interaction(layout, cursor_position, viewport)
+            layout,
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -375,11 +386,12 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, B, Renderer>> {
         let mapper = &self.mapper;
 
         self.widget
-            .overlay(layout)
+            .overlay(layout, renderer)
             .map(move |overlay| overlay.map(mapper))
     }
 }
@@ -482,10 +494,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.element
+        self.element.widget.mouse_interaction(
-            .widget
+            layout,
-            .mouse_interaction(layout, cursor_position, viewport)
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -495,7 +511,8 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
-        self.element.overlay(layout)
+        self.element.overlay(layout, renderer)
     }
 }

native/src/overlay.rs

@@ -84,6 +84,7 @@ where
         _layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         mouse::Interaction::Idle
     }

native/src/overlay/element.rs

@@ -80,9 +80,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.overlay
+        self.overlay.mouse_interaction(
-            .mouse_interaction(layout, cursor_position, viewport)
+            layout,
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     /// Draws the [`Element`] and its children using the given [`Layout`].
@@ -160,9 +165,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.content
+        self.content.mouse_interaction(
-            .mouse_interaction(layout, cursor_position, viewport)
+            layout,
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     fn draw(

native/src/overlay/menu.rs

@@ -239,9 +239,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.container
+        self.container.mouse_interaction(
-            .mouse_interaction(layout, cursor_position, viewport)
+            layout,
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     fn draw(
@@ -392,6 +397,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         let is_mouse_over = layout.bounds().contains(cursor_position);
 

native/src/user_interface.rs

@@ -205,7 +205,7 @@ where
         let mut state = State::Updated;
 
         let (base_cursor, overlay_statuses) = if let Some(mut overlay) =
-            self.root.overlay(Layout::new(&self.base.layout))
+            self.root.overlay(Layout::new(&self.base.layout), renderer)
         {
             let bounds = self.bounds;
 
@@ -391,7 +391,7 @@ where
         let viewport = Rectangle::with_size(self.bounds);
 
         if let Some(mut overlay) =
-            self.root.overlay(Layout::new(&self.base.layout))
+            self.root.overlay(Layout::new(&self.base.layout), renderer)
         {
             let layer = Self::overlay_layer(
                 self.overlay.take(),
@@ -432,6 +432,7 @@ where
             Layout::new(&self.base.layout),
             cursor_position,
             &viewport,
+            renderer,
         );
 
         let Self {
@@ -449,30 +450,33 @@ where
         overlay
             .as_ref()
             .and_then(|layer| {
-                root.overlay(Layout::new(&base.layout)).map(|overlay| {
+                root.overlay(Layout::new(&base.layout), renderer).map(
-                    let overlay_interaction = overlay.mouse_interaction(
+                    |overlay| {
-                        Layout::new(&layer.layout),
+                        let overlay_interaction = overlay.mouse_interaction(
-                        cursor_position,
-                        &viewport,
-                    );
-
-                    let overlay_bounds = layer.layout.bounds();
-
-                    renderer.with_layer(overlay_bounds, |renderer| {
-                        overlay.draw(
-                            renderer,
-                            &renderer::Style::default(),
                             Layout::new(&layer.layout),
                             cursor_position,
+                            &viewport,
+                            renderer,
                         );
-                    });
 
-                    if overlay_bounds.contains(cursor_position) {
+                        let overlay_bounds = layer.layout.bounds();
-                        overlay_interaction
+
-                    } else {
+                        renderer.with_layer(overlay_bounds, |renderer| {
-                        base_interaction
+                            overlay.draw(
-                    }
+                                renderer,
-                })
+                                &renderer::Style::default(),
+                                Layout::new(&layer.layout),
+                                cursor_position,
+                            );
+                        });
+
+                        if overlay_bounds.contains(cursor_position) {
+                            overlay_interaction
+                        } else {
+                            base_interaction
+                        }
+                    },
+                )
             })
             .unwrap_or(base_interaction)
     }

native/src/widget.rs

@@ -179,6 +179,7 @@ where
         _layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         mouse::Interaction::Idle
     }
@@ -187,6 +188,7 @@ where
     fn overlay(
         &mut self,
         _layout: Layout<'_>,
+        _renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         None
     }

native/src/widget/button.rs

@@ -253,6 +253,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         let is_mouse_over = layout.bounds().contains(cursor_position);
         let is_disabled = self.on_press.is_none();
@@ -343,8 +344,10 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
-        self.content.overlay(layout.children().next().unwrap())
+        self.content
+            .overlay(layout.children().next().unwrap(), renderer)
     }
 }
 

native/src/widget/checkbox.rs

@@ -195,6 +195,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         if layout.bounds().contains(cursor_position) {
             mouse::Interaction::Pointer

native/src/widget/column.rs

@@ -169,6 +169,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         self.children
             .iter()
@@ -178,6 +179,7 @@ where
                     layout,
                     cursor_position,
                     viewport,
+                    renderer,
                 )
             })
             .max()
@@ -217,11 +219,14 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         self.children
             .iter_mut()
             .zip(layout.children())
-            .filter_map(|(child, layout)| child.widget.overlay(layout))
+            .filter_map(|(child, layout)| {
+                child.widget.overlay(layout, renderer)
+            })
             .next()
     }
 }

native/src/widget/container.rs

@@ -184,11 +184,13 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         self.content.widget.mouse_interaction(
             layout.children().next().unwrap(),
             cursor_position,
             viewport,
+            renderer,
         )
     }
 
@@ -235,8 +237,10 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
-        self.content.overlay(layout.children().next().unwrap())
+        self.content
+            .overlay(layout.children().next().unwrap(), renderer)
     }
 }
 

native/src/widget/image/viewer.rs

@@ -286,6 +286,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         let bounds = layout.bounds();
         let is_mouse_over = bounds.contains(cursor_position);

native/src/widget/pane_grid.rs

@@ -472,6 +472,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         if self.state.picked_pane().is_some() {
             return mouse::Interaction::Grab;
@@ -511,7 +512,12 @@ where
             .iter()
             .zip(layout.children())
             .map(|((_pane, content), layout)| {
-                content.mouse_interaction(layout, cursor_position, viewport)
+                content.mouse_interaction(
+                    layout,
+                    cursor_position,
+                    viewport,
+                    renderer,
+                )
             })
             .max()
             .unwrap_or_default()
@@ -678,11 +684,12 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         self.elements
             .iter_mut()
             .zip(layout.children())
-            .filter_map(|((_, pane), layout)| pane.overlay(layout))
+            .filter_map(|((_, pane), layout)| pane.overlay(layout, renderer))
             .next()
     }
 }

native/src/widget/pane_grid/content.rs

@@ -205,6 +205,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         let (body_layout, title_bar_interaction) =
             if let Some(title_bar) = &self.title_bar {
@@ -222,6 +223,7 @@ where
                     title_bar_layout,
                     cursor_position,
                     viewport,
+                    renderer,
                 );
 
                 (children.next().unwrap(), mouse_interaction)
@@ -230,7 +232,7 @@ where
             };
 
         self.body
-            .mouse_interaction(body_layout, cursor_position, viewport)
+            .mouse_interaction(body_layout, cursor_position, viewport, renderer)
             .max(title_bar_interaction)
     }
 
@@ -245,17 +247,18 @@ where
     pub(crate) fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         if let Some(title_bar) = self.title_bar.as_mut() {
             let mut children = layout.children();
             let title_bar_layout = children.next()?;
 
-            match title_bar.overlay(title_bar_layout) {
+            match title_bar.overlay(title_bar_layout, renderer) {
                 Some(overlay) => Some(overlay),
-                None => self.body.overlay(children.next()?),
+                None => self.body.overlay(children.next()?, renderer),
             }
         } else {
-            self.body.overlay(layout)
+            self.body.overlay(layout, renderer)
         }
     }
 }

native/src/widget/pane_grid/title_bar.rs

@@ -258,6 +258,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         let mut children = layout.children();
         let padded = children.next().unwrap();
@@ -269,13 +270,19 @@ where
             title_layout,
             cursor_position,
             viewport,
+            renderer,
         );
 
         if let Some(controls) = &self.controls {
             let controls_layout = children.next().unwrap();
 
             controls
-                .mouse_interaction(controls_layout, cursor_position, viewport)
+                .mouse_interaction(
+                    controls_layout,
+                    cursor_position,
+                    viewport,
+                    renderer,
+                )
                 .max(title_interaction)
         } else {
             title_interaction
@@ -285,6 +292,7 @@ where
     pub(crate) fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         let mut children = layout.children();
         let padded = children.next()?;
@@ -296,11 +304,11 @@ where
             content, controls, ..
         } = self;
 
-        content.overlay(title_layout).or_else(move || {
+        content.overlay(title_layout, renderer).or_else(move || {
             controls.as_mut().and_then(|controls| {
                 let controls_layout = children.next()?;
 
-                controls.overlay(controls_layout)
+                controls.overlay(controls_layout, renderer)
             })
         })
     }

native/src/widget/pick_list.rs

@@ -331,6 +331,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         let bounds = layout.bounds();
         let is_mouse_over = bounds.contains(cursor_position);
@@ -415,6 +416,7 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        _renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         if *self.is_open {
             let bounds = layout.bounds();

native/src/widget/radio.rs

@@ -209,6 +209,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         if layout.bounds().contains(cursor_position) {
             mouse::Interaction::Pointer

native/src/widget/row.rs

@@ -168,6 +168,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         self.children
             .iter()
@@ -177,6 +178,7 @@ where
                     layout,
                     cursor_position,
                     viewport,
+                    renderer,
                 )
             })
             .max()
@@ -216,11 +218,14 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         self.children
             .iter_mut()
             .zip(layout.children())
-            .filter_map(|(child, layout)| child.widget.overlay(layout))
+            .filter_map(|(child, layout)| {
+                child.widget.overlay(layout, renderer)
+            })
             .next()
     }
 }

native/src/widget/scrollable.rs

@@ -427,6 +427,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
         let bounds = layout.bounds();
         let content_layout = layout.children().next().unwrap();
@@ -457,6 +458,7 @@ where
                     y: bounds.y + offset as f32,
                     ..bounds
                 },
+                renderer,
             )
         }
     }
@@ -581,11 +583,12 @@ where
     fn overlay(
         &mut self,
         layout: Layout<'_>,
+        renderer: &Renderer,
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         let Self { content, state, .. } = self;
 
         content
-            .overlay(layout.children().next().unwrap())
+            .overlay(layout.children().next().unwrap(), renderer)
             .map(|overlay| {
                 let bounds = layout.bounds();
                 let content_layout = layout.children().next().unwrap();

native/src/widget/slider.rs

@@ -361,6 +361,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         let bounds = layout.bounds();
         let is_mouse_over = bounds.contains(cursor_position);

native/src/widget/text_input.rs

@@ -764,6 +764,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         if layout.bounds().contains(cursor_position) {
             mouse::Interaction::Text

native/src/widget/toggler.rs

@@ -196,6 +196,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
+        _renderer: &Renderer,
     ) -> mouse::Interaction {
         if layout.bounds().contains(cursor_position) {
             mouse::Interaction::Pointer

native/src/widget/tooltip.rs

@@ -147,9 +147,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
+        renderer: &Renderer,
     ) -> mouse::Interaction {
-        self.content
+        self.content.mouse_interaction(
-            .mouse_interaction(layout, cursor_position, viewport)
+            layout,
+            cursor_position,
+            viewport,
+            renderer,
+        )
     }
 
     fn draw(