From 42d8ea4656c2fb78f78b1f2d24ee713d4d9ad367 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 10:43:55 -0700 Subject: [PATCH] refactor(kde): remove the Shared wrapper, KDE's Backend extends the shared one komorebi-for-kde's Backend is now `trait Backend: komorebi_backend::Backend` and declares only what is KDE's own: drag_origin and drag_end, apply_look, set_border_colours, set_wallpaper and shutdown. The 26 operations that have shared names and semantics (docs/dev/seam.md section 2.1) are the shared trait's; KWinBackend and the KDE FakeBackend implement it directly (supports() is true for every capability, batches are the default no-ops) and the backend::shared module with its Shared adapter is deleted. The shared contract tests (check_all and the KDE-specific assertions) now run against FakeBackend itself. Integration tests import the shared trait to call the fake's operations. No behaviour change. Coverage removed with the duplicated declarations: the doc examples of the KDE set_opacity and set_focus_follows_mouse (the fake tests and the shared contract still exercise both) and the 'id too wide for u32' wrapper test (the same rule is in KWinBackend raw()). Verified: KDE cargo test --workspace --no-fail-fast, 878 passed, 0 failed (native, FakeBackend; was 881 before this revision, the 3 removed tests are the ones named above). Not run: KDE VM suites. --- komorebi-for-kde/komorebi/src/backend/fake.rs | 149 +++++++--- komorebi-for-kde/komorebi/src/backend/mod.rs | 258 +----------------- .../komorebi/src/backend/shared.rs | 223 --------------- komorebi-for-kde/komorebi/src/desktop.rs | 6 +- komorebi-for-kde/komorebi/src/kwin/mod.rs | 57 ++-- .../komorebi/src/process_command.rs | 10 +- komorebi-for-kde/komorebi/src/window.rs | 2 +- komorebi-for-kde/komorebi/tests/drag_swap.rs | 2 +- .../komorebi/tests/maximize_commands.rs | 2 +- komorebi-for-kde/komorebi/tests/monitors.rs | 2 +- komorebi-for-kde/komorebi/tests/monocle.rs | 2 +- komorebi-for-kde/komorebi/tests/stacks.rs | 2 +- komorebi-for-kde/komorebi/tests/workspaces.rs | 2 +- 13 files changed, 176 insertions(+), 541 deletions(-) delete mode 100644 komorebi-for-kde/komorebi/src/backend/shared.rs diff --git a/komorebi-for-kde/komorebi/src/backend/fake.rs b/komorebi-for-kde/komorebi/src/backend/fake.rs index 6967c5e9..8fb3af2f 100644 --- a/komorebi-for-kde/komorebi/src/backend/fake.rs +++ b/komorebi-for-kde/komorebi/src/backend/fake.rs @@ -9,7 +9,7 @@ //! # Example //! //! ```rust -//! use komorebi::backend::Backend; +//! use komorebi_backend::Backend; //! use komorebi::backend::fake::Command; //! use komorebi::backend::fake::FakeBackend; //! use komorebi::core::Rect; @@ -45,7 +45,6 @@ use komorebi_backend::MonitorId; use komorebi_backend::WindowId; use komorebi_backend::fake::Command as SharedCommand; use parking_lot::Mutex; -use shared::Backend as SharedBackend; use std::collections::HashMap; use std::path::Path; use std::path::PathBuf; @@ -53,40 +52,40 @@ use std::path::PathBuf; /// A command the window manager sent to the backend. #[derive(Clone, Debug, PartialEq)] pub enum Command { - /// [`Backend::set_rect`]: the window and the rectangle it was asked to take. + /// [`komorebi_backend::Backend::set_rect`]: the window and the rectangle it was asked to take. SetRect(u32, Rect), - /// [`Backend::focus`]: the window, and whether the pointer was to follow. + /// [`komorebi_backend::Backend::focus`]: the window, and whether the pointer was to follow. Focus(u32, bool), - /// [`Backend::raise`]. + /// [`komorebi_backend::Backend::raise`]. Raise(u32), - /// [`Backend::hide`]. + /// [`komorebi_backend::Backend::hide`]. Hide(u32), - /// [`Backend::restore`]. + /// [`komorebi_backend::Backend::restore`]. Restore(u32), - /// [`Backend::minimize`]. + /// [`komorebi_backend::Backend::minimize`]. Minimize(u32), - /// [`Backend::unminimize`]. + /// [`komorebi_backend::Backend::unminimize`]. Unminimize(u32), - /// [`Backend::close`]. + /// [`komorebi_backend::Backend::close`]. Close(u32), - /// [`Backend::center_cursor_in`]. + /// [`komorebi_backend::Backend::center_cursor_in`]. CenterCursor(Rect), - /// [`Backend::ensure_workspaces`]: how many workspaces were asked for. + /// [`komorebi_backend::Backend::ensure_workspaces`]: how many workspaces were asked for. EnsureWorkspaces(usize), - /// [`Backend::maximize`]: the window, and whether it was to be maximized or restored. + /// [`komorebi_backend::Backend::maximize`]: the window, and whether it was to be maximized or restored. Maximize(u32, bool), - /// [`Backend::switch_workspace`]: the monitor, and the workspace it was asked to show. + /// [`komorebi_backend::Backend::switch_workspace`]: the monitor, and the workspace it was asked to show. SwitchWorkspace(u32, usize), - /// [`Backend::set_window_workspace`]: the window, and the workspace it was put on. + /// [`komorebi_backend::Backend::set_window_workspace`]: the window, and the workspace it was put on. SetWindowWorkspace(u32, usize), /// [`Backend::apply_look`]: the look, when it is not the one applied before. ApplyLook(Look), /// [`Backend::set_border_colours`]: the colors of each window's border, when they are not the /// ones given before. BorderColours(Vec<(u32, u32)>), - /// [`Backend::set_opacity`]: the window, and how opaque it was asked to be. + /// [`komorebi_backend::Backend::set_opacity`]: the window, and how opaque it was asked to be. SetOpacity(u32, u8), - /// [`Backend::set_focus_follows_mouse`]: whether it was turned on or off. + /// [`komorebi_backend::Backend::set_focus_follows_mouse`]: whether it was turned on or off. FocusFollowsMouse(bool), /// [`Backend::set_wallpaper`]: the monitor, and the picture it was asked to show. SetWallpaper(u32, PathBuf), @@ -252,7 +251,7 @@ impl FakeBackend { self.kde.lock().drag_ends.insert(id, rect); } - /// Gives a window a minimum size. A [`Backend::set_rect`] for something smaller leaves it at + /// Gives a window a minimum size. A [`komorebi_backend::Backend::set_rect`] for something smaller leaves it at /// the minimum, which is how a GTK4 client answers. pub fn set_min_size(&self, id: u32, width: i32, height: i32) { self.inner.set_min_size(wid(id), width, height); @@ -299,7 +298,7 @@ impl FakeBackend { self.inner.rect_of(wid(id)) } - /// Returns true if and only if the window is hidden ([`Backend::hide`]), as opposed to being + /// Returns true if and only if the window is hidden ([`komorebi_backend::Backend::hide`]), as opposed to being /// on a workspace that is not showing. pub fn is_hidden(&self, id: u32) -> bool { self.inner.is_hidden(wid(id)) @@ -382,7 +381,7 @@ impl FakeBackend { } } -impl Backend for FakeBackend { +impl komorebi_backend::Backend for FakeBackend { fn windows(&self) -> Vec { self.inner.windows() } @@ -403,10 +402,6 @@ impl Backend for FakeBackend { self.inner.cursor_pos() } - fn drag_end(&self, id: WindowId) -> Option { - self.kde.lock().drag_ends.get(&raw(id)).copied() - } - fn set_rect(&self, id: WindowId, rect: &Rect) -> shared::Result<()> { self.inner.set_rect(id, rect) } @@ -467,6 +462,24 @@ impl Backend for FakeBackend { self.inner.maximize(id, maximize) } + fn set_focus_follows_mouse(&self, enable: bool) -> shared::Result<()> { + self.inner.set_focus_follows_mouse(enable) + } + + fn set_opacity(&self, id: WindowId, alpha: u8) -> shared::Result<()> { + self.inner.set_opacity(id, alpha) + } + + fn supports(&self, _capability: komorebi_backend::Capability) -> bool { + true + } +} + +impl Backend for FakeBackend { + fn drag_end(&self, id: WindowId) -> Option { + self.kde.lock().drag_ends.get(&raw(id)).copied() + } + fn apply_look(&self, look: &Look) -> eyre::Result { let mut kde = self.kde.lock(); // like a real backend, remember what was applied and say nothing twice @@ -477,10 +490,6 @@ impl Backend for FakeBackend { Ok(kde.borders_drawn && look.border.is_some()) } - fn set_focus_follows_mouse(&self, enable: bool) -> shared::Result<()> { - self.inner.set_focus_follows_mouse(enable) - } - fn set_wallpaper(&self, monitor_id: MonitorId, path: &Path) -> eyre::Result<()> { self.kde .lock() @@ -493,10 +502,6 @@ impl Backend for FakeBackend { Ok(()) } - fn set_opacity(&self, id: WindowId, alpha: u8) -> shared::Result<()> { - self.inner.set_opacity(id, alpha) - } - fn set_border_colours(&self, colours: &[(u32, u32)]) -> eyre::Result { let mut kde = self.kde.lock(); let colours_now: HashMap = colours.iter().copied().collect(); @@ -513,6 +518,7 @@ impl Backend for FakeBackend { #[cfg(test)] mod tests { use super::*; + use komorebi_backend::Backend as _; fn tile(left: i32, width: i32) -> Rect { Rect { @@ -962,3 +968,82 @@ mod tests { Ok(()) } } + +/// The KDE fake is a [`komorebi_backend::Backend`] itself, and passes what every backend has to. +#[cfg(test)] +mod shared_contract { + use super::*; + use komorebi_backend::Backend as _; + use komorebi_backend::Capability; + use komorebi_backend::Error; + use komorebi_backend::contract::Harness; + use komorebi_backend::contract::check_all; + + struct KdeFake(FakeBackend); + + impl Harness for KdeFake { + type B = FakeBackend; + + fn new() -> Self { + Self(FakeBackend::with_one_monitor()) + } + + fn backend(&self) -> &Self::B { + &self.0 + } + + fn open_window(&self, seed: u32) -> WindowId { + self.0.open_window(seed, "foot", "foot", "a terminal"); + WindowId::from_u32(seed) + } + + fn destroy_window(&self, id: WindowId) { + self.0.close_window_now(id.to_u32().expect("a KDE id")); + } + } + + #[test] + fn the_kde_fake_passes_the_shared_contract() { + check_all::(); + } + + #[test] + fn kde_is_the_first_implementation_and_supports_every_capability() { + let kde = KdeFake::new(); + + for capability in Capability::ALL { + assert!(kde.backend().supports(capability)); + } + } + + #[test] + fn a_command_about_a_window_that_is_gone_is_window_gone_and_other_failures_are_not() { + let kde = KdeFake::new(); + let id = kde.open_window(4); + + let gone = kde.backend().focus(WindowId::from_u32(9), false); + + assert!(matches!(gone, Err(Error::WindowGone(WindowId(9))))); + assert_eq!(gone.unwrap_err().to_string(), "no such window: 9"); + assert!(kde.backend().focus(id, false).is_ok()); + } + + #[test] + fn every_field_kde_knows_comes_through() { + let kde = KdeFake::new(); + let id = kde.open_window(4); + + let info = kde.backend().window(id).expect("window 4 was opened"); + + assert_eq!(info.id, id); + assert_eq!(info.class.as_deref(), Some("foot")); + assert_eq!(info.normal, Some(true)); + assert_eq!(info.fullscreen, Some(false)); + assert_eq!( + kde.backend().monitors().expect("one monitor")[0] + .name + .as_deref(), + Some("Virtual-0") + ); + } +} diff --git a/komorebi-for-kde/komorebi/src/backend/mod.rs b/komorebi-for-kde/komorebi/src/backend/mod.rs index 1eb88569..9d5afa53 100644 --- a/komorebi-for-kde/komorebi/src/backend/mod.rs +++ b/komorebi-for-kde/komorebi/src/backend/mod.rs @@ -24,16 +24,16 @@ //! # Workspaces //! //! komorebi's workspaces are the compositor's virtual desktops, per monitor: the window manager -//! asks for workspace `i` to be shown on a monitor ([`Backend::switch_workspace`]) and for a window -//! to be put on workspace `i` ([`Backend::set_window_workspace`]), and the compositor does the +//! asks for workspace `i` to be shown on a monitor ([`komorebi_backend::Backend::switch_workspace`]) and for a window +//! to be put on workspace `i` ([`komorebi_backend::Backend::set_window_workspace`]), and the compositor does the //! showing, the hiding and the focusing. When something else changes what a monitor shows, the //! backend raises an event and the window manager follows it. //! //! # Hiding //! //! The one thing the window manager hides itself is the back of a stack: a container tiles one -//! window, so the others in it are taken out of sight ([`Backend::hide`]) and brought back -//! ([`Backend::restore`]) when they are given the tile. A hidden window stays alive, stays on its +//! window, so the others in it are taken out of sight ([`komorebi_backend::Backend::hide`]) and brought back +//! ([`komorebi_backend::Backend::restore`]) when they are given the tile. A hidden window stays alive, stays on its //! workspace and is not minimized, so what the compositor reports about it is not taken for the //! user's doing (the window manager keeps a table of the windows it has hidden). //! @@ -59,7 +59,6 @@ use std::path::Path; use std::sync::Arc; pub mod fake; -pub mod shared; /// What the compositor currently knows about one window. #[derive(Clone, Debug, Default, PartialEq)] @@ -84,7 +83,7 @@ pub struct WindowInfo { /// manager leaves it where it is. pub fullscreen: bool, /// Whether the window is maximized, whether by the user (the title bar, a double click, a - /// shortcut) or because komorebi asked ([`Backend::maximize`]). + /// shortcut) or because komorebi asked ([`komorebi_backend::Backend::maximize`]). pub maximized: bool, /// Whether the compositor considers this a normal application window, as opposed to a dialog, /// a splash screen, a utility window, a dock and so on. @@ -243,17 +242,17 @@ pub struct BorderLook { /// /// # Contract /// -/// - Queries never block on the compositor and never fail, except [`Backend::monitors`], which may +/// - Queries never block on the compositor and never fail, except [`komorebi_backend::Backend::monitors`], which may /// fail when the compositor cannot say. /// - A command about a window that does not exist, or is no longer alive, returns an error. It does /// not panic. /// - A backend is `Send + Sync`: the window manager calls it from several threads. /// - Workspace `i` is the compositor's virtual desktop `i` on every monitor, and each monitor shows -/// one of them at a time ([`Backend::switch_workspace`]). The compositor shows the windows of the +/// one of them at a time ([`komorebi_backend::Backend::switch_workspace`]). The compositor shows the windows of the /// workspace in front and hides the others; the window manager never hides a window to leave a /// workspace. -/// - A hidden window ([`Backend::hide`]) is still alive and still on its workspace: it is out of -/// sight until [`Backend::restore`], and [`Backend::window_workspace`] names the workspace it +/// - A hidden window ([`komorebi_backend::Backend::hide`]) is still alive and still on its workspace: it is out of +/// sight until [`komorebi_backend::Backend::restore`], and [`komorebi_backend::Backend::window_workspace`] names the workspace it /// comes back to. /// - A backend asked to show a workspace, or to put a window on one, that has no desktop yet makes /// the desktops up to it first. @@ -275,55 +274,16 @@ pub struct BorderLook { /// /// ```rust,compile_fail,E0277 /// # use std::rc::Rc; -/// # use color_eyre::eyre; /// # use komorebi::backend::Backend; /// # use komorebi::core::Rect; /// # use komorebi_backend::{MonitorId, WindowId}; /// struct NotShareable(Rc); /// -/// # impl Backend for NotShareable { -/// # fn windows(&self) -> Vec { vec![] } -/// # fn window(&self, _: WindowId) -> Option { None } -/// # fn foreground_window(&self) -> Option { None } -/// # fn monitors(&self) -> komorebi_backend::Result> { Ok(vec![]) } -/// # fn cursor_pos(&self) -> Option<(i32, i32)> { None } -/// # fn set_rect(&self, _: WindowId, _: &Rect) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn focus(&self, _: WindowId, _: bool) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn raise(&self, _: WindowId) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn hide(&self, _: WindowId) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn restore(&self, _: WindowId) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn minimize(&self, _: WindowId) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn unminimize(&self, _: WindowId) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn close(&self, _: WindowId) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn center_cursor_in(&self, _: &Rect) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn ensure_workspaces(&self, _: &[String]) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn switch_workspace(&self, _: MonitorId, _: usize) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn set_window_workspace(&self, _: WindowId, _: usize) -> komorebi_backend::Result<()> { Ok(()) } -/// # fn window_workspace(&self, _: WindowId) -> komorebi_backend::Result> { Ok(None) } -/// # fn current_workspaces(&self) -> komorebi_backend::Result> { Ok(vec![]) } -/// # } +/// # impl komorebi_backend::Backend for NotShareable {} +/// impl Backend for NotShareable {} /// ``` -pub trait Backend: Send + Sync + 'static { - // ---- queries ------------------------------------------------------------------------------- - - /// Returns every window on the desktop that is a candidate for management, ordered by id. - fn windows(&self) -> Vec; - - /// Returns what is known about the window, or `None` if the compositor has never heard of it. - fn window(&self, id: WindowId) -> Option; - - /// Returns the id of the window that has the focus, if any window does. - fn foreground_window(&self) -> Option; - - /// Returns every connected monitor. - /// - /// # Errors - /// - /// When the compositor cannot report its outputs. - fn monitors(&self) -> komorebi_backend::Result>; - - /// Returns where the pointer is, if the compositor says. - fn cursor_pos(&self) -> Option<(i32, i32)>; +pub trait Backend: komorebi_backend::Backend + 'static { + // ---- drag frames: KWin remembers them, and the shared trait has no place for them ---------- /// Returns the frame the window had when the user last began to drag it, if the backend has /// kept it. @@ -380,82 +340,6 @@ pub trait Backend: Send + Sync + 'static { None } - // ---- commands ------------------------------------------------------------------------------ - - /// Moves and resizes the window to `rect`, a position and a size. - /// - /// A client may refuse the size (a minimum size, for one), so the frame the window ends up with - /// is [`Backend::window_rect`], not `rect`. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn set_rect(&self, id: WindowId, rect: &Rect) -> komorebi_backend::Result<()>; - - /// Gives the window the focus, and, if `mouse_follows_focus`, puts the pointer in its middle. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn focus(&self, id: WindowId, mouse_follows_focus: bool) -> komorebi_backend::Result<()>; - - /// Raises the window above the others. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn raise(&self, id: WindowId) -> komorebi_backend::Result<()>; - - /// Takes the window out of sight without closing or minimizing it, which is how the window - /// manager keeps the back of a stack out of the way. On KWin it goes to a virtual desktop that - /// nobody looks at. - /// - /// The window stays on its workspace ([`Backend::window_workspace`]), and - /// [`Backend::set_window_workspace`] changes the workspace it comes back to, not where it is - /// hidden. A window that is hidden already is left as it is. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive, or the compositor cannot make the - /// place the window is hidden in. - fn hide(&self, id: WindowId) -> komorebi_backend::Result<()>; - - /// Brings a hidden window back, to the workspace it is on. A window that is not hidden is left - /// as it is. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn restore(&self, id: WindowId) -> komorebi_backend::Result<()>; - - /// Minimizes the window. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn minimize(&self, id: WindowId) -> komorebi_backend::Result<()>; - - /// Brings a minimized window back. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn unminimize(&self, id: WindowId) -> komorebi_backend::Result<()>; - - /// Asks the window to close. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn close(&self, id: WindowId) -> komorebi_backend::Result<()>; - - /// Puts the pointer in the middle of `rect`. - /// - /// # Errors - /// - /// When the compositor refuses to move the pointer. - fn center_cursor_in(&self, rect: &Rect) -> komorebi_backend::Result<()>; - // ---- workspaces ---------------------------------------------------------------------------- // // komorebi's workspaces are the compositor's own virtual desktops: workspace `i` is desktop `i` @@ -464,41 +348,6 @@ pub trait Backend: Send + Sync + 'static { // follows the compositor when something else (a pager, a shortcut, an app raising a window) // changes what a monitor shows. - /// Makes sure there are at least as many desktops as `names`, creating the missing ones with - /// those names. - /// - /// A desktop that is already there keeps its name, unless nobody chose it (the compositor's - /// own "Desktop 2"), in which case it may take the name it is given. - /// - /// # Errors - /// - /// When the compositor refuses to create or rename a desktop. - fn ensure_workspaces(&self, names: &[String]) -> komorebi_backend::Result<()>; - - /// Shows workspace `idx` on the monitor `monitor_id`, leaving the other monitors as they are. - /// - /// The compositor shows the windows on that workspace, hides the rest, and gives the focus to a - /// window of that workspace by itself. - /// - /// # Errors - /// - /// When there is no desktop for `idx` and one cannot be made. - fn switch_workspace(&self, monitor_id: MonitorId, idx: usize) -> komorebi_backend::Result<()>; - - /// Puts a window on workspace `idx`. It is visible at once to [`Backend::window_workspace`]. - /// - /// # Errors - /// - /// When the window does not exist, or there is no desktop for `idx` and one cannot be made. - fn set_window_workspace(&self, id: WindowId, idx: usize) -> komorebi_backend::Result<()>; - - /// Returns the workspace a window is on, or `None` for a window the compositor does not know or - /// that is on every workspace. - fn window_workspace(&self, id: WindowId) -> komorebi_backend::Result>; - - /// Returns the workspace each monitor shows, as `(monitor id, workspace index)`. - fn current_workspaces(&self) -> komorebi_backend::Result>; - // ---- look, which a backend that draws nothing need not say anything about -------------------- /// Asks the compositor to draw this look, and returns true if and only if window borders are @@ -573,55 +422,6 @@ pub trait Backend: Send + Sync + 'static { Ok(false) } - /// Asks the compositor to draw the window with this opacity: 255 is not see-through at all. - /// The default does nothing. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - /// - /// # Example - /// - /// ```rust - /// use komorebi::backend::Backend; - /// use komorebi::backend::fake::FakeBackend; - /// - /// let fake = FakeBackend::with_one_monitor(); - /// fake.open_window(7, "foot", "foot", "a terminal"); - /// assert_eq!(fake.opacity_of(7), 255); - /// - /// fake.set_opacity(7.into(), 150)?; - /// assert_eq!(fake.opacity_of(7), 150); - /// # Ok::<(), color_eyre::eyre::Report>(()) - /// ``` - fn set_opacity(&self, _id: WindowId, _alpha: u8) -> komorebi_backend::Result<()> { - Ok(()) - } - - /// Asks the compositor to give the focus to the window under the pointer, as the pointer moves - /// (`true`), or to stop doing that and go back to the focus policy the user had (`false`). The - /// default does nothing. - /// - /// # Errors - /// - /// When the compositor's configuration cannot be changed. - /// - /// # Example - /// - /// ```rust - /// use komorebi::backend::Backend; - /// use komorebi::backend::fake::Command; - /// use komorebi::backend::fake::FakeBackend; - /// - /// let fake = FakeBackend::with_one_monitor(); - /// fake.set_focus_follows_mouse(true)?; - /// assert_eq!(fake.commands(), [Command::FocusFollowsMouse(true)]); - /// # Ok::<(), color_eyre::eyre::Report>(()) - /// ``` - fn set_focus_follows_mouse(&self, _enable: bool) -> komorebi_backend::Result<()> { - Ok(()) - } - /// Shows this picture as the wallpaper of a monitor, filling the screen. The window manager /// asks for it every time a workspace of the monitor comes into view, since the user may have /// changed the wallpaper by hand since, so a backend does nothing when the monitor already @@ -663,37 +463,6 @@ pub trait Backend: Send + Sync + 'static { /// The default does nothing. Implementors should not need to override it unless they created /// something in the compositor. fn shutdown(&self) {} - - /// Has the compositor maximize the window to the work area of its monitor, panels left alone, - /// or, with `maximize` false, give it back the frame it had before. - /// - /// The default does nothing, for a compositor that has no maximize of its own. - /// - /// # Errors - /// - /// When the window does not exist or is no longer alive. - fn maximize(&self, _id: WindowId, _maximize: bool) -> komorebi_backend::Result<()> { - Ok(()) - } - - /// Returns true if and only if the compositor has a live window with this id. - fn is_window(&self, id: WindowId) -> bool { - self.window(id).is_some_and(|w| w.alive) - } - - /// Returns the window's frame, if the compositor knows the window. - fn window_rect(&self, id: WindowId) -> Option { - self.window(id).map(|w| w.rect) - } - - /// Returns the id of the monitor whose bounds contain the point. - fn monitor_from_point(&self, x: i32, y: i32) -> Option { - self.monitors().ok()?.into_iter().find_map(|m| { - let (l, t) = (m.size.left, m.size.top); - let (r, b) = (l + m.size.right, t + m.size.bottom); - (x >= l && x < r && y >= t && y < b).then_some(m.id) - }) - } } static BACKEND: RwLock>> = RwLock::new(None); @@ -778,6 +547,7 @@ pub fn with_backend(backend: Arc, f: impl FnOnce() -> R) -> R { mod tests { use super::*; use fake::FakeBackend; + use komorebi_backend::Backend as _; #[test] fn a_thread_that_installs_nothing_gets_a_permissive_fake_in_unit_tests() { diff --git a/komorebi-for-kde/komorebi/src/backend/shared.rs b/komorebi-for-kde/komorebi/src/backend/shared.rs deleted file mode 100644 index 2412b305..00000000 --- a/komorebi-for-kde/komorebi/src/backend/shared.rs +++ /dev/null @@ -1,223 +0,0 @@ -//! komorebi for KDE's backends, seen as the shared [`komorebi_backend::Backend`]. -//! -//! [`Shared`] wraps any KDE [`Backend`](super::Backend) (the real KWin one or the fake) and -//! implements the trait that every komorebi shares, which is how KDE is its first implementation: -//! the daemon keeps calling its own trait (`u32` ids, `eyre` errors, the look, the wallpaper and -//! the drag frames) until the shared core is adopted, and everything the shared trait asks for is -//! answered by the KDE methods underneath. Nothing about how KDE behaves changes. -//! -//! What the translation does: -//! -//! - an id is a [`WindowId`] made from the `u32` ([`WindowId::from_u32`]); an id too wide for a -//! `u32` is a window KDE never had; -//! - errors need no translation: KDE's trait already fails with the shared [`Error`]; -//! - KDE fills every field of a window, so the optional fields are all `Some`; -//! - every [`Capability`] is supported: KDE has workspaces, maximize, opacity and focus follows -//! mouse; -//! - a batch does nothing: KDE batches by construction (the answer to a held poll carries every -//! command that was queued). - -use super::Backend; -use komorebi_backend as shared; -use komorebi_backend::Capability; -use komorebi_backend::MonitorId; -use komorebi_backend::Rect; -use komorebi_backend::WindowId; -use std::sync::Arc; - -/// A KDE [`Backend`] as the shared [`komorebi_backend::Backend`]. -pub struct Shared(pub Arc); - -impl Shared { - /// Returns the KDE backend underneath. - pub fn kde(&self) -> &B { - &self.0 - } -} - -impl shared::Backend for Shared { - fn windows(&self) -> Vec { - self.0.windows() - } - - fn window(&self, id: WindowId) -> Option { - self.0.window(id) - } - - fn foreground_window(&self) -> Option { - self.0.foreground_window() - } - - fn monitors(&self) -> shared::Result> { - self.0.monitors() - } - - fn cursor_pos(&self) -> Option<(i32, i32)> { - self.0.cursor_pos() - } - - fn set_rect(&self, id: WindowId, rect: &Rect) -> shared::Result<()> { - self.0.set_rect(id, rect) - } - - fn focus(&self, id: WindowId, mouse_follows_focus: bool) -> shared::Result<()> { - self.0.focus(id, mouse_follows_focus) - } - - fn raise(&self, id: WindowId) -> shared::Result<()> { - self.0.raise(id) - } - - fn hide(&self, id: WindowId) -> shared::Result<()> { - self.0.hide(id) - } - - fn restore(&self, id: WindowId) -> shared::Result<()> { - self.0.restore(id) - } - - fn minimize(&self, id: WindowId) -> shared::Result<()> { - self.0.minimize(id) - } - - fn unminimize(&self, id: WindowId) -> shared::Result<()> { - self.0.unminimize(id) - } - - fn close(&self, id: WindowId) -> shared::Result<()> { - self.0.close(id) - } - - fn center_cursor_in(&self, rect: &Rect) -> shared::Result<()> { - self.0.center_cursor_in(rect) - } - - fn supports(&self, _capability: Capability) -> bool { - true - } - - fn maximize(&self, id: WindowId, maximize: bool) -> shared::Result<()> { - self.0.maximize(id, maximize) - } - - fn set_opacity(&self, id: WindowId, alpha: u8) -> shared::Result<()> { - self.0.set_opacity(id, alpha) - } - - fn set_focus_follows_mouse(&self, enable: bool) -> shared::Result<()> { - self.0.set_focus_follows_mouse(enable) - } - - fn ensure_workspaces(&self, names: &[String]) -> shared::Result<()> { - self.0.ensure_workspaces(names) - } - - fn switch_workspace(&self, monitor: MonitorId, idx: usize) -> shared::Result<()> { - self.0.switch_workspace(monitor, idx) - } - - fn set_window_workspace(&self, id: WindowId, idx: usize) -> shared::Result<()> { - self.0.set_window_workspace(id, idx) - } - - fn window_workspace(&self, id: WindowId) -> shared::Result> { - self.0.window_workspace(id) - } - - fn current_workspaces(&self) -> shared::Result> { - self.0.current_workspaces() - } - - // `is_window`, `window_rect` and `monitor_from_point` are the provided ones, over `window` and - // `monitors`, exactly as KDE's own are; `begin_batch` and `end_batch` do nothing, as KDE's - // queue is flushed as a whole. -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::backend::fake::FakeBackend; - use komorebi_backend::Backend as _; - use komorebi_backend::Error; - use komorebi_backend::contract::Harness; - use komorebi_backend::contract::check_all; - - struct KdeFake(Shared); - - impl Harness for KdeFake { - type B = Shared; - - fn new() -> Self { - Self(Shared(Arc::new(FakeBackend::with_one_monitor()))) - } - - fn backend(&self) -> &Self::B { - &self.0 - } - - fn open_window(&self, seed: u32) -> WindowId { - self.0.kde().open_window(seed, "foot", "foot", "a terminal"); - WindowId::from_u32(seed) - } - - fn destroy_window(&self, id: WindowId) { - self.0 - .kde() - .close_window_now(id.to_u32().expect("a KDE id")); - } - } - - #[test] - fn the_kde_fake_passes_the_shared_contract() { - check_all::(); - } - - #[test] - fn kde_is_the_first_implementation_and_supports_every_capability() { - let kde = KdeFake::new(); - - for capability in Capability::ALL { - assert!(kde.backend().supports(capability)); - } - } - - #[test] - fn a_command_about_a_window_that_is_gone_is_window_gone_and_other_failures_are_not() { - let kde = KdeFake::new(); - let id = kde.open_window(4); - - let gone = kde.backend().focus(WindowId::from_u32(9), false); - - assert!(matches!(gone, Err(Error::WindowGone(WindowId(9))))); - assert_eq!(gone.unwrap_err().to_string(), "no such window: 9"); - assert!(kde.backend().focus(id, false).is_ok()); - } - - #[test] - fn an_id_too_wide_for_kde_is_a_window_kde_never_had() { - let kde = KdeFake::new(); - let wide = WindowId(u64::from(u32::MAX) + 1); - - assert!(kde.backend().window(wide).is_none()); - assert!(kde.backend().hide(wide).unwrap_err().is_window_gone()); - } - - #[test] - fn every_field_kde_knows_comes_through() { - let kde = KdeFake::new(); - let id = kde.open_window(4); - - let info = kde.backend().window(id).expect("window 4 was opened"); - - assert_eq!(info.id, id); - assert_eq!(info.class.as_deref(), Some("foot")); - assert_eq!(info.normal, Some(true)); - assert_eq!(info.fullscreen, Some(false)); - assert_eq!( - kde.backend().monitors().expect("one monitor")[0] - .name - .as_deref(), - Some("Virtual-0") - ); - } -} diff --git a/komorebi-for-kde/komorebi/src/desktop.rs b/komorebi-for-kde/komorebi/src/desktop.rs index 6ced9a55..058f881c 100644 --- a/komorebi-for-kde/komorebi/src/desktop.rs +++ b/komorebi-for-kde/komorebi/src/desktop.rs @@ -61,7 +61,7 @@ fn contains_point(area: &Rect, x: i32, y: i32) -> bool { /// # Errors /// /// When the backend cannot report its monitors -/// ([`Backend::monitors`](crate::backend::Backend::monitors)). +/// ([`Backend::monitors`](komorebi_backend::Backend::monitors)). /// /// # Example /// @@ -103,7 +103,7 @@ pub fn latest_monitor_information() -> eyre::Result> { /// # Errors /// /// When the backend cannot report its monitors -/// ([`Backend::monitors`](crate::backend::Backend::monitors)). +/// ([`Backend::monitors`](komorebi_backend::Backend::monitors)). /// /// # Example /// @@ -227,7 +227,7 @@ pub fn load_monitor_information(wm: &mut WindowManager) -> eyre::Result<()> { /// # Errors /// /// - The backend cannot report its monitors -/// ([`Backend::monitors`](crate::backend::Backend::monitors)). +/// ([`Backend::monitors`](komorebi_backend::Backend::monitors)). /// - There is no focused monitor or workspace, or the windows of the focused workspace cannot be /// put in their tiles. /// diff --git a/komorebi-for-kde/komorebi/src/kwin/mod.rs b/komorebi-for-kde/komorebi/src/kwin/mod.rs index f800c244..93481b58 100644 --- a/komorebi-for-kde/komorebi/src/kwin/mod.rs +++ b/komorebi-for-kde/komorebi/src/kwin/mod.rs @@ -99,6 +99,7 @@ use crate::window_manager_event_listener; use color_eyre::eyre; use color_eyre::eyre::OptionExt; use futures_util::StreamExt; +use komorebi_backend::Backend as _; use komorebi_backend::MonitorId; use komorebi_backend::WindowId; use parking_lot::Condvar; @@ -822,7 +823,7 @@ impl KWinBackend { } } -impl Backend for KWinBackend { +impl komorebi_backend::Backend for KWinBackend { fn windows(&self) -> Vec { self.shared .table @@ -846,16 +847,6 @@ impl Backend for KWinBackend { .map(WindowId::from_u32) } - fn drag_origin(&self, id: WindowId) -> Option { - let id = id.to_u32()?; - self.shared.table.lock().drag_origin(id) - } - - fn drag_end(&self, id: WindowId) -> Option { - let id = id.to_u32()?; - self.shared.table.lock().drag_end(id) - } - fn monitors(&self) -> komorebi_backend::Result> { let monitors = self.shared.table.lock().monitors(); if monitors.is_empty() { @@ -1049,20 +1040,6 @@ impl Backend for KWinBackend { Ok(()) } - fn apply_look(&self, look: &Look) -> eyre::Result { - let shared = self.shared.clone(); - let look = look.clone(); - - self.shared.block_on(async move { - let Some(kwinrc) = &shared.kwinrc else { - return Ok(false); - }; - let connection = shared.connection().await?; - let mut effects = shared.effects.lock().await; - effects.apply(&connection, kwinrc, &look).await - })? - } - fn set_opacity(&self, id: WindowId, alpha: u8) -> komorebi_backend::Result<()> { let id = raw(id)?; self.command( @@ -1100,6 +1077,36 @@ impl Backend for KWinBackend { .map_err(platform) } + fn supports(&self, _capability: komorebi_backend::Capability) -> bool { + true + } +} + +impl Backend for KWinBackend { + fn drag_origin(&self, id: WindowId) -> Option { + let id = id.to_u32()?; + self.shared.table.lock().drag_origin(id) + } + + fn drag_end(&self, id: WindowId) -> Option { + let id = id.to_u32()?; + self.shared.table.lock().drag_end(id) + } + + fn apply_look(&self, look: &Look) -> eyre::Result { + let shared = self.shared.clone(); + let look = look.clone(); + + self.shared.block_on(async move { + let Some(kwinrc) = &shared.kwinrc else { + return Ok(false); + }; + let connection = shared.connection().await?; + let mut effects = shared.effects.lock().await; + effects.apply(&connection, kwinrc, &look).await + })? + } + fn set_wallpaper(&self, monitor_id: MonitorId, path: &std::path::Path) -> eyre::Result<()> { if !self.shared.alive.load(Ordering::SeqCst) { eyre::bail!("KWin is gone"); diff --git a/komorebi-for-kde/komorebi/src/process_command.rs b/komorebi-for-kde/komorebi/src/process_command.rs index 6ab7abce..463e1b09 100644 --- a/komorebi-for-kde/komorebi/src/process_command.rs +++ b/komorebi-for-kde/komorebi/src/process_command.rs @@ -192,7 +192,7 @@ //! - **FocusFollowsMouse** and **ToggleFocusFollowsMouse** set whether the compositor gives the //! focus to the window under the pointer, as the pointer moves: KWin's own focus policy, whichever //! of the two implementations is named, put back when it is turned off and when komorebi exits -//! ([`Backend::set_focus_follows_mouse`](crate::backend::Backend::set_focus_follows_mouse)). +//! ([`Backend::set_focus_follows_mouse`](komorebi_backend::Backend::set_focus_follows_mouse)). //! - **Border** sets whether the compositor draws a border around each window, and **BorderWidth** //! and **BorderOffset** the room the layout leaves for it: each asks the backend for the look //! again ([`border_manager::send_notification`]), as does every message once it has been @@ -2105,8 +2105,7 @@ impl WindowManager { | SocketMessage::WatchConfiguration(..) | SocketMessage::WindowHidingBehaviour(..) | SocketMessage::WorkspaceLayoutCustom(..) - | SocketMessage::WorkspaceLayoutCustomRule(..) - => { + | SocketMessage::WorkspaceLayoutCustomRule(..) => { reply.write_all(message.not_supported_reply().as_bytes())?; return Ok(()); } @@ -2149,10 +2148,7 @@ impl WindowManager { /// - The connection cannot be read, or cloned to be read and written at once. /// - A line is not a [`SocketMessage`]: the lines after it are not read. /// - [`WindowManager::process_command`] fails: the lines after it are not read. -pub fn read_commands_uds( - wm: &Arc>, - stream: UnixStream, -) -> eyre::Result<()> { +pub fn read_commands_uds(wm: &Arc>, stream: UnixStream) -> eyre::Result<()> { komorebi_transport::read_commands::(wm, stream, &NoPolicy) } diff --git a/komorebi-for-kde/komorebi/src/window.rs b/komorebi-for-kde/komorebi/src/window.rs index 4e8c4e02..0cba3420 100644 --- a/komorebi-for-kde/komorebi/src/window.rs +++ b/komorebi-for-kde/komorebi/src/window.rs @@ -311,7 +311,7 @@ impl Window { backend().unminimize(self.window_id()) } - /// Takes the window out of sight ([`Backend::hide`](crate::backend::Backend::hide)): the back + /// Takes the window out of sight ([`Backend::hide`](komorebi_backend::Backend::hide)): the back /// of a stack, which on KDE goes to a virtual desktop nobody looks at /// /// The id is recorded in [`struct@HIDDEN_WINDOWS`] first, so that what the compositor reports diff --git a/komorebi-for-kde/komorebi/tests/drag_swap.rs b/komorebi-for-kde/komorebi/tests/drag_swap.rs index 8fe3c437..95d01a56 100644 --- a/komorebi-for-kde/komorebi/tests/drag_swap.rs +++ b/komorebi-for-kde/komorebi/tests/drag_swap.rs @@ -4,7 +4,6 @@ //! //! Window ids are in the 10_000s and the 51_000s. -use komorebi::backend::Backend; use komorebi::backend::fake::FakeBackend; use komorebi::backend::with_backend; use komorebi::core::Rect; @@ -14,6 +13,7 @@ use komorebi::window_manager::WindowManager; use komorebi::window_manager_event::KWinNotification; use komorebi::window_manager_event::SystemNotification; use komorebi::window_manager_event::WindowManagerEvent; +use komorebi_backend::Backend as _; use std::sync::Arc; fn added(id: u32) -> WindowManagerEvent { diff --git a/komorebi-for-kde/komorebi/tests/maximize_commands.rs b/komorebi-for-kde/komorebi/tests/maximize_commands.rs index ac052811..f6b11bd0 100644 --- a/komorebi-for-kde/komorebi/tests/maximize_commands.rs +++ b/komorebi-for-kde/komorebi/tests/maximize_commands.rs @@ -5,7 +5,6 @@ //! //! Window ids are in the 36_000s. -use komorebi::backend::Backend; use komorebi::backend::fake::Command; use komorebi::backend::fake::FakeBackend; use komorebi::backend::with_backend; @@ -19,6 +18,7 @@ use komorebi::window_manager::WindowManager; use komorebi::window_manager_event::KWinNotification; use komorebi::window_manager_event::SystemNotification; use komorebi::window_manager_event::WindowManagerEvent; +use komorebi_backend::Backend as _; use std::sync::Arc; fn added(id: u32) -> WindowManagerEvent { diff --git a/komorebi-for-kde/komorebi/tests/monitors.rs b/komorebi-for-kde/komorebi/tests/monitors.rs index 2b21721c..509d3dcd 100644 --- a/komorebi-for-kde/komorebi/tests/monitors.rs +++ b/komorebi-for-kde/komorebi/tests/monitors.rs @@ -6,7 +6,6 @@ //! //! Window ids are in the 32_000s. -use komorebi::backend::Backend; use komorebi::backend::fake::FakeBackend; use komorebi::backend::with_backend; use komorebi::core::CycleDirection; @@ -19,6 +18,7 @@ use komorebi::window_manager::WindowManager; use komorebi::window_manager_event::KWinNotification; use komorebi::window_manager_event::SystemNotification; use komorebi::window_manager_event::WindowManagerEvent; +use komorebi_backend::Backend as _; use std::sync::Arc; const LEFT: u32 = 1; diff --git a/komorebi-for-kde/komorebi/tests/monocle.rs b/komorebi-for-kde/komorebi/tests/monocle.rs index 31082e28..bf587a12 100644 --- a/komorebi-for-kde/komorebi/tests/monocle.rs +++ b/komorebi-for-kde/komorebi/tests/monocle.rs @@ -5,7 +5,6 @@ //! //! Window ids are in the 35_000s. -use komorebi::backend::Backend; use komorebi::backend::fake::Command; use komorebi::backend::fake::FakeBackend; use komorebi::backend::with_backend; @@ -20,6 +19,7 @@ use komorebi::window_manager::WindowManager; use komorebi::window_manager_event::KWinNotification; use komorebi::window_manager_event::SystemNotification; use komorebi::window_manager_event::WindowManagerEvent; +use komorebi_backend::Backend as _; use std::sync::Arc; fn added(id: u32) -> WindowManagerEvent { diff --git a/komorebi-for-kde/komorebi/tests/stacks.rs b/komorebi-for-kde/komorebi/tests/stacks.rs index df6ab711..7e11e56b 100644 --- a/komorebi-for-kde/komorebi/tests/stacks.rs +++ b/komorebi-for-kde/komorebi/tests/stacks.rs @@ -9,7 +9,6 @@ //! //! Window ids are in the 33_000s; the hidden-window table is process-wide. -use komorebi::backend::Backend; use komorebi::backend::fake::FakeBackend; use komorebi::backend::with_backend; use komorebi::core::CycleDirection; @@ -21,6 +20,7 @@ use komorebi::window_manager::WindowManager; use komorebi::window_manager_event::KWinNotification; use komorebi::window_manager_event::SystemNotification; use komorebi::window_manager_event::WindowManagerEvent; +use komorebi_backend::Backend as _; use std::sync::Arc; fn added(id: u32) -> WindowManagerEvent { diff --git a/komorebi-for-kde/komorebi/tests/workspaces.rs b/komorebi-for-kde/komorebi/tests/workspaces.rs index 5e4d0c30..8f9a4647 100644 --- a/komorebi-for-kde/komorebi/tests/workspaces.rs +++ b/komorebi-for-kde/komorebi/tests/workspaces.rs @@ -263,7 +263,7 @@ fn a_window_open_on_a_desktop_at_startup_starts_on_that_workspace() { // the user had put one on the second desktop, and was looking at the first fake.show_workspace_by_user(MONITOR, 0); { - use komorebi::backend::Backend; + use komorebi_backend::Backend; fake.set_window_workspace(10_112.into(), 1).unwrap(); fake.clear_commands(); }