raw_window_handle/
unix.rs

1use core::ffi::{c_int, c_ulong, c_void};
2use core::num::NonZeroU32;
3use core::ptr::NonNull;
4
5/// Raw display handle for Xlib.
6#[non_exhaustive]
7#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
8pub struct XlibDisplayHandle {
9    /// A pointer to an Xlib `Display`.
10    ///
11    /// It is strongly recommended to set this value, however it may be set to
12    /// `None` to request the default display when using EGL.
13    pub display: Option<NonNull<c_void>>,
14
15    /// An X11 screen to use with this display handle.
16    ///
17    /// Note, that X11 could have multiple screens, however
18    /// graphics APIs could work only with one screen at the time,
19    /// given that multiple screens usually reside on different GPUs.
20    pub screen: c_int,
21}
22
23impl XlibDisplayHandle {
24    /// Create a new handle to a display.
25    ///
26    ///
27    /// # Example
28    ///
29    /// ```
30    /// # use core::ffi::c_void;
31    /// # use core::ptr::NonNull;
32    /// # use raw_window_handle::XlibDisplayHandle;
33    /// #
34    /// let display: NonNull<c_void>;
35    /// let screen;
36    /// # display = NonNull::from(&()).cast();
37    /// # screen = 0;
38    /// let handle = XlibDisplayHandle::new(Some(display), screen);
39    /// ```
40    pub fn new(display: Option<NonNull<c_void>>, screen: c_int) -> Self {
41        Self { display, screen }
42    }
43}
44
45/// Raw window handle for Xlib.
46#[non_exhaustive]
47#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
48pub struct XlibWindowHandle {
49    /// An Xlib `Window`.
50    pub window: c_ulong,
51    /// An Xlib visual ID, or 0 if unknown.
52    pub visual_id: c_ulong,
53}
54
55impl XlibWindowHandle {
56    /// Create a new handle to a window.
57    ///
58    ///
59    /// # Example
60    ///
61    /// ```
62    /// # use core::ffi::c_ulong;
63    /// # use raw_window_handle::XlibWindowHandle;
64    /// #
65    /// let window: c_ulong;
66    /// # window = 0;
67    /// let mut handle = XlibWindowHandle::new(window);
68    /// // Optionally set the visual ID.
69    /// handle.visual_id = 0;
70    /// ```
71    pub fn new(window: c_ulong) -> Self {
72        Self {
73            window,
74            visual_id: 0,
75        }
76    }
77}
78
79/// Raw display handle for Xcb.
80#[non_exhaustive]
81#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
82pub struct XcbDisplayHandle {
83    /// A pointer to an X server `xcb_connection_t`.
84    ///
85    /// It is strongly recommended to set this value, however it may be set to
86    /// `None` to request the default display when using EGL.
87    pub connection: Option<NonNull<c_void>>,
88
89    /// An X11 screen to use with this display handle.
90    ///
91    /// Note, that X11 could have multiple screens, however
92    /// graphics APIs could work only with one screen at the time,
93    /// given that multiple screens usually reside on different GPUs.
94    pub screen: c_int,
95}
96
97impl XcbDisplayHandle {
98    /// Create a new handle to a connection and screen.
99    ///
100    ///
101    /// # Example
102    ///
103    /// ```
104    /// # use core::ffi::c_void;
105    /// # use core::ptr::NonNull;
106    /// # use raw_window_handle::XcbDisplayHandle;
107    /// #
108    /// let connection: NonNull<c_void>;
109    /// let screen;
110    /// # connection = NonNull::from(&()).cast();
111    /// # screen = 0;
112    /// let handle = XcbDisplayHandle::new(Some(connection), screen);
113    /// ```
114    pub fn new(connection: Option<NonNull<c_void>>, screen: c_int) -> Self {
115        Self { connection, screen }
116    }
117}
118
119/// Raw window handle for Xcb.
120#[non_exhaustive]
121#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
122pub struct XcbWindowHandle {
123    /// An X11 `xcb_window_t`.
124    pub window: NonZeroU32, // Based on xproto.h
125    /// An X11 `xcb_visualid_t`.
126    pub visual_id: Option<NonZeroU32>,
127}
128
129impl XcbWindowHandle {
130    /// Create a new handle to a window.
131    ///
132    ///
133    /// # Example
134    ///
135    /// ```
136    /// # use core::num::NonZeroU32;
137    /// # use raw_window_handle::XcbWindowHandle;
138    /// #
139    /// let window: NonZeroU32;
140    /// # window = NonZeroU32::new(1).unwrap();
141    /// let mut handle = XcbWindowHandle::new(window);
142    /// // Optionally set the visual ID.
143    /// handle.visual_id = None;
144    /// ```
145    pub fn new(window: NonZeroU32) -> Self {
146        Self {
147            window,
148            visual_id: None,
149        }
150    }
151}
152
153/// Raw display handle for Wayland.
154#[non_exhaustive]
155#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
156pub struct WaylandDisplayHandle {
157    /// A pointer to a `wl_display`.
158    pub display: NonNull<c_void>,
159}
160
161impl WaylandDisplayHandle {
162    /// Create a new display handle.
163    ///
164    ///
165    /// # Example
166    ///
167    /// ```
168    /// # use core::ffi::c_void;
169    /// # use core::ptr::NonNull;
170    /// # use raw_window_handle::WaylandDisplayHandle;
171    /// #
172    /// let display: NonNull<c_void>;
173    /// # display = NonNull::from(&()).cast();
174    /// let handle = WaylandDisplayHandle::new(display);
175    /// ```
176    pub fn new(display: NonNull<c_void>) -> Self {
177        Self { display }
178    }
179}
180
181/// Raw window handle for Wayland.
182#[non_exhaustive]
183#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
184pub struct WaylandWindowHandle {
185    /// A pointer to a `wl_surface`.
186    pub surface: NonNull<c_void>,
187}
188
189impl WaylandWindowHandle {
190    /// Create a new handle to a surface.
191    ///
192    ///
193    /// # Example
194    ///
195    /// ```
196    /// # use core::ffi::c_void;
197    /// # use core::ptr::NonNull;
198    /// # use raw_window_handle::WaylandWindowHandle;
199    /// #
200    /// let surface: NonNull<c_void>;
201    /// # surface = NonNull::from(&()).cast();
202    /// let handle = WaylandWindowHandle::new(surface);
203    /// ```
204    pub fn new(surface: NonNull<c_void>) -> Self {
205        Self { surface }
206    }
207}
208
209/// Raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager.
210#[non_exhaustive]
211#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
212pub struct DrmDisplayHandle {
213    /// The drm file descriptor.
214    // TODO: Use `std::os::fd::RawFd`?
215    pub fd: i32,
216}
217
218impl DrmDisplayHandle {
219    /// Create a new handle to a file descriptor.
220    ///
221    ///
222    /// # Example
223    ///
224    /// ```
225    /// # use raw_window_handle::DrmDisplayHandle;
226    /// #
227    /// let fd: i32;
228    /// # fd = 0;
229    /// let handle = DrmDisplayHandle::new(fd);
230    /// ```
231    pub fn new(fd: i32) -> Self {
232        Self { fd }
233    }
234}
235
236/// Raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager.
237#[non_exhaustive]
238#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
239pub struct DrmWindowHandle {
240    /// The primary drm plane handle.
241    pub plane: u32,
242}
243
244impl DrmWindowHandle {
245    /// Create a new handle to a plane.
246    ///
247    ///
248    /// # Example
249    ///
250    /// ```
251    /// # use raw_window_handle::DrmWindowHandle;
252    /// #
253    /// let plane: u32;
254    /// # plane = 0;
255    /// let handle = DrmWindowHandle::new(plane);
256    /// ```
257    pub fn new(plane: u32) -> Self {
258        Self { plane }
259    }
260}
261
262/// Raw display handle for the Linux Generic Buffer Manager.
263#[non_exhaustive]
264#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
265pub struct GbmDisplayHandle {
266    /// The gbm device.
267    pub gbm_device: NonNull<c_void>,
268}
269
270impl GbmDisplayHandle {
271    /// Create a new handle to a device.
272    ///
273    ///
274    /// # Example
275    ///
276    /// ```
277    /// # use core::ffi::c_void;
278    /// # use core::ptr::NonNull;
279    /// # use raw_window_handle::GbmDisplayHandle;
280    /// #
281    /// let ptr: NonNull<c_void>;
282    /// # ptr = NonNull::from(&()).cast();
283    /// let handle = GbmDisplayHandle::new(ptr);
284    /// ```
285    pub fn new(gbm_device: NonNull<c_void>) -> Self {
286        Self { gbm_device }
287    }
288}
289
290/// Raw window handle for the Linux Generic Buffer Manager.
291#[non_exhaustive]
292#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
293pub struct GbmWindowHandle {
294    /// The gbm surface.
295    pub gbm_surface: NonNull<c_void>,
296}
297
298impl GbmWindowHandle {
299    /// Create a new handle to a surface.
300    ///
301    ///
302    /// # Example
303    ///
304    /// ```
305    /// # use core::ffi::c_void;
306    /// # use core::ptr::NonNull;
307    /// # use raw_window_handle::GbmWindowHandle;
308    /// #
309    /// let ptr: NonNull<c_void>;
310    /// # ptr = NonNull::from(&()).cast();
311    /// let handle = GbmWindowHandle::new(ptr);
312    /// ```
313    pub fn new(gbm_surface: NonNull<c_void>) -> Self {
314        Self { gbm_surface }
315    }
316}
raw_window_handle/unix.rs

raw_window_handle/
unix.rs
