Struct CaptureOptions 

#[non_exhaustive]
pub struct CaptureOptions {
    pub include_tree: bool,
    pub include_screenshot: bool,
    pub text_limit: Option<usize>,
    pub max_nodes: usize,
    pub max_depth: usize,
    pub max_screenshot_dimension: Option<u32>,
    pub launch_if_needed: bool,
}

Limits and toggles for Computer::get_app_state.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

include_tree: bool

Walk the accessibility tree. Disabling this invalidates element indexes.

include_screenshot: bool

Capture a screenshot. Disabling this prevents coordinate-based actions.

text_limit: Option<usize>

Maximum characters kept per text attribute; None keeps everything.

max_nodes: usize

Maximum number of raw accessibility nodes visited.

max_depth: usize

Maximum tree depth visited.

max_screenshot_dimension: Option<u32>

Screenshots larger than this on either side are downscaled; None keeps full resolution.

launch_if_needed: bool

Launch the app (without activating it) if it is installed but not running.

Implementations

impl CaptureOptions

pub const fn include_tree(self, yes: bool) -> Self

Sets include_tree.

pub const fn include_screenshot(self, yes: bool) -> Self

Sets include_screenshot.

Examples found in repository

examples/textedit.rs (line 20)

fn main() -> computer_use::Result<()> {
    use std::time::Duration;

    use computer_use::{
        CaptureOptions, ClickMethod, ClickOptions, ClickTarget, Computer, ElementQuery, Error, TextSelection,
    };

    const APP: &str = "TextEdit";
    let mut computer = Computer::new()?.settle_delay(Duration::from_millis(300));
    let tree_only = CaptureOptions::default().include_screenshot(false);

    let state = computer.get_app_state(APP, &tree_only)?;
    let new_doc = state.find(&ElementQuery::text("New Document").with_role("button").exact(true)).next();
    if let Some(button) = new_doc.map(|e| e.index) {
        println!(
            "click New Document: {:?}",
            computer.click(APP, ClickTarget::Element(button), ClickOptions::default())?
        );
    }

    let state = computer.get_app_state(APP, &tree_only)?;
    let text_area = state
        .find(&ElementQuery::role("AXTextArea"))
        .next()
        .map(|e| e.index)
        .ok_or_else(|| Error::StateUnavailable("no text area".into()))?;
    println!(
        "click text area {text_area}: {:?}",
        computer.click(APP, ClickTarget::Element(text_area), ClickOptions::default())?
    );
    computer.set_value(APP, text_area, "")?;
    computer.type_text(APP, "Hello from computer-use-rs!\nSecond line.")?;

    let state = computer.get_app_state(APP, &tree_only)?;
    let value = state.find(&ElementQuery::role("AXTextArea")).next().and_then(|e| e.value.clone());
    println!("text area now contains: {value:?}");

    computer.select_text(APP, text_area, &TextSelection::new("computer-use-rs"))?;
    let state = computer.get_app_state(APP, &tree_only)?;
    println!("selected text: {:?}", state.selected_text);

    computer.press_key(APP, "BackSpace")?;
    let state = computer.get_app_state(APP, &tree_only)?;
    let value = state.find(&ElementQuery::role("AXTextArea")).next().and_then(|e| e.value.clone());
    println!("after BackSpace: {value:?}");

    computer.press_key(APP, "super+a")?;
    let state = computer.get_app_state(APP, &tree_only)?;
    println!("after super+a, selected: {:?}", state.selected_text);

    let focused = ClickOptions::default().method(ClickMethod::FocusedBackground);
    println!("focused click: {:?}", computer.click(APP, ClickTarget::Element(text_area), focused)?);
    computer.type_text(APP, " The end.")?;
    let state = computer.get_app_state(APP, &tree_only)?;
    let value = state.find(&ElementQuery::role("AXTextArea")).next().and_then(|e| e.value.clone());
    println!("final text: {value:?}");

    Ok(())
}

pub const fn text_limit(self, limit: Option<usize>) -> Self

Sets text_limit.

pub const fn max_nodes(self, max: usize) -> Self

Sets max_nodes.

pub const fn max_depth(self, max: usize) -> Self

Sets max_depth.

pub const fn max_screenshot_dimension(self, max: Option<u32>) -> Self

Sets max_screenshot_dimension.

pub const fn launch_if_needed(self, yes: bool) -> Self

Sets launch_if_needed.

Trait Implementations

impl Clone for CaptureOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CaptureOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CaptureOptions

fn default() -> Self

Returns the “default value” for a type.

impl Eq for CaptureOptions

impl PartialEq for CaptureOptions

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CaptureOptions