sdl3 0.18.0

Bindings to SDL3, a cross-platform library to abstract the platform-specific details for building applications.
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

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

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

    #[cfg(target_os = "windows")]
    #[test]
    fn get_windows_handle() {
        use raw_window_handle::RawDisplayHandle;

        let window = new_hidden_window();
        let window_handle = match window.window_handle() {
            Ok(v) => v,
            Err(err) => panic!(
                "Received error while getting window handle for Windows: {:?}",
                err
            ),
        };
        let raw_handle = match window_handle.as_raw() {
            RawWindowHandle::Win32(v) => v,
            x => panic!("Received wrong RawWindowHandle type for Windows: {:?}", x),
        };
        assert_ne!(raw_handle.hwnd.get(), 0);
        println!("Successfully received Windows RawWindowHandle!");
        let display_handle = match window.display_handle() {
            Ok(v) => v,
            Err(err) => panic!(
                "Received error while getting display handle for Windows: {:?}",
                err
            ),
        };
        match display_handle.as_raw() {
            RawDisplayHandle::Windows(_) => {}
            x => panic!("Received wrong RawDisplayHandle type for Windows: {:?}", x),
        }
        println!("Successfully received Windows RawDisplayHandle!");
    }

    #[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().unwrap().as_raw() {
            RawWindowHandle::Xlib(x11_handle) => {
                assert_ne!(x11_handle.window, 0, "Window for X11 should not be 0");
                println!("Successfully received linux X11 RawWindowHandle!");
            }
            RawWindowHandle::Wayland(wayland_handle) => {
                assert_ne!(
                    wayland_handle.surface.as_ptr(),
                    std::ptr::null_mut(),
                    "Surface for Wayland should not be null"
                );
                println!("Successfully received linux Wayland RawWindowHandle!");
            }
            x => assert!(
                false,
                "Received wrong RawWindowHandle type for linux: {:?}",
                x
            ),
        }
        match window.display_handle().unwrap().as_raw() {
            RawDisplayHandle::Xlib(x11_display) => {
                assert_ne!(
                    x11_display.display.unwrap().as_ptr(),
                    std::ptr::null_mut(),
                    "Display for X11 should not be null"
                );
            }
            RawDisplayHandle::Wayland(wayland_display) => {
                assert_ne!(
                    wayland_display.display.as_ptr(),
                    std::ptr::null_mut(),
                    "Display for Wayland should not be null"
                );
            }
            x => assert!(
                false,
                "Received wrong RawDisplayHandle type for linux: {:?}",
                x
            ),
        }
    }

    #[cfg(target_os = "macos")]
    #[test]
    fn get_macos_handle() {
        let window = new_hidden_window();
        let window_handle = match window.window_handle() {
            Ok(v) => v,
            Err(err) => panic!(
                "Received error while getting window handle for MacOs: {:?}",
                err
            ),
        };
        match window_handle.as_raw() {
            RawWindowHandle::AppKit(macos_handle) => {
                assert!(
                    !macos_handle.ns_view.as_ptr().is_null(),
                    "ns_view should not be null"
                );
            }
            x => assert!(
                false,
                "Received wrong RawWindowHandle type for macOS: {:?}",
                x
            ),
        }
        let display_handle = match window.display_handle() {
            Ok(v) => v,
            Err(err) => panic!(
                "Received error while getting display handle for MacOS: {:?}",
                err
            ),
        };
        match display_handle.as_raw() {
            RawDisplayHandle::AppKit(_) => {}
            x => assert!(
                false,
                "Received wrong RawDisplayHandle type for macOS: {:?}",
                x
            ),
        }
    }

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