Clears control anchor set by Set Anchor

This means that all following keywords accessing elements will use active window or desktop as root element.

Mouse click on element matching given locator.

Exception ActionNotPossible is raised if element does not allow Click action.

Example:

Click  id:button1
Click  id:button2 offset:10,10
${element}=  Click  name:SendButton  wait_time=5.0

Closes current active window or logs a warning message.

Example:

${status}=  Close Current Window

Closes identified windows or logs the problems.

Example:

${closed_count} =     Close Window    Calculator

Get control of child window of the active window by locator.

Example:

Control Window   subname:"Sage 50" type:Window
# actions on the main application window
# ...
# get control of child window of Sage application
Control Child Window   subname:"Test Company" depth:1

Controls the window defined by the locator.

This means that this window is used as a root element for all the following keywords using locators.

Returns WindowsElement.

Example:

Control Window   Calculator
Control Window   name:Calculator
Control Window   subname:Notepad
Control Window   regex:.*Notepad
${window}=  Control Window   executable:Spotify.exe

Disables process iteration in List Windows keyword.

Double mouse click on element matching given locator.

Exception ActionNotPossible is raised if element does not allow Click action.

Example:

${element}=  Double Click  name:ResetButton

Drag and drop the source element into target element.

Example:

# copying a file, report.html, from source (File Explorer) window
# into a target (File Explorer) Window
# locator
Drag And Drop
...    name:C:\temp type:Windows > name:report.html type:ListItem
...    name:%{USERPROFILE}\Documents\artifacts type:Windows > name:"Items View"
...    copy=True

Example:

# moving *.txt files into subfolder within one (File Explorer) window
${source_dir}=    Set Variable    %{USERPROFILE}\Documents\test
Control Window    name:${source_dir}
${files}=    Find Files    ${source_dir}${/}*.txt
# first copy files to folder2
FOR    ${file}    IN    @{files}
    Drag And Drop    name:${file.name}    name:folder2 type:ListItem    copy=True
END
# second move files to folder1
FOR    ${file}    IN    @{files}
    Drag And Drop    name:${file.name}    name:folder1 type:ListItem
END

Enables process iteration in List Windows keyword.

Bring the current active window or the window defined by the locator to the foreground.

Example:

${window}=  Foreground Window   Calculator

Get attribute value of the element defined by the locator.

Example:

${id}=   Get Attribute  type:Edit name:firstname   AutomationId

Get a Control Windows element defined by the locator.

The returned element can be used instead of a locator string for other keywords accepting the locator parameter. Keyword Get Attribute can be used to read element attribute values.

If locator is None, then the returned element will be in this priority:

1. root_element if provided.
2. Anchor element if that has been previously set with Set Anchor.
3. Current active window if that has been set with Control Window.
4. Last resort is the "Desktop" element.

Example: Robot Framework

*** Tasks ***
Set Text Into Notepad Window
    Windows Run    Notepad
    Control Window      subname:Notepad
    ${element} =    Get Element    regex:"Text (E|e)ditor"
    Set Value    ${element}    note to myself

Example: Python

from RPA.Windows import Windows

lib = Windows()
lib.windows_run("calc.exe")
one_btn = lib.get_element("Calculator > path:2|3|2|8|2")
lib.close_window("Calculator")

Get a list of elements matching the locator.

By default, only the siblings (similar elements on the same level) are taken into account. In order to search globally, turn siblings_only off, but be aware that this will take more time to process.

Note that if the syntax parent_locator > child_locator is used in the locator, it is assumed that parent_locator returns a singular element - i.e. if the locator parent_locator returns multiple elements, only the first result is used for further processing, even if siblings_only is off.

For more details on the rest of parameters, take a look at the Get Element keyword.

Example: Robot Framework

*** Tasks ***
Get Headers On Same Level
    Set Anchor      id:DataGrid
    @{elements} =   Get Elements    type:HeaderItem
    FOR    ${element}    IN    @{elements}
        Log To Console    ${element.name}
    END

Get All Calculator Buttons Matching Expression
    Windows Run    Calc
    Control Window    subname:Calc
    @{buttons} =    Get Elements    class:Button regex:.*o.*
    ...     siblings_only=${False}
    Log List    ${buttons}
    ${length} =     Get Length      ${buttons}
    Log To Console      Number of buttons: ${length}

Get text from Control element defined by the locator.

Exception ActionNotPossible is raised if element does not allow GetWindowText action.

Example:

${date} =  Get Text   type:Edit name:"Date of birth"

Get the value of the element defined by the provided locator.

The ActionNotPossible exception is raised if the identified element doesn't support value retrieval.

Example: Robot Framework

${value} =   Get Value   type:DataItem name:column1

Example: Python

from RPA.Windows import Windows

lib_win = Windows()
text = lib_win.get_value("Rich Text Window")
print(text)

Get the selection state of the element defined by the provided locator.

The ActionNotPossible exception is raised if the identified element doesn't support selection item retrieval.

Example: Robot Framework

${value} =   Is Selected   type:RadioButtonControl name:Apple

Example: Python

from RPA.Windows import Windows

lib_win = Windows()
value = lib_win.is_selected("type:RadioButtonControl name:Apple")
print(value)

List all element attributes.

List all window element on the system.

Example:

${windows}=  List Windows
FOR  ${window}  IN  @{windows}
    Log  Window title:${window}[title]
    Log  Window process name:${window}[name]
    Log  Window process id:${window}[pid]
    Log  Window process handle:${window}[handle]
END

Maximize the current active window or the window defined by the locator.

Example:

${window} =    Maximize Window  # Current active window
Maximize Window    executable:Spotify.exe

Right mouse click on element matching given locator.

Exception ActionNotPossible is raised if element does not allow Click action.

Example:

${element}=  Middle Click  name:button2

Minimize the current active window or the window defined by the locator.

Example:

${window} =    Minimize Window  # Current active window
Minimize Window    executable:Spotify.exe

Print a tree of control elements.

A Windows application structure can contain multilevel element structure. Understanding this structure is crucial for creating locators. (based on controls' details and their parent-child relationship)

This keyword can be used to output logs of application's element structure, starting with the element defined by the provided locator as root. Switch the return_structure parameter to True to get a tree of elements returned as well. (off by default to save memory)

• The printed structure displays a tree prefixed with "depth" - "position" so you know how deep (0 means root) in the tree you are and on what position (1-indexed) the child you're looking for is.
• The returned structure is a dictionary with all the children flattened per depth level. Additionally, these WindowsElement objects contain a relevant locator composed of "root > path" which will help to identify the element in the tree.

Portal example: https://robocorp.com/portal/robot/robocorp/example-windows-element-path

Example: Robot Framework

*** Tasks ***
Display Element Structure
    ${tree} =   Print Tree      Calculator > path:2|3|2|8
    ...     return_structure=${True}
    Log To Console      ${tree}

Example: Python

from RPA.Windows import Windows

lib = Windows()
tree = lib.print_tree("Calculator > path:2|3|2|8", return_structure=True)
print(tree)

Window restore the current active window or the window defined by the locator.

Example:

${window} =    Restore Window  # Current active window
Restore Window    executable:Spotify.exe

Right mouse click on element matching given locator.

Exception ActionNotPossible is raised if element does not allow Click action.

Example:

${element}=  Right Click  name:MenuButton

Take a screenshot of the element defined by the locator.

An ActionNotPossible exception is raised if the element doesn't allow being captured.

Example: Robot Framework

*** Tasks ***
Take Screenshots
    Screenshot    desktop    desktop.png
    Screenshot    subname:Notepad    ${OUTPUT_DIR}${/}notepad.png

Example: Python

from RPA.Windows import Windows
lib = Windows()

def take_screenshots():
    lib.screenshot("desktop", "desktop.png")
    lib.screenshot("subname:Notepad", "output/notepad.png")

Select a value on the passed element if such action is supported.

The ActionNotPossible exception is raised when the element does not allow the Select action. This is usually used with combo box elements.

Example: Robot Framework

* Settings * Library RPA.Windows

* Tasks * Set Notepad Size

System Message: ERROR/3 (<string>, line 17)

Unexpected indentation.

Select id:FontSizeComboBox 22

Example: Python

from RPA.Windows import Windows

lib = Windows()

def set_notepad_size():
    lib.select("id:FontSizeComboBox", "22")

Send keys to desktop, current window or to Control element defined by given locator.

If locator is None then keys are sent to desktop.

Exception ActionNotPossible is raised if element does not allow SendKeys action.

Example:

Send Keys  desktop   {Ctrl}{F4}
Send Keys  keys={Ctrl}{F4}   # locator will be NONE, keys sent to desktop
Send Keys  id:input5  username   send_enter=${True}
${element}=   Get Element   id:pass
Send Keys  ${element}  password   send_enter=${True}

Set anchor to an element specified by the locator.

All following keywords using locators will use this element as a root element. Specific use case could be setting anchor to TableControl element and then getting column data belonging to that TableControl element.

To release anchor call Clear Anchor keyword.

Example:

Set Anchor  type:Table name:Orders depth:16
FOR  ${row}  IN RANGE  200
    ${number}=  Get Value   name:number row ${row}
    Exit For Loop If   $number == ${EMPTY}
    ${sum}=  Get Value   name:sum row ${row}
    Log   Order number:${number} has sum:{sum}
END
Clear Anchor

Set view focus to the element defined by the locator.

Example:

Set Focus  name:Buy type:Button

Set global timeout for element search. Applies also to Control Window keyword.

By default, the library has a timeout of 10 seconds.

Example:

${old_timeout}=  Set Global Timeout  20
${old_timeout}=  Set Global Timeout  9.5

Enable or disable mouse movement simulation during clicks and other actions.

Returns the previous set value as True/False.

Example: Robot Framework

*** Tasks ***
Disable Mouse Move
    ${previous} =   Set Mouse Movement      ${True}
    Log To Console   Previous mouse simulation: ${previous} (now enabled)

Example: Python

from RPA.Windows import Windows

lib_win = Windows()
previous = lib_win.set_mouse_movement(True)
print(f"Previous mouse simulation: {previous} (now enabled)")

Set value of the element defined by the locator.

Note: An anchor will work only on element structures where you can rely on the stability of that root/child element tree, as remaining the same. Usually these kind of structures are tables. (but not restricted to)

Note: It is important to set append=${True} if you want to keep the current text in the element. Other option is to read the current text into a variable, then modify that value as you wish and pass it to the Set Value keyword for a complete text replacement. (without setting the append flag)

The following exceptions may be raised:

• ActionNotPossible if the element does not allow the SetValue action to be run on it nor having send_keys_fallback=${True}.
• ValueError if the new value to be set can't be set correctly.

Example: Robot Framework

*** Tasks ***
Set Values In Notepad
    Set Value   type:DataItem name:column1   ab c  # Set value to "ab c"
    # Press ENTER after setting the value.
    Set Value    type:Edit name:"File name:"    console.txt   enter=${True}

    # Add newline (manually) at the end of the string. (Notepad example)
    Set Value    name:"Text Editor"  abc\n
    # Add newline with parameter.
    Set Value    name:"Text Editor"  abc   newline=${True}

    # Clear Notepad window and start appending text.
    Set Anchor  name:"Text Editor"
    # All the following keyword calls will use the anchor element as a
    #  starting point, UNLESS they specify a locator explicitly or
    #  Clear Anchor is used.
    ${time} =    Get Time
    # Clears with append=${False}. (default)
    Set Value    value=The time now is ${time}
    # Append text and add a newline at the end.
    Set Value    value= and it's the task run time.   append=${True}
    ...    newline=${True}
    # Continue appending and ensure a new line at the end by pressing
    #  the Enter key this time.
    Set Value    value=But this will appear on the 2nd line now.
    ...    append=${True}   enter=${True}   validator=${None}

Example: Python

from RPA.Windows import Windows

lib_win = Windows()
locator = "Document - WordPad > Rich Text Window"
elem = lib_win.set_value(locator, value="My text", send_keys_fallback=True)
text = lib_win.get_value(elem)
print(text)

Set library wait time for action keywords.

The wait_time is spent after each keyword performing mouse or keyboard action.

Library default wait_time is 0.5

Returns value of the previous wait_time value.

Example:

${old_wait_time}=  Set Wait Time  0.2

Use Windows Run window to launch an application.

Activated by pressing Win + R. Then the app name is typed in and finally the "Enter" key is pressed.

Example: Robot Framework

*** Tasks ***
Run Notepad
    Windows Run   notepad

Example: Python

from RPA.Windows import Windows
lib = Windows()

def run_notepad():
    lib.windows_run("notepad")

Use Windows search window to launch application.

Activated by pressing win + s.

Example:

Windows Search   Outlook