rustautogui 2.5.0

Highly optimized GUI automation library for controlling the mouse and keyboard, with template matching support.
Documentation 
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

use std::{
    ffi::{CString, NulError},
    fmt,
};

#[cfg(feature = "opencl")]
use ocl;

#[derive(Debug)]
pub enum AutoGuiError {
    OSFailure(String),
    UnSupportedKey(String),
    IoError(std::io::Error),
    AliasError(String),
    OutOfBoundsError(String),
    #[cfg(not(feature = "lite"))]
    ImageError(ImageProcessingError),
    ImgError(String),
    NulError(NulError),
    #[cfg(feature = "opencl")]
    OclError(ocl::Error),
}

impl fmt::Display for AutoGuiError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AutoGuiError::OSFailure(err) => write!(f, "OS Failure: {}", err),
            AutoGuiError::UnSupportedKey(err) => write!(f, "Key not supported: {}", err),
            AutoGuiError::IoError(err) => write!(f, "IO Error: {}", err),
            AutoGuiError::AliasError(err) => write!(f, "Alias Error: {}", err),
            AutoGuiError::OutOfBoundsError(err) => write!(f, "Out of bounds error: {}", err),
            #[cfg(not(feature = "lite"))]
            AutoGuiError::ImageError(err) => write!(f, "Image Error: {}", err),
            AutoGuiError::ImgError(err) => write!(f, "Image Error: {}", err),
            AutoGuiError::NulError(err) => write!(f, "Convert to C String nulerror: {}", err),
            #[cfg(feature = "opencl")]
            AutoGuiError::OclError(err) => write!(f, "OpenCL Error: {}", err),
        }
    }
}

impl From<NulError> for AutoGuiError {
    fn from(err: NulError) -> Self {
        AutoGuiError::NulError(err)
    }
}
#[cfg(not(feature = "lite"))]
impl From<image::ImageError> for AutoGuiError {
    fn from(err: image::ImageError) -> Self {
        AutoGuiError::ImageError(ImageProcessingError::External(err))
    }
}
#[cfg(not(feature = "lite"))]
impl From<ImageProcessingError> for AutoGuiError {
    fn from(err: ImageProcessingError) -> Self {
        AutoGuiError::ImageError(err)
    }
}

impl From<std::io::Error> for AutoGuiError {
    fn from(err: std::io::Error) -> Self {
        AutoGuiError::IoError(err)
    }
}
#[cfg(feature = "opencl")]
impl From<ocl::Error> for AutoGuiError {
    fn from(err: ocl::Error) -> Self {
        AutoGuiError::OclError(err)
    }
}

#[derive(Debug)]
#[cfg(not(feature = "lite"))]
pub enum ImageProcessingError {
    External(image::ImageError),
    Custom(String),
}
#[cfg(not(feature = "lite"))]
impl ImageProcessingError {
    pub fn new(msg: &str) -> Self {
        Self::Custom(msg.to_string())
    }
}
#[cfg(not(feature = "lite"))]
impl fmt::Display for ImageProcessingError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ImageProcessingError::External(err) => write!(f, "{}", err),
            ImageProcessingError::Custom(err) => write!(f, "{}", err),
        }
    }
}

impl std::error::Error for AutoGuiError {}
#[cfg(not(feature = "lite"))]
impl std::error::Error for ImageProcessingError {}