ui-automation 0.1.1

Control the User Interface, cross-platform.
Documentation 
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

// Copyright (C) 2024 Tristan Gerritsen <tristan@thewoosh.org>
// All Rights Reserved.

use std::{error::Error, fmt::Display};

use thiserror::Error;

pub type UIResult<T> = Result<T, UIError>;

#[derive(Debug)]
pub struct UIError {
    pub(crate) kind: UIErrorKind,
}

impl UIError {
    #[must_use]
    pub fn kind(&self) -> &UIErrorKind {
        &self.kind
    }
}

impl Display for UIError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.kind.fmt(f)
    }
}

impl Error for UIError {}

#[derive(Debug, PartialEq, Eq, Error)]
pub enum UIErrorKind {
    #[error("failed to allocate a platform-dependent resource: {resource}")]
    AllocationFailed { resource: &'static str },

    #[error("cannot inspect system window")]
    CannotInspectSystemWindow,

    #[error("failed to convert between platform-specific types: {description}")]
    ConversionError{ description: &'static str },

    #[error("feature `{feature:?}` disabled")]
    FeatureDisabled { feature: UIFeature },

    #[error("platform issue: {issue}")]
    PlatformIssue { issue: &'static str },

    #[error("the current platform is not supported")]
    PlatformNotSupported,

    #[error("the process has no windows")]
    ProcessHasNoWindows,
}

impl From<UIErrorKind> for UIError {
    fn from(value: UIErrorKind) -> Self {
        Self {
            kind: value,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UIFeature {
    Accessibility,
}