uiautomation 0.17.2

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

use std::fmt::Debug;

use crate::controls::ControlType;

use super::core::UIElement;
use super::errors::Result;

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

pub struct AndFilter {
    pub left: Box<dyn MatcherFilter>,
    pub right: Box<dyn MatcherFilter>
}

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

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

        Ok(ret)
    }
}

pub struct OrFilter {
    pub left: Box<dyn MatcherFilter>,
    pub right: Box<dyn MatcherFilter>
}

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

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

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

impl MatcherFilter for NameFilter {
    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 ClassNameFilter {
    pub classname: String
}

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

#[derive(Debug)]
pub struct ControlTypeFilter {
    pub control_type: ControlType
}

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

pub struct FnFilter<F> where F: Fn(&UIElement) -> Result<bool> {
    pub filter: Box<F>
}

impl<F> MatcherFilter for FnFilter<F> where F: Fn(&UIElement) -> Result<bool> {
    fn judge(&self, element: &UIElement) -> Result<bool> {
        (self.filter)(element)
    }
}