mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-22 08:31:50 +01:00
The stock KDE Rounded Corners has one color for the active window and one for the others, and komorebi colors a window by what it is to the layout: the focused window, the others, a locked container that does not have the focus, a floating window that has it, a stack, a monocle. komorebi's build of the effect takes a color for each window over D-Bus. After every event and message the border manager works out the kind of each window and tells the backend, which sends the effect what changed, and tells it that no window has a color when borders are off. Without that build the borders are the look's two colors, and the backend says so once. komorebic gets border-colour. The fake desktop keeps the colors it was told, and gets window_commands, which leaves the look out of the list of what the window manager asked for. vm-features reads the colors of the kinds of window in a real session. The colors of a stack and of a monocled window are read from the fake and, in vm-features, from the pixels. The border_colours key of komorebi.json is not here: its colors are written as the Colour of komorebi-themes, which the themes (49) bring, and 49 adds the key. The maximize check of vm-features, which was the whole suite, reads a pixel a quarter of the way into the window and not the middle one: komorebi puts the pointer in the middle of the window it focuses, and a screenshot has the arrow on it, white. It read the arrow on most runs once the border effect was loaded. vm-features waits for the panel's room too, where it starts the daemon for its sections B to E: the border colors of section C are read from the pixels around a window, which the panel can cover.
246 lines
8.5 KiB
Rust
246 lines
8.5 KiB
Rust
//! Minimizing, closing, unmanaging and managing the focused window, pausing the window manager,
|
|
//! and the unmanaged window operation behavior, against an in-memory desktop: the messages go in
|
|
//! through [`WindowManager::process_command`], and what comes out is what the backend was asked
|
|
//! for and the order of the containers.
|
|
//!
|
|
//! `UnmanageFocusedWindow` and `ManageFocusedWindow` raise an event on the process-wide channel of
|
|
//! [`window_manager_event_listener`], where the daemon's events thread would take it: the tests
|
|
//! that read the channel hold [`CHANNEL`] so that they do not take each other's events.
|
|
//!
|
|
//! Window ids are in the 27_000s.
|
|
|
|
use komorebi::backend::fake::Command;
|
|
use komorebi::backend::fake::FakeBackend;
|
|
use komorebi::backend::with_backend;
|
|
use komorebi::core::OperationBehaviour;
|
|
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 komorebi::window_manager_event_listener;
|
|
use std::sync::Arc;
|
|
use std::sync::Mutex;
|
|
use std::time::Duration;
|
|
|
|
static CHANNEL: Mutex<()> = Mutex::new(());
|
|
|
|
fn added(id: u32) -> WindowManagerEvent {
|
|
WindowManagerEvent::Show(
|
|
SystemNotification::KWin(KWinNotification::WindowAdded),
|
|
Window::from(id),
|
|
)
|
|
}
|
|
|
|
fn minimized(id: u32) -> WindowManagerEvent {
|
|
WindowManagerEvent::Minimize(
|
|
SystemNotification::KWin(KWinNotification::WindowMinimized),
|
|
Window::from(id),
|
|
)
|
|
}
|
|
|
|
/// A window manager over a fake desktop with one 1920x1080 monitor, and a window for each of
|
|
/// `ids`, opened in that order. The last one has the focus.
|
|
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/kmm-{}-{}.sock",
|
|
std::process::id(),
|
|
NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
|
|
));
|
|
|
|
let mut wm = with_backend(fake.clone(), || {
|
|
let mut wm = WindowManager::new(receiver, Some(socket)).unwrap();
|
|
wm.init().unwrap();
|
|
wm
|
|
});
|
|
for &id in ids {
|
|
open(&fake, &mut wm, id);
|
|
}
|
|
fake.set_foreground(ids.last().copied());
|
|
|
|
(fake, wm)
|
|
}
|
|
|
|
fn open(fake: &Arc<FakeBackend>, wm: &mut WindowManager, id: u32) {
|
|
fake.open_window(id, "foot", "foot", &format!("terminal {id}"));
|
|
with_backend(fake.clone(), || wm.process_event(added(id))).unwrap();
|
|
}
|
|
|
|
fn send(
|
|
fake: &Arc<FakeBackend>,
|
|
wm: &mut WindowManager,
|
|
message: SocketMessage,
|
|
) -> color_eyre::Result<()> {
|
|
with_backend(fake.clone(), || wm.process_command(message, Vec::new()))
|
|
}
|
|
|
|
/// Takes the event about window `id` off the channel the daemon's events thread reads, and has
|
|
/// the window manager handle it, as that thread does
|
|
fn handle_raised(fake: &Arc<FakeBackend>, wm: &mut WindowManager, id: u32) -> WindowManagerEvent {
|
|
let events = window_manager_event_listener::event_rx();
|
|
loop {
|
|
let event = events
|
|
.recv_timeout(Duration::from_secs(5))
|
|
.expect("an event about the window is raised");
|
|
if event.window_id() == Some(id) {
|
|
with_backend(fake.clone(), || wm.process_event(event)).unwrap();
|
|
return event;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The window of each container of the focused workspace, in order
|
|
fn order(wm: &WindowManager) -> Vec<u32> {
|
|
wm.focused_workspace()
|
|
.unwrap()
|
|
.containers()
|
|
.iter()
|
|
.map(|container| container.focused_window().unwrap().id)
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn minimize_and_close_ask_the_compositor_about_the_window_that_has_the_focus() {
|
|
let (fake, mut wm) = desktop_with(&[27_001, 27_002]);
|
|
fake.clear_commands();
|
|
|
|
send(&fake, &mut wm, SocketMessage::Minimize).unwrap();
|
|
assert_eq!(fake.window_commands(), [Command::Minimize(27_002)]);
|
|
// the window leaves the layout when the compositor reports it minimized, not before
|
|
assert_eq!(order(&wm), [27_001, 27_002]);
|
|
with_backend(fake.clone(), || wm.process_event(minimized(27_002))).unwrap();
|
|
assert_eq!(order(&wm), [27_001]);
|
|
|
|
fake.set_foreground(Some(27_001));
|
|
fake.clear_commands();
|
|
send(&fake, &mut wm, SocketMessage::Close).unwrap();
|
|
assert_eq!(fake.window_commands(), [Command::Close(27_001)]);
|
|
|
|
fake.set_foreground(None);
|
|
assert_eq!(
|
|
send(&fake, &mut wm, SocketMessage::Close).map_err(|error| error.to_string()),
|
|
Err(String::from("there is no foreground window"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unmanage_takes_the_focused_window_out_until_manage_takes_it_back() {
|
|
let _channel = CHANNEL
|
|
.lock()
|
|
.unwrap_or_else(|poisoned| poisoned.into_inner());
|
|
let (fake, mut wm) = desktop_with(&[27_011, 27_012]);
|
|
let tile = fake.rect_of(27_012).unwrap();
|
|
|
|
send(&fake, &mut wm, SocketMessage::UnmanageFocusedWindow).unwrap();
|
|
let event = handle_raised(&fake, &mut wm, 27_012);
|
|
assert!(
|
|
matches!(event, WindowManagerEvent::Unmanage(_)),
|
|
"{event:?}"
|
|
);
|
|
|
|
assert_eq!(order(&wm), [27_011]);
|
|
// the window stays open, centered in the 1920x1050 work area with the size of its tile
|
|
assert_eq!(
|
|
fake.rect_of(27_012),
|
|
Some(Rect {
|
|
left: (1920 - tile.right) / 2,
|
|
top: (1050 - tile.bottom) / 2,
|
|
right: tile.right,
|
|
bottom: tile.bottom,
|
|
})
|
|
);
|
|
|
|
// the compositor announcing it again does not bring it back
|
|
with_backend(fake.clone(), || wm.process_event(added(27_012))).unwrap();
|
|
assert_eq!(order(&wm), [27_011]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::ManageFocusedWindow).unwrap();
|
|
let event = handle_raised(&fake, &mut wm, 27_012);
|
|
assert!(matches!(event, WindowManagerEvent::Manage(_)), "{event:?}");
|
|
|
|
assert_eq!(order(&wm), [27_011, 27_012]);
|
|
}
|
|
|
|
#[test]
|
|
fn while_paused_no_event_changes_the_layout_and_manage_takes_in_a_window_it_missed() {
|
|
let _channel = CHANNEL
|
|
.lock()
|
|
.unwrap_or_else(|poisoned| poisoned.into_inner());
|
|
let (fake, mut wm) = desktop_with(&[27_021]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::TogglePause).unwrap();
|
|
assert!(State::from(&wm).is_paused);
|
|
open(&fake, &mut wm, 27_022);
|
|
assert_eq!(order(&wm), [27_021], "a window that opens is left alone");
|
|
|
|
send(&fake, &mut wm, SocketMessage::TogglePause).unwrap();
|
|
assert!(!State::from(&wm).is_paused);
|
|
open(&fake, &mut wm, 27_023);
|
|
assert_eq!(
|
|
order(&wm),
|
|
[27_021, 27_023],
|
|
"the event that was missed is not handled afterwards"
|
|
);
|
|
|
|
fake.set_foreground(Some(27_022));
|
|
send(&fake, &mut wm, SocketMessage::ManageFocusedWindow).unwrap();
|
|
handle_raised(&fake, &mut wm, 27_022);
|
|
assert_eq!(order(&wm), [27_021, 27_023, 27_022]);
|
|
}
|
|
|
|
#[test]
|
|
fn with_no_op_every_message_is_refused_while_the_focused_window_is_not_tiled() {
|
|
let (fake, mut wm) = desktop_with(&[27_031, 27_032]);
|
|
// a dialog, which komorebi does not manage, takes the focus
|
|
fake.open_window(27_033, "foot", "foot", "a dialog");
|
|
fake.set_normal(27_033, false);
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::UnmanagedWindowOperationBehaviour(OperationBehaviour::NoOp),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
State::from(&wm).unmanaged_window_operation_behaviour,
|
|
OperationBehaviour::NoOp
|
|
);
|
|
send(&fake, &mut wm, SocketMessage::Retile).unwrap();
|
|
|
|
fake.set_foreground(Some(27_033));
|
|
let refused = Err(String::from(
|
|
"ignoring commands while active window is not managed by komorebi",
|
|
));
|
|
assert_eq!(
|
|
send(&fake, &mut wm, SocketMessage::Retile).map_err(|error| error.to_string()),
|
|
refused
|
|
);
|
|
// this message too, while the dialog has the focus
|
|
assert_eq!(
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::UnmanagedWindowOperationBehaviour(OperationBehaviour::Op),
|
|
)
|
|
.map_err(|error| error.to_string()),
|
|
refused
|
|
);
|
|
|
|
fake.set_foreground(Some(27_032));
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::UnmanagedWindowOperationBehaviour(OperationBehaviour::Op),
|
|
)
|
|
.unwrap();
|
|
fake.set_foreground(Some(27_033));
|
|
send(&fake, &mut wm, SocketMessage::Retile).unwrap();
|
|
}
|