mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-20 07:31:39 +01:00
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.
368 lines
13 KiB
Rust
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));
|
|
}
|