Files
komorebi/komorebi-linux/src/kwin/state.rs
T
LGUG2Z cd3892de76 refactor(repo): move the platform libraries to their final directories (pure move)
komorebi/                          -> komorebi-windows/
komorebi-for-kde/komorebi/         -> komorebi-linux/
komorebi-for-mac/komorebi/         -> komorebi-macos/
komorebi-for-kde/komorebi-hotkeys/ -> komorebi-hotkeys/

The directories now carry the names of their packages (komorebi-windows, komorebi-linux,
komorebi-macos). Renames only: every file is a 100% rename (270 files); nothing is edited,
so the workspace does not build at this revision. The next revision fixes the paths.
2026-11-05 15:03:27 -08:00

2599 lines
93 KiB
Rust

//! The daemon's model of the compositor: the windows, monitors and virtual desktops KWin reports,
//! kept up to date by the events the script in KWin sends, and the window events the window manager
//! gets from them.
//!
//! This is pure: JSON in, [`Output`]s out, no D-Bus and no threads, so everything the bridge
//! decides can be tested without a compositor. The script (`bridge.js`) holds no logic: it reports
//! what KWin tells it, and every decision about what a report means is made here. The events are
//! JSON objects with a `type`, described on [`Table::handle`].
//!
//! Every virtual desktop is a workspace: workspace `i` is KWin's desktop `i`, and each output
//! shows one desktop of its own, because komorebi turns on KWin's per-output virtual desktops. The
//! commands that show a workspace and put a window on one are made here too
//! ([`Table::switch_commands`], [`Table::window_workspace_commands`]), so that the table knows what
//! komorebi asked for and does not report it back as somebody else's doing.
//!
//! A window komorebi hides, the back of a stack, goes to one more desktop, the parking desktop
//! ([`PARK_DESKTOP_NAME`]), which is not a workspace and which nobody looks at
//! ([`Table::hide_commands`], [`Table::restore_commands`]). The table keeps the desktop the window
//! came from, so that [`Table::window_workspace`] still names its workspace, and does not report
//! the move to the parking desktop as somebody else's doing. A parking desktop that an earlier run
//! left behind is found in the first snapshot, its windows are sent home, and it is removed.
//!
//! # Example
//!
//! The script's first report is a snapshot of the desktop. A window that opens after it is an
//! `added` event, which the window manager gets as a [`WindowManagerEvent::Show`]:
//!
//! ```rust
//! use std::time::Instant;
//!
//! use komorebi::kwin::state::{Output, Table};
//! use komorebi::window_manager_event::WindowManagerEvent;
//! use serde_json::json;
//!
//! let mut table = Table::new();
//! let now = Instant::now();
//!
//! table.handle(
//! &json!({
//! "type": "snapshot",
//! "windows": [],
//! "screens": [{
//! "name": "DP-1", "manufacturer": "ACME", "model": "M1", "serial": "S1",
//! "geo": { "x": 0, "y": 0, "w": 1920, "h": 1080 },
//! "area": { "x": 0, "y": 0, "w": 1920, "h": 1050 },
//! }],
//! "active": null,
//! "cursor": { "x": 960, "y": 540 },
//! }),
//! now,
//! );
//!
//! let out = table.handle(
//! &json!({
//! "type": "added", "id": "{6b9c}", "pid": 0, "class": "foot",
//! "caption": "a terminal", "normal": true, "minimized": false,
//! "geo": { "x": 0, "y": 0, "w": 800, "h": 600 },
//! }),
//! now,
//! );
//!
//! // KWin names the window by a UUID; komorebi gives it a number of its own
//! assert!(matches!(&out[..], [Output::Event(WindowManagerEvent::Show(_, window))] if window.id == 1));
//! assert_eq!(table.windows()[0].title, "a terminal");
//! assert_eq!(table.monitors()[0].work_area.bottom, 1050);
//! ```
use crate::backend::MonitorInfo;
use crate::backend::WindowInfo;
use crate::core::Rect;
use crate::monitor_reconciliator::MonitorNotification;
use crate::window::Window;
use crate::window_manager_event::KWinNotification;
use crate::window_manager_event::SystemNotification;
use crate::window_manager_event::WindowManagerEvent;
use komorebi_hotkeys::engine::Focus;
use serde_json::Value;
use serde_json::json;
use std::collections::HashMap;
use std::time::Duration;
use std::time::Instant;
/// The name of the virtual desktop komorebi hides windows on
pub const PARK_DESKTOP_NAME: &str = "komorebi-park";
/// How long a closed window can still be asked about, so that the `Destroy` event that names it
/// can be logged and serialized
const TOMBSTONE: Duration = Duration::from_secs(60);
/// A drag of a window by the user with the pointer, which KWin calls an interactive move or
/// resize
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Drag {
Move,
Resize,
}
struct Entry {
uuid: String,
info: WindowInfo,
/// The name of the window's desktop entry, without `.desktop`, as KWin says
desktop_file: String,
/// What KWin says: a normal window, as opposed to a dialog, splash, panel, popup...
kwin_normal: bool,
desktops: Vec<String>,
/// The drag the user is in the middle of, if any
drag: Option<Drag>,
/// The frame the window had when the drag began, which a drag is measured from. It is kept
/// apart from `info.rect`, which the steps and the frame events go on changing before the
/// window manager has handled the start
drag_origin: Option<Rect>,
/// The frame the user asked for when they let go of an edge of the window, which the end of
/// the resize is. It is kept apart from `info.rect`, which the frame events that follow the
/// end of the drag go on changing before the window manager has handled it, and the client
/// is short of it until it has drawn at the new size
drag_end: Option<Rect>,
/// komorebi put it on the parking desktop
parked: bool,
/// The desktop the window was on when it was parked
home: Option<String>,
closed_at: Option<Instant>,
}
/// The work a handled event leaves for the rest of the daemon.
#[derive(Debug)]
pub enum Output {
/// A window event for the window manager.
Event(WindowManagerEvent),
/// A change of the monitors, for the monitor reconciliator.
Monitor(MonitorNotification),
/// A command for the script, to be queued with the others.
Command(Value),
/// The answer to a cursor query.
Cursor {
/// The query this answers, as the daemon numbered it.
token: u64,
/// Where the pointer is, across.
x: i32,
/// Where the pointer is, down.
y: i32,
},
}
/// The windows and monitors of the desktop, as the script last reported them.
///
/// A window is known by the UUID KWin gives it, and the table gives it a `u32` the first time it
/// sees it ([`WindowInfo::id`]), which is how every other part of komorebi names it. An id is never
/// given to another window, also after the window has closed. A closed window stays in the table,
/// with [`WindowInfo::alive`] false, for a minute, so that the event that names it can still be
/// logged.
#[derive(Default)]
pub struct Table {
next_id: u32,
by_uuid: HashMap<String, u32>,
windows: HashMap<u32, Entry>,
monitors: Vec<MonitorInfo>,
foreground: Option<u32>,
cursor: Option<(i32, i32)>,
/// `(id, name)` of every virtual desktop, in KWin's order
desktops: Vec<(String, String)>,
/// The desktop each output shows, by output name. They are independent (komorebi turns on
/// KWin's per-output virtual desktops), which is what lets every monitor have a workspace of
/// its own in front.
current: HashMap<String, String>,
/// The workspace desktop an output showed before the parking desktop, so that it can be sent
/// back
previous: HashMap<String, String>,
/// The desktop this run hides windows on, once it has made one
park_desktop: Option<String>,
/// A parking desktop left behind by an earlier run, to be removed once it is empty
stale_park: Option<String>,
}
fn rect(v: &Value) -> Rect {
let n = |k: &str| v[k].as_i64().unwrap_or(0) as i32;
Rect {
left: n("x"),
top: n("y"),
right: n("w"),
bottom: n("h"),
}
}
fn strings(v: &Value) -> Vec<String> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|s| s.as_str().map(String::from))
.collect()
})
.unwrap_or_default()
}
/// FNV-1a: a monitor's id has to be the same on every run, so no `RandomState`
fn stable_id(s: &str) -> u32 {
let mut hash: u32 = 0x811c_9dc5;
for b in s.bytes() {
hash ^= u32::from(b);
hash = hash.wrapping_mul(0x0100_0193);
}
hash
}
fn monitor(v: &Value) -> MonitorInfo {
let name = v["name"].as_str().unwrap_or_default().to_string();
let serial = v["serial"].as_str().unwrap_or_default();
// an output's name follows the port it is plugged into; its serial follows the monitor
let serial_number_id = if serial.is_empty() {
name.clone()
} else {
format!(
"{}-{}-{serial}",
v["manufacturer"].as_str().unwrap_or_default(),
v["model"].as_str().unwrap_or_default()
)
};
MonitorInfo {
id: stable_id(&serial_number_id),
name,
serial_number_id,
size: rect(&v["geo"]),
work_area: rect(&v["area"]),
}
}
fn kwin(n: KWinNotification) -> SystemNotification {
SystemNotification::KWin(n)
}
impl Table {
/// Returns an empty table. The first window it sees gets the id 1.
pub fn new() -> Self {
Self {
next_id: 1,
..Self::default()
}
}
// ---- queries ---------------------------------------------------------------------------
/// Returns what is known about the window, or `None` if the table has never seen it or it
/// closed more than a minute ago.
pub fn window(&self, id: u32) -> Option<WindowInfo> {
self.windows.get(&id).map(|e| e.info.clone())
}
/// Returns the frame the window had when the user last began to drag it, or `None` if they
/// have not since the table first saw it.
pub fn drag_origin(&self, id: u32) -> Option<Rect> {
self.windows.get(&id).and_then(|e| e.drag_origin)
}
/// Returns the frame the user asked for when they last let go of an edge of the window, or
/// `None` if the last drag was a move, or a resize that sent no step, or if they have not
/// dragged it since the table first saw it.
pub fn drag_end(&self, id: u32) -> Option<Rect> {
self.windows.get(&id).and_then(|e| e.drag_end)
}
/// Returns the windows komorebi may manage that are open right now, ordered by id.
pub fn windows(&self) -> Vec<WindowInfo> {
let mut windows: Vec<_> = self
.windows
.values()
.filter(|e| e.info.alive && self.manageable(e))
.map(|e| e.info.clone())
.collect();
windows.sort_by_key(|w| w.id);
windows
}
/// Returns the monitors, in the order KWin lists its outputs.
pub fn monitors(&self) -> Vec<MonitorInfo> {
self.monitors.clone()
}
/// Returns the id of the window KWin last reported active, if it is still open.
pub fn foreground(&self) -> Option<u32> {
self.foreground
.filter(|id| self.windows.get(id).is_some_and(|e| e.info.alive))
}
/// Returns the application of the window that has the focus, as key bindings name
/// applications, or `None` when no window that is open has the focus.
///
/// The window can be one komorebi does not manage, such as a dialog: a key binding for an
/// application is for its dialogs too.
pub fn focused_application(&self) -> Option<Focus> {
let entry = self.windows.get(&self.foreground()?)?;
Some(Focus {
exe: entry.info.exe.clone(),
app_id: entry.info.class.clone(),
desktop_entry: entry.desktop_file.clone(),
})
}
/// Returns where the pointer was the last time the script said.
pub fn cursor(&self) -> Option<(i32, i32)> {
self.cursor
}
/// Returns the UUID KWin knows the window by, which is how a command for the script names
/// it, or `None` if the table does not know the window.
pub fn uuid(&self, id: u32) -> Option<String> {
self.windows.get(&id).map(|e| e.uuid.clone())
}
/// Returns the desktop this run hides windows on, if it has made one. It is not in step with
/// the desktops KWin lists: [`Table::hide_commands`] checks that it is still there.
pub fn park_desktop(&self) -> Option<&str> {
self.park_desktop.as_deref()
}
/// Returns the parking desktop an earlier run left behind, until it has been removed. It is
/// never the parking desktop of this run: it goes as soon as the windows on it have moved home.
pub fn stale_park(&self) -> Option<&str> {
self.stale_park.as_deref()
}
/// Records that the stale parking desktop is gone.
pub fn clear_stale_park(&mut self) {
self.stale_park = None;
}
/// Whether komorebi should have anything to do with this window: a normal window, as opposed
/// to a dialog, a panel, a popup. Every desktop is a workspace of komorebi's.
fn manageable(&self, entry: &Entry) -> bool {
entry.kwin_normal
}
// ---- workspaces ------------------------------------------------------------------------
/// The ids of the desktops that are workspaces, in order: all of them but the parking desktop
fn workspace_desktops(&self) -> Vec<&str> {
self.desktops
.iter()
.filter(|(_, name)| name != PARK_DESKTOP_NAME)
.map(|(id, _)| id.as_str())
.collect()
}
/// Which workspace a desktop is
fn workspace_index(&self, desktop: &str) -> Option<usize> {
self.workspace_desktops().iter().position(|d| *d == desktop)
}
/// Where windows go when nothing says otherwise: the first desktop
fn default_desktop(&self) -> Option<String> {
self.workspace_desktops().first().map(|d| d.to_string())
}
/// Returns the workspace a window is on: the first of its desktops. A window komorebi has
/// hidden is on the workspace it will come back to, and one on every desktop (KWin gives it no
/// desktop) is on none.
pub fn window_workspace(&self, id: u32) -> Option<usize> {
let entry = self.windows.get(&id)?;
let desktop = if entry.parked {
entry.home.as_ref()
} else {
entry.desktops.first()
}?;
self.workspace_index(desktop)
}
/// Returns the workspace each monitor shows, as `(monitor id, workspace index)`
pub fn current_workspaces(&self) -> Vec<(u32, usize)> {
self.monitors
.iter()
.filter_map(|m| {
let desktop = self.current.get(&m.name)?;
Some((m.id, self.workspace_index(desktop)?))
})
.collect()
}
/// Returns how many workspace desktops there are
pub fn workspace_count(&self) -> usize {
self.workspace_desktops().len()
}
/// Replaces the list of desktops with what KWin says it is now, for after komorebi created
/// some. The list is `(id, name)` pairs, in KWin's order.
pub fn set_desktops(&mut self, desktops: Vec<(String, String)>) {
self.desktops = desktops;
}
/// Returns the commands that show workspace `idx` on a monitor, and records that the monitor
/// shows it, so that KWin's report of the switch is not taken for somebody else's. A monitor
/// the table does not know gets no command.
///
/// # Errors
///
/// [`NeedsDesktops`] when there are not that many desktops yet: make them, then ask again.
pub fn switch_commands(
&mut self,
monitor_id: u32,
idx: usize,
) -> Result<Vec<Value>, NeedsDesktops> {
let desktop = self
.workspace_desktops()
.get(idx)
.map(|d| d.to_string())
.ok_or(NeedsDesktops(idx + 1))?;
let Some(monitor) = self.monitors.iter().find(|m| m.id == monitor_id) else {
return Ok(vec![]);
};
let output = monitor.name.clone();
self.current.insert(output.clone(), desktop.clone());
Ok(vec![
json!({ "op": "output_desktop", "output": output, "v": desktop }),
])
}
/// Returns the commands that put a window on workspace `idx`, and records the window there,
/// so that the next query sees it at once and KWin's report of the move raises nothing. A
/// window the table does not know gets no command, and a window komorebi has hidden stays
/// hidden and comes back to the workspace.
///
/// # Errors
///
/// [`NeedsDesktops`] when there are not that many desktops yet: make them, then ask again.
pub fn window_workspace_commands(
&mut self,
id: u32,
idx: usize,
) -> Result<Vec<Value>, NeedsDesktops> {
let desktop = self
.workspace_desktops()
.get(idx)
.map(|d| d.to_string())
.ok_or(NeedsDesktops(idx + 1))?;
let Some(entry) = self.windows.get_mut(&id) else {
return Ok(vec![]);
};
if entry.parked {
entry.home = Some(desktop);
return Ok(vec![]);
}
entry.desktops = vec![desktop.clone()];
Ok(vec![
json!({ "op": "desktop", "id": entry.uuid, "v": desktop }),
])
}
// ---- hiding ----------------------------------------------------------------------------
/// Returns the commands that hide a window: onto the parking desktop, which is where KDE puts
/// what should be out of the way. The window remembers the desktop it came from. A window the
/// table does not know, or that is hidden already, gets no command.
///
/// # Errors
///
/// [`NeedsPark`] when this run has no parking desktop, or KWin no longer lists the one it made
/// (somebody removed it, in System Settings, say, and windows sent to it would have nowhere to
/// go): make one, tell the table with [`Table::set_park`], then ask again.
///
/// # Example
///
/// ```rust
/// use std::time::Instant;
///
/// use komorebi::kwin::state::{NeedsPark, PARK_DESKTOP_NAME, Table};
/// use serde_json::json;
///
/// let mut table = Table::new();
/// let now = Instant::now();
/// table.handle(
/// &json!({
/// "type": "snapshot",
/// "windows": [{
/// "id": "{a}", "pid": 0, "class": "foot", "caption": "a terminal",
/// "normal": true, "minimized": false, "desktops": ["d1"],
/// "geo": { "x": 0, "y": 0, "w": 800, "h": 600 },
/// }],
/// "screens": [],
/// "desktops": [{ "id": "d1", "name": "Desktop 1" }],
/// "current_desktops": [],
/// "active": null,
/// "cursor": { "x": 0, "y": 0 },
/// }),
/// now,
/// );
///
/// // there is no parking desktop yet: the backend makes one, and says which it is
/// assert!(matches!(table.hide_commands(1), Err(NeedsPark)));
/// table.handle(
/// &json!({ "type": "desktop_list", "desktops": [
/// { "id": "d1", "name": "Desktop 1" },
/// { "id": "p1", "name": PARK_DESKTOP_NAME },
/// ] }),
/// now,
/// );
/// table.set_park(String::from("p1"));
///
/// assert_eq!(
/// table.hide_commands(1).unwrap(),
/// [json!({ "op": "desktop", "id": "{a}", "v": "p1" })]
/// );
/// // it is still on its workspace, which is where it goes back to
/// assert_eq!(table.window_workspace(1), Some(0));
/// assert_eq!(
/// table.restore_commands(1),
/// [json!({ "op": "desktop", "id": "{a}", "v": "d1" })]
/// );
/// ```
pub fn hide_commands(&mut self, id: u32) -> Result<Vec<Value>, NeedsPark> {
// the one this run made, if it is still there: whoever removed it (the user, in System
// Settings, say) leaves windows sent to it with nowhere to go, and nothing says so
let park = self
.park_desktop
.clone()
.filter(|park| self.desktops.iter().any(|(id, _)| id == park));
let current = self.default_desktop();
let Some(entry) = self.windows.get_mut(&id) else {
return Ok(vec![]);
};
if entry.parked {
return Ok(vec![]);
}
let park = park.ok_or(NeedsPark)?;
// remember where it came from; a window on every desktop goes back to the current one
if entry.home.is_none() {
entry.home = entry.desktops.first().cloned().or(current);
}
entry.parked = true;
Ok(vec![
json!({ "op": "desktop", "id": entry.uuid, "v": park }),
])
}
/// Returns the commands that undo [`Table::hide_commands`]: the window goes back to the desktop
/// it came from, or to the first desktop when that is not known. A window that is not hidden
/// gets no command.
pub fn restore_commands(&mut self, id: u32) -> Vec<Value> {
let fallback = self.default_desktop();
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
if !std::mem::take(&mut entry.parked) {
return vec![];
}
let home = entry.home.take().or(fallback);
home.map(|home| vec![json!({ "op": "desktop", "id": entry.uuid, "v": home })])
.unwrap_or_default()
}
/// KWin went away. Its windows go with it, and nothing will report them closing.
///
/// Returns a [`WindowManagerEvent::Destroy`] for every window the window manager may manage,
/// as if each had been closed, and forgets which window has the focus and the parking desktop
/// (a new KWin may have kept it, and then finds it as a stale one). The windows stay in
/// the table as closed ones, so their ids are not given out again. A KWin that comes back
/// reports its desktop in a new snapshot.
pub fn compositor_lost(&mut self, now: Instant) -> Vec<Output> {
let ids: Vec<u32> = self
.windows
.iter()
.filter(|(_, e)| e.info.alive)
.map(|(id, _)| *id)
.collect();
let mut out = vec![];
for id in ids {
let uuid = self.windows[&id].uuid.clone();
out.extend(self.on_removed(&json!({ "id": uuid }), now));
}
self.foreground = None;
self.park_desktop = None;
out
}
/// Records the desktop this run hides windows on, which the backend made
pub fn set_park(&mut self, id: String) {
self.park_desktop = Some(id);
}
/// Forgets the parking desktop, so that the next [`Table::hide_commands`] asks for one again
pub fn forget_park(&mut self) {
self.park_desktop = None;
}
/// Records the frame komorebi has just asked KWin to give a window, so that the window manager
/// sees it at once. The `geometry` event that says what the client did replaces it.
pub fn note_requested_rect(&mut self, id: u32, rect: Rect) {
if let Some(entry) = self.windows.get_mut(&id) {
entry.info.rect = rect;
}
}
// ---- events ----------------------------------------------------------------------------
fn id_for(&mut self, uuid: &str) -> u32 {
if let Some(id) = self.by_uuid.get(uuid) {
return *id;
}
let id = self.next_id.max(1);
self.next_id = id + 1;
self.by_uuid.insert(uuid.to_string(), id);
id
}
fn entry_from(&mut self, w: &Value) -> (u32, Entry) {
let uuid = w["id"].as_str().unwrap_or_default().to_string();
let id = self.id_for(&uuid);
let class = w["class"].as_str().unwrap_or_default().to_string();
let pid = w["pid"].as_i64().unwrap_or_default() as i32;
let (exe, path) = process(pid, &class);
let info = WindowInfo {
id,
pid,
title: w["caption"].as_str().unwrap_or_default().to_string(),
class,
exe,
path,
rect: rect(&w["geo"]),
minimized: w["minimized"].as_bool().unwrap_or(false),
fullscreen: w["fullscreen"].as_bool().unwrap_or(false),
maximized: w["maximized"].as_bool().unwrap_or(false),
normal: false,
alive: true,
};
let entry = Entry {
uuid,
info,
desktop_file: w["desktopFile"].as_str().unwrap_or_default().to_string(),
kwin_normal: w["normal"].as_bool().unwrap_or(false),
desktops: strings(&w["desktops"]),
drag: None,
drag_origin: None,
drag_end: None,
parked: false,
home: None,
closed_at: None,
};
(id, entry)
}
/// `WindowInfo::normal` is "may be managed", which is kept in step after every change rather
/// than recomputed by the consumer
fn sync_normal(&mut self, id: u32) {
let manageable = self.windows.get(&id).is_some_and(|e| self.manageable(e));
if let Some(entry) = self.windows.get_mut(&id) {
entry.info.normal = manageable;
}
}
fn prune(&mut self, now: Instant) {
let expired: Vec<u32> = self
.windows
.iter()
.filter(|(_, e)| {
e.closed_at
.is_some_and(|t| now.duration_since(t) > TOMBSTONE)
})
.map(|(id, _)| *id)
.collect();
for id in expired {
if let Some(entry) = self.windows.remove(&id) {
self.by_uuid.remove(&entry.uuid);
}
}
}
/// Updates the table with one event from the script, and returns what the rest of the daemon
/// has to do about it. `now` is when the event arrived; a closed window is forgotten a minute
/// after it closed.
///
/// The event's `type` is one of:
///
/// - `snapshot`: everything on the desktop (`windows`, `screens`, `desktops`,
/// `current_desktops`, `active`, `cursor`), sent once, when the script starts. It fills the
/// table and raises no event: the window manager reads the desktop from the table when it
/// starts. A parking desktop in it is one an earlier run left, and the windows on it are sent
/// home with [`Output::Command`]s.
/// - `added`, `removed`: a window opened or closed. For a window komorebi may manage, they are
/// a [`WindowManagerEvent::Show`] and a [`WindowManagerEvent::Destroy`].
/// - `activated`: KWin gave a window the focus ([`WindowManagerEvent::FocusChange`]), or,
/// with no `id`, took it away from every window.
/// - `minimized`: a window was minimized or brought back ([`WindowManagerEvent::Minimize`],
/// [`WindowManagerEvent::Restore`]).
/// - `fullscreen`: a window went fullscreen or came back from it
/// ([`WindowManagerEvent::FullscreenChange`]).
/// - `maximized`: a window was maximized or restored, by the user or by komorebi's own
/// command ([`WindowManagerEvent::MaximizeChange`]).
/// - `output`: a window is on another output. It carries the frame the window has now, which
/// goes with the output, since the two events arrive in no fixed order
/// ([`WindowManagerEvent::OutputChange`]).
/// - `caption`: a window's title changed ([`WindowManagerEvent::TitleUpdate`]).
/// - `geometry`: a window's frame changed. It raises no event.
/// - `desktops`: a window is on other desktops. When it is now on another workspace than the
/// table had it on, this is a [`WindowManagerEvent::WorkspaceMove`]; komorebi's own move
/// ([`Table::window_workspace_commands`]) is on it already, and raises nothing, and neither
/// does a window on the parking desktop.
/// - `move_resize_started`, `move_resize_finished`: the user took hold of a window with the
/// pointer (`geo` is its frame then, which [`Table::drag_origin`] keeps) and let go of it
/// (`geo` is its frame, `cursor` where the pointer is). For a move, they are a
/// [`WindowManagerEvent::MoveStart`] and a [`WindowManagerEvent::MoveEnd`]. For a resize
/// they are a [`WindowManagerEvent::ResizeStart`] and a [`WindowManagerEvent::ResizeEnd`],
/// and the end of the resize is `requested`, where the user took the edges, when the event
/// has one ([`Table::drag_end`]): the window's frame stays the one KWin reports, which the
/// `geometry` events that follow go on changing.
/// - `move_resize_step`: part way through a resize, the frame the user is asking for (`geo`),
/// which becomes the window's frame and a [`WindowManagerEvent::ResizeStep`]. A step of a
/// move, or with no drag going on, is nothing.
/// - `current_desktops`: the desktop each output shows. An output that shows another desktop
/// than the table had it showing is a [`WindowManagerEvent::WorkspaceChange`]; komorebi's own
/// switch ([`Table::switch_commands`]) raises nothing. An output that shows the parking
/// desktop (KWin followed an activation of a hidden window there) is sent back to the
/// desktop it showed before, with an [`Output::Command`].
/// - `desktop_list`: the virtual desktops, in order. It raises no event.
/// - `screens`: the outputs, with their geometry and work area, sent when they are not what
/// was last sent. A monitor that came or went is a
/// [`MonitorNotification::DisplayConnectionChange`], and one whose size or work area changed
/// a [`MonitorNotification::Resize`] ([`Output::Monitor`]).
/// - `cursor`: the answer to a cursor query ([`Output::Cursor`]).
/// - `failed`: commands the script could not carry out. They are logged.
///
/// Anything else is logged at debug level and ignored. A dialog, a panel or a popup is in the
/// table, and can have the focus, but it raises no window event.
pub fn handle(&mut self, event: &Value, now: Instant) -> Vec<Output> {
self.prune(now);
match event["type"].as_str() {
Some("snapshot") => self.on_snapshot(event),
Some("added") => self.on_added(event),
Some("removed") => self.on_removed(event, now),
Some("activated") => self.on_activated(event),
Some("minimized") => self.on_minimized(event),
Some("fullscreen") => self.on_fullscreen(event),
Some("maximized") => self.on_maximized(event),
Some("move_resize_step") => self.on_drag_step(event),
Some("output") => self.on_output(event),
Some("caption") => self.on_caption(event),
Some("geometry") => {
if let Some(entry) = self.entry_mut(event) {
entry.info.rect = rect(&event["geo"]);
}
vec![]
}
Some("desktops") => self.on_desktops(event),
Some("move_resize_started") => self.on_drag_started(event),
Some("move_resize_finished") => self.on_drag_finished(event),
Some("screens") => self.on_screens(event),
Some("current_desktops") => self.on_current_desktops(event),
Some("desktop_list") => {
self.desktops = desktop_list(&event["desktops"]);
vec![]
}
Some("cursor") => {
let (x, y) = (
event["x"].as_i64().unwrap_or(0) as i32,
event["y"].as_i64().unwrap_or(0) as i32,
);
self.cursor = Some((x, y));
vec![Output::Cursor {
token: event["token"].as_u64().unwrap_or(0),
x,
y,
}]
}
Some("failed") => {
tracing::warn!("the bridge could not do: {}", event["cmds"]);
vec![]
}
other => {
tracing::debug!("ignoring unknown bridge event {other:?}");
vec![]
}
}
}
fn entry_mut(&mut self, event: &Value) -> Option<&mut Entry> {
let uuid = event["id"].as_str()?;
let id = *self.by_uuid.get(uuid)?;
self.windows.get_mut(&id)
}
fn id_of(&self, event: &Value) -> Option<u32> {
self.by_uuid.get(event["id"].as_str()?).copied()
}
fn on_snapshot(&mut self, event: &Value) -> Vec<Output> {
let mut out = vec![];
// desktops first: which workspace a window is on depends on them
self.desktops = desktop_list(&event["desktops"]);
self.current = current_map(&event["current_desktops"]);
self.previous = self.current.clone();
// a parking desktop at startup is left over from a run that did not clean up. It is not this
// run's: it is about to be removed, and anything parked on it would go with it. This run
// makes its own the first time it needs one.
self.park_desktop = None;
self.stale_park = self
.desktops
.iter()
.find(|(_, name)| name == PARK_DESKTOP_NAME)
.map(|(id, _)| id.clone());
// rebuild the windows, keeping the ids of those we already knew
let old = std::mem::take(&mut self.windows);
for w in event["windows"].as_array().cloned().unwrap_or_default() {
let (id, entry) = self.entry_from(&w);
self.windows.insert(id, entry);
self.sync_normal(id);
}
// closed windows still within their grace period
for (id, entry) in old {
if entry.closed_at.is_some() {
self.windows.entry(id).or_insert(entry);
}
}
// windows an earlier run parked: put them back where the user will see them
if let (Some(park), Some(home)) = (self.stale_park.clone(), self.default_desktop()) {
for entry in self.windows.values() {
if entry.desktops == [park.clone()] {
out.push(Output::Command(
json!({ "op": "desktop", "id": entry.uuid, "v": home }),
));
}
}
}
self.foreground = event["active"]
.as_str()
.and_then(|u| self.by_uuid.get(u))
.copied();
if let (Some(x), Some(y)) = (event["cursor"]["x"].as_i64(), event["cursor"]["y"].as_i64()) {
self.cursor = Some((x as i32, y as i32));
}
out.extend(self.set_monitors(&event["screens"], false));
out
}
/// Replaces the monitors with `screens`. When `announce` is set and they are not what the
/// table had, the change is announced: as a [`MonitorNotification::DisplayConnectionChange`]
/// when the monitors are not the same (a monitor came or went), and otherwise as a
/// [`MonitorNotification::Resize`] of the first monitor whose size or work area is not what it
/// was.
fn set_monitors(&mut self, screens: &Value, announce: bool) -> Vec<Output> {
let monitors: Vec<MonitorInfo> = screens
.as_array()
.map(|a| a.iter().map(monitor).collect())
.unwrap_or_default();
let previous = std::mem::replace(&mut self.monitors, monitors);
if !announce || previous == self.monitors {
return vec![];
}
let ids = |m: &[MonitorInfo]| {
let mut ids: Vec<u32> = m.iter().map(|m| m.id).collect();
ids.sort_unstable();
ids
};
if ids(&previous) != ids(&self.monitors) {
vec![Output::Monitor(
MonitorNotification::DisplayConnectionChange(0),
)]
} else {
// same monitors, different geometry or work area
let changed = self
.monitors
.iter()
.find(|m| previous.iter().any(|p| p.id == m.id && p != *m))
.map_or(0, |m| m.id);
vec![Output::Monitor(MonitorNotification::Resize(changed))]
}
}
fn on_screens(&mut self, event: &Value) -> Vec<Output> {
self.set_monitors(&event["screens"], true)
}
fn on_added(&mut self, event: &Value) -> Vec<Output> {
let (id, entry) = self.entry_from(event);
if self.windows.get(&id).is_some_and(|e| e.info.alive) {
// already announced (the script announces on activation as well as on creation)
return vec![];
}
self.windows.insert(id, entry);
self.sync_normal(id);
if self.windows[&id].info.normal {
vec![Output::Event(WindowManagerEvent::Show(
kwin(KWinNotification::WindowAdded),
Window::from(id),
))]
} else {
vec![]
}
}
fn on_removed(&mut self, event: &Value, now: Instant) -> Vec<Output> {
let Some(id) = self.id_of(event) else {
return vec![];
};
let manageable = self.windows.get(&id).is_some_and(|e| e.info.normal);
if let Some(entry) = self.windows.get_mut(&id) {
entry.info.alive = false;
entry.info.normal = false;
entry.closed_at = Some(now);
entry.parked = false;
}
if self.foreground == Some(id) {
self.foreground = None;
}
if manageable {
vec![Output::Event(WindowManagerEvent::Destroy(
kwin(KWinNotification::WindowRemoved),
Window::from(id),
))]
} else {
vec![]
}
}
fn on_activated(&mut self, event: &Value) -> Vec<Output> {
let Some(uuid) = event["id"].as_str() else {
self.foreground = None;
return vec![];
};
let Some(id) = self.by_uuid.get(uuid).copied() else {
return vec![];
};
self.foreground = Some(id);
tracing::debug!(
"KWin activated window {id} ({})",
self.windows.get(&id).map_or("?", |e| e.info.title.as_str())
);
if self.windows.get(&id).is_some_and(|e| e.info.normal) {
vec![Output::Event(WindowManagerEvent::FocusChange(
kwin(KWinNotification::WindowActivated),
Window::from(id),
))]
} else {
vec![]
}
}
fn on_minimized(&mut self, event: &Value) -> Vec<Output> {
let minimized = event["v"].as_bool().unwrap_or(false);
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
entry.info.minimized = minimized;
if !entry.info.normal {
return vec![];
}
let window = Window::from(id);
vec![Output::Event(if minimized {
WindowManagerEvent::Minimize(kwin(KWinNotification::WindowMinimized), window)
} else {
WindowManagerEvent::Restore(kwin(KWinNotification::WindowRestored), window)
})]
}
fn on_fullscreen(&mut self, event: &Value) -> Vec<Output> {
let fullscreen = event["v"].as_bool().unwrap_or(false);
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
entry.info.fullscreen = fullscreen;
if !entry.info.normal {
return vec![];
}
vec![Output::Event(WindowManagerEvent::FullscreenChange(
kwin(KWinNotification::WindowFullScreenChanged),
Window::from(id),
fullscreen,
))]
}
fn on_output(&mut self, event: &Value) -> Vec<Output> {
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
// the frame that goes with the output (the two events arrive in no fixed order)
if event["geo"].is_object() {
entry.info.rect = rect(&event["geo"]);
}
if !entry.info.normal {
return vec![];
}
vec![Output::Event(WindowManagerEvent::OutputChange(
kwin(KWinNotification::WindowOutputChanged),
Window::from(id),
))]
}
fn on_maximized(&mut self, event: &Value) -> Vec<Output> {
let maximized = event["v"].as_bool().unwrap_or(false);
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
entry.info.maximized = maximized;
if !entry.info.normal {
return vec![];
}
vec![Output::Event(WindowManagerEvent::MaximizeChange(
kwin(KWinNotification::WindowMaximizedChanged),
Window::from(id),
maximized,
))]
}
fn on_caption(&mut self, event: &Value) -> Vec<Output> {
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
entry.info.title = event["caption"].as_str().unwrap_or_default().to_string();
if entry.info.normal {
vec![Output::Event(WindowManagerEvent::TitleUpdate(
kwin(KWinNotification::CaptionChanged),
Window::from(id),
))]
} else {
vec![]
}
}
fn on_desktops(&mut self, event: &Value) -> Vec<Output> {
let Some(id) = self.id_of(event) else {
return vec![];
};
let before = self.window_workspace(id);
let desktops = strings(&event["desktops"]);
// (or on the one an earlier run left, which they are being sent home from)
let parked_by_us = self
.park_desktop
.iter()
.chain(self.stale_park.iter())
.any(|park| desktops.contains(park));
if let Some(entry) = self.windows.get_mut(&id) {
entry.desktops = desktops;
}
// A window komorebi parked is where it put it. Otherwise this is a window that is on
// another workspace's desktop than it was: komorebi's own doing coming back (the window
// manager already has it there) or somebody else's, which it will adopt.
let after = self
.windows
.get(&id)
.filter(|e| e.info.normal && e.info.alive)
.and_then(|e| e.desktops.first())
.and_then(|d| self.workspace_index(d));
match after {
Some(idx) if !parked_by_us && before != Some(idx) => {
vec![Output::Event(WindowManagerEvent::WorkspaceMove(
kwin(KWinNotification::WindowMovedToDesktop),
Window::from(id),
idx,
))]
}
_ => vec![],
}
}
fn on_drag_started(&mut self, event: &Value) -> Vec<Output> {
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
entry.info.rect = rect(&event["geo"]);
entry.drag_origin = Some(entry.info.rect);
entry.drag_end = None;
let (kind, notification) = if event["resize"].as_bool().unwrap_or(false) {
(Drag::Resize, KWinNotification::InteractiveResizeStarted)
} else {
(Drag::Move, KWinNotification::InteractiveMoveStarted)
};
entry.drag = Some(kind);
if !entry.info.normal {
return vec![];
}
let window = Window::from(id);
vec![Output::Event(match kind {
Drag::Move => WindowManagerEvent::MoveStart(kwin(notification), window),
Drag::Resize => WindowManagerEvent::ResizeStart(kwin(notification), window),
})]
}
/// Part way through a drag: for a resize, where the user has the edges now. That is what the
/// window manager is told the window is until the drag is over; the frame follows when the client
/// has drawn at the new size, and is short of it.
fn on_drag_step(&mut self, event: &Value) -> Vec<Output> {
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
if entry.drag != Some(Drag::Resize) || !entry.info.normal || !event["geo"].is_object() {
return vec![];
}
entry.info.rect = rect(&event["geo"]);
vec![Output::Event(WindowManagerEvent::ResizeStep(
kwin(KWinNotification::InteractiveResizeStepped),
Window::from(id),
))]
}
fn on_drag_finished(&mut self, event: &Value) -> Vec<Output> {
if let (Some(x), Some(y)) = (event["cursor"]["x"].as_i64(), event["cursor"]["y"].as_i64()) {
self.cursor = Some((x as i32, y as i32));
}
let Some(id) = self.id_of(event) else {
return vec![];
};
let Some(entry) = self.windows.get_mut(&id) else {
return vec![];
};
// The window's frame is the one KWin has, and goes on changing as the client draws. For a
// resize, where the user took the edges to is the end of the drag, and is kept apart from
// the frame: the frame follows when the client has drawn at the new size, at the end of a
// drag it can be well short of that, and the frame events that follow it come before the
// window manager, which may be busy with an earlier event, handles the end.
entry.info.rect = rect(&event["geo"]);
entry.drag_end = match (entry.drag, event["requested"].is_object()) {
(Some(Drag::Resize), true) => Some(rect(&event["requested"])),
_ => None,
};
let Some(kind) = entry.drag.take() else {
return vec![];
};
if !entry.info.normal {
return vec![];
}
let window = Window::from(id);
vec![Output::Event(match kind {
Drag::Move => {
WindowManagerEvent::MoveEnd(kwin(KWinNotification::InteractiveMoveFinished), window)
}
Drag::Resize => WindowManagerEvent::ResizeEnd(
kwin(KWinNotification::InteractiveResizeFinished),
window,
),
})]
}
/// Some output now shows another desktop: komorebi's request, or a pager, a shortcut, an app
/// raising a window (KWin switches that output to the window's desktop)
fn on_current_desktops(&mut self, event: &Value) -> Vec<Output> {
let now = current_map(&event["current"]);
let mut out = vec![];
let mut changes: Vec<(String, String)> = now
.iter()
.filter(|(output, desktop)| self.current.get(*output) != Some(*desktop))
.map(|(o, d)| (o.clone(), d.clone()))
.collect();
changes.sort();
for (output, desktop) in changes {
let before = self.current.insert(output.clone(), desktop.clone());
// Activating a window komorebi has hidden (a taskbar click, an app raising itself) makes
// KWin follow it to the parking desktop, which has nothing on it but hidden windows. Go
// straight back; the window's own activation then tells komorebi to bring it forward.
if self.park_desktop.as_deref() == Some(desktop.as_str()) {
if let Some(back) = self.previous.get(&output).cloned().or(before) {
self.current.insert(output.clone(), back.clone());
out.push(Output::Command(
json!({ "op": "output_desktop", "output": output, "v": back }),
));
}
continue;
}
self.previous.insert(output.clone(), desktop.clone());
let (Some(idx), Some(monitor)) = (
self.workspace_index(&desktop),
self.monitors.iter().find(|m| m.name == output),
) else {
continue;
};
out.push(Output::Event(WindowManagerEvent::WorkspaceChange(
kwin(KWinNotification::WorkspaceChanged),
monitor.id,
idx,
)));
}
out
}
}
fn desktop_list(v: &Value) -> Vec<(String, String)> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|d| {
Some((
d["id"].as_str()?.to_string(),
d["name"].as_str()?.to_string(),
))
})
.collect()
})
.unwrap_or_default()
}
fn current_map(v: &Value) -> HashMap<String, String> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|d| {
Some((
d["output"].as_str()?.to_string(),
d["id"].as_str()?.to_string(),
))
})
.collect()
})
.unwrap_or_default()
}
/// The error of a request to hide a window when there is no parking desktop to hide it on: it has
/// to be made first.
///
/// [`Table::hide_commands`] returns it; the KWin backend makes the desktop, records it with
/// [`Table::set_park`] and asks again.
#[derive(Debug)]
pub struct NeedsPark;
/// The error of a request for a workspace that has no desktop yet: at least this many desktops
/// are needed.
///
/// [`Table::switch_commands`] and [`Table::window_workspace_commands`] return it; the KWin backend
/// makes the desktops and asks again.
#[derive(Debug)]
pub struct NeedsDesktops(pub usize);
/// The executable of a process, by name and by path.
///
/// Rules match on these (`Exe` is the basename, `Path` the full path), as they do on Windows.
/// `/proc/<pid>/exe` is a symlink to the executable; for a window whose process cannot be read
/// (another user's, a sandbox) the class is the best identity there is.
fn process(pid: i32, class: &str) -> (String, String) {
#[cfg(target_os = "linux")]
if pid > 0
&& let Ok(path) = std::fs::read_link(format!("/proc/{pid}/exe"))
{
let exe = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
return (exe, path.to_string_lossy().to_string());
}
let _ = pid;
(class.to_string(), String::new())
}
#[cfg(test)]
mod tests {
use super::*;
fn win(id: &str, desktops: &[&str]) -> Value {
json!({
"id": id, "pid": 0, "class": "foot", "caption": "terminal", "normal": true,
"minimized": false, "fullscreen": false,
"geo": { "x": 10, "y": 20, "w": 800, "h": 600 },
"desktops": desktops,
})
}
fn snapshot(windows: Vec<Value>) -> Value {
json!({
"type": "snapshot",
"windows": windows,
"screens": [{
"name": "DP-1", "manufacturer": "ACME", "model": "M1", "serial": "S1",
"geo": { "x": 0, "y": 0, "w": 1920, "h": 1080 },
"area": { "x": 0, "y": 0, "w": 1920, "h": 1050 },
}],
"desktops": [{ "id": "d1", "name": "Desktop 1" }, { "id": "d2", "name": "Desktop 2" }],
"current_desktops": [{ "output": "DP-1", "id": "d1" }],
"active": null,
"cursor": { "x": 5, "y": 6 },
})
}
fn table(windows: Vec<Value>) -> Table {
let mut t = Table::new();
t.handle(&snapshot(windows), Instant::now());
t
}
/// The parking desktop as it is when it has been made: listed by the compositor, and the one
/// windows are hidden on
fn with_park(t: &mut Table) {
let mut desktops: Vec<Value> = t
.desktops
.iter()
.map(|(id, name)| json!({ "id": id, "name": name }))
.collect();
desktops.push(json!({ "id": "park", "name": PARK_DESKTOP_NAME }));
t.handle(
&json!({ "type": "desktop_list", "desktops": desktops }),
Instant::now(),
);
t.set_park("park".to_string());
}
fn events(out: &[Output]) -> Vec<String> {
out.iter()
.filter_map(|o| match o {
Output::Event(e) => Some(format!("{e} {}", e.window_id().unwrap_or(0))),
_ => None,
})
.collect()
}
/// The events of a session as the bridge sends them: `bridge.test.js` plays the session
/// against a fake KWin and checks that the bridge sends exactly these
#[test]
fn the_bridges_events_for_a_session_are_the_window_events_komorebi_expects() {
let session: Vec<Value> =
serde_json::from_str(include_str!("fixtures/events.json")).unwrap();
let mut t = Table::new();
let now = Instant::now();
let mut trace = vec![];
for event in &session {
let out = t.handle(event, now);
let said: Vec<String> = out
.iter()
.map(|output| match output {
Output::Event(WindowManagerEvent::WorkspaceMove(_, window, idx)) => {
format!("WorkspaceMove {} to {idx}", window.id)
}
Output::Event(WindowManagerEvent::WorkspaceChange(_, _, idx)) => {
format!("WorkspaceChange to {idx}")
}
Output::Event(e) => format!("{e} {}", e.window_id().unwrap_or(0)),
Output::Monitor(notification) => format!("Monitor {notification}"),
Output::Command(command) => format!("Command {command}"),
Output::Cursor { token, x, y } => format!("Cursor {token} at {x},{y}"),
})
.collect();
trace.push(format!(
"{} -> {}",
event["type"].as_str().unwrap(),
said.join(", ")
));
// what komorebi asks for next (fixtures/commands.json, batch 3): the editor on the
// second workspace, and the output showing it
if event["seq"] == 17 {
let monitor = t.monitors()[0].id;
t.window_workspace_commands(1, 1).unwrap();
t.switch_commands(monitor, 1).unwrap();
}
// the end of the resize is where the user took the edge, and the window's frame is
// the one KWin has: the frame at the end of the session is the one the editor has on
// the other output
if event["seq"] == 29 {
assert_eq!(
t.drag_end(1).unwrap().right,
1100,
"where the user took the edge"
);
assert_eq!(t.window(1).unwrap().rect.right, 1040, "the frame KWin has");
}
if event["type"] == "added" && event["caption"] == "a terminal" {
let w = t.window(2).unwrap();
assert_eq!(
(w.pid, w.class.as_str(), w.title.as_str()),
(4343, "foot", "a terminal")
);
assert_eq!(
w.rect,
Rect {
left: 480,
top: 270,
right: 960,
bottom: 540
}
);
assert!(w.normal && !w.minimized);
}
}
assert_eq!(
trace,
[
"snapshot -> ",
"added -> Show 2",
"activated -> FocusChange 2",
"added -> ",
"minimized -> Minimize 2",
"minimized -> Restore 2",
"geometry -> ",
"cursor -> Cursor 1 at 1200,701",
"removed -> Destroy 2",
// the window manager's commands, and the terminal's, which had closed
"geometry -> ",
"activated -> FocusChange 1",
"minimized -> Minimize 1",
"minimized -> Restore 1",
"maximized -> MaximizeChange 1",
"maximized -> MaximizeChange 1",
"removed -> ",
"failed -> ",
// komorebi's own move and switch, coming back
"desktops -> ",
"current_desktops -> ",
// somebody else's: a new desktop, the editor moved back, the first one shown
"desktop_list -> ",
"desktops -> WorkspaceMove 1 to 0",
"current_desktops -> WorkspaceChange to 0",
// the user drags the editor, and then its right edge
"move_resize_started -> MoveStart 1",
"geometry -> ",
"move_resize_finished -> MoveEnd 1",
"move_resize_started -> ResizeStart 1",
"move_resize_step -> ResizeStep 1",
"geometry -> ",
"move_resize_finished -> ResizeEnd 1",
// a panel takes room from the monitor
"screens -> Monitor Resize",
// somebody moves the editor to another output
"output -> OutputChange 1",
// the user takes the editor fullscreen and back
"fullscreen -> FullscreenChange 1",
"fullscreen -> FullscreenChange 1",
]
);
// the editor of the snapshot is left; its dialog, which komorebi does not manage, closed
let windows = t.windows();
assert_eq!(windows.len(), 1);
assert_eq!(windows[0].title, "notes.txt — Kate");
assert_eq!(
windows[0].rect.right, 1040,
"the frame that goes with the output"
);
assert_eq!(t.window(3).map(|w| w.alive), Some(false));
assert_eq!(t.window(2).unwrap().rect.bottom, 532, "the geometry event");
assert_eq!(t.foreground(), Some(1));
assert_eq!(t.cursor(), Some((1500, 600)), "where the drag ended");
assert_eq!(t.workspace_count(), 3);
assert_eq!(t.window_workspace(1), Some(0));
assert_eq!(t.current_workspaces(), [(t.monitors()[0].id, 0)]);
let monitor = &t.monitors()[0];
assert_eq!(
(monitor.name.as_str(), monitor.serial_number_id.as_str()),
("DP-1", "ACME-M1-S1")
);
assert_eq!(
monitor.work_area,
Rect {
left: 0,
top: 0,
right: 1920,
bottom: 1000
}
);
}
#[test]
fn the_snapshot_fills_the_table_without_raising_events() {
let mut t = Table::new();
let out = t.handle(
&snapshot(vec![win("a", &["d1"]), win("b", &["d1"])]),
Instant::now(),
);
assert!(events(&out).is_empty());
let windows = t.windows();
assert_eq!(windows.len(), 2);
assert_eq!(
windows[0].rect,
Rect {
left: 10,
top: 20,
right: 800,
bottom: 600
}
);
assert_eq!(t.cursor(), Some((5, 6)));
assert_eq!(t.current_workspaces(), vec![(t.monitors()[0].id, 0)]);
}
#[test]
fn the_focused_application_is_the_one_of_the_window_kwin_activated() {
let mut dialog = win("b", &["d1"]);
dialog["normal"] = json!(false);
dialog["desktopFile"] = json!("org.codeberg.dnkl.foot");
let mut t = table(vec![win("a", &["d1"]), dialog]);
assert_eq!(t.focused_application(), None);
// a dialog is its application's too
t.handle(&json!({ "type": "activated", "id": "b" }), Instant::now());
assert_eq!(
t.focused_application(),
Some(Focus {
// pid 0 has no executable to read: the class stands in for it
exe: "foot".into(),
app_id: "foot".into(),
desktop_entry: "org.codeberg.dnkl.foot".into(),
})
);
t.handle(&json!({ "type": "activated", "id": null }), Instant::now());
assert_eq!(t.focused_application(), None);
t.handle(&json!({ "type": "activated", "id": "b" }), Instant::now());
t.handle(&json!({ "type": "removed", "id": "b" }), Instant::now());
assert_eq!(t.focused_application(), None);
}
#[test]
fn monitors_get_a_stable_identity_from_the_serial_not_the_port() {
let t = table(vec![]);
let m = &t.monitors()[0];
assert_eq!(m.serial_number_id, "ACME-M1-S1");
assert_eq!(m.id, stable_id("ACME-M1-S1"));
assert_eq!(m.work_area.bottom, 1050);
let mut t2 = Table::new();
let mut s = snapshot(vec![]);
s["screens"][0]["name"] = json!("HDMI-A-2");
t2.handle(&s, Instant::now());
assert_eq!(
t2.monitors()[0].id,
m.id,
"same monitor on another port keeps its id"
);
}
#[test]
fn a_monitor_without_a_serial_is_identified_by_its_name() {
let mut t = Table::new();
let mut s = snapshot(vec![]);
s["screens"][0]["serial"] = json!("");
t.handle(&s, Instant::now());
assert_eq!(t.monitors()[0].serial_number_id, "DP-1");
}
#[test]
fn ids_are_assigned_once_per_window_and_survive_a_new_snapshot() {
let mut t = table(vec![win("a", &["d1"]), win("b", &["d1"])]);
let before: Vec<u32> = t.windows().iter().map(|w| w.id).collect();
t.handle(
&snapshot(vec![
win("b", &["d1"]),
win("a", &["d1"]),
win("c", &["d1"]),
]),
Instant::now(),
);
let after: Vec<u32> = t.windows().iter().map(|w| w.id).collect();
assert_eq!(&after[..2], &before[..]);
assert_eq!(after.len(), 3);
}
#[test]
fn a_new_window_raises_show_and_then_focus_in_that_order() {
let mut t = table(vec![]);
let now = Instant::now();
let shown = t.handle(
&json!({ "type": "added", "id": "w1", "pid": 0, "class": "foot",
"caption": "x", "normal": true, "geo": {"x":0,"y":0,"w":1,"h":1}, "desktops": ["d1"] }),
now,
);
let focused = t.handle(&json!({ "type": "activated", "id": "w1" }), now);
assert_eq!(events(&shown), vec!["Show 1"]);
assert_eq!(events(&focused), vec!["FocusChange 1"]);
assert_eq!(t.foreground(), Some(1));
}
#[test]
fn announcing_the_same_window_twice_shows_it_once() {
let mut t = table(vec![]);
let added = json!({ "type": "added", "id": "w1", "pid": 0, "class": "foot", "caption": "x",
"normal": true, "geo": {"x":0,"y":0,"w":1,"h":1}, "desktops": ["d1"] });
assert_eq!(events(&t.handle(&added, Instant::now())).len(), 1);
assert!(events(&t.handle(&added, Instant::now())).is_empty());
}
#[test]
fn dialogs_panels_and_popups_raise_nothing() {
let mut t = table(vec![]);
let now = Instant::now();
let mut dialog = win("dlg", &["d1"]);
dialog["type"] = json!("added");
dialog["normal"] = json!(false);
assert!(t.handle(&dialog, now).is_empty());
assert!(
t.handle(&json!({ "type": "activated", "id": "dlg" }), now)
.is_empty()
);
assert!(t.windows().is_empty());
// ... though they are still known, and still have a foreground
assert_eq!(t.foreground(), Some(1));
}
#[test]
fn a_closed_window_raises_destroy_and_can_still_be_asked_about() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
t.handle(&json!({ "type": "activated", "id": "a" }), now);
let out = t.handle(&json!({ "type": "removed", "id": "a" }), now);
assert_eq!(events(&out), vec!["Destroy 1"]);
assert_eq!(t.foreground(), None);
let info = t.window(1).expect("a tombstone is kept");
assert!(!info.alive);
assert_eq!(info.title, "terminal");
assert!(t.windows().is_empty());
}
#[test]
fn tombstones_are_dropped_after_a_while_and_their_ids_are_not_reused() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
t.handle(&json!({ "type": "removed", "id": "a" }), now);
t.handle(
&json!({ "type": "geometry", "id": "nobody", "geo": {"x":0,"y":0,"w":0,"h":0} }),
now + Duration::from_secs(61),
);
assert!(t.window(1).is_none());
let out = t.handle(
&json!({ "type": "added", "id": "b", "pid": 0, "class": "foot", "caption": "x",
"normal": true, "geo": {"x":0,"y":0,"w":1,"h":1}, "desktops": ["d1"] }),
now,
);
assert_eq!(events(&out), vec!["Show 2"]);
}
#[test]
fn minimize_and_restore_map_to_their_events() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
assert_eq!(
events(&t.handle(&json!({ "type": "minimized", "id": "a", "v": true }), now)),
vec!["Minimize 1"]
);
assert!(t.window(1).unwrap().minimized);
assert_eq!(
events(&t.handle(&json!({ "type": "minimized", "id": "a", "v": false }), now)),
vec!["Restore 1"]
);
}
#[test]
fn going_fullscreen_and_coming_back_are_events_and_are_remembered() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
assert_eq!(
events(&t.handle(&json!({ "type": "fullscreen", "id": "a", "v": true }), now)),
vec!["FullscreenChange 1"]
);
assert!(t.window(1).unwrap().fullscreen);
assert_eq!(
events(&t.handle(&json!({ "type": "fullscreen", "id": "a", "v": false }), now)),
vec!["FullscreenChange 1"]
);
assert!(!t.window(1).unwrap().fullscreen);
}
#[test]
fn a_window_that_is_fullscreen_when_the_script_starts_is_fullscreen() {
let mut fullscreen = win("a", &["d1"]);
fullscreen["fullscreen"] = json!(true);
let t = table(vec![fullscreen, win("b", &["d1"])]);
assert!(t.window(1).unwrap().fullscreen);
assert!(!t.window(2).unwrap().fullscreen);
}
#[test]
fn maximizing_and_restoring_are_events_and_are_remembered() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
assert!(!t.window(1).unwrap().maximized);
assert_eq!(
events(&t.handle(&json!({ "type": "maximized", "id": "a", "v": true }), now)),
vec!["MaximizeChange 1"]
);
assert!(t.window(1).unwrap().maximized);
assert_eq!(
events(&t.handle(&json!({ "type": "maximized", "id": "a", "v": false }), now)),
vec!["MaximizeChange 1"]
);
assert!(!t.window(1).unwrap().maximized);
}
#[test]
fn a_window_that_is_maximized_when_the_script_starts_is_maximized() {
let mut maximized = win("a", &["d1"]);
maximized["maximized"] = json!(true);
let t = table(vec![maximized, win("b", &["d1"])]);
assert!(t.window(1).unwrap().maximized);
assert!(!t.window(2).unwrap().maximized);
}
#[test]
fn a_dialog_that_is_maximized_is_remembered_and_raises_nothing() {
let mut dialog = win("dlg", &["d1"]);
dialog["normal"] = json!(false);
let mut t = table(vec![dialog]);
let out = t.handle(
&json!({ "type": "maximized", "id": "dlg", "v": true }),
Instant::now(),
);
assert!(out.is_empty());
assert!(t.window(1).unwrap().maximized);
assert!(
t.windows().is_empty(),
"it is not a window komorebi may manage"
);
}
#[test]
fn geometry_updates_the_rect_silently() {
let mut t = table(vec![win("a", &["d1"])]);
let out = t.handle(
&json!({ "type": "geometry", "id": "a", "geo": {"x":1,"y":2,"w":3,"h":4} }),
Instant::now(),
);
assert!(out.is_empty());
assert_eq!(
t.window(1).unwrap().rect,
Rect {
left: 1,
top: 2,
right: 3,
bottom: 4
}
);
}
#[test]
fn a_window_on_another_output_raises_an_output_change_with_the_frame_it_has_there() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let out = t.handle(
&json!({
"type": "output", "id": "a", "output": "DP-2",
"geo": { "x": 2100, "y": 300, "w": 800, "h": 600 },
}),
now,
);
assert_eq!(events(&out), vec!["OutputChange 1"]);
let window = t.window(1).unwrap();
assert_eq!(
window.rect,
Rect {
left: 2100,
top: 300,
right: 800,
bottom: 600
}
);
}
#[test]
fn an_output_change_of_a_dialog_or_of_a_window_nobody_knows_raises_nothing() {
let mut t = table(vec![]);
t.handle(
&json!({
"type": "added", "id": "dialog", "pid": 0, "class": "foot", "caption": "Save As",
"normal": false, "minimized": false, "fullscreen": false,
"geo": { "x": 0, "y": 0, "w": 100, "h": 100 }, "desktops": ["d1"],
}),
Instant::now(),
);
for id in ["dialog", "nobody"] {
let out = t.handle(
&json!({ "type": "output", "id": id, "output": "DP-2" }),
Instant::now(),
);
assert!(out.is_empty(), "{out:?}");
}
}
#[test]
fn a_title_change_raises_a_title_update() {
let mut t = table(vec![win("a", &["d1"])]);
let out = t.handle(
&json!({ "type": "caption", "id": "a", "caption": "renamed" }),
Instant::now(),
);
assert_eq!(events(&out), vec!["TitleUpdate 1"]);
assert_eq!(t.window(1).unwrap().title, "renamed");
}
#[test]
fn a_drag_is_reported_as_a_move_or_a_resize_from_start_to_end() {
let mut t = table(vec![win("a", &["d1"]), win("b", &["d1"])]);
let now = Instant::now();
let geo = json!({"x":0,"y":0,"w":100,"h":100});
let started = t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": true, "resize": false, "geo": geo }), now);
let finished = t.handle(&json!({ "type": "move_resize_finished", "id": "a", "geo": geo, "cursor": {"x": 50, "y": 60} }), now);
assert_eq!(events(&started), vec!["MoveStart 1"]);
assert_eq!(events(&finished), vec!["MoveEnd 1"]);
assert_eq!(
t.cursor(),
Some((50, 60)),
"the cursor at the end of the drag is kept"
);
let started = t.handle(&json!({ "type": "move_resize_started", "id": "b", "move": false, "resize": true, "geo": geo }), now);
let finished = t.handle(&json!({ "type": "move_resize_finished", "id": "b", "geo": geo, "cursor": {"x": 1, "y": 1} }), now);
assert_eq!(events(&started), vec!["ResizeStart 2"]);
assert_eq!(events(&finished), vec!["ResizeEnd 2"]);
}
#[test]
fn the_end_of_a_resize_is_where_the_user_took_it_not_where_the_frame_had_got_to() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let start = json!({"x":10,"y":10,"w":100,"h":100});
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": false, "resize": true, "geo": start }), now);
t.handle(
&json!({ "type": "move_resize_finished", "id": "a",
"geo": {"x":10,"y":10,"w":112,"h":100},
"requested": {"x":10,"y":10,"w":172,"h":100},
"cursor": {"x": 1, "y": 1} }),
now,
);
let end = t.drag_end(1).unwrap();
assert_eq!((end.left, end.right), (10, 172), "{end:?}");
let frame = t.window(1).unwrap().rect;
assert_eq!(
(frame.left, frame.right),
(10, 112),
"the frame is KWin's: {frame:?}"
);
}
/// The order of a run of the VM test that failed: the user lets go, the client has not drawn
/// at the size they asked for, KWin reports its frame a millisecond after the end, and the
/// window manager, busy with an earlier event, gets to the end 17 ms after that
#[test]
fn a_frame_that_follows_the_end_of_a_resize_does_not_change_where_the_user_took_it() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": false, "resize": true, "geo": {"x":10,"y":10,"w":100,"h":100} }), now);
let finished = t.handle(
&json!({ "type": "move_resize_finished", "id": "a",
"geo": {"x":10,"y":10,"w":112,"h":100},
"requested": {"x":10,"y":10,"w":172,"h":100},
"cursor": {"x": 1, "y": 1} }),
now,
);
assert_eq!(events(&finished), vec!["ResizeEnd 1"]);
t.handle(
&json!({ "type": "geometry", "id": "a", "geo": {"x":10,"y":10,"w":160,"h":100} }),
now + Duration::from_millis(1),
);
// what the window manager reads when it handles the end, 17 ms after the end
let end = t.drag_end(1).unwrap();
assert_eq!((end.left, end.right), (10, 172), "{end:?}");
let frame = t.window(1).unwrap().rect;
assert_eq!(frame.right, 160, "the frame is the one KWin reported last");
}
#[test]
fn a_resize_with_no_step_or_a_move_has_no_end_of_its_own() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let start = json!({"x":10,"y":10,"w":100,"h":100});
let end = json!({ "type": "move_resize_finished", "id": "a",
"geo": {"x":10,"y":10,"w":112,"h":100}, "cursor": {"x": 1, "y": 1} });
// a resize that sent no step: its end is the frame
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": false, "resize": true, "geo": start }), now);
t.handle(&end, now);
assert_eq!(t.drag_end(1), None);
// the end of the last resize is forgotten when the window is taken hold of again
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": false, "resize": true, "geo": start }), now);
t.handle(
&json!({ "type": "move_resize_finished", "id": "a",
"geo": {"x":10,"y":10,"w":112,"h":100},
"requested": {"x":10,"y":10,"w":172,"h":100},
"cursor": {"x": 1, "y": 1} }),
now,
);
assert!(t.drag_end(1).is_some());
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": true, "resize": false, "geo": start }), now);
assert_eq!(t.drag_end(1), None, "a new drag has no end yet");
// and a move has none, whatever the event says
t.handle(
&json!({ "type": "move_resize_finished", "id": "a",
"geo": {"x":50,"y":60,"w":100,"h":100},
"requested": {"x":999,"y":999,"w":100,"h":100},
"cursor": {"x": 1, "y": 1} }),
now,
);
assert_eq!(t.drag_end(1), None);
}
#[test]
fn the_frame_a_drag_began_with_is_kept_while_the_frame_changes() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": false, "resize": true, "geo": {"x":10,"y":10,"w":100,"h":100} }), now);
t.handle(
&json!({ "type": "geometry", "id": "a", "geo": {"x":10,"y":10,"w":140,"h":100} }),
now,
);
assert_eq!(t.window(1).unwrap().rect.right, 140);
let origin = t.drag_origin(1).unwrap();
assert_eq!((origin.left, origin.right), (10, 100), "{origin:?}");
}
#[test]
fn steps_are_events_with_where_the_user_has_the_edge_and_do_not_lose_where_the_drag_began() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let start = json!({"x":10,"y":10,"w":100,"h":100});
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": false, "resize": true, "geo": start }), now);
let step = t.handle(
&json!({ "type": "move_resize_step", "id": "a", "geo": {"x":10,"y":10,"w":130,"h":100} }),
now,
);
assert_eq!(events(&step), vec!["ResizeStep 1"]);
assert_eq!(
t.window(1).unwrap().rect.right,
130,
"the window is where the user has it"
);
let origin = t.drag_origin(1).unwrap();
assert_eq!(
(origin.left, origin.right),
(10, 100),
"the drag began somewhere else: {origin:?}"
);
}
#[test]
fn steps_of_a_move_and_steps_with_no_drag_are_nothing() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let geo = json!({"x":10,"y":10,"w":100,"h":100});
// no drag
assert!(
t.handle(
&json!({ "type": "move_resize_step", "id": "a", "geo": geo }),
now
)
.is_empty()
);
// a move
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": true, "resize": false, "geo": geo }), now);
assert!(
t.handle(
&json!({ "type": "move_resize_step", "id": "a", "geo": geo }),
now
)
.is_empty()
);
}
#[test]
fn a_move_is_where_the_frame_is() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let start = json!({"x":10,"y":10,"w":100,"h":100});
t.handle(&json!({ "type": "move_resize_started", "id": "a", "move": true, "resize": false, "geo": start }), now);
t.handle(
&json!({ "type": "move_resize_finished", "id": "a",
"geo": {"x":50,"y":60,"w":100,"h":100},
"requested": {"x":999,"y":999,"w":100,"h":100},
"cursor": {"x": 1, "y": 1} }),
now,
);
assert_eq!(t.window(1).unwrap().rect.left, 50);
}
#[test]
fn a_finish_without_a_start_is_ignored() {
let mut t = table(vec![win("a", &["d1"])]);
let out = t.handle(&json!({ "type": "move_resize_finished", "id": "a", "geo": {"x":0,"y":0,"w":1,"h":1}, "cursor": {"x":0,"y":0} }), Instant::now());
assert!(events(&out).is_empty());
}
#[test]
fn every_desktop_is_a_workspace_and_a_window_is_on_the_one_it_is_on() {
let t = table(vec![
win("first", &["d1"]),
win("second", &["d2"]),
win("everywhere", &[]),
]);
assert_eq!(
t.windows().len(),
3,
"windows on any desktop are komorebi's"
);
assert_eq!(t.window_workspace(1), Some(0));
assert_eq!(t.window_workspace(2), Some(1));
assert_eq!(
t.window_workspace(3),
None,
"a window on every desktop is on none"
);
assert_eq!(t.workspace_count(), 2);
}
#[test]
fn the_parking_desktop_is_not_a_workspace() {
let mut t = Table::new();
let mut s = snapshot(vec![win("a", &["d1"])]);
s["desktops"] = json!([
{ "id": "d1", "name": "Desktop 1" },
{ "id": "d2", "name": "Desktop 2" },
{ "id": "park", "name": PARK_DESKTOP_NAME },
]);
t.handle(&s, Instant::now());
assert_eq!(t.workspace_count(), 2);
}
#[test]
fn moving_a_window_to_another_desktop_is_reported_once_as_a_workspace_move() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
let out = t.handle(
&json!({ "type": "desktops", "id": "a", "desktops": ["d2"] }),
now,
);
assert!(
matches!(
&out[..],
[Output::Event(WindowManagerEvent::WorkspaceMove(_, _, 1))]
),
"{out:?}"
);
assert_eq!(t.window_workspace(1), Some(1));
assert!(t.window(1).unwrap().normal);
// the same again is nothing new
let out = t.handle(
&json!({ "type": "desktops", "id": "a", "desktops": ["d2"] }),
now,
);
assert!(out.is_empty());
}
#[test]
fn komorebis_own_move_and_its_park_and_restore_raise_nothing_new() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
// komorebi put it on workspace 1; kwin says so
t.window_workspace_commands(1, 1).unwrap();
let out = t.handle(
&json!({ "type": "desktops", "id": "a", "desktops": ["d2"] }),
now,
);
assert!(out.is_empty(), "{out:?}");
// komorebi parked it; kwin says so, and then that it is back
with_park(&mut t);
t.hide_commands(1).unwrap();
let out = t.handle(
&json!({ "type": "desktops", "id": "a", "desktops": ["park"] }),
now,
);
assert!(out.is_empty(), "{out:?}");
t.restore_commands(1);
let out = t.handle(
&json!({ "type": "desktops", "id": "a", "desktops": ["d2"] }),
now,
);
assert!(
matches!(
&out[..],
[Output::Event(WindowManagerEvent::WorkspaceMove(_, _, 1))]
),
"restoring reports the workspace it came back to; the window manager already has it there: {out:?}"
);
}
#[test]
fn a_window_is_put_on_a_workspace_by_putting_it_on_its_desktop() {
let mut t = table(vec![win("a", &["d1"])]);
assert_eq!(
t.window_workspace_commands(1, 1).unwrap(),
vec![json!({ "op": "desktop", "id": "a", "v": "d2" })]
);
assert_eq!(
t.window_workspace(1),
Some(1),
"visible to the next query at once"
);
// a window komorebi has hidden stays hidden, and comes back to the new workspace
with_park(&mut t);
t.hide_commands(1).unwrap();
assert!(t.window_workspace_commands(1, 0).unwrap().is_empty());
assert_eq!(t.window_workspace(1), Some(0));
assert_eq!(
t.restore_commands(1),
vec![json!({ "op": "desktop", "id": "a", "v": "d1" })]
);
}
#[test]
fn showing_a_workspace_switches_that_output_only() {
let mut t = table(vec![]);
let monitor = t.monitors()[0].id;
assert_eq!(
t.switch_commands(monitor, 1).unwrap(),
vec![json!({ "op": "output_desktop", "output": "DP-1", "v": "d2" })]
);
assert_eq!(t.current_workspaces(), vec![(monitor, 1)]);
}
#[test]
fn a_workspace_without_a_desktop_asks_for_one() {
let mut t = table(vec![win("a", &["d1"])]);
let monitor = t.monitors()[0].id;
assert!(matches!(
t.switch_commands(monitor, 4),
Err(NeedsDesktops(5))
));
assert!(matches!(
t.window_workspace_commands(1, 2),
Err(NeedsDesktops(3))
));
}
#[test]
fn parking_a_window_hides_it_without_unmanaging_it() {
let mut t = table(vec![win("a", &["d1"])]);
let now = Instant::now();
assert!(
t.hide_commands(1).is_err(),
"there is no parking desktop yet"
);
with_park(&mut t);
let cmds = t.hide_commands(1).unwrap();
assert_eq!(
cmds,
vec![json!({ "op": "desktop", "id": "a", "v": "park" })]
);
// kwin reports the window now being on the parking desktop: still ours
let out = t.handle(
&json!({ "type": "desktops", "id": "a", "desktops": ["park"] }),
now,
);
assert!(events(&out).is_empty());
assert!(t.window(1).unwrap().normal);
// and restoring sends it home again, not to wherever the user is now
let cmds = t.restore_commands(1);
assert_eq!(cmds, vec![json!({ "op": "desktop", "id": "a", "v": "d1" })]);
assert!(
t.restore_commands(1).is_empty(),
"restoring twice is a no-op"
);
}
#[test]
fn a_window_on_every_desktop_is_parked_and_returned_to_the_home_desktop() {
let mut t = table(vec![win("a", &[])]);
with_park(&mut t);
t.hide_commands(1).unwrap();
assert_eq!(
t.restore_commands(1),
vec![json!({ "op": "desktop", "id": "a", "v": "d1" })]
);
}
#[test]
fn a_parking_desktop_left_by_a_crashed_run_is_swept() {
let mut t = Table::new();
let mut s = snapshot(vec![win("stuck", &["park"]), win("fine", &["d1"])]);
s["desktops"] = json!([
{ "id": "d1", "name": "Desktop 1" },
{ "id": "park", "name": PARK_DESKTOP_NAME },
]);
let out = t.handle(&s, Instant::now());
let commands: Vec<&Value> = out
.iter()
.filter_map(|o| {
if let Output::Command(c) = o {
Some(c)
} else {
None
}
})
.collect();
assert_eq!(
commands,
vec![&json!({ "op": "desktop", "id": "stuck", "v": "d1" })]
);
assert_eq!(t.stale_park(), Some("park"));
t.clear_stale_park();
assert!(t.stale_park().is_none());
}
#[test]
fn a_stale_parking_desktop_is_not_the_one_windows_are_hidden_on() {
let mut t = Table::new();
let mut s = snapshot(vec![win("a", &["d1"])]);
s["desktops"] = json!([
{ "id": "d1", "name": "Desktop 1" },
{ "id": "stale", "name": PARK_DESKTOP_NAME },
]);
t.handle(&s, Instant::now());
// the stale one goes; hiding now needs a parking desktop of its own, and is not sent to it
assert!(t.hide_commands(1).is_err());
assert_eq!(t.park_desktop(), None);
}
#[test]
fn a_parking_desktop_that_has_gone_is_made_again_not_sent_windows() {
let mut t = table(vec![win("a", &["d1"])]);
t.set_park("park".to_string());
// nothing lists it: somebody removed it
assert!(
t.hide_commands(1).is_err(),
"a parking desktop that is not there is not one"
);
// once it is there, it is used
t.handle(
&json!({ "type": "desktop_list", "desktops": [
{ "id": "d1", "name": "Desktop 1" },
{ "id": "park", "name": PARK_DESKTOP_NAME },
] }),
Instant::now(),
);
t.set_park("park".to_string());
assert_eq!(
t.hide_commands(1).unwrap(),
vec![json!({ "op": "desktop", "id": "a", "v": "park" })]
);
}
#[test]
fn forgetting_the_parking_desktop_makes_hiding_ask_for_one_again() {
let mut t = table(vec![win("a", &["d1"])]);
with_park(&mut t);
assert_eq!(t.park_desktop(), Some("park"));
t.forget_park();
assert_eq!(t.park_desktop(), None);
assert!(t.hide_commands(1).is_err());
}
#[test]
fn a_window_the_table_does_not_know_is_neither_hidden_nor_restored() {
let mut t = table(vec![]);
with_park(&mut t);
assert!(t.hide_commands(9).unwrap().is_empty());
assert!(t.restore_commands(9).is_empty());
}
#[test]
fn a_window_that_closes_while_hidden_is_not_hidden_when_it_is_asked_about_again() {
let mut t = table(vec![win("a", &["d1"])]);
with_park(&mut t);
t.hide_commands(1).unwrap();
t.handle(&json!({ "type": "removed", "id": "a" }), Instant::now());
assert!(t.restore_commands(1).is_empty());
}
#[test]
fn following_a_hidden_window_to_the_parking_desktop_sends_that_output_back() {
let mut t = table(vec![win("a", &["d1"])]);
with_park(&mut t);
let out = t.handle(
&json!({ "type": "current_desktops", "current": [{ "output": "DP-1", "id": "park" }] }),
Instant::now(),
);
assert!(
matches!(&out[..], [Output::Command(c)]
if *c == json!({ "op": "output_desktop", "output": "DP-1", "v": "d1" })),
"{out:?}"
);
}
#[test]
fn another_party_switching_a_monitor_is_a_workspace_change() {
let mut t = table(vec![]);
let monitor = t.monitors()[0].id;
let out = t.handle(
&json!({ "type": "current_desktops", "current": [{ "output": "DP-1", "id": "d2" }] }),
Instant::now(),
);
assert!(
matches!(&out[..], [Output::Event(WindowManagerEvent::WorkspaceChange(_, m, 1))] if *m == monitor),
"{out:?}"
);
// the same again says nothing
let out = t.handle(
&json!({ "type": "current_desktops", "current": [{ "output": "DP-1", "id": "d2" }] }),
Instant::now(),
);
assert!(out.is_empty());
}
#[test]
fn komorebi_switching_a_monitor_comes_back_as_a_change_to_what_it_already_knows() {
let mut t = table(vec![]);
let monitor = t.monitors()[0].id;
t.switch_commands(monitor, 1).unwrap();
// the table already believes it, so KWin's report of it raises nothing a second time
let out = t.handle(
&json!({ "type": "current_desktops", "current": [{ "output": "DP-1", "id": "d2" }] }),
Instant::now(),
);
assert!(out.is_empty(), "{out:?}");
}
#[test]
fn a_new_list_of_desktops_is_read_and_raises_nothing() {
let mut t = table(vec![win("a", &["d3"])]);
assert_eq!(t.window_workspace(1), None, "d3 is not a desktop yet");
let out = t.handle(
&json!({ "type": "desktop_list", "desktops": [
{ "id": "d1", "name": "Desktop 1" },
{ "id": "d2", "name": "Desktop 2" },
{ "id": "d3", "name": "mail" },
] }),
Instant::now(),
);
assert!(out.is_empty(), "{out:?}");
assert_eq!(t.workspace_count(), 3);
assert_eq!(t.window_workspace(1), Some(2));
}
#[test]
fn plugging_in_a_monitor_is_a_connection_change_and_a_new_panel_is_a_resize() {
let mut t = table(vec![]);
let now = Instant::now();
let mut screens = snapshot(vec![])["screens"].clone();
// a work area change: the panel grew
screens[0]["area"]["h"] = json!(1000);
let out = t.handle(
&json!({ "type": "screens", "screens": screens.clone() }),
now,
);
assert!(
matches!(&out[..], [Output::Monitor(MonitorNotification::Resize(id))] if *id == t.monitors()[0].id),
"{out:?}"
);
assert_eq!(t.monitors()[0].work_area.bottom, 1000);
// a resolution change
screens[0]["geo"]["w"] = json!(1280);
screens[0]["geo"]["h"] = json!(720);
let out = t.handle(
&json!({ "type": "screens", "screens": screens.clone() }),
now,
);
assert!(matches!(
&out[..],
[Output::Monitor(MonitorNotification::Resize(_))]
));
assert_eq!(t.monitors()[0].size.right, 1280);
// a second monitor appears
let mut two = screens.clone();
two.as_array_mut().unwrap().push(json!({
"name": "DP-2", "manufacturer": "ACME", "model": "M1", "serial": "S2",
"geo": { "x": 1920, "y": 0, "w": 1920, "h": 1080 }, "area": { "x": 1920, "y": 0, "w": 1920, "h": 1080 },
}));
let two_screens = two.clone();
let out = t.handle(&json!({ "type": "screens", "screens": two }), now);
assert!(matches!(
&out[..],
[Output::Monitor(
MonitorNotification::DisplayConnectionChange(_)
)]
));
assert_eq!(t.monitors().len(), 2);
// the same screens again change nothing
let again = json!({ "type": "screens", "screens": two_screens });
assert!(t.handle(&again, now).is_empty());
// and one goes
let out = t.handle(&json!({ "type": "screens", "screens": screens }), now);
assert!(matches!(
&out[..],
[Output::Monitor(
MonitorNotification::DisplayConnectionChange(_)
)]
));
assert_eq!(t.monitors().len(), 1);
}
#[test]
fn a_cursor_query_answer_is_passed_on_and_remembered() {
let mut t = table(vec![]);
let out = t.handle(
&json!({ "type": "cursor", "token": 7, "x": 300, "y": 400 }),
Instant::now(),
);
assert!(matches!(
&out[..],
[Output::Cursor {
token: 7,
x: 300,
y: 400
}]
));
assert_eq!(t.cursor(), Some((300, 400)));
}
#[test]
fn a_requested_rect_is_visible_at_once_and_replaced_by_the_real_one() {
let mut t = table(vec![win("a", &["d1"])]);
t.note_requested_rect(
1,
Rect {
left: 0,
top: 0,
right: 960,
bottom: 1050,
},
);
assert_eq!(t.window(1).unwrap().rect.right, 960);
t.handle(
&json!({ "type": "geometry", "id": "a", "geo": {"x":0,"y":0,"w":956,"h":1048} }),
Instant::now(),
);
assert_eq!(
t.window(1).unwrap().rect.right,
956,
"the client rounded it to its cell grid"
);
}
#[test]
fn when_kwin_goes_away_every_window_it_had_is_destroyed() {
let mut t = table(vec![win("a", &["d1"]), win("b", &["d1"])]);
with_park(&mut t);
t.handle(&json!({ "type": "activated", "id": "a" }), Instant::now());
let mut destroyed = events(&t.compositor_lost(Instant::now()));
destroyed.sort();
assert_eq!(destroyed, vec!["Destroy 1", "Destroy 2"]);
assert_eq!(t.foreground(), None);
assert_eq!(t.park_desktop(), None);
assert!(t.windows().is_empty());
assert!(
t.compositor_lost(Instant::now()).is_empty(),
"a window is destroyed once"
);
// the windows of the KWin that comes back are new ones, with ids of their own
t.handle(&snapshot(vec![win("c", &["d1"])]), Instant::now());
let ids: Vec<u32> = t.windows().iter().map(|w| w.id).collect();
assert_eq!(ids, vec![3]);
}
}