Files
komorebi/komorebi/tests/maximize_commands.rs
T
LGUG2Z 2b116ea2a3 feat(kwin): wallpapers for monitors and workspaces
Plasma keeps one wallpaper for each screen, not for each virtual desktop, so a
workspace that wants a picture of its own has nowhere to keep it in the shell.
komorebi sets the wallpaper of a screen when a workspace comes into view: the
workspace's own, else its monitor's. It does so however the workspace came into
view (a komorebic command, a pager, an application raising a window) and for the
workspace in front when it starts. A monitor and a workspace with no wallpaper
are left alone.

The Plasma shell sets it over D-Bus, with the call plasma-apply-wallpaperimage
makes, but for one screen. Backend::set_wallpaper asks for it every time a
workspace comes into view, and the KWin backend asks the shell what the screen
shows first, so a picture the user changed by hand is put back and one that is
already right is not touched. The request runs in the background, so switching
workspaces never waits for the shell, and goes on trying for about half a minute
when the shell is not up yet.

A wallpaper also gives the borders the colors of the palette made from its
picture, unless it says generate_theme is false, and theme_options choose the
variant and the color each border takes. The colors change before the workspace
is shown, so its borders are right at once.

komorebi.json takes the wallpaper of a monitor and the wallpaper of a workspace,
and a file that is read again shows the wallpaper of the workspace each monitor
has in front at once. vm-wallpaper runs against the real shell: set at start and
by workspace, a switch komorebi did not make, the colors of the borders, a
wallpaper changed by hand, the palette cache, and komorebi that starts before
the shell.
2026-10-28 07:20:49 -07:00

368 lines
13 KiB
Rust

//! What `toggle-maximize` does to the rest of the window manager, against an in-memory desktop: a
//! window that is maximized is in no container, the messages about the tiles do nothing until it
//! is restored, and the state has it. The focus crosses to a monitor where one is maximized, and a
//! window that is maximized is hidden and shown with its workspace.
//!
//! 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;
use komorebi::core::CycleDirection;
use komorebi::core::OperationDirection;
use komorebi::core::Rect;
use komorebi::core::SocketMessage;
use komorebi::state::State;
use komorebi::window::Window;
use komorebi::window_manager::WindowManager;
use komorebi::window_manager_event::KWinNotification;
use komorebi::window_manager_event::SystemNotification;
use komorebi::window_manager_event::WindowManagerEvent;
use std::sync::Arc;
fn added(id: u32) -> WindowManagerEvent {
WindowManagerEvent::Show(
SystemNotification::KWin(KWinNotification::WindowAdded),
Window::from(id),
)
}
fn activated(id: u32) -> WindowManagerEvent {
WindowManagerEvent::FocusChange(
SystemNotification::KWin(KWinNotification::WindowActivated),
Window::from(id),
)
}
/// A window manager over a fake desktop with one 1920x1080 monitor (1920x1050 without the panel),
/// and a window for each of `ids`, opened in that order
fn desktop_with(ids: &[u32]) -> (Arc<FakeBackend>, WindowManager) {
let fake = Arc::new(FakeBackend::with_one_monitor());
let (_sender, receiver) = crossbeam_channel::bounded(1);
// unix socket paths are limited to ~104 bytes on macOS, which the temp dir alone can exceed
static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
let socket = std::path::PathBuf::from(format!(
"/tmp/kmx-{}-{}.sock",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
));
let wm = with_backend(fake.clone(), || {
let mut wm = WindowManager::new(receiver, Some(socket)).unwrap();
wm.init().unwrap();
for &id in ids {
fake.open_window(id, "foot", "foot", &format!("terminal {id}"));
wm.process_event(added(id)).unwrap();
}
wm
});
(fake, wm)
}
/// A window manager over a fake desktop with two monitors side by side, and a window for each of
/// `left` on the one on the left and of `right` on the one on the right, opened in that order
fn two_monitors_with(left: &[u32], right: &[u32]) -> (Arc<FakeBackend>, WindowManager) {
let fake = FakeBackend::with_one_monitor();
let right_half = Rect {
left: 1920,
top: 0,
right: 1920,
bottom: 1080,
};
fake.add_monitor(2, "Virtual-1", right_half, right_half);
let fake = Arc::new(fake);
let (_sender, receiver) = crossbeam_channel::bounded(1);
// unix socket paths are limited to ~104 bytes on macOS, which the temp dir alone can exceed
static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(1000);
let socket = std::path::PathBuf::from(format!(
"/tmp/kmx-{}-{}.sock",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
));
let wm = with_backend(fake.clone(), || {
let mut wm = WindowManager::new(receiver, Some(socket)).unwrap();
wm.init().unwrap();
for (ids, on_right) in [(left, false), (right, true)] {
for &id in ids {
fake.open_window(id, "foot", "foot", &format!("terminal {id}"));
if on_right {
fake.move_window_by_user(
id,
Rect {
left: 2020,
top: 100,
right: 800,
bottom: 600,
},
);
}
wm.process_event(added(id)).unwrap();
}
}
wm
});
(fake, wm)
}
fn try_send(
fake: &Arc<FakeBackend>,
wm: &mut WindowManager,
message: SocketMessage,
) -> Result<(), String> {
with_backend(fake.clone(), || wm.process_command(message, Vec::new()))
.map_err(|error| error.to_string())
}
fn send(fake: &Arc<FakeBackend>, wm: &mut WindowManager, message: SocketMessage) {
try_send(fake, wm, message).unwrap();
}
fn event(fake: &Arc<FakeBackend>, wm: &mut WindowManager, event: WindowManagerEvent) {
with_backend(fake.clone(), || wm.process_event(event)).unwrap();
}
/// The windows the layout tiles, in the order of their containers
fn tiled(wm: &WindowManager) -> Vec<u32> {
wm.focused_workspace()
.unwrap()
.containers()
.iter()
.map(|container| container.focused_window().unwrap().id)
.collect()
}
fn maximized(wm: &WindowManager) -> Option<u32> {
wm.focused_workspace()
.unwrap()
.maximized_window
.map(|window| window.id)
}
#[test]
fn a_window_goes_back_in_a_container_of_its_own_at_the_index_it_came_from() {
let (fake, mut wm) = desktop_with(&[36_001, 36_002, 36_003]);
event(&fake, &mut wm, activated(36_002));
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
assert_eq!(maximized(&wm), Some(36_002));
assert_eq!(tiled(&wm), [36_001, 36_003]);
assert!(wm.focused_workspace().unwrap().contains_window(36_002));
assert!(
wm.focused_workspace()
.unwrap()
.contains_managed_window(36_002)
);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
assert_eq!(maximized(&wm), None);
assert_eq!(tiled(&wm), [36_001, 36_002, 36_003]);
assert_eq!(wm.focused_workspace().unwrap().focused_container_idx(), 1);
}
#[test]
fn while_a_window_is_maximized_what_is_about_the_tiles_does_nothing() {
let (fake, mut wm) = desktop_with(&[36_011, 36_012]);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
let asked = fake.window_commands();
for message in [
SocketMessage::MoveWindow(OperationDirection::Left),
SocketMessage::CycleMoveWindow(CycleDirection::Next),
SocketMessage::StackWindow(OperationDirection::Left),
SocketMessage::UnstackWindow,
SocketMessage::StackAll,
SocketMessage::UnstackAll,
SocketMessage::CycleStack(CycleDirection::Next),
SocketMessage::CycleStackIndex(CycleDirection::Next),
SocketMessage::FocusStackWindow(0),
SocketMessage::MoveContainerToWorkspaceNumber(1),
SocketMessage::SendContainerToWorkspaceNumber(1),
SocketMessage::MoveContainerToMonitorNumber(1),
SocketMessage::SendContainerToMonitorNumber(1),
SocketMessage::Promote,
SocketMessage::ToggleLock,
SocketMessage::ToggleFloat,
SocketMessage::ToggleMonocle,
SocketMessage::PreselectDirection(OperationDirection::Left),
] {
send(&fake, &mut wm, message);
}
assert_eq!(maximized(&wm), Some(36_012));
assert_eq!(tiled(&wm), [36_011]);
assert!(wm.focused_workspace().unwrap().monocle_container.is_none());
assert!(
wm.focused_workspace()
.unwrap()
.floating_windows()
.is_empty()
);
assert_eq!(
fake.window_commands(),
asked,
"nothing was asked of the backend"
);
}
#[test]
fn a_retile_while_a_window_is_maximized_asks_the_compositor_to_maximize_it_again() {
let (fake, mut wm) = desktop_with(&[36_021, 36_022]);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
fake.clear_commands();
send(&fake, &mut wm, SocketMessage::Retile);
assert_eq!(fake.window_commands(), [Command::Maximize(36_022, true)]);
assert!(fake.is_maximized(36_022));
}
#[test]
fn the_window_in_monocle_that_is_maximized_leaves_the_monocle() {
let (fake, mut wm) = desktop_with(&[36_031, 36_032]);
event(&fake, &mut wm, activated(36_031));
send(&fake, &mut wm, SocketMessage::ToggleMonocle);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
let workspace = wm.focused_workspace().unwrap();
assert!(workspace.monocle_container.is_none());
assert_eq!(maximized(&wm), Some(36_031));
assert_eq!(workspace.maximized_window_restore_idx, Some(0));
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
assert_eq!(tiled(&wm), [36_031, 36_032]);
}
#[test]
fn a_window_that_opens_meanwhile_is_tiled_when_the_maximized_one_is_restored() {
let (fake, mut wm) = desktop_with(&[36_041, 36_042]);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
fake.open_window(36_043, "foot", "foot", "terminal 36043");
event(&fake, &mut wm, added(36_043));
assert_eq!(maximized(&wm), Some(36_042));
assert_eq!(tiled(&wm), [36_041, 36_043]);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
let rects: Vec<_> = tiled(&wm)
.iter()
.map(|&id| fake.rect_of(id).unwrap())
.collect();
assert_eq!(rects.len(), 3);
for (i, a) in rects.iter().enumerate() {
for b in &rects[i + 1..] {
let overlap = a.left < b.left + b.right
&& b.left < a.left + a.right
&& a.top < b.top + b.bottom
&& b.top < a.top + a.bottom;
assert!(!overlap, "{a:?} and {b:?} overlap");
}
}
}
#[test]
fn toggle_maximize_without_a_window_is_an_error() {
let (fake, mut wm) = desktop_with(&[]);
assert_eq!(
try_send(&fake, &mut wm, SocketMessage::ToggleMaximize),
Err(String::from("there is no container"))
);
assert_eq!(maximized(&wm), None);
}
#[test]
fn the_state_shows_the_maximized_window_and_the_index_it_goes_back_to() {
let (fake, mut wm) = desktop_with(&[36_051, 36_052]);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
let state = with_backend(fake.clone(), || {
serde_json::to_value(State::from(&wm)).unwrap()
});
let workspace = &state["monitors"]["elements"][0]["workspaces"]["elements"][0];
assert_eq!(workspace["maximized_window"]["id"], 36_052);
assert_eq!(workspace["maximized_window_restore_idx"], 1);
}
#[test]
fn focusing_towards_a_monitor_with_a_maximized_window_gives_it_the_focus() {
let (fake, mut wm) = two_monitors_with(&[36_061, 36_062], &[36_063, 36_064]);
event(&fake, &mut wm, activated(36_064));
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
event(&fake, &mut wm, activated(36_062));
assert_eq!(wm.focused_monitor_idx(), 0);
send(
&fake,
&mut wm,
SocketMessage::FocusWindow(OperationDirection::Right),
);
assert_eq!(wm.focused_monitor_idx(), 1);
assert_eq!(fake.foreground_window(), Some(36_064));
}
#[test]
fn a_maximized_window_is_hidden_with_its_workspace_and_shown_and_focused_with_it() {
let (fake, mut wm) = desktop_with(&[36_071, 36_072]);
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
let workspace = wm.focused_workspace_mut().unwrap();
with_backend(fake.clone(), || workspace.hide(None)).unwrap();
assert!(fake.is_hidden(36_071) && fake.is_hidden(36_072));
fake.clear_commands();
with_backend(fake.clone(), || workspace.restore(true, 0, &None)).unwrap();
assert!(!fake.is_hidden(36_072), "the maximized window is shown");
assert!(
fake.window_commands()
.ends_with(&[Command::Focus(36_072, true)]),
"and has the focus, ahead of the window of the container: {:?}",
fake.window_commands()
);
}
#[test]
fn a_workspace_with_a_maximized_window_is_not_closed() {
let (fake, mut wm) = desktop_with(&[]);
send(&fake, &mut wm, SocketMessage::EnsureWorkspaces(0, 2));
send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumber(1));
fake.open_window(36_081, "foot", "foot", "terminal 36081");
event(&fake, &mut wm, added(36_081));
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
assert!(wm.focused_workspace().unwrap().containers().is_empty());
send(&fake, &mut wm, SocketMessage::CloseWorkspace);
assert_eq!(wm.focused_monitor().unwrap().workspaces().len(), 2);
assert_eq!(maximized(&wm), Some(36_081));
}
#[test]
fn eager_focus_finds_the_maximized_window_of_an_executable() {
let (fake, mut wm) = desktop_with(&[36_091]);
fake.open_window(36_092, "kate", "kate", "terminal 36092");
event(&fake, &mut wm, added(36_092));
send(&fake, &mut wm, SocketMessage::ToggleMaximize);
event(&fake, &mut wm, activated(36_091));
assert_eq!(fake.foreground_window(), Some(36_091));
send(
&fake,
&mut wm,
SocketMessage::EagerFocus(String::from("kate")),
);
assert_eq!(fake.foreground_window(), Some(36_092));
}