Struct rustautogui::RustAutoGui

pub struct RustAutoGui { /* private fields */ }

Main struct for Rustautogui Struct gets assigned keyboard, mouse and struct to it implemented functions execute commands from each of assigned substructs executes also correlation algorithms when doing find_image_on_screen

Implementations

impl RustAutoGui

pub fn new(debug: bool) -> Self

initiation of screen, keyboard and mouse that are assigned to new rustautogui struct. all the other struct fields are initiated as 0 or None

Examples found in repository

examples/find_image_move_mouse_and_input.rs (line 6)

fn main() {

    // initialize autogui
    let mut gui = rustautogui::RustAutoGui::new(false);

    // load the image searching for. Region is Option<(startx, starty, width, height)> of search. Matchmode FFT or Segmented (not implemented before 1.0 version), max segments, only important for Segmented match mode
    gui.load_and_prepare_template("test.png", Some((0,0, 500, 300)), rustautogui::MatchMode::FFT, &None);

    // automatically move mouse to found template position in this case it was browser url input field
    gui.find_image_on_screen_and_move_mouse(0.9, 1.0);

    // click the url input field
    gui.left_click();

    // input url
    gui.keyboard_input("test.hr", &false);

    // press enter
    gui.keyboard_command("return");


    // maybe you would want to loop search until image is found and break the loop then
    loop {
        let pos = gui.find_image_on_screen_and_move_mouse(0.9, 1.0);    
        match pos {
            Some(_) => break,
            None => (),
        }
    }
}

pub fn load_and_prepare_template( &mut self, template_path: &str, region: Option<(u32, u32, u32, u32)>, match_mode: MatchMode, max_segments: &Option<u32>, )

Loads template image from provided path and sets all the fields across structs as needed. Depending on match_mode, different template preparation process is executed. When using FFT, region is also important for zero-pad calculation Loading and preparing template is a necessary process before calling find_image_on_screen function

creates vector of data stored under PreparedData enumerator, and stored inside struct field self.prepared_data

Examples found in repository

examples/find_image_move_mouse_and_input.rs (line 9)

fn main() {

    // initialize autogui
    let mut gui = rustautogui::RustAutoGui::new(false);

    // load the image searching for. Region is Option<(startx, starty, width, height)> of search. Matchmode FFT or Segmented (not implemented before 1.0 version), max segments, only important for Segmented match mode
    gui.load_and_prepare_template("test.png", Some((0,0, 500, 300)), rustautogui::MatchMode::FFT, &None);

    // automatically move mouse to found template position in this case it was browser url input field
    gui.find_image_on_screen_and_move_mouse(0.9, 1.0);

    // click the url input field
    gui.left_click();

    // input url
    gui.keyboard_input("test.hr", &false);

    // press enter
    gui.keyboard_command("return");


    // maybe you would want to loop search until image is found and break the loop then
    loop {
        let pos = gui.find_image_on_screen_and_move_mouse(0.9, 1.0);    
        match pos {
            Some(_) => break,
            None => (),
        }
    }
}

pub fn change_prepared_settings( &mut self, region: Option<(u32, u32, u32, u32)>, match_mode: MatchMode, max_segments: &Option<u32>, )

change certain settings for prepared template, like region, match_mode or max_segments. If MatchMode is not changed, whole template recalculation may still be needed if certain other parameters are changed, depending on current MatchMode. For FFT, changing region starts complete recalculation again, because of change in zero pad image. While changing max_segments calls recalculation of template for Segmented matchmode

pub fn change_debug_state(&mut self, state: bool)

changes debug mode

pub fn find_image_on_screen( &mut self, precision: f32, ) -> Option<Vec<(u32, u32, f64)>>

Searches for prepared template on screen. On windows only main monitor search is supported, while on linux, all monitors work more details in README

pub fn save_screenshot(&mut self, path: &str)

saves screenshot and saves it at provided path

pub fn find_image_on_screen_and_move_mouse( &mut self, precision: f32, moving_time: f32, ) -> Option<Vec<(u32, u32, f64)>>

executes find_image_on_screen and moves mouse to the middle of the image.

Examples found in repository

examples/find_image_move_mouse_and_input.rs (line 12)

fn main() {

    // initialize autogui
    let mut gui = rustautogui::RustAutoGui::new(false);

    // load the image searching for. Region is Option<(startx, starty, width, height)> of search. Matchmode FFT or Segmented (not implemented before 1.0 version), max segments, only important for Segmented match mode
    gui.load_and_prepare_template("test.png", Some((0,0, 500, 300)), rustautogui::MatchMode::FFT, &None);

    // automatically move mouse to found template position in this case it was browser url input field
    gui.find_image_on_screen_and_move_mouse(0.9, 1.0);

    // click the url input field
    gui.left_click();

    // input url
    gui.keyboard_input("test.hr", &false);

    // press enter
    gui.keyboard_command("return");


    // maybe you would want to loop search until image is found and break the loop then
    loop {
        let pos = gui.find_image_on_screen_and_move_mouse(0.9, 1.0);    
        match pos {
            Some(_) => break,
            None => (),
        }
    }
}

pub fn move_mouse_to_pos(&self, x: i32, y: i32, moving_time: f32)

moves mouse to x, y pixel coordinate

pub fn left_click(&self)

executes left mouse click

Examples found in repository

examples/find_image_move_mouse_and_input.rs (line 15)

fn main() {

    // initialize autogui
    let mut gui = rustautogui::RustAutoGui::new(false);

    // load the image searching for. Region is Option<(startx, starty, width, height)> of search. Matchmode FFT or Segmented (not implemented before 1.0 version), max segments, only important for Segmented match mode
    gui.load_and_prepare_template("test.png", Some((0,0, 500, 300)), rustautogui::MatchMode::FFT, &None);

    // automatically move mouse to found template position in this case it was browser url input field
    gui.find_image_on_screen_and_move_mouse(0.9, 1.0);

    // click the url input field
    gui.left_click();

    // input url
    gui.keyboard_input("test.hr", &false);

    // press enter
    gui.keyboard_command("return");


    // maybe you would want to loop search until image is found and break the loop then
    loop {
        let pos = gui.find_image_on_screen_and_move_mouse(0.9, 1.0);    
        match pos {
            Some(_) => break,
            None => (),
        }
    }
}

pub fn right_click(&self)

executes right mouse click

pub fn middle_click(&self)

executes middle mouse click

pub fn double_click(&self)

executes double left mouse click

pub fn scroll_up(&self)

pub fn scroll_down(&self)

pub fn keyboard_input(&self, input: &str, shifted: &bool)

accepts string and mimics keyboard key presses for each character in string

Examples found in repository

examples/find_image_move_mouse_and_input.rs (line 18)

fn main() {

    // initialize autogui
    let mut gui = rustautogui::RustAutoGui::new(false);

    // load the image searching for. Region is Option<(startx, starty, width, height)> of search. Matchmode FFT or Segmented (not implemented before 1.0 version), max segments, only important for Segmented match mode
    gui.load_and_prepare_template("test.png", Some((0,0, 500, 300)), rustautogui::MatchMode::FFT, &None);

    // automatically move mouse to found template position in this case it was browser url input field
    gui.find_image_on_screen_and_move_mouse(0.9, 1.0);

    // click the url input field
    gui.left_click();

    // input url
    gui.keyboard_input("test.hr", &false);

    // press enter
    gui.keyboard_command("return");


    // maybe you would want to loop search until image is found and break the loop then
    loop {
        let pos = gui.find_image_on_screen_and_move_mouse(0.9, 1.0);    
        match pos {
            Some(_) => break,
            None => (),
        }
    }
}

pub fn keyboard_command(&self, input: &str)

executes keyboard command like “return” or “escape”

Examples found in repository

examples/find_image_move_mouse_and_input.rs (line 21)

fn main() {

    // initialize autogui
    let mut gui = rustautogui::RustAutoGui::new(false);

    // load the image searching for. Region is Option<(startx, starty, width, height)> of search. Matchmode FFT or Segmented (not implemented before 1.0 version), max segments, only important for Segmented match mode
    gui.load_and_prepare_template("test.png", Some((0,0, 500, 300)), rustautogui::MatchMode::FFT, &None);

    // automatically move mouse to found template position in this case it was browser url input field
    gui.find_image_on_screen_and_move_mouse(0.9, 1.0);

    // click the url input field
    gui.left_click();

    // input url
    gui.keyboard_input("test.hr", &false);

    // press enter
    gui.keyboard_command("return");


    // maybe you would want to loop search until image is found and break the loop then
    loop {
        let pos = gui.find_image_on_screen_and_move_mouse(0.9, 1.0);    
        match pos {
            Some(_) => break,
            None => (),
        }
    }
}

pub fn keyboard_multi_key( &self, input1: &str, input2: &str, input3: Option<&str>, )

Trait Implementations

impl Drop for RustAutoGui

fn drop(&mut self)

Executes the destructor for this type.