From 1ca8b65e85e6fd57d56151f24be800df10e0f44f Mon Sep 17 00:00:00 2001 From: Mads Marquart Date: Thu, 1 Sep 2022 07:05:32 +0200 Subject: [PATCH] Split `platform::unix` into `platform::x11` and `platform::wayland` This also removes deprecated `WindowExtUnix::is_ready`. --- .github/CODEOWNERS | 5 +- CHANGELOG.md | 2 + src/platform/android.rs | 2 - src/platform/ios.rs | 2 - src/platform/macos.rs | 2 - src/platform/mod.rs | 38 +++++- src/platform/run_return.rs | 11 -- src/platform/wayland.rs | 176 ++++++++++++++++++++++++ src/platform/web.rs | 2 - src/platform/windows.rs | 2 - src/platform/{unix.rs => x11.rs} | 222 +++---------------------------- src/platform_impl/linux/mod.rs | 2 +- 12 files changed, 239 insertions(+), 227 deletions(-) create mode 100644 src/platform/wayland.rs rename src/platform/{unix.rs => x11.rs} (57%) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index c1a2358b..daa94dde 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -13,14 +13,15 @@ /src/platform/ios.rs @francesca64 @madsmtm /src/platform_impl/ios @francesca64 @madsmtm -# Unix in general -/src/platform/unix.rs @kchibisov +# Unix /src/platform_impl/linux/mod.rs @kchibisov # Wayland +/src/platform/wayland.rs @kchibisov /src/platform_impl/linux/wayland @kchibisov # X11 +/src/platform/x11.rs @kchibisov /src/platform_impl/linux/x11 @kchibisov # macOS diff --git a/CHANGELOG.md b/CHANGELOG.md index 47d135dc..acc85680 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,8 @@ And please only add new entries to the top of this list, right below the `# Unre # Unreleased +- **Breaking:** Split the `platform::unix` module into `platform::x11` and `platform::wayland`. The extension types are similarly renamed. +- **Breaking:**: Removed deprecated method `platform::unix::WindowExtUnix::is_ready`. - Removed `parking_lot` dependency. - On Windows, added `WindowExtWindows::set_undecorated_shadow` and `WindowBuilderExtWindows::with_undecorated_shadow` to draw the drop shadow behind a borderless window. - On Windows, fixed default window features (ie snap, animations, shake, etc.) when decorations are disabled. diff --git a/src/platform/android.rs b/src/platform/android.rs index af15f3ef..aae8c826 100644 --- a/src/platform/android.rs +++ b/src/platform/android.rs @@ -1,5 +1,3 @@ -#![cfg(any(target_os = "android"))] - use crate::{ event_loop::{EventLoop, EventLoopWindowTarget}, window::{Window, WindowBuilder}, diff --git a/src/platform/ios.rs b/src/platform/ios.rs index 9d982ac5..6254020f 100644 --- a/src/platform/ios.rs +++ b/src/platform/ios.rs @@ -1,5 +1,3 @@ -#![cfg(target_os = "ios")] - use std::os::raw::c_void; use crate::{ diff --git a/src/platform/macos.rs b/src/platform/macos.rs index 10997e52..d7fe84a2 100644 --- a/src/platform/macos.rs +++ b/src/platform/macos.rs @@ -1,5 +1,3 @@ -#![cfg(target_os = "macos")] - use std::os::raw::c_void; use crate::{ diff --git a/src/platform/mod.rs b/src/platform/mod.rs index dde4c079..f819414e 100644 --- a/src/platform/mod.rs +++ b/src/platform/mod.rs @@ -15,11 +15,47 @@ //! //! However only the module corresponding to the platform you're compiling to will be available. +#[cfg(target_os = "android")] pub mod android; +#[cfg(target_os = "ios")] pub mod ios; +#[cfg(target_os = "macos")] pub mod macos; -pub mod unix; +#[cfg(all( + feature = "wayland", + any( + target_os = "linux", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd", + ) +))] +pub mod wayland; +#[cfg(target_arch = "wasm32")] pub mod web; +#[cfg(target_os = "windows")] pub mod windows; +#[cfg(all( + feature = "x11", + any( + target_os = "linux", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd", + ) +))] +pub mod x11; +#[cfg(any( + target_os = "windows", + target_os = "macos", + target_os = "android", + target_os = "linux", + target_os = "dragonfly", + target_os = "freebsd", + target_os = "netbsd", + target_os = "openbsd" +))] pub mod run_return; diff --git a/src/platform/run_return.rs b/src/platform/run_return.rs index 5013823b..750b0416 100644 --- a/src/platform/run_return.rs +++ b/src/platform/run_return.rs @@ -1,14 +1,3 @@ -#![cfg(any( - target_os = "windows", - target_os = "macos", - target_os = "android", - target_os = "linux", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "netbsd", - target_os = "openbsd" -))] - use crate::{ event::Event, event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget}, diff --git a/src/platform/wayland.rs b/src/platform/wayland.rs new file mode 100644 index 00000000..eedcb365 --- /dev/null +++ b/src/platform/wayland.rs @@ -0,0 +1,176 @@ +use std::os::raw; + +use crate::{ + event_loop::{EventLoopBuilder, EventLoopWindowTarget}, + monitor::MonitorHandle, + window::{Window, WindowBuilder}, +}; + +use crate::platform_impl::{ + ApplicationName, Backend, EventLoopWindowTarget as LinuxEventLoopWindowTarget, + Window as LinuxWindow, +}; + +pub use crate::window::Theme; + +/// Additional methods on [`EventLoopWindowTarget`] that are specific to Wayland. +pub trait EventLoopWindowTargetExtWayland { + /// True if the [`EventLoopWindowTarget`] uses Wayland. + fn is_wayland(&self) -> bool; + + /// Returns a pointer to the `wl_display` object of wayland that is used by this + /// [`EventLoopWindowTarget`]. + /// + /// Returns `None` if the [`EventLoop`] doesn't use wayland (if it uses xlib for example). + /// + /// The pointer will become invalid when the winit [`EventLoop`] is destroyed. + /// + /// [`EventLoop`]: crate::event_loop::EventLoop + fn wayland_display(&self) -> Option<*mut raw::c_void>; +} + +impl EventLoopWindowTargetExtWayland for EventLoopWindowTarget { + #[inline] + fn is_wayland(&self) -> bool { + self.p.is_wayland() + } + + #[inline] + fn wayland_display(&self) -> Option<*mut raw::c_void> { + match self.p { + LinuxEventLoopWindowTarget::Wayland(ref p) => { + Some(p.display().get_display_ptr() as *mut _) + } + #[cfg(feature = "x11")] + _ => None, + } + } +} + +/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland. +pub trait EventLoopBuilderExtWayland { + /// Force using Wayland. + fn with_wayland(&mut self) -> &mut Self; + + /// Whether to allow the event loop to be created off of the main thread. + /// + /// By default, the window is only allowed to be created on the main + /// thread, to make platform compatibility easier. + fn with_any_thread(&mut self, any_thread: bool) -> &mut Self; +} + +impl EventLoopBuilderExtWayland for EventLoopBuilder { + #[inline] + fn with_wayland(&mut self) -> &mut Self { + self.platform_specific.forced_backend = Some(Backend::Wayland); + self + } + + #[inline] + fn with_any_thread(&mut self, any_thread: bool) -> &mut Self { + self.platform_specific.any_thread = any_thread; + self + } +} + +/// Additional methods on [`Window`] that are specific to Wayland. +pub trait WindowExtWayland { + /// Returns a pointer to the `wl_surface` object of wayland that is used by this window. + /// + /// Returns `None` if the window doesn't use wayland (if it uses xlib for example). + /// + /// The pointer will become invalid when the [`Window`] is destroyed. + fn wayland_surface(&self) -> Option<*mut raw::c_void>; + + /// Returns a pointer to the `wl_display` object of wayland that is used by this window. + /// + /// Returns `None` if the window doesn't use wayland (if it uses xlib for example). + /// + /// The pointer will become invalid when the [`Window`] is destroyed. + fn wayland_display(&self) -> Option<*mut raw::c_void>; + + /// Updates [`Theme`] of window decorations. + /// + /// You can also use `WINIT_WAYLAND_CSD_THEME` env variable to set the theme. + /// Possible values for env variable are: "dark" and light". + /// + /// When unspecified a theme is automatically selected. + fn wayland_set_csd_theme(&self, config: Theme); +} + +impl WindowExtWayland for Window { + #[inline] + fn wayland_surface(&self) -> Option<*mut raw::c_void> { + match self.window { + LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _), + #[cfg(feature = "x11")] + _ => None, + } + } + + #[inline] + fn wayland_display(&self) -> Option<*mut raw::c_void> { + match self.window { + LinuxWindow::Wayland(ref w) => Some(w.display().get_display_ptr() as *mut _), + #[cfg(feature = "x11")] + _ => None, + } + } + + #[inline] + fn wayland_set_csd_theme(&self, theme: Theme) { + #[allow(clippy::single_match)] + match self.window { + LinuxWindow::Wayland(ref w) => w.set_csd_theme(theme), + #[cfg(feature = "x11")] + _ => (), + } + } +} + +/// Additional methods on [`WindowBuilder`] that are specific to Wayland. +pub trait WindowBuilderExtWayland { + /// Build window with the given name. + /// + /// The `general` name sets an application ID, which should match the `.desktop` + /// file destributed with your program. The `instance` is a `no-op`. + /// + /// For details about application ID conventions, see the + /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id) + fn with_name(self, general: impl Into, instance: impl Into) -> Self; + + /// Build window with certain decoration [`Theme`] + /// + /// You can also use `WINIT_WAYLAND_CSD_THEME` env variable to set the theme. + /// Possible values for env variable are: "dark" and light". + /// + /// When unspecified a theme is automatically selected. + fn with_wayland_csd_theme(self, theme: Theme) -> Self; +} + +impl WindowBuilderExtWayland for WindowBuilder { + #[inline] + fn with_name(mut self, general: impl Into, instance: impl Into) -> Self { + self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into())); + self + } + + #[inline] + fn with_wayland_csd_theme(mut self, theme: Theme) -> Self { + self.platform_specific.csd_theme = Some(theme); + self + } +} + +/// Additional methods on `MonitorHandle` that are specific to Wayland. +pub trait MonitorHandleExtWayland { + /// Returns the inner identifier of the monitor. + fn native_id(&self) -> u32; +} + +impl MonitorHandleExtWayland for MonitorHandle { + #[inline] + fn native_id(&self) -> u32 { + self.inner.native_identifier() + } +} diff --git a/src/platform/web.rs b/src/platform/web.rs index 82e42db3..f78a01fb 100644 --- a/src/platform/web.rs +++ b/src/platform/web.rs @@ -1,5 +1,3 @@ -#![cfg(target_arch = "wasm32")] - //! The web target does not automatically insert the canvas element object into the web page, to //! allow end users to determine how the page should be laid out. Use the [`WindowExtWebSys`] trait //! to retrieve the canvas from the Window. Alternatively, use the [`WindowBuilderExtWebSys`] trait diff --git a/src/platform/windows.rs b/src/platform/windows.rs index 63c90ff7..d97c3678 100644 --- a/src/platform/windows.rs +++ b/src/platform/windows.rs @@ -1,5 +1,3 @@ -#![cfg(target_os = "windows")] - use std::{ffi::c_void, path::Path}; use crate::{ diff --git a/src/platform/unix.rs b/src/platform/x11.rs similarity index 57% rename from src/platform/unix.rs rename to src/platform/x11.rs index 9b027d55..05c57689 100644 --- a/src/platform/unix.rs +++ b/src/platform/x11.rs @@ -1,13 +1,4 @@ -#![cfg(any( - target_os = "linux", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "netbsd", - target_os = "openbsd" -))] - use std::os::raw; -#[cfg(feature = "x11")] use std::{ptr, sync::Arc}; use crate::{ @@ -16,31 +7,22 @@ use crate::{ window::{Window, WindowBuilder}, }; -#[cfg(feature = "x11")] use crate::dpi::Size; -#[cfg(feature = "x11")] -use crate::platform_impl::{x11::ffi::XVisualInfo, x11::XConnection, XLIB_ERROR_HOOKS}; use crate::platform_impl::{ - ApplicationName, Backend, EventLoopWindowTarget as LinuxEventLoopWindowTarget, - Window as LinuxWindow, + x11::ffi::XVisualInfo, x11::XConnection, ApplicationName, Backend, + EventLoopWindowTarget as LinuxEventLoopWindowTarget, Window as LinuxWindow, XLIB_ERROR_HOOKS, }; // TODO: stupid hack so that glutin can do its work #[doc(hidden)] -#[cfg(feature = "x11")] pub use crate::platform_impl::x11; -#[cfg(feature = "x11")] pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported}; -#[cfg(feature = "wayland")] -pub use crate::window::Theme; - /// The first argument in the provided hook will be the pointer to `XDisplay` /// and the second one the pointer to [`XErrorEvent`]. The returned `bool` is an /// indicator whether the error was handled by the callback. /// /// [`XErrorEvent`]: https://linux.die.net/man/3/xerrorevent -#[cfg(feature = "x11")] pub type XlibErrorHook = Box bool + Send + Sync>; @@ -52,7 +34,6 @@ pub type XlibErrorHook = /// /// [`unsafe`]: https://www.remlab.net/op/xlib.shtml #[inline] -#[cfg(feature = "x11")] pub fn register_xlib_error_hook(hook: XlibErrorHook) { // Append new hook. unsafe { @@ -60,47 +41,22 @@ pub fn register_xlib_error_hook(hook: XlibErrorHook) { } } -/// Additional methods on [`EventLoopWindowTarget`] that are specific to Unix. -pub trait EventLoopWindowTargetExtUnix { - /// True if the [`EventLoopWindowTarget`] uses Wayland. - #[cfg(feature = "wayland")] - fn is_wayland(&self) -> bool; - +/// Additional methods on [`EventLoopWindowTarget`] that are specific to X11. +pub trait EventLoopWindowTargetExtX11 { /// True if the [`EventLoopWindowTarget`] uses X11. - #[cfg(feature = "x11")] fn is_x11(&self) -> bool; #[doc(hidden)] - #[cfg(feature = "x11")] fn xlib_xconnection(&self) -> Option>; - - /// Returns a pointer to the `wl_display` object of wayland that is used by this - /// [`EventLoopWindowTarget`]. - /// - /// Returns `None` if the [`EventLoop`] doesn't use wayland (if it uses xlib for example). - /// - /// The pointer will become invalid when the winit [`EventLoop`] is destroyed. - /// - /// [`EventLoop`]: crate::event_loop::EventLoop - #[cfg(feature = "wayland")] - fn wayland_display(&self) -> Option<*mut raw::c_void>; } -impl EventLoopWindowTargetExtUnix for EventLoopWindowTarget { +impl EventLoopWindowTargetExtX11 for EventLoopWindowTarget { #[inline] - #[cfg(feature = "wayland")] - fn is_wayland(&self) -> bool { - self.p.is_wayland() - } - - #[inline] - #[cfg(feature = "x11")] fn is_x11(&self) -> bool { !self.p.is_wayland() } #[inline] - #[cfg(feature = "x11")] fn xlib_xconnection(&self) -> Option> { match self.p { LinuxEventLoopWindowTarget::X(ref e) => Some(e.x_connection().clone()), @@ -108,30 +64,13 @@ impl EventLoopWindowTargetExtUnix for EventLoopWindowTarget { _ => None, } } - - #[inline] - #[cfg(feature = "wayland")] - fn wayland_display(&self) -> Option<*mut raw::c_void> { - match self.p { - LinuxEventLoopWindowTarget::Wayland(ref p) => { - Some(p.display().get_display_ptr() as *mut _) - } - #[cfg(feature = "x11")] - _ => None, - } - } } -/// Additional methods on [`EventLoopBuilder`] that are specific to Unix. -pub trait EventLoopBuilderExtUnix { +/// Additional methods on [`EventLoopBuilder`] that are specific to X11. +pub trait EventLoopBuilderExtX11 { /// Force using X11. - #[cfg(feature = "x11")] fn with_x11(&mut self) -> &mut Self; - /// Force using Wayland. - #[cfg(feature = "wayland")] - fn with_wayland(&mut self) -> &mut Self; - /// Whether to allow the event loop to be created off of the main thread. /// /// By default, the window is only allowed to be created on the main @@ -139,21 +78,13 @@ pub trait EventLoopBuilderExtUnix { fn with_any_thread(&mut self, any_thread: bool) -> &mut Self; } -impl EventLoopBuilderExtUnix for EventLoopBuilder { +impl EventLoopBuilderExtX11 for EventLoopBuilder { #[inline] - #[cfg(feature = "x11")] fn with_x11(&mut self) -> &mut Self { self.platform_specific.forced_backend = Some(Backend::X); self } - #[inline] - #[cfg(feature = "wayland")] - fn with_wayland(&mut self) -> &mut Self { - self.platform_specific.forced_backend = Some(Backend::Wayland); - self - } - #[inline] fn with_any_thread(&mut self, any_thread: bool) -> &mut Self { self.platform_specific.any_thread = any_thread; @@ -161,12 +92,11 @@ impl EventLoopBuilderExtUnix for EventLoopBuilder { } } -/// Additional methods on [`Window`] that are specific to Unix. -pub trait WindowExtUnix { +/// Additional methods on [`Window`] that are specific to X11. +pub trait WindowExtX11 { /// Returns the ID of the [`Window`] xlib object that is used by this window. /// /// Returns `None` if the window doesn't use xlib (if it uses wayland for example). - #[cfg(feature = "x11")] fn xlib_window(&self) -> Option; /// Returns a pointer to the `Display` object of xlib that is used by this window. @@ -174,14 +104,11 @@ pub trait WindowExtUnix { /// Returns `None` if the window doesn't use xlib (if it uses wayland for example). /// /// The pointer will become invalid when the [`Window`] is destroyed. - #[cfg(feature = "x11")] fn xlib_display(&self) -> Option<*mut raw::c_void>; - #[cfg(feature = "x11")] fn xlib_screen_id(&self) -> Option; #[doc(hidden)] - #[cfg(feature = "x11")] fn xlib_xconnection(&self) -> Option>; /// This function returns the underlying `xcb_connection_t` of an xlib `Display`. @@ -189,47 +116,11 @@ pub trait WindowExtUnix { /// Returns `None` if the window doesn't use xlib (if it uses wayland for example). /// /// The pointer will become invalid when the [`Window`] is destroyed. - #[cfg(feature = "x11")] fn xcb_connection(&self) -> Option<*mut raw::c_void>; - - /// Returns a pointer to the `wl_surface` object of wayland that is used by this window. - /// - /// Returns `None` if the window doesn't use wayland (if it uses xlib for example). - /// - /// The pointer will become invalid when the [`Window`] is destroyed. - #[cfg(feature = "wayland")] - fn wayland_surface(&self) -> Option<*mut raw::c_void>; - - /// Returns a pointer to the `wl_display` object of wayland that is used by this window. - /// - /// Returns `None` if the window doesn't use wayland (if it uses xlib for example). - /// - /// The pointer will become invalid when the [`Window`] is destroyed. - #[cfg(feature = "wayland")] - fn wayland_display(&self) -> Option<*mut raw::c_void>; - - /// Updates [`Theme`] of window decorations. - /// - /// You can also use `WINIT_WAYLAND_CSD_THEME` env variable to set the theme. - /// Possible values for env variable are: "dark" and light" - /// - /// When unspecified a theme is automatically selected. - #[cfg(feature = "wayland")] - fn wayland_set_csd_theme(&self, config: Theme); - - /// Check if the window is ready for drawing - /// - /// It is a remnant of a previous implementation detail for the - /// wayland backend, and is no longer relevant. - /// - /// Always return `true`. - #[deprecated] - fn is_ready(&self) -> bool; } -impl WindowExtUnix for Window { +impl WindowExtX11 for Window { #[inline] - #[cfg(feature = "x11")] fn xlib_window(&self) -> Option { match self.window { LinuxWindow::X(ref w) => Some(w.xlib_window()), @@ -239,7 +130,6 @@ impl WindowExtUnix for Window { } #[inline] - #[cfg(feature = "x11")] fn xlib_display(&self) -> Option<*mut raw::c_void> { match self.window { LinuxWindow::X(ref w) => Some(w.xlib_display()), @@ -249,7 +139,6 @@ impl WindowExtUnix for Window { } #[inline] - #[cfg(feature = "x11")] fn xlib_screen_id(&self) -> Option { match self.window { LinuxWindow::X(ref w) => Some(w.xlib_screen_id()), @@ -259,7 +148,6 @@ impl WindowExtUnix for Window { } #[inline] - #[cfg(feature = "x11")] fn xlib_xconnection(&self) -> Option> { match self.window { LinuxWindow::X(ref w) => Some(w.xlib_xconnection()), @@ -269,7 +157,6 @@ impl WindowExtUnix for Window { } #[inline] - #[cfg(feature = "x11")] fn xcb_connection(&self) -> Option<*mut raw::c_void> { match self.window { LinuxWindow::X(ref w) => Some(w.xcb_connection()), @@ -277,58 +164,17 @@ impl WindowExtUnix for Window { _ => None, } } - - #[inline] - #[cfg(feature = "wayland")] - fn wayland_surface(&self) -> Option<*mut raw::c_void> { - match self.window { - LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _), - #[cfg(feature = "x11")] - _ => None, - } - } - - #[inline] - #[cfg(feature = "wayland")] - fn wayland_display(&self) -> Option<*mut raw::c_void> { - match self.window { - LinuxWindow::Wayland(ref w) => Some(w.display().get_display_ptr() as *mut _), - #[cfg(feature = "x11")] - _ => None, - } - } - - #[inline] - #[cfg(feature = "wayland")] - fn wayland_set_csd_theme(&self, theme: Theme) { - #[allow(clippy::single_match)] - match self.window { - LinuxWindow::Wayland(ref w) => w.set_csd_theme(theme), - #[cfg(feature = "x11")] - _ => (), - } - } - - #[inline] - fn is_ready(&self) -> bool { - true - } } -/// Additional methods on [`WindowBuilder`] that are specific to Unix. -pub trait WindowBuilderExtUnix { - #[cfg(feature = "x11")] +/// Additional methods on [`WindowBuilder`] that are specific to X11. +pub trait WindowBuilderExtX11 { fn with_x11_visual(self, visual_infos: *const T) -> Self; - #[cfg(feature = "x11")] fn with_x11_screen(self, screen_id: i32) -> Self; /// Build window with the given `general` and `instance` names. /// - /// On Wayland, the `general` name sets an application ID, which should match the `.desktop` - /// file destributed with your program. The `instance` is a `no-op`. - /// - /// On X11, the `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the + /// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "general", "instance"`. /// /// For details about application ID conventions, see the @@ -336,39 +182,26 @@ pub trait WindowBuilderExtUnix { fn with_name(self, general: impl Into, instance: impl Into) -> Self; /// Build window with override-redirect flag; defaults to false. Only relevant on X11. - #[cfg(feature = "x11")] fn with_override_redirect(self, override_redirect: bool) -> Self; /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`. Only relevant on X11. - #[cfg(feature = "x11")] fn with_x11_window_type(self, x11_window_type: Vec) -> Self; /// Build window with `_GTK_THEME_VARIANT` hint set to the specified value. Currently only relevant on X11. - #[cfg(feature = "x11")] fn with_gtk_theme_variant(self, variant: String) -> Self; - /// Build window with certain decoration [`Theme`] - /// - /// You can also use `WINIT_WAYLAND_CSD_THEME` env variable to set the theme. - /// Possible values for env variable are: "dark" and light" - /// - /// When unspecified a theme is automatically selected. - #[cfg(feature = "wayland")] - fn with_wayland_csd_theme(self, theme: Theme) -> Self; - /// Build window with resize increment hint. Only implemented on X11. /// /// ``` /// # use winit::dpi::{LogicalSize, PhysicalSize}; /// # use winit::window::WindowBuilder; - /// # use winit::platform::unix::WindowBuilderExtUnix; + /// # use winit::platform::x11::WindowBuilderExtX11; /// // Specify the size in logical dimensions like this: /// WindowBuilder::new().with_resize_increments(LogicalSize::new(400.0, 200.0)); /// /// // Or specify the size in physical dimensions like this: /// WindowBuilder::new().with_resize_increments(PhysicalSize::new(400, 200)); /// ``` - #[cfg(feature = "x11")] fn with_resize_increments>(self, increments: S) -> Self; /// Build window with base size hint. Only implemented on X11. @@ -376,20 +209,18 @@ pub trait WindowBuilderExtUnix { /// ``` /// # use winit::dpi::{LogicalSize, PhysicalSize}; /// # use winit::window::WindowBuilder; - /// # use winit::platform::unix::WindowBuilderExtUnix; + /// # use winit::platform::x11::WindowBuilderExtX11; /// // Specify the size in logical dimensions like this: /// WindowBuilder::new().with_base_size(LogicalSize::new(400.0, 200.0)); /// /// // Or specify the size in physical dimensions like this: /// WindowBuilder::new().with_base_size(PhysicalSize::new(400, 200)); /// ``` - #[cfg(feature = "x11")] fn with_base_size>(self, base_size: S) -> Self; } -impl WindowBuilderExtUnix for WindowBuilder { +impl WindowBuilderExtX11 for WindowBuilder { #[inline] - #[cfg(feature = "x11")] fn with_x11_visual(mut self, visual_infos: *const T) -> Self { { self.platform_specific.visual_infos = @@ -399,7 +230,6 @@ impl WindowBuilderExtUnix for WindowBuilder { } #[inline] - #[cfg(feature = "x11")] fn with_x11_screen(mut self, screen_id: i32) -> Self { self.platform_specific.screen_id = Some(screen_id); self @@ -412,55 +242,43 @@ impl WindowBuilderExtUnix for WindowBuilder { } #[inline] - #[cfg(feature = "x11")] fn with_override_redirect(mut self, override_redirect: bool) -> Self { self.platform_specific.override_redirect = override_redirect; self } #[inline] - #[cfg(feature = "x11")] fn with_x11_window_type(mut self, x11_window_types: Vec) -> Self { self.platform_specific.x11_window_types = x11_window_types; self } #[inline] - #[cfg(feature = "x11")] fn with_gtk_theme_variant(mut self, variant: String) -> Self { self.platform_specific.gtk_theme_variant = Some(variant); self } #[inline] - #[cfg(feature = "wayland")] - fn with_wayland_csd_theme(mut self, theme: Theme) -> Self { - self.platform_specific.csd_theme = Some(theme); - self - } - - #[inline] - #[cfg(feature = "x11")] fn with_resize_increments>(mut self, increments: S) -> Self { self.platform_specific.resize_increments = Some(increments.into()); self } #[inline] - #[cfg(feature = "x11")] fn with_base_size>(mut self, base_size: S) -> Self { self.platform_specific.base_size = Some(base_size.into()); self } } -/// Additional methods on `MonitorHandle` that are specific to Linux. -pub trait MonitorHandleExtUnix { +/// Additional methods on `MonitorHandle` that are specific to X11. +pub trait MonitorHandleExtX11 { /// Returns the inner identifier of the monitor. fn native_id(&self) -> u32; } -impl MonitorHandleExtUnix for MonitorHandle { +impl MonitorHandleExtX11 for MonitorHandle { #[inline] fn native_id(&self) -> u32 { self.inner.native_identifier() diff --git a/src/platform_impl/linux/mod.rs b/src/platform_impl/linux/mod.rs index 79ca7a32..a4ced5af 100644 --- a/src/platform_impl/linux/mod.rs +++ b/src/platform_impl/linux/mod.rs @@ -30,7 +30,7 @@ pub use self::x11::XNotSupported; #[cfg(feature = "x11")] use self::x11::{ffi::XVisualInfo, util::WindowType as XWindowType, XConnection, XError}; #[cfg(feature = "x11")] -use crate::platform::unix::XlibErrorHook; +use crate::platform::x11::XlibErrorHook; #[cfg(feature = "wayland")] use crate::window::Theme; use crate::{