sdl2 0.38.0

SDL2 bindings for Rust
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
157
158
159
160

#[cfg(feature = "raw-window-handle")]
mod raw_window_handle_test {
    extern crate raw_window_handle;
    extern crate sdl2;

    use self::raw_window_handle::{
        HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle,
    };
    use self::sdl2::video::Window;

    #[cfg(target_os = "windows")]
    #[test]
    fn get_windows_handle() {
        let window = new_hidden_window();
        match window.window_handle() {
            Ok(window_handle) => match window_handle.as_raw() {
                RawWindowHandle::Win32(_) => {
                    println!("Successfully received Win32 window handle")
                }
                RawWindowHandle::WinRt(_) => {
                    println!("Successfully received WinRt window handle")
                }
                raw_handle => {
                    assert!(
                        false,
                        "Wrong window handle type for Windows: {:?}",
                        raw_handle
                    )
                }
            },
            Err(e) => {
                assert!(false, "Failed to recieve window handle on Windows: {:?}", e)
            }
        }
        match window.display_handle() {
            Ok(display_handle) => match display_handle.as_raw() {
                RawDisplayHandle::Windows(_) => {
                    println!("Successfully received Windows display handle")
                }
                raw_handle => {
                    assert!(
                        false,
                        "Wrong display handle type for Windows: {:?}",
                        raw_handle
                    )
                }
            },
            Err(e) => {
                assert!(
                    false,
                    "Failed to recieve display handle on Windows: {:?}",
                    e
                )
            }
        }
    }

    #[cfg(any(
        target_os = "linux",
        target_os = "dragonfly",
        target_os = "freebsd",
        target_os = "netbsd",
        target_os = "openbsd",
    ))]
    #[test]
    fn get_linux_handle() {
        let window = new_hidden_window();
        match window.window_handle() {
            Ok(handle) => match handle.as_raw() {
                RawWindowHandle::Xlib(_) => {
                    println!("Successfully received X11 window handle")
                }
                RawWindowHandle::Wayland(_) => {
                    println!("Successfully received Wayland window handle")
                }
                raw_handle => {
                    assert!(
                        false,
                        "Wrong window handle type for Linux: {:?}",
                        raw_handle
                    )
                }
            },
            Err(e) => {
                assert!(false, "Failed to recieve window handle on Linux: {:?}", e)
            }
        }
        match window.display_handle() {
            Ok(handle) => match handle.as_raw() {
                RawDisplayHandle::Xlib(_) => {
                    println!("Successfully recieved X11 display handle")
                }
                RawDisplayHandle::Wayland(_) => {
                    println!("Successfully recieved Wayland display handle")
                }
                raw_handle => {
                    assert!(
                        false,
                        "Wrong display handle type for Linux: {:?}",
                        raw_handle
                    )
                }
            },
            Err(e) => {
                assert!(false, "Failed to recieve display handle on Linux: {:?}", e)
            }
        }
    }

    #[cfg(target_os = "macos")]
    #[test]
    fn get_macos_handle() {
        let window = new_hidden_window();
        match window.window_handle() {
            Ok(handle) => match handle.as_raw() {
                RawWindowHandle::AppKit(_) => {
                    println!("Successfully recieved AppKit window handle")
                }
                raw_handle => {
                    assert!(
                        false,
                        "Wrong window handle type for macOS: {:?}",
                        raw_handle
                    )
                }
            },
            Err(e) => {
                assert!(false, "Failed to recieve window handle on macOS: {:?}", e)
            }
        };
        match window.display_handle() {
            Ok(handle) => match handle.as_raw() {
                RawDisplayHandle::AppKit(_) => {
                    println!("Successfully recieved AppKit display handle")
                }
                raw_handle => {
                    assert!(
                        false,
                        "Wrong display handle type for macOS: {:?}",
                        raw_handle
                    )
                }
            },
            Err(e) => {
                assert!(false, "Failed to recieve display handle on macOS: {:?}", e)
            }
        }
    }

    pub fn new_hidden_window() -> Window {
        let context = sdl2::init().unwrap();
        let video_subsystem = context.video().unwrap();
        video_subsystem
            .window("Hello, World!", 800, 600)
            .hidden()
            .metal_view()
            .build()
            .unwrap()
    }
}