uiautomation 0.0.3

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
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
129
130
131
132
133
134
135
136
137
138
139

use windows::Win32::UI::Accessibility::IUIAutomationElement;
use windows::Win32::UI::Accessibility::UIA_ButtonControlTypeId;
use windows::Win32::UI::Accessibility::UIA_InvokePatternId;
use windows::Win32::UI::Accessibility::UIA_ListItemControlTypeId;
use windows::Win32::UI::Accessibility::UIA_SelectionItemPatternId;

use crate::Error;
use crate::Result;
use crate::UIElement;
use crate::errors::ERR_TYPE;
use crate::patterns::UIInvokePattern;
use crate::patterns::UIScrollItemPattern;
use crate::patterns::UISelectionItemPattern;

/// Wrapper an button element as a control.
pub struct ButtonControl {
    control: UIElement
}

impl ButtonControl {
    /// Perform a click event on this control.
    pub fn click(&self) -> Result<()> {
        let pattern: UIInvokePattern = self.control.get_pattern()?;
        pattern.invoke()
    }
}

impl TryFrom<UIElement> for ButtonControl {
    type Error = Error;

    fn try_from(value: UIElement) -> Result<Self> {
        if value.get_control_type()? == UIA_ButtonControlTypeId {
            Ok(Self {
                control: value
            })
        } else {
            Err(Error::new(ERR_TYPE, "Error Control Type"))
        }
    }
}

impl Into<UIElement> for ButtonControl {
    fn into(self) -> UIElement {
        self.control
    }
}

impl AsRef<UIElement> for ButtonControl {
    fn as_ref(&self) -> &UIElement {
        &self.control
    }
}

/// Wrapper a listitem element as a control.
pub struct ListItemControl {
    control: UIElement
}

impl ListItemControl {
    /// Determines whether this control is clickable.
    pub fn is_clickable(&self) -> bool {
        let element: &IUIAutomationElement = self.control.as_ref();
        let pattern = unsafe { 
            element.GetCurrentPattern(UIA_InvokePatternId)
        };
        pattern.is_ok()
    }

    /// Perform a click event on this control.
    pub fn click(&self) -> Result<()> {
        let pattern: UIInvokePattern = self.control.get_pattern()?;
        pattern.invoke()
    }

    /// Scroll this item into view.
    pub fn scroll_into_view(&self) -> Result<()> {
        let pattern: UIScrollItemPattern = self.control.get_pattern()?;
        pattern.scroll_into_view()
    }

    /// Determines whether this control is slectable.
    pub fn is_selectable(&self) -> bool {
        let element: &IUIAutomationElement = self.control.as_ref();
        let pattern = unsafe {
            element.GetCurrentPattern(UIA_SelectionItemPatternId)
        };
        pattern.is_ok()
    }

    /// Select current item.
    pub fn select(&self) -> Result<()> {
        let pattern: UISelectionItemPattern = self.control.get_pattern()?;
        pattern.select()
    }

    /// Add current item to selection.
    pub fn add_to_selection(&self) -> Result<()> {
        let pattern: UISelectionItemPattern = self.control.get_pattern()?;
        pattern.add_to_selection()
    }

    /// Remove current item from selection.
    pub fn remove_from_selection(&self) -> Result<()> {
        let pattern: UISelectionItemPattern = self.control.get_pattern()?;
        pattern.remove_from_selection()
    }

    /// Determines whether this item is selected.
    pub fn is_selected(&self) -> Result<bool> {
        let pattern: UISelectionItemPattern = self.control.get_pattern()?;
        pattern.is_selected()
    }
}

impl TryFrom<UIElement> for ListItemControl {
    type Error = Error;

    fn try_from(value: UIElement) -> Result<Self> {
        if value.get_control_type()? == UIA_ListItemControlTypeId {
            Ok(Self {
                control: value
            })
        } else {
            Err(Error::new(ERR_TYPE, "Error Control Type"))
        }
    }
}

impl Into<UIElement> for ListItemControl {
    fn into(self) -> UIElement {
        self.control
    }
}

impl AsRef<UIElement> for ListItemControl {
    fn as_ref(&self) -> &UIElement {
        &self.control
    }
}