autogui 0.4.1

GUI Automation toolbox for Rust
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::Position;
use action::{self, MouseButton};
use actor::{Actor, ChainedAction};

use action::InputAction;

use crate::platform::current;

/// Mouse controller
#[derive(Debug)]
pub struct Mouse {
    position: Position,
    actual_position: Position,
}
impl Mouse {
    pub(crate) fn new() -> Mouse {
        Mouse {
            position: Position::new(0, 0),
            actual_position: Position::new(0, 0),
        }
    }

    /// Is mouse on screen at where it should be for the next action
    fn is_placed(&self) -> bool {
        self.position == self.actual_position
    }

    /// Move mouse to next position if it was delayed
    #[allow(dead_code)]
    fn sync(self) -> Mouse {
        if !self.is_placed() {
            let p = self.position;
            self.move_to(p)
        } else {
            self
        }
    }

    /// Perform next event at given position
    pub fn at(self, new_pos: Position) -> Mouse {
        Mouse {
            position: new_pos,
            ..self
        }
    }

    /// Move mouse to new position
    pub fn move_to(self, new_pos: Position) -> Mouse {
        let mouse = Mouse {
            position: new_pos,
            actual_position: new_pos,
        };

        mouse.event(action::InputAction::MouseMove)
    }

    /// Alias for left_drag_to
    pub fn drag_to(self, new_pos: Position) -> Mouse {
        self.left_drag_to(new_pos)
    }

    /// Drag from the current position to new position with left mouse button
    pub fn left_drag_to(self, new_pos: Position) -> Mouse {
        self.drag_to_with(new_pos, MouseButton::Left)
    }

    /// Drag from the current position to new position with right mouse button
    pub fn right_drag_to(self, new_pos: Position) -> Mouse {
        self.drag_to_with(new_pos, MouseButton::Right)
    }

    /// Drag from the current position to new position with given mouse button
    pub fn drag_to_with(self, new_pos: Position, button: MouseButton) -> Mouse {
        let start_pos = self.position;

        // drag end
        self.move_to(start_pos)
            .down(button)
            .at(new_pos)
            .event(action::InputAction::MouseDrag(button))
            .up(button)
    }

    /// Press the given mouse button down
    pub fn down(self, button: MouseButton) -> Mouse {
        self.event(action::InputAction::MouseDown(button))
    }

    /// Release the given mouse button
    pub fn up(self, button: MouseButton) -> Mouse {
        self.event(action::InputAction::MouseUp(button))
    }

    /// Alias for left_click
    pub fn click(self) -> Mouse {
        self.left_click()
    }

    /// Click with left button
    pub fn left_click(self) -> Mouse {
        self.click_with(MouseButton::Left)
    }

    /// Click with right button
    pub fn right_click(self) -> Mouse {
        self.click_with(MouseButton::Right)
    }

    /// Click with the given button
    pub fn click_with(self, button: MouseButton) -> Mouse {
        self.event(action::InputAction::MouseClickN(button, 1))
    }

    /// Alias for left_doubleclick
    pub fn doubleclick(self) -> Mouse {
        self.event(action::InputAction::MouseClickN(MouseButton::Left, 2))
    }

    /// Double click with left button
    pub fn left_doubleclick(self) -> Mouse {
        self.event(action::InputAction::MouseClickN(MouseButton::Left, 2))
    }

    /// Double click with right button
    pub fn right_doubleclick(self) -> Mouse {
        self.doubleclick_with(MouseButton::Right)
    }

    /// Double click with the given mouse button
    pub fn doubleclick_with(self, button: MouseButton) -> Mouse {
        self.event(action::InputAction::MouseClickN(button, 2))
    }
}
impl Actor for Mouse {
    fn event(self, t: InputAction) -> Self {
        current::process_event(t, Some(self.position));
        self
    }
}
impl ChainedAction for Mouse {}