uiautomation 0.0.2

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

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

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)
    }
}

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)
                }
            }
        )
    }
}