winrt-xaml 1.0.0

A Rust library for creating modern Windows UIs using WinRT and XAML with reactive data binding
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
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

//! Error types for WinRT-XAML.

use thiserror::Error;

/// Result type alias using our Error type.
pub type Result<T> = std::result::Result<T, Error>;

/// Error type for WinRT-XAML operations.
#[derive(Error, Debug)]
pub enum Error {
    /// Windows API error
    #[error("Windows API error: {0}")]
    WindowsError(String),

    /// Window creation failed
    #[error("Failed to create window: {0}")]
    WindowCreation(String),

    /// Control creation failed
    #[error("Failed to create control: {0}")]
    ControlCreation(String),

    /// XAML parsing error
    #[error("XAML parse error: {0}")]
    XamlParse(String),

    /// Resource not found
    #[error("Resource not found: {0}")]
    ResourceNotFound(String),

    /// Invalid operation
    #[error("Invalid operation: {0}")]
    InvalidOperation(String),

    /// Not implemented
    #[error("Feature not implemented: {0}")]
    NotImplemented(String),

    /// Application error
    #[error("Application error: {0}")]
    Application(String),

    /// Initialization error
    #[error("Initialization error: {0}")]
    Initialization(String),

    /// Synchronization error.
    #[error("Synchronization error: {0}")]
    Synchronization(String),

    /// I/O error
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    /// UTF-8 conversion error
    #[error("UTF-8 error: {0}")]
    Utf8(#[from] std::string::FromUtf8Error),

    /// Other error
    #[error("{0}")]
    Other(String),
}

impl Error {
    /// Create a Windows API error.
    pub fn windows(msg: impl Into<String>) -> Self {
        Self::WindowsError(msg.into())
    }

    /// Create a window creation error.
    pub fn window_creation(msg: impl Into<String>) -> Self {
        Self::WindowCreation(msg.into())
    }

    /// Create a control creation error.
    pub fn control_creation(msg: impl Into<String>) -> Self {
        Self::ControlCreation(msg.into())
    }

    /// Create a XAML parse error.
    pub fn xaml_parse(msg: impl Into<String>) -> Self {
        Self::XamlParse(msg.into())
    }

    /// Create a resource not found error.
    pub fn resource_not_found(msg: impl Into<String>) -> Self {
        Self::ResourceNotFound(msg.into())
    }

    /// Create an invalid operation error.
    pub fn invalid_operation(msg: impl Into<String>) -> Self {
        Self::InvalidOperation(msg.into())
    }

    /// Create a not implemented error.
    pub fn not_implemented(msg: impl Into<String>) -> Self {
        Self::NotImplemented(msg.into())
    }

    /// Create an application error.
    pub fn application(msg: impl Into<String>) -> Self {
        Self::Application(msg.into())
    }

    /// Create an initialization error.
    pub fn initialization(msg: impl Into<String>) -> Self {
        Self::Initialization(msg.into())
    }

    /// Create a synchronization error.
    pub fn synchronization(msg: impl Into<String>) -> Self {
        Self::Synchronization(msg.into())
    }
}

impl From<windows::core::Error> for Error {
    fn from(err: windows::core::Error) -> Self {
        Error::WindowsError(format!("{:?}", err))
    }
}

impl From<&str> for Error {
    fn from(s: &str) -> Self {
        Error::Other(s.to_string())
    }
}

impl From<String> for Error {
    fn from(s: String) -> Self {
        Error::Other(s)
    }
}