Introduce mouse_interaction method to Widget trait

native/src/element.rs

@@ -1,5 +1,6 @@
 use crate::event::{self, Event};
 use crate::layout;
+use crate::mouse;
 use crate::overlay;
 use crate::renderer;
 use crate::{
@@ -251,6 +252,16 @@ where
             .draw(renderer, style, layout, cursor_position, viewport)
     }
 
+    pub fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        viewport: &Rectangle,
+        cursor_position: Point,
+    ) -> mouse::Interaction {
+        self.widget
+            .mouse_interaction(layout, viewport, cursor_position)
+    }
+
     /// Computes the _layout_ hash of the [`Element`].
     pub fn hash_layout(&self, state: &mut Hasher) {
         self.widget.hash_layout(state);
@@ -346,6 +357,16 @@ where
             .draw(renderer, style, layout, cursor_position, viewport)
     }
 
+    fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        viewport: &Rectangle,
+        cursor_position: Point,
+    ) -> mouse::Interaction {
+        self.widget
+            .mouse_interaction(layout, viewport, cursor_position)
+    }
+
     fn hash_layout(&self, state: &mut Hasher) {
         self.widget.hash_layout(state);
     }
@@ -426,6 +447,17 @@ where
     ) {
     }
 
+    fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        viewport: &Rectangle,
+        cursor_position: Point,
+    ) -> mouse::Interaction {
+        self.element
+            .widget
+            .mouse_interaction(layout, viewport, cursor_position)
+    }
+
     fn hash_layout(&self, state: &mut Hasher) {
         self.element.widget.hash_layout(state);
     }

native/src/overlay.rs

@@ -8,8 +8,9 @@ pub use menu::Menu;
 
 use crate::event::{self, Event};
 use crate::layout;
+use crate::mouse;
 use crate::renderer;
-use crate::{Clipboard, Hasher, Layout, Point, Size};
+use crate::{Clipboard, Hasher, Layout, Point, Rectangle, Size};
 
 /// An interactive component that can be displayed on top of other widgets.
 pub trait Overlay<Message, Renderer>
@@ -74,4 +75,16 @@ where
     ) -> event::Status {
         event::Status::Ignored
     }
+
+    /// Returns the current [`mouse::Interaction`] of the [`Widget`].
+    ///
+    /// By default, it returns [`mouse::Interaction::Idle`].
+    fn mouse_interaction(
+        &self,
+        _layout: Layout<'_>,
+        _viewport: &Rectangle,
+        _cursor_position: Point,
+    ) -> mouse::Interaction {
+        mouse::Interaction::Idle
+    }
 }

native/src/overlay/element.rs

@@ -2,8 +2,9 @@ pub use crate::Overlay;
 
 use crate::event::{self, Event};
 use crate::layout;
+use crate::mouse;
 use crate::renderer;
-use crate::{Clipboard, Hasher, Layout, Point, Size, Vector};
+use crate::{Clipboard, Hasher, Layout, Point, Rectangle, Size, Vector};
 
 /// A generic [`Overlay`].
 #[allow(missing_debug_implementations)]
@@ -68,6 +69,16 @@ where
         )
     }
 
+    pub fn mouse_interaction(
+        &self,
+        layout: Layout<'_>,
+        viewport: &Rectangle,
+        cursor_position: Point,
+    ) -> mouse::Interaction {
+        self.overlay
+            .mouse_interaction(layout, viewport, cursor_position)
+    }
+
     /// Draws the [`Element`] and its children using the given [`Layout`].
     pub fn draw(
         &self,

native/src/program/state.rs

@@ -1,3 +1,4 @@
+use crate::mouse;
 use crate::{
     Cache, Clipboard, Command, Debug, Event, Point, Program, Size,
     UserInterface,
@@ -14,6 +15,7 @@ where
     cache: Option<Cache>,
     queued_events: Vec<Event>,
     queued_messages: Vec<P::Message>,
+    mouse_interaction: mouse::Interaction,
 }
 
 impl<P> State<P>
@@ -25,11 +27,10 @@ where
     pub fn new(
         mut program: P,
         bounds: Size,
-        cursor_position: Point,
         renderer: &mut P::Renderer,
         debug: &mut Debug,
     ) -> Self {
-        let mut user_interface = build_user_interface(
+        let user_interface = build_user_interface(
             &mut program,
             Cache::default(),
             renderer,
@@ -44,6 +45,7 @@ where
             cache,
             queued_events: Vec::new(),
             queued_messages: Vec::new(),
+            mouse_interaction: mouse::Interaction::Idle,
         }
     }
 
@@ -71,6 +73,11 @@ where
         self.queued_events.is_empty() && self.queued_messages.is_empty()
     }
 
+    /// Returns the current [`mouse::Interaction`] of the [`State`].
+    pub fn mouse_interaction(&self) -> mouse::Interaction {
+        self.mouse_interaction
+    }
+
     /// Processes all the queued events and messages, rebuilding and redrawing
     /// the widgets of the linked [`Program`] if necessary.
     ///
@@ -109,7 +116,8 @@ where
 
         if messages.is_empty() {
             debug.draw_started();
-            user_interface.draw(renderer, cursor_position);
+            self.mouse_interaction =
+                user_interface.draw(renderer, cursor_position);
             debug.draw_finished();
 
             self.cache = Some(user_interface.into_cache());
@@ -140,7 +148,8 @@ where
             );
 
             debug.draw_started();
-            user_interface.draw(renderer, cursor_position);
+            self.mouse_interaction =
+                user_interface.draw(renderer, cursor_position);
             debug.draw_finished();
 
             self.cache = Some(user_interface.into_cache());

native/src/user_interface.rs

@@ -1,5 +1,6 @@
 use crate::event::{self, Event};
 use crate::layout;
+use crate::mouse;
 use crate::overlay;
 use crate::renderer;
 use crate::{Clipboard, Element, Layout, Point, Rectangle, Size, Vector};
@@ -330,7 +331,11 @@ where
     ///     // Flush rendering operations...
     /// }
     /// ```
-    pub fn draw(&mut self, renderer: &mut Renderer, cursor_position: Point) {
+    pub fn draw(
+        &mut self,
+        renderer: &mut Renderer,
+        cursor_position: Point,
+    ) -> mouse::Interaction {
         // TODO: Move to shell level (?)
         renderer.clear();
 
@@ -346,6 +351,12 @@ where
                 renderer,
             );
 
+            let mouse_interaction = overlay.mouse_interaction(
+                Layout::new(&layer.layout),
+                &viewport,
+                cursor_position,
+            );
+
             let overlay_bounds = layer.layout.bounds();
 
             renderer.with_layer(
@@ -363,12 +374,12 @@ where
 
             self.overlay = Some(layer);
 
-            Some(overlay_bounds)
+            Some((overlay_bounds, mouse_interaction))
         } else {
             None
         };
 
-        if let Some(overlay_bounds) = overlay {
+        if let Some((overlay_bounds, overlay_interaction)) = overlay {
             let base_cursor = if overlay_bounds.contains(cursor_position) {
                 Point::new(-1.0, -1.0)
             } else {
@@ -382,6 +393,8 @@ where
                 base_cursor,
                 &viewport,
             );
+
+            overlay_interaction
         } else {
             self.root.widget.draw(
                 renderer,
@@ -390,6 +403,12 @@ where
                 cursor_position,
                 &viewport,
             );
+
+            self.root.widget.mouse_interaction(
+                Layout::new(&self.base.layout),
+                &viewport,
+                cursor_position,
+            )
         }
     }
 

native/src/widget.rs

@@ -80,6 +80,7 @@ pub use tooltip::Tooltip;
 
 use crate::event::{self, Event};
 use crate::layout;
+use crate::mouse;
 use crate::overlay;
 use crate::renderer;
 use crate::{Clipboard, Hasher, Layout, Length, Point, Rectangle};
@@ -175,6 +176,18 @@ where
         event::Status::Ignored
     }
 
+    /// Returns the current [`mouse::Interaction`] of the [`Widget`].
+    ///
+    /// By default, it returns [`mouse::Interaction::Idle`].
+    fn mouse_interaction(
+        &self,
+        _layout: Layout<'_>,
+        _viewport: &Rectangle,
+        _cursor_position: Point,
+    ) -> mouse::Interaction {
+        mouse::Interaction::Idle
+    }
+
     /// Returns the overlay of the [`Widget`], if there is any.
     fn overlay(
         &mut self,