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
133

//! # WinRT-XAML
//!
//! A Rust library for creating UIs using WinRT and XAML.
//!
//! This library provides a safe, idiomatic Rust interface to Windows Runtime (WinRT)
//! XAML APIs, enabling the creation of modern Windows applications with XAML-based UIs.
//!
//! ## Features
//!
//! - **Application Management**: Easy application lifecycle management
//! - **Window Management**: Create and manage windows with XAML content
//! - **XAML Controls**: Rich set of UI controls (Button, TextBlock, TextBox, etc.)
//! - **Layout Panels**: Flexible layout system (StackPanel, Grid, Canvas)
//! - **Event Handling**: Type-safe event subscription and handling
//! - **Data Binding**: Reactive data binding support
//! - **XAML Parsing**: Runtime and compile-time XAML parsing
//! - **Compile-Time XAML**: `xaml!` macro for zero-cost abstractions
//! - **Styling**: Resource dictionaries and style management
//!
//! ## Example
//!
//! ```rust,no_run
//! use winrt_xaml::prelude::*;
//!
//! fn main() -> Result<()> {
//!     let app = Application::new()?;
//!
//!     let window = Window::new()?
//!         .title("My XAML App")
//!         .size(800, 600);
//!
//!     let button = Button::new()
//!         .content("Click Me!")
//!         .on_click(|_| {
//!             println!("Button clicked!");
//!         });
//!
//!     window.set_content(button)?;
//!     app.run()
//! }
//! ```
//!
//! ## XAML Islands
//!
//! For desktop (Win32) applications, this library uses XAML Islands to host
//! XAML content within traditional windows. Enable the `xaml-islands` feature
//! (enabled by default) to use this functionality.

#![cfg(windows)]
#![warn(missing_docs)]
#![warn(rust_2018_idioms)]

#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod winrt;
pub mod xaml_native;

#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod xaml_islands;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod app;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod controls;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod error;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod events;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod layout;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod media;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod resources;
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod window;

/// Reactive state management and data binding.
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod reactive;

// Re-export windows crate for advanced usage
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub use windows;

/// Prelude module for convenient imports
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub mod prelude {
    pub use crate::app::Application;
    pub use crate::controls::*;
    pub use crate::error::{Error, Result};
    pub use crate::events::*;
    pub use crate::layout::{self, *};
    pub use crate::media::*;
    pub use crate::resources::*;
    pub use crate::window::Window;

    // Re-export WinRT XAML types
    #[cfg(feature = "xaml-islands")]
    pub use crate::xaml_native::{
        ImageStretch, ListViewSelectionMode, ScrollBarVisibility, ScrollMode, XamlButton,
        XamlCheckBox, XamlComboBox, XamlGrid, XamlImage, XamlListView, XamlManager,
        XamlProgressBar, XamlRadioButton, XamlScrollViewer, XamlSlider, XamlSource,
        XamlStackPanel, XamlTextBlock, XamlTextBox, XamlUIElement,
    };

    // Re-export reactive types
    #[cfg(any(feature = "xaml-islands", feature = "uwp"))]
    pub use crate::reactive::{Property, ObservableCollection, Computed, CollectionChange};
}

/// Re-export of the Result type with our Error
#[cfg(any(feature = "xaml-islands", feature = "uwp"))]
pub type Result<T> = std::result::Result<T, error::Error>;

// Re-export the compile-time XAML macro
/// Compile-time XAML parsing macro.
///
/// Parses XAML at compile time and generates Rust code to create WinRT controls.
///
/// # Example
///
/// ```rust,ignore
/// use winrt_xaml::xaml;
///
/// let button = xaml! {
///     r#"<Button Content="Click Me"
///               Width="200"
///               Height="50"
///               Background="#FF0078D4"
///               Foreground="#FFFFFFFF"
///               CornerRadius="8" />"#
/// };
/// ```
pub use winrt_xaml_macros::xaml;