Rename mouse::Cursor to Mouse

Author: hecrj

benches/wgpu.rs

@@ -2,10 +2,9 @@
 use criterion::{Bencher, Criterion, criterion_group, criterion_main};
 
 use iced::alignment;
-use iced::mouse;
 use iced::widget::{canvas, scrollable, stack, text};
 use iced::{
-    Color, Element, Font, Length, Pixels, Point, Rectangle, Size, Theme,
+    Color, Element, Font, Length, Mouse, Pixels, Point, Rectangle, Size, Theme,
 };
 use iced_wgpu::Renderer;
 use iced_wgpu::wgpu;
@@ -129,7 +128,7 @@ fn benchmark<'a>(
             &core::renderer::Style {
                 text_color: Color::WHITE,
             },
-            mouse::Cursor::Unavailable,
+            Mouse::Unavailable,
         );
 
         cache = Some(user_interface.into_cache());
@@ -172,7 +171,7 @@ fn scene<'a, Message: 'a>(n: usize) -> Element<'a, Message, Theme, Renderer> {
             renderer: &Renderer,
             _theme: &Theme,
             bounds: Rectangle,
-            _cursor: mouse::Cursor,
+            _mouse: Mouse,
         ) -> Vec<canvas::Geometry<Renderer>> {
             vec![cache.draw(renderer, bounds.size(), |frame| {
                 for i in 0..self.n {

core/src/element.rs

@@ -5,8 +5,8 @@ use crate::renderer;
 use crate::widget;
 use crate::widget::tree::{self, Tree};
 use crate::{
-    Border, Clipboard, Color, Event, Layout, Length, Rectangle, Shell, Size,
-    Vector, Widget,
+    Border, Clipboard, Color, Event, Layout, Length, Mouse, Rectangle, Shell,
+    Size, Vector, Widget,
 };
 
 use std::borrow::Borrow;
@@ -314,7 +314,7 @@ where
         tree: &mut Tree,
         event: &Event,
         layout: Layout<'_>,
-        cursor: mouse::Cursor,
+        mouse: Mouse,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, B>,
@@ -327,7 +327,7 @@ where
             tree,
             event,
             layout,
-            cursor,
+            mouse,
             renderer,
             clipboard,
             &mut local_shell,
@@ -344,23 +344,23 @@ where
         theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
-        cursor: mouse::Cursor,
+        mouse: Mouse,
         viewport: &Rectangle,
     ) {
         self.widget
-            .draw(tree, renderer, theme, style, layout, cursor, viewport);
+            .draw(tree, renderer, theme, style, layout, mouse, viewport);
     }
 
     fn mouse_interaction(
         &self,
         tree: &Tree,
         layout: Layout<'_>,
-        cursor: mouse::Cursor,
+        mouse: Mouse,
         viewport: &Rectangle,
         renderer: &Renderer,
     ) -> mouse::Interaction {
         self.widget
-            .mouse_interaction(tree, layout, cursor, viewport, renderer)
+            .mouse_interaction(tree, layout, mouse, viewport, renderer)
     }
 
     fn overlay<'b>(
@@ -450,14 +450,14 @@ where
         state: &mut Tree,
         event: &Event,
         layout: Layout<'_>,
-        cursor: mouse::Cursor,
+        mouse: Mouse,
         renderer: &Renderer,
         clipboard: &mut dyn Clipboard,
         shell: &mut Shell<'_, Message>,
         viewport: &Rectangle,
     ) {
         self.element.widget.update(
-            state, event, layout, cursor, renderer, clipboard, shell, viewport,
+            state, event, layout, mouse, renderer, clipboard, shell, viewport,
         );
     }
 
@@ -468,7 +468,7 @@ where
         theme: &Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
-        cursor: mouse::Cursor,
+        mouse: Mouse,
         viewport: &Rectangle,
     ) {
         fn explain_layout<Renderer: crate::Renderer>(
@@ -496,7 +496,7 @@ where
 
         self.element
             .widget
-            .draw(state, renderer, theme, style, layout, cursor, viewport);
+            .draw(state, renderer, theme, style, layout, mouse, viewport);
 
         explain_layout(renderer, self.color, layout);
     }
@@ -505,13 +505,13 @@ where
         &self,
         state: &Tree,
         layout: Layout<'_>,
-        cursor: mouse::Cursor,
+        mouse: Mouse,
         viewport: &Rectangle,
         renderer: &Renderer,
     ) -> mouse::Interaction {
         self.element
             .widget
-            .mouse_interaction(state, layout, cursor, viewport, renderer)
+            .mouse_interaction(state, layout, mouse, viewport, renderer)
     }
 
     fn overlay<'b>(

core/src/lib.rs

@@ -65,6 +65,7 @@ pub use image::Image;
 pub use input_method::InputMethod;
 pub use layout::Layout;
 pub use length::Length;
+pub use mouse::Mouse;
 pub use overlay::Overlay;
 pub use padding::Padding;
 pub use pixels::Pixels;

core/src/mouse.rs

@@ -2,12 +2,103 @@
 pub mod click;
 
 mod button;
-mod cursor;
 mod event;
 mod interaction;
 
 pub use button::Button;
 pub use click::Click;
-pub use cursor::Cursor;
 pub use event::{Event, ScrollDelta};
 pub use interaction::Interaction;
+
+use crate::{Point, Rectangle, Transformation, Vector};
+
+/// The mouse state.
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub enum Mouse {
+    /// The mouse has a defined position.
+    Available(Point),
+
+    /// The mouse has a defined position, but it's levitating over a layer above.
+    Levitating(Point),
+
+    /// The mouse is currently unavailable (i.e. out of bounds or busy).
+    #[default]
+    Unavailable,
+}
+
+impl Mouse {
+    /// Returns the absolute position of the [`Mouse`], if available.
+    pub fn position(self) -> Option<Point> {
+        match self {
+            Mouse::Available(position) => Some(position),
+            Mouse::Levitating(_) | Mouse::Unavailable => None,
+        }
+    }
+
+    /// Returns the absolute position of the [`Mouse`], if available and inside
+    /// the given bounds.
+    ///
+    /// If the [`Mouse`] is not over the provided bounds, this method will
+    /// return `None`.
+    pub fn position_over(self, bounds: Rectangle) -> Option<Point> {
+        self.position().filter(|p| bounds.contains(*p))
+    }
+
+    /// Returns the relative position of the [`Mouse`] inside the given bounds,
+    /// if available.
+    ///
+    /// If the [`Mouse`] is not over the provided bounds, this method will
+    /// return `None`.
+    pub fn position_in(self, bounds: Rectangle) -> Option<Point> {
+        self.position_over(bounds)
+            .map(|p| p - Vector::new(bounds.x, bounds.y))
+    }
+
+    /// Returns the relative position of the [`Mouse`] from the given origin,
+    /// if available.
+    pub fn position_from(self, origin: Point) -> Option<Point> {
+        self.position().map(|p| p - Vector::new(origin.x, origin.y))
+    }
+
+    /// Returns true if the [`Mouse`] is over the given `bounds`.
+    pub fn is_over(self, bounds: Rectangle) -> bool {
+        self.position_over(bounds).is_some()
+    }
+
+    /// Returns true if the [`Mouse`] is levitating over a layer above.
+    pub fn is_levitating(self) -> bool {
+        matches!(self, Self::Levitating(_))
+    }
+
+    /// Makes the [`Mouse`] levitate over a layer above.
+    pub fn levitate(self) -> Self {
+        match self {
+            Self::Available(position) => Self::Levitating(position),
+            _ => self,
+        }
+    }
+
+    /// Brings the [`Mouse`] back to the current layer.
+    pub fn land(self) -> Self {
+        match self {
+            Mouse::Levitating(position) => Mouse::Available(position),
+            _ => self,
+        }
+    }
+}
+
+impl std::ops::Mul<Transformation> for Mouse {
+    type Output = Self;
+
+    fn mul(self, transformation: Transformation) -> Self {
+        match self {
+            Self::Available(position) => {
+                Self::Available(position * transformation)
+            }
+            Self::Levitating(position) => {
+                Self::Levitating(position * transformation)
+            }
+            Self::Unavailable => Self::Unavailable,
+        }
+    }
+}