uiautomation 0.0.7

UI Automation Framework for Windows
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
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

use std::fmt::Debug;

use crate::core::UIElement;
use crate::errors::Result;

/// `Condition` is a element filter that can be used in `UIMatcher`.
pub trait Condition {
    fn judge(&self, element: &UIElement) -> Result<bool>;
}

pub struct AndCondition {
    pub left: Box<dyn Condition>,
    pub right: Box<dyn Condition>
}

impl AndCondition {
    pub fn new(left: Box<dyn Condition>, right: Box<dyn Condition>) -> Self {
        Self {
            left,
            right
        }
    }
}

impl Condition for AndCondition {
    fn judge(&self, element: &UIElement) -> Result<bool> {
        let ret = self.left.judge(element)? && self.right.judge(element)?;

        Ok(ret)
    }
}

pub struct OrCondition {
    pub left: Box<dyn Condition>,
    pub right: Box<dyn Condition>
}

impl OrCondition {
    pub fn new(left: Box<dyn Condition>, right: Box<dyn Condition>) -> Self {
        Self {
            left,
            right
        }
    }
}

impl Condition for OrCondition {
    fn judge(&self, element: &UIElement) -> Result<bool> {
        let ret = self.left.judge(element)? || self.right.judge(element)?;
        Ok(ret)
    }
}

#[derive(Debug, Default)]
pub struct NameCondition {
    pub value: String,
    pub casesensitive: bool,
    pub partial: bool
}

// impl Default for NameCondition {
//     fn default() -> Self {
//         Self { 
//             value: Default::default(), 
//             casesensitive: false, 
//             partial: true
//         }
//     }
// }

impl Condition for NameCondition {
    fn judge(&self, element: &UIElement) -> Result<bool> {
        let element_name = element.get_name()?;
        let element_name = element_name.as_str();
        let condition_name = self.value.as_str();

        Ok(
            if self.partial {
                if self.casesensitive {
                    element_name.contains(condition_name)
                } else {
                    let element_name = element_name.to_lowercase();
                    let condition_name = condition_name.to_lowercase();

                    element_name.contains(&condition_name)
                }
            } else {
                if self.casesensitive {
                    element_name == condition_name
                } else {
                    element_name.eq_ignore_ascii_case(condition_name)
                }
            }
        )
    }
}

#[derive(Debug, Default)]
pub struct ClassNameCondition {
    pub classname: String
}

// impl Default for ClassNameCondition {
//     fn default() -> Self {
//         Self { 
//             classname: Default::default() 
//         }
//     }
// }

impl Condition for ClassNameCondition {
    fn judge(&self, element: &UIElement) -> Result<bool> {
        let cur_classname = element.get_classname()?;
        Ok(self.classname == cur_classname)
    }
}

#[derive(Debug, Default)]
pub struct ControlTypeCondition {
    pub control_type: i32
}

impl Condition for ControlTypeCondition {
    fn judge(&self, element: &UIElement) -> Result<bool> {
        let ctrl_type = element.get_control_type()?;
        Ok(self.control_type == ctrl_type)
    }
}