computeruse-rs 2.0.0

A Playwright-style SDK for automating desktop GUI applications
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

use std::time::Duration;
use computeruse::Desktop;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt::init();
    let desktop = Desktop::new_default()?;

    // Open notepad
    let app = desktop.open_application("notepad.exe")?;
    println!("Notepad opened successfully.");

    // Define a locator for the main text area in Notepad.
    // On Windows, this is often an "Edit" control, but on newer versions it might be "RichEditD2DPT"
    let editor_locator = desktop.locator("ClassName:Edit");
    let editor_locator_alt = desktop.locator("ClassName:RichEditD2DPT");

    // Test 1: Find the editor, expecting it to be visible.
    println!("Searching for visible editor...");
    let visible_editor = match editor_locator
        .visible(true)
        .first(Some(Duration::from_secs(2)))
        .await
    {
        Ok(element) => Ok(element),
        Err(_) => {
            editor_locator_alt
                .visible(true)
                .first(Some(Duration::from_secs(3)))
                .await
        }
    };

    match visible_editor {
        Ok(element) => {
            println!(
                "SUCCESS: Found visible editor: {:?}",
                element.name().unwrap_or_default()
            );
        }
        Err(e) => {
            println!("FAILURE: Did not find visible editor: {e}");
        }
    }

    // Test 2: Search for the editor with visible:false, expecting it to fail.
    println!("\nSearching for a non-visible editor (this should time out)...");
    let non_visible_editor = match editor_locator
        .visible(false)
        .first(Some(Duration::from_secs(2)))
        .await
    {
        Ok(element) => Ok(element),
        Err(_) => {
            editor_locator_alt
                .visible(false)
                .first(Some(Duration::from_secs(3)))
                .await
        }
    };

    match non_visible_editor {
        Ok(element) => {
            println!(
                "FAILURE: Found an element that should not be visible: {:?}",
                element.name().unwrap_or_default()
            );
        }
        Err(e) => {
            println!("SUCCESS: Correctly failed to find non-visible editor: {e}");
        }
    }

    // Close notepad
    app.close()?;
    println!("\nNotepad closed.");

    Ok(())
}