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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Tests for Animation System functionality

#[cfg(feature = "xaml-islands")]
mod animation_tests {
    use winrt_xaml::xaml_native::{XamlDoubleAnimation, XamlColorAnimation, XamlStoryboard};

    #[test]
    fn test_storyboard_create() {
        let storyboard = XamlStoryboard::new();
        assert!(storyboard.is_ok(), "Should create Storyboard");
    }

    #[test]
    fn test_double_animation_create() {
        let animation = XamlDoubleAnimation::new();
        assert!(animation.is_ok(), "Should create DoubleAnimation");
    }

    #[test]
    fn test_double_animation_set_from() {
        let animation = XamlDoubleAnimation::new().unwrap();
        let result = animation.set_from(0.0);
        assert!(result.is_ok(), "Should set from value");
    }

    #[test]
    fn test_double_animation_set_to() {
        let animation = XamlDoubleAnimation::new().unwrap();
        let result = animation.set_to(100.0);
        assert!(result.is_ok(), "Should set to value");
    }

    #[test]
    fn test_double_animation_set_duration() {
        let animation = XamlDoubleAnimation::new().unwrap();
        let result = animation.set_duration_ms(500);
        assert!(result.is_ok(), "Should set duration");
    }

    #[test]
    fn test_double_animation_builder() {
        let animation = XamlDoubleAnimation::builder()
            .from(0.0)
            .to(100.0)
            .duration_ms(300)
            .build();

        assert!(animation.is_ok(), "Should build animation with builder pattern");
    }

    #[test]
    fn test_color_animation_create() {
        let animation = XamlColorAnimation::new();
        assert!(animation.is_ok(), "Should create ColorAnimation");
    }

    #[test]
    fn test_color_animation_set_from() {
        let animation = XamlColorAnimation::new().unwrap();
        let result = animation.set_from(0xFFFF0000); // Red
        assert!(result.is_ok(), "Should set from color");
    }

    #[test]
    fn test_color_animation_set_to() {
        let animation = XamlColorAnimation::new().unwrap();
        let result = animation.set_to(0xFF00FF00); // Green
        assert!(result.is_ok(), "Should set to color");
    }

    #[test]
    fn test_color_animation_set_duration() {
        let animation = XamlColorAnimation::new().unwrap();
        let result = animation.set_duration_ms(500);
        assert!(result.is_ok(), "Should set duration");
    }

    #[test]
    fn test_color_animation_builder() {
        let animation = XamlColorAnimation::builder()
            .from(0xFFFF0000)
            .to(0xFF00FF00)
            .duration_ms(400)
            .build();

        assert!(animation.is_ok(), "Should build color animation with builder pattern");
    }

    #[test]
    fn test_storyboard_add_animation() {
        let storyboard = XamlStoryboard::new().unwrap();
        let animation = XamlDoubleAnimation::new().unwrap();

        let result = storyboard.add_animation(&animation);
        assert!(result.is_ok(), "Should add animation to storyboard");
    }

    #[test]
    fn test_storyboard_add_color_animation() {
        let storyboard = XamlStoryboard::new().unwrap();
        let animation = XamlColorAnimation::new().unwrap();

        let result = storyboard.add_color_animation(&animation);
        assert!(result.is_ok(), "Should add color animation to storyboard");
    }

    #[test]
    fn test_default_storyboard() {
        let storyboard = XamlStoryboard::default();

        // Should be able to use the default storyboard
        let animation = XamlDoubleAnimation::new().unwrap();
        let result = storyboard.add_animation(&animation);
        assert!(result.is_ok(), "Default storyboard should be usable");
    }

    #[test]
    fn test_default_double_animation() {
        let animation = XamlDoubleAnimation::default();

        // Should be able to configure the default animation
        let result = animation.set_from(0.0);
        assert!(result.is_ok(), "Default animation should be usable");
    }

    #[test]
    fn test_default_color_animation() {
        let animation = XamlColorAnimation::default();

        // Should be able to configure the default animation
        let result = animation.set_from(0xFFFFFFFF);
        assert!(result.is_ok(), "Default color animation should be usable");
    }

    #[test]
    fn test_multiple_animations_in_storyboard() {
        let storyboard = XamlStoryboard::new().unwrap();

        let anim1 = XamlDoubleAnimation::builder()
            .from(0.0)
            .to(100.0)
            .duration_ms(300)
            .build()
            .unwrap();

        let anim2 = XamlDoubleAnimation::builder()
            .from(1.0)
            .to(0.0)
            .duration_ms(500)
            .build()
            .unwrap();

        assert!(storyboard.add_animation(&anim1).is_ok());
        assert!(storyboard.add_animation(&anim2).is_ok());
    }
}