summaryrefslogtreecommitdiffstats
path: root/third_party/rust/raw-window-handle/src/unix.rs
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/raw-window-handle/src/unix.rs')
-rw-r--r--third_party/rust/raw-window-handle/src/unix.rs316
1 files changed, 316 insertions, 0 deletions
diff --git a/third_party/rust/raw-window-handle/src/unix.rs b/third_party/rust/raw-window-handle/src/unix.rs
new file mode 100644
index 0000000000..259fed35b9
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/unix.rs
@@ -0,0 +1,316 @@
+use core::ffi::{c_int, c_ulong, c_void};
+use core::num::NonZeroU32;
+use core::ptr::NonNull;
+
+/// Raw display handle for Xlib.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XlibDisplayHandle {
+ /// A pointer to an Xlib `Display`.
+ ///
+ /// It is strongly recommended to set this value, however it may be set to
+ /// `None` to request the default display when using EGL.
+ pub display: Option<NonNull<c_void>>,
+
+ /// An X11 screen to use with this display handle.
+ ///
+ /// Note, that X11 could have multiple screens, however
+ /// graphics APIs could work only with one screen at the time,
+ /// given that multiple screens usually reside on different GPUs.
+ pub screen: c_int,
+}
+
+impl XlibDisplayHandle {
+ /// Create a new handle to a display.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::XlibDisplayHandle;
+ /// #
+ /// let display: NonNull<c_void>;
+ /// let screen;
+ /// # display = NonNull::from(&()).cast();
+ /// # screen = 0;
+ /// let handle = XlibDisplayHandle::new(Some(display), screen);
+ /// ```
+ pub fn new(display: Option<NonNull<c_void>>, screen: c_int) -> Self {
+ Self { display, screen }
+ }
+}
+
+/// Raw window handle for Xlib.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XlibWindowHandle {
+ /// An Xlib `Window`.
+ pub window: c_ulong,
+ /// An Xlib visual ID, or 0 if unknown.
+ pub visual_id: c_ulong,
+}
+
+impl XlibWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_ulong;
+ /// # use raw_window_handle::XlibWindowHandle;
+ /// #
+ /// let window: c_ulong;
+ /// # window = 0;
+ /// let mut handle = XlibWindowHandle::new(window);
+ /// // Optionally set the visual ID.
+ /// handle.visual_id = 0;
+ /// ```
+ pub fn new(window: c_ulong) -> Self {
+ Self {
+ window,
+ visual_id: 0,
+ }
+ }
+}
+
+/// Raw display handle for Xcb.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XcbDisplayHandle {
+ /// A pointer to an X server `xcb_connection_t`.
+ ///
+ /// It is strongly recommended to set this value, however it may be set to
+ /// `None` to request the default display when using EGL.
+ pub connection: Option<NonNull<c_void>>,
+
+ /// An X11 screen to use with this display handle.
+ ///
+ /// Note, that X11 could have multiple screens, however
+ /// graphics APIs could work only with one screen at the time,
+ /// given that multiple screens usually reside on different GPUs.
+ pub screen: c_int,
+}
+
+impl XcbDisplayHandle {
+ /// Create a new handle to a connection and screen.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::XcbDisplayHandle;
+ /// #
+ /// let connection: NonNull<c_void>;
+ /// let screen;
+ /// # connection = NonNull::from(&()).cast();
+ /// # screen = 0;
+ /// let handle = XcbDisplayHandle::new(Some(connection), screen);
+ /// ```
+ pub fn new(connection: Option<NonNull<c_void>>, screen: c_int) -> Self {
+ Self { connection, screen }
+ }
+}
+
+/// Raw window handle for Xcb.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XcbWindowHandle {
+ /// An X11 `xcb_window_t`.
+ pub window: NonZeroU32, // Based on xproto.h
+ /// An X11 `xcb_visualid_t`.
+ pub visual_id: Option<NonZeroU32>,
+}
+
+impl XcbWindowHandle {
+ /// Create a new handle to a window.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::num::NonZeroU32;
+ /// # use raw_window_handle::XcbWindowHandle;
+ /// #
+ /// let window: NonZeroU32;
+ /// # window = NonZeroU32::new(1).unwrap();
+ /// let mut handle = XcbWindowHandle::new(window);
+ /// // Optionally set the visual ID.
+ /// handle.visual_id = None;
+ /// ```
+ pub fn new(window: NonZeroU32) -> Self {
+ Self {
+ window,
+ visual_id: None,
+ }
+ }
+}
+
+/// Raw display handle for Wayland.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WaylandDisplayHandle {
+ /// A pointer to a `wl_display`.
+ pub display: NonNull<c_void>,
+}
+
+impl WaylandDisplayHandle {
+ /// Create a new display handle.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WaylandDisplayHandle;
+ /// #
+ /// let display: NonNull<c_void>;
+ /// # display = NonNull::from(&()).cast();
+ /// let handle = WaylandDisplayHandle::new(display);
+ /// ```
+ pub fn new(display: NonNull<c_void>) -> Self {
+ Self { display }
+ }
+}
+
+/// Raw window handle for Wayland.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WaylandWindowHandle {
+ /// A pointer to a `wl_surface`.
+ pub surface: NonNull<c_void>,
+}
+
+impl WaylandWindowHandle {
+ /// Create a new handle to a surface.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::WaylandWindowHandle;
+ /// #
+ /// let surface: NonNull<c_void>;
+ /// # surface = NonNull::from(&()).cast();
+ /// let handle = WaylandWindowHandle::new(surface);
+ /// ```
+ pub fn new(surface: NonNull<c_void>) -> Self {
+ Self { surface }
+ }
+}
+
+/// Raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DrmDisplayHandle {
+ /// The drm file descriptor.
+ // TODO: Use `std::os::fd::RawFd`?
+ pub fd: i32,
+}
+
+impl DrmDisplayHandle {
+ /// Create a new handle to a file descriptor.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::DrmDisplayHandle;
+ /// #
+ /// let fd: i32;
+ /// # fd = 0;
+ /// let handle = DrmDisplayHandle::new(fd);
+ /// ```
+ pub fn new(fd: i32) -> Self {
+ Self { fd }
+ }
+}
+
+/// Raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DrmWindowHandle {
+ /// The primary drm plane handle.
+ pub plane: u32,
+}
+
+impl DrmWindowHandle {
+ /// Create a new handle to a plane.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use raw_window_handle::DrmWindowHandle;
+ /// #
+ /// let plane: u32;
+ /// # plane = 0;
+ /// let handle = DrmWindowHandle::new(plane);
+ /// ```
+ pub fn new(plane: u32) -> Self {
+ Self { plane }
+ }
+}
+
+/// Raw display handle for the Linux Generic Buffer Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GbmDisplayHandle {
+ /// The gbm device.
+ pub gbm_device: NonNull<c_void>,
+}
+
+impl GbmDisplayHandle {
+ /// Create a new handle to a device.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::GbmDisplayHandle;
+ /// #
+ /// let ptr: NonNull<c_void>;
+ /// # ptr = NonNull::from(&()).cast();
+ /// let handle = GbmDisplayHandle::new(ptr);
+ /// ```
+ pub fn new(gbm_device: NonNull<c_void>) -> Self {
+ Self { gbm_device }
+ }
+}
+
+/// Raw window handle for the Linux Generic Buffer Manager.
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GbmWindowHandle {
+ /// The gbm surface.
+ pub gbm_surface: NonNull<c_void>,
+}
+
+impl GbmWindowHandle {
+ /// Create a new handle to a surface.
+ ///
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// # use core::ffi::c_void;
+ /// # use core::ptr::NonNull;
+ /// # use raw_window_handle::GbmWindowHandle;
+ /// #
+ /// let ptr: NonNull<c_void>;
+ /// # ptr = NonNull::from(&()).cast();
+ /// let handle = GbmWindowHandle::new(ptr);
+ /// ```
+ pub fn new(gbm_surface: NonNull<c_void>) -> Self {
+ Self { gbm_surface }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-18 00:59:21 +0000