Move X11 backend to winit-x11 (#4253)

Author: madsmtm

.github/CODEOWNERS

@@ -15,8 +15,7 @@
 /winit-wayland                      @kchibisov
 
 # X11
-/src/platform/x11.rs                @kchibisov @notgull
-/src/platform_impl/linux/x11        @kchibisov @notgull
+/winit-x11                          @kchibisov @notgull
 
 # Web
 /src/platform/web.rs                @daxpedda

.github/workflows/ci.yml

@@ -210,6 +210,10 @@ jobs:
       if: contains(matrix.platform.target, 'windows')
       run: cargo $CMD test -p winit-win32 --target=${{ matrix.platform.target }}
 
+    - name: Test winit X11
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-x11 --target=${{ matrix.platform.target }}
+
     - name: Test winit Wayland
       if: contains(matrix.platform.target, 'linux-gnu')
       run: cargo $CMD test -p winit-wayland --target=${{ matrix.platform.target }}

Cargo.toml

@@ -19,6 +19,7 @@ winit-orbital = { version = "0.0.0", path = "winit-orbital" }
 winit-uikit = { version = "0.0.0", path = "winit-uikit" }
 winit-wayland = { version = "0.0.0", path = "winit-wayland", default-features = false }
 winit-win32 = { version = "0.0.0", path = "winit-win32" }
+winit-x11 = { version = "0.0.0", path = "winit-x11" }
 
 # Core dependencies.
 bitflags = "2"
@@ -173,7 +174,7 @@ wayland-csd-adwaita = ["winit-wayland/csd-adwaita"]
 wayland-csd-adwaita-crossfont = ["winit-wayland/csd-adwaita-crossfont"]
 wayland-csd-adwaita-notitle = ["winit-wayland/csd-adwaita-notitle"]
 wayland-dlopen = ["winit-wayland/dlopen"]
-x11 = ["x11-dl", "bytemuck", "percent-encoding", "xkbcommon-dl/x11", "x11rb", "winit-common/x11"]
+x11 = ["dep:winit-x11"]
 
 [build-dependencies]
 cfg_aliases.workspace = true
@@ -298,25 +299,11 @@ winit-win32.workspace = true
 
 # Linux
 [target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_vendor = "apple"))))'.dependencies]
-bytemuck = { workspace = true, optional = true }
-calloop.workspace = true
 libc.workspace = true
-percent-encoding = { workspace = true, optional = true }
-rustix = { workspace = true, features = ["std", "system", "thread", "process"] }
+rustix = { workspace = true, features = ["std", "thread"] }
 winit-common = { workspace = true, features = ["xkb"] }
 winit-wayland = { workspace = true, optional = true, default-features = false }
-x11-dl = { workspace = true, optional = true }
-x11rb = { workspace = true, optional = true, features = [
-    "allow-unsafe-code",
-    "cursor",
-    "dl-libxcb",
-    "randr",
-    "resource_manager",
-    "sync",
-    "xinput",
-    "xkb",
-] }
-xkbcommon-dl.workspace = true
+winit-x11 = { workspace = true, optional = true }
 
 [target.'cfg(target_os = "redox")'.dependencies]
 winit-orbital.workspace = true

src/event_loop.rs

@@ -395,6 +395,29 @@ impl winit_win32::EventLoopBuilderExtWindows for EventLoopBuilder {
     }
 }
 
+#[cfg(x11_platform)]
+impl winit_x11::EventLoopExtX11 for EventLoop {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.event_loop.is_wayland()
+    }
+}
+
+#[cfg(x11_platform)]
+impl winit_x11::EventLoopBuilderExtX11 for EventLoopBuilder {
+    #[inline]
+    fn with_x11(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
 /// ```compile_error
 /// use winit::event_loop::run_on_demand::EventLoopExtRunOnDemand;
 /// use winit::event_loop::EventLoop;

src/platform/mod.rs

@@ -19,7 +19,7 @@ pub mod web;
 #[cfg(windows_platform)]
 pub use winit_win32 as windows;
 #[cfg(x11_platform)]
-pub mod x11;
+pub use winit_x11 as x11;
 
 #[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, docsrs))]
 pub mod scancode;

src/platform/startup_notify.rs

@@ -80,7 +80,7 @@ impl WindowExtStartupNotify for dyn Window + '_ {
         }
 
         #[cfg(x11_platform)]
-        if let Some(window) = self.cast_ref::<crate::platform_impl::x11::window::Window>() {
+        if let Some(window) = self.cast_ref::<crate::platform_impl::x11::Window>() {
             return window.request_activation_token();
         }
 

src/platform_impl/linux/mod.rs

@@ -7,21 +7,15 @@ use std::env;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::time::Duration;
 
-#[cfg(x11_platform)]
-use dpi::Size;
 pub(crate) use winit_common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
 use winit_core::application::ApplicationHandler;
 use winit_core::error::{EventLoopError, NotSupportedError};
 use winit_core::event_loop::pump_events::PumpStatus;
 use winit_core::event_loop::ActiveEventLoop;
-use winit_core::window::ActivationToken;
 #[cfg(wayland_platform)]
 pub(crate) use winit_wayland as wayland;
-
-#[cfg(x11_platform)]
-use crate::platform::x11::WindowType as XWindowType;
 #[cfg(x11_platform)]
-pub(crate) mod x11;
+pub(crate) use winit_x11 as x11;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum Backend {
@@ -37,59 +31,6 @@ pub(crate) struct PlatformSpecificEventLoopAttributes {
     pub(crate) any_thread: bool,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApplicationName {
-    pub general: String,
-    pub instance: String,
-}
-
-impl ApplicationName {
-    #[allow(dead_code)]
-    pub fn new(general: String, instance: String) -> Self {
-        Self { general, instance }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct PlatformSpecificWindowAttributes {
-    pub name: Option<ApplicationName>,
-    pub activation_token: Option<ActivationToken>,
-    #[cfg(x11_platform)]
-    pub x11: X11WindowAttributes,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg(x11_platform)]
-pub struct X11WindowAttributes {
-    pub visual_id: Option<x11rb::protocol::xproto::Visualid>,
-    pub screen_id: Option<i32>,
-    pub base_size: Option<Size>,
-    pub override_redirect: bool,
-    pub x11_window_types: Vec<XWindowType>,
-
-    /// The parent window to embed this window into.
-    pub embed_window: Option<x11rb::protocol::xproto::Window>,
-}
-
-#[cfg_attr(not(x11_platform), allow(clippy::derivable_impls))]
-impl Default for PlatformSpecificWindowAttributes {
-    fn default() -> Self {
-        Self {
-            name: None,
-            activation_token: None,
-            #[cfg(x11_platform)]
-            x11: X11WindowAttributes {
-                visual_id: None,
-                screen_id: None,
-                base_size: None,
-                override_redirect: false,
-                x11_window_types: vec![XWindowType::Normal],
-                embed_window: None,
-            },
-        }
-    }
-}
-
 /// `x11_or_wayland!(match expr; Enum(foo) => foo.something())`
 /// expands to the equivalent of
 /// ```ignore
@@ -242,14 +183,6 @@ impl AsRawFd for EventLoop {
     }
 }
 
-/// Returns the minimum `Option<Duration>`, taking into account that `None`
-/// equates to an infinite timeout, not a zero timeout (so can't just use
-/// `Option::min`)
-#[allow(dead_code)]
-fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
-    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
-}
-
 #[cfg(target_os = "linux")]
 fn is_main_thread() -> bool {
     rustix::thread::gettid() == rustix::process::getpid()

winit-x11/Cargo.toml

@@ -0,0 +1,48 @@
+[package]
+description = "Winit's X11 backend"
+documentation = "https://docs.rs/winit-x11"
+edition.workspace = true
+license.workspace = true
+name = "winit-x11"
+repository.workspace = true
+rust-version.workspace = true
+version = "0.0.0"
+
+[features]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]
+
+[dependencies]
+bitflags.workspace = true
+cursor-icon.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+bytemuck.workspace = true
+calloop.workspace = true
+libc.workspace = true
+percent-encoding.workspace = true
+rustix = { workspace = true, features = ["std", "system", "thread", "process"] }
+winit-common = { workspace = true, features = ["xkb", "x11"] }
+x11-dl.workspace = true
+x11rb = { workspace = true, features = [
+    "allow-unsafe-code",
+    "cursor",
+    "dl-libxcb",
+    "randr",
+    "resource_manager",
+    "sync",
+    "xinput",
+    "xkb",
+] }
+xkbcommon-dl = { workspace = true, features = ["x11"] }
+
+[dev-dependencies]
+winit.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true

winit-x11/README.md

@@ -0,0 +1 @@
+../README.md

src/platform_impl/linux/x11/activation.rs winit-x11/src/activation.rssrc/platform_impl/linux/x11/activation.rs renamed to winit-x11/src/activation.rs

@@ -10,8 +10,9 @@ use std::fmt::Write;
 
 use x11rb::protocol::xproto::{self, ConnectionExt as _};
 
-use super::atoms::*;
-use super::{VoidCookie, X11Error, XConnection};
+use crate::atoms::*;
+use crate::event_loop::{VoidCookie, X11Error};
+use crate::xdisplay::XConnection;
 
 impl XConnection {
     /// "Request" a new activation token from the server.