1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
use iced_native::{Point, Rectangle};

/// The mouse cursor state.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Cursor {
    /// The cursor has a defined position.
    Available(Point),

    /// The cursor is currently unavailable (i.e. out of bounds or busy).
    Unavailable,
}

impl Cursor {
    // TODO: Remove this once this type is used in `iced_native` to encode
    // proper cursor availability
    pub(crate) fn from_window_position(position: Point) -> Self {
        if position.x < 0.0 || position.y < 0.0 {
            Cursor::Unavailable
        } else {
            Cursor::Available(position)
        }
    }

    /// Returns the absolute position of the [`Cursor`], if available.
    ///
    /// [`Cursor`]: enum.Cursor.html
    pub fn position(&self) -> Option<Point> {
        match self {
            Cursor::Available(position) => Some(*position),
            Cursor::Unavailable => None,
        }
    }

    /// Returns the relative position of the [`Cursor`] inside the given bounds,
    /// if available.
    ///
    /// If the [`Cursor`] is not over the provided bounds, this method will
    /// return `None`.
    ///
    /// [`Cursor`]: enum.Cursor.html
    pub fn position_in(&self, bounds: &Rectangle) -> Option<Point> {
        if self.is_over(bounds) {
            self.position_from(bounds.position())
        } else {
            None
        }
    }

    /// Returns the relative position of the [`Cursor`] from the given origin,
    /// if available.
    ///
    /// [`Cursor`]: enum.Cursor.html
    pub fn position_from(&self, origin: Point) -> Option<Point> {
        match self {
            Cursor::Available(position) => {
                Some(Point::new(position.x - origin.x, position.y - origin.y))
            }
            Cursor::Unavailable => None,
        }
    }

    /// Returns whether the [`Cursor`] is currently over the provided bounds
    /// or not.
    ///
    /// [`Cursor`]: enum.Cursor.html
    pub fn is_over(&self, bounds: &Rectangle) -> bool {
        match self {
            Cursor::Available(position) => bounds.contains(*position),
            Cursor::Unavailable => false,
        }
    }
}