mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 13:51:19 +01:00
Pure renames, no content changes. This revision does not build on its own; the next one routes the workspace to the new paths.
639 lines
20 KiB
Rust
639 lines
20 KiB
Rust
//! Stacking windows in one container, taking the windows a stack does not show out of sight, and
|
|
//! choosing which window of a stack is in front, against an in-memory desktop.
|
|
//!
|
|
//! A container tiles one window, so the other windows of a stack are hidden: the backend is asked
|
|
//! to take them out of sight, and the window manager records them as hidden so that what the
|
|
//! compositor reports about them is not mistaken for the user's doing. The messages go in through
|
|
//! [`WindowManager::process_command`], and what comes out is which windows the containers hold and
|
|
//! which of them the fake desktop has hidden.
|
|
//!
|
|
//! Window ids are in the 33_000s; the hidden-window table is process-wide.
|
|
|
|
use komorebi::backend::fake::FakeBackend;
|
|
use komorebi::backend::with_backend;
|
|
use komorebi::core::CycleDirection;
|
|
use komorebi::core::OperationDirection;
|
|
use komorebi::core::SocketMessage;
|
|
use komorebi::core::WindowContainerBehaviour;
|
|
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_backend::Backend as _;
|
|
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),
|
|
)
|
|
}
|
|
|
|
fn removed(id: u32) -> WindowManagerEvent {
|
|
WindowManagerEvent::Destroy(
|
|
SystemNotification::KWin(KWinNotification::WindowRemoved),
|
|
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 (1920x1050 without the panel),
|
|
/// 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/kms-{}-{}.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, wm)
|
|
}
|
|
|
|
/// Opens a window, which KWin gives the focus, as it does a new window
|
|
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();
|
|
fake.set_foreground(Some(id));
|
|
with_backend(fake.clone(), || wm.process_event(activated(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()))
|
|
}
|
|
|
|
fn process(
|
|
fake: &Arc<FakeBackend>,
|
|
wm: &mut WindowManager,
|
|
event: WindowManagerEvent,
|
|
) -> color_eyre::Result<()> {
|
|
with_backend(fake.clone(), || wm.process_event(event))
|
|
}
|
|
|
|
/// The ids of the windows of each container of the focused workspace, in order, the one in front
|
|
/// first
|
|
fn containers(wm: &WindowManager) -> Vec<Vec<u32>> {
|
|
wm.focused_workspace()
|
|
.unwrap()
|
|
.containers()
|
|
.iter()
|
|
.map(|container| {
|
|
let front = container.focused_window().unwrap().id;
|
|
let mut ids = vec![front];
|
|
ids.extend(
|
|
container
|
|
.windows()
|
|
.iter()
|
|
.map(|window| window.id)
|
|
.filter(|id| *id != front),
|
|
);
|
|
ids
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// The windows among `ids` that the fake desktop has hidden
|
|
fn hidden(fake: &FakeBackend, ids: &[u32]) -> Vec<u32> {
|
|
ids.iter()
|
|
.copied()
|
|
.filter(|id| fake.is_hidden(*id))
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn a_minimize_komorebi_asked_for_is_not_mistaken_for_the_user() {
|
|
let (fake, mut wm) = desktop_with(&[33_001]);
|
|
|
|
// komorebi hides it (as it does the back of a stack), and the compositor reports a minimize
|
|
with_backend(fake.clone(), || Window::from(33_001).hide());
|
|
process(&fake, &mut wm, minimized(33_001)).unwrap();
|
|
|
|
assert!(wm.focused_workspace().unwrap().contains_window(33_001));
|
|
assert!(!wm.minimized_windows.contains_key(&33_001));
|
|
}
|
|
|
|
#[test]
|
|
fn a_minimize_the_user_asked_for_takes_the_window_out_of_the_layout() {
|
|
let (fake, mut wm) = desktop_with(&[33_011, 33_012]);
|
|
|
|
process(&fake, &mut wm, minimized(33_011)).unwrap();
|
|
|
|
assert!(!wm.focused_workspace().unwrap().contains_window(33_011));
|
|
assert!(wm.minimized_windows.contains_key(&33_011));
|
|
}
|
|
|
|
#[test]
|
|
fn stacking_puts_two_windows_in_one_container_and_hides_the_one_behind() {
|
|
let (fake, mut wm) = desktop_with(&[33_021, 33_022, 33_023]);
|
|
let ids = [33_021, 33_022, 33_023];
|
|
assert!(hidden(&fake, &ids).is_empty());
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::StackWindow(OperationDirection::Up),
|
|
)
|
|
.unwrap();
|
|
|
|
// 33_023 is the bottom right tile and had the focus: it goes onto 33_022, above it
|
|
assert_eq!(containers(&wm), [vec![33_021], vec![33_023, 33_022]]);
|
|
assert_eq!(hidden(&fake, &ids), [33_022]);
|
|
assert_eq!(
|
|
fake.foreground_window().and_then(|id| id.to_u32()),
|
|
Some(33_023)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn stacking_where_the_layout_has_nothing_changes_nothing() {
|
|
let (fake, mut wm) = desktop_with(&[33_031, 33_032]);
|
|
|
|
// the focused container is the last one, and BSP has nothing after it
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::StackWindow(OperationDirection::Right),
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(containers(&wm), [vec![33_031], vec![33_032]]);
|
|
assert!(hidden(&fake, &[33_031, 33_032]).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn unstacking_gives_the_window_in_front_a_container_of_its_own_and_shows_the_next() {
|
|
let (fake, mut wm) = desktop_with(&[33_041, 33_042, 33_043]);
|
|
let ids = [33_041, 33_042, 33_043];
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::StackWindow(OperationDirection::Up),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(hidden(&fake, &ids), [33_042]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::UnstackWindow).unwrap();
|
|
|
|
assert_eq!(
|
|
containers(&wm),
|
|
[vec![33_041], vec![33_042], vec![33_043]],
|
|
"the window that was in front gets a container after the stack"
|
|
);
|
|
assert!(hidden(&fake, &ids).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn a_window_alone_in_its_container_cannot_be_unstacked() {
|
|
let (fake, mut wm) = desktop_with(&[33_051, 33_052]);
|
|
|
|
let error = send(&fake, &mut wm, SocketMessage::UnstackWindow).unwrap_err();
|
|
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"a container must have at least one window"
|
|
);
|
|
assert_eq!(containers(&wm), [vec![33_051], vec![33_052]]);
|
|
}
|
|
|
|
#[test]
|
|
fn stack_all_puts_every_window_in_one_container_and_unstack_all_gives_them_each_one_back() {
|
|
let (fake, mut wm) = desktop_with(&[33_061, 33_062, 33_063]);
|
|
let ids = [33_061, 33_062, 33_063];
|
|
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
|
|
assert_eq!(containers(&wm), [vec![33_063, 33_061, 33_062]]);
|
|
assert_eq!(hidden(&fake, &ids), [33_061, 33_062]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::UnstackAll).unwrap();
|
|
|
|
let containers = containers(&wm);
|
|
assert_eq!(containers.len(), 3);
|
|
assert!(containers.iter().all(|windows| windows.len() == 1));
|
|
assert!(hidden(&fake, &ids).is_empty());
|
|
assert_eq!(
|
|
wm.focused_window().unwrap().id,
|
|
33_063,
|
|
"the window that had the focus keeps it"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn closing_the_window_in_front_of_a_stack_brings_the_next_one_forward() {
|
|
let (fake, mut wm) = desktop_with(&[33_071, 33_072]);
|
|
let ids = [33_071, 33_072];
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
assert_eq!(containers(&wm), [vec![33_072, 33_071]]);
|
|
assert_eq!(hidden(&fake, &ids), [33_071]);
|
|
|
|
fake.close_window_now(33_072);
|
|
process(&fake, &mut wm, removed(33_072)).unwrap();
|
|
|
|
assert_eq!(containers(&wm), [vec![33_071]]);
|
|
assert!(hidden(&fake, &ids).is_empty());
|
|
assert_eq!(
|
|
fake.foreground_window().and_then(|id| id.to_u32()),
|
|
Some(33_071)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_window_closed_while_it_is_hidden_leaves_the_stack_alone() {
|
|
let (fake, mut wm) = desktop_with(&[33_081, 33_082]);
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
|
|
fake.close_window_now(33_081);
|
|
process(&fake, &mut wm, removed(33_081)).unwrap();
|
|
|
|
assert_eq!(containers(&wm), [vec![33_082]]);
|
|
assert!(!fake.is_hidden(33_082));
|
|
}
|
|
|
|
#[test]
|
|
fn the_back_of_a_stack_stays_hidden_across_a_workspace_round_trip() {
|
|
let (fake, mut wm) = desktop_with(&[33_091, 33_092]);
|
|
let ids = [33_091, 33_092];
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
assert_eq!(hidden(&fake, &ids), [33_091]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumber(1)).unwrap();
|
|
send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumber(0)).unwrap();
|
|
|
|
assert_eq!(containers(&wm), [vec![33_092, 33_091]]);
|
|
assert_eq!(hidden(&fake, &ids), [33_091]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_stack_goes_to_another_workspace_whole_and_the_back_of_it_stays_hidden() {
|
|
let (fake, mut wm) = desktop_with(&[33_101, 33_102]);
|
|
let ids = [33_101, 33_102];
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::SendContainerToWorkspaceNumber(1),
|
|
)
|
|
.unwrap();
|
|
send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumber(1)).unwrap();
|
|
|
|
assert_eq!(
|
|
wm.focused_workspace()
|
|
.unwrap()
|
|
.containers()
|
|
.iter()
|
|
.map(|container| container.windows().len())
|
|
.collect::<Vec<_>>(),
|
|
[2]
|
|
);
|
|
assert_eq!(fake.workspace_of(33_101), Some(1));
|
|
assert_eq!(fake.workspace_of(33_102), Some(1));
|
|
assert_eq!(hidden(&fake, &ids), [33_101]);
|
|
}
|
|
|
|
#[test]
|
|
fn with_append_a_window_that_opens_joins_the_focused_container() {
|
|
let (fake, mut wm) = desktop_with(&[33_111]);
|
|
let ids = [33_111, 33_112, 33_113];
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::ToggleWindowContainerBehaviour,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
wm.window_management_behaviour(0, 0).current_behaviour,
|
|
WindowContainerBehaviour::Append
|
|
);
|
|
open(&fake, &mut wm, 33_112);
|
|
open(&fake, &mut wm, 33_113);
|
|
|
|
assert_eq!(containers(&wm), [vec![33_113, 33_111, 33_112]]);
|
|
assert_eq!(hidden(&fake, &ids), [33_111, 33_112]);
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::ToggleWindowContainerBehaviour,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
wm.window_management_behaviour(0, 0).current_behaviour,
|
|
WindowContainerBehaviour::Create
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn an_empty_workspace_has_nothing_to_append_to() {
|
|
let (fake, mut wm) = desktop_with(&[]);
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::ToggleWindowContainerBehaviour,
|
|
)
|
|
.unwrap();
|
|
open(&fake, &mut wm, 33_121);
|
|
open(&fake, &mut wm, 33_122);
|
|
|
|
assert_eq!(
|
|
containers(&wm),
|
|
[vec![33_122, 33_121]],
|
|
"the second window joins the first, which got a container of its own"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_behavior_of_one_workspace_does_not_change_the_others() {
|
|
let (fake, mut wm) = desktop_with(&[33_131]);
|
|
send(&fake, &mut wm, SocketMessage::EnsureWorkspaces(0, 2)).unwrap();
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::ToggleWorkspaceWindowContainerBehaviour,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
wm.window_management_behaviour(0, 0).current_behaviour,
|
|
WindowContainerBehaviour::Append
|
|
);
|
|
assert_eq!(
|
|
wm.window_management_behaviour(0, 1).current_behaviour,
|
|
WindowContainerBehaviour::Create,
|
|
"an empty workspace that is not set to append creates"
|
|
);
|
|
assert_eq!(
|
|
wm.window_management_behaviour.current_behaviour,
|
|
WindowContainerBehaviour::Create,
|
|
"the window manager's own is unchanged"
|
|
);
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::ToggleWorkspaceWindowContainerBehaviour,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(
|
|
wm.window_management_behaviour(0, 0).current_behaviour,
|
|
WindowContainerBehaviour::Create
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn with_the_float_override_a_window_that_opens_floats() {
|
|
let (fake, mut wm) = desktop_with(&[33_141]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::ToggleFloatOverride).unwrap();
|
|
fake.open_window(33_142, "foot", "foot", "terminal 33142");
|
|
process(&fake, &mut wm, added(33_142)).unwrap();
|
|
|
|
let workspace = wm.focused_workspace().unwrap();
|
|
assert_eq!(containers(&wm), [vec![33_141]]);
|
|
assert!(workspace.floating_windows().iter().any(|w| w.id == 33_142));
|
|
|
|
send(&fake, &mut wm, SocketMessage::ToggleFloatOverride).unwrap();
|
|
open(&fake, &mut wm, 33_143);
|
|
assert_eq!(containers(&wm), [vec![33_141], vec![33_143]]);
|
|
}
|
|
|
|
#[test]
|
|
fn the_float_override_of_a_workspace_takes_the_opposite_of_the_global_one_the_first_time() {
|
|
let (fake, mut wm) = desktop_with(&[33_151]);
|
|
send(&fake, &mut wm, SocketMessage::ToggleFloatOverride).unwrap();
|
|
assert!(wm.window_management_behaviour(0, 0).float_override);
|
|
|
|
send(&fake, &mut wm, SocketMessage::ToggleWorkspaceFloatOverride).unwrap();
|
|
assert!(
|
|
!wm.window_management_behaviour(0, 0).float_override,
|
|
"the workspace's own override is the opposite of the global one that was on"
|
|
);
|
|
assert!(wm.window_management_behaviour.float_override);
|
|
|
|
send(&fake, &mut wm, SocketMessage::ToggleWorkspaceFloatOverride).unwrap();
|
|
assert!(wm.window_management_behaviour(0, 0).float_override);
|
|
}
|
|
|
|
#[test]
|
|
fn restoring_every_window_brings_back_the_hidden_ones_unless_it_is_told_to_ignore_that() {
|
|
let (fake, mut wm) = desktop_with(&[33_161, 33_162, 33_163]);
|
|
let ids = [33_161, 33_162, 33_163];
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
assert_eq!(hidden(&fake, &ids).len(), 2);
|
|
|
|
with_backend(fake.clone(), || wm.restore_all_windows(true)).unwrap();
|
|
assert_eq!(
|
|
hidden(&fake, &ids).len(),
|
|
2,
|
|
"with ignore_restore they stay hidden"
|
|
);
|
|
|
|
with_backend(fake.clone(), || wm.restore_all_windows(false)).unwrap();
|
|
assert!(hidden(&fake, &ids).is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn the_state_has_the_new_window_behavior_and_the_float_override() {
|
|
let (fake, mut wm) = desktop_with(&[33_171]);
|
|
let mut state = Vec::new();
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::ToggleWindowContainerBehaviour,
|
|
)
|
|
.unwrap();
|
|
send(&fake, &mut wm, SocketMessage::ToggleFloatOverride).unwrap();
|
|
with_backend(fake.clone(), || {
|
|
wm.process_command(SocketMessage::State, &mut state)
|
|
})
|
|
.unwrap();
|
|
|
|
let state: serde_json::Value = serde_json::from_slice(&state).unwrap();
|
|
assert_eq!(state["new_window_behaviour"], "Append");
|
|
assert_eq!(state["float_override"], true);
|
|
}
|
|
|
|
/// A fake desktop with the windows `ids` in one stack, the last in front
|
|
fn stack_of(ids: &[u32]) -> (Arc<FakeBackend>, WindowManager) {
|
|
let (fake, mut wm) = desktop_with(ids);
|
|
send(&fake, &mut wm, SocketMessage::StackAll).unwrap();
|
|
(fake, wm)
|
|
}
|
|
|
|
#[test]
|
|
fn cycling_the_stack_brings_the_next_window_to_the_front_and_hides_the_one_that_was() {
|
|
let (fake, mut wm) = stack_of(&[33_201, 33_202, 33_203]);
|
|
let ids = [33_201, 33_202, 33_203];
|
|
assert_eq!(containers(&wm), [vec![33_203, 33_201, 33_202]]);
|
|
|
|
// the stack is 33_201, 33_202, 33_203 with the last in front: next wraps to the first
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::CycleStack(CycleDirection::Next),
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_201);
|
|
assert_eq!(hidden(&fake, &ids), [33_202, 33_203]);
|
|
assert_eq!(
|
|
fake.foreground_window().and_then(|id| id.to_u32()),
|
|
Some(33_201)
|
|
);
|
|
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::CycleStack(CycleDirection::Previous),
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_203);
|
|
assert_eq!(hidden(&fake, &ids), [33_201, 33_202]);
|
|
assert_eq!(
|
|
fake.foreground_window().and_then(|id| id.to_u32()),
|
|
Some(33_203)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cycling_a_window_that_is_alone_is_an_error() {
|
|
let (fake, mut wm) = desktop_with(&[33_211, 33_212]);
|
|
|
|
for message in [
|
|
SocketMessage::CycleStack(CycleDirection::Next),
|
|
SocketMessage::CycleStackIndex(CycleDirection::Previous),
|
|
] {
|
|
let error = send(&fake, &mut wm, message).unwrap_err();
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"there is only one window in this container"
|
|
);
|
|
}
|
|
assert_eq!(containers(&wm), [vec![33_211], vec![33_212]]);
|
|
}
|
|
|
|
#[test]
|
|
fn cycling_the_index_moves_the_front_window_along_the_stack_and_keeps_it_in_front() {
|
|
let (fake, mut wm) = stack_of(&[33_221, 33_222, 33_223]);
|
|
let ids = [33_221, 33_222, 33_223];
|
|
let order = |wm: &WindowManager| -> Vec<u32> {
|
|
wm.focused_workspace()
|
|
.unwrap()
|
|
.containers()
|
|
.iter()
|
|
.flat_map(|container| container.windows().iter().map(|window| window.id))
|
|
.collect()
|
|
};
|
|
assert_eq!(order(&wm), [33_221, 33_222, 33_223]);
|
|
|
|
// 33_223 is in front and last: the next place wraps to the first
|
|
send(
|
|
&fake,
|
|
&mut wm,
|
|
SocketMessage::CycleStackIndex(CycleDirection::Next),
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(order(&wm), [33_223, 33_222, 33_221]);
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_223);
|
|
assert_eq!(hidden(&fake, &ids), [33_221, 33_222]);
|
|
assert_eq!(
|
|
fake.foreground_window().and_then(|id| id.to_u32()),
|
|
Some(33_223)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn focus_stack_window_brings_the_window_at_an_index_to_the_front() {
|
|
let (fake, mut wm) = stack_of(&[33_231, 33_232, 33_233]);
|
|
let ids = [33_231, 33_232, 33_233];
|
|
|
|
send(&fake, &mut wm, SocketMessage::FocusStackWindow(1)).unwrap();
|
|
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_232);
|
|
assert_eq!(hidden(&fake, &ids), [33_231, 33_233]);
|
|
assert_eq!(
|
|
fake.foreground_window().and_then(|id| id.to_u32()),
|
|
Some(33_232)
|
|
);
|
|
|
|
send(&fake, &mut wm, SocketMessage::FocusStackWindow(0)).unwrap();
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_231);
|
|
assert_eq!(hidden(&fake, &ids), [33_232, 33_233]);
|
|
}
|
|
|
|
#[test]
|
|
fn focus_stack_window_refuses_an_index_the_stack_does_not_have() {
|
|
let (fake, mut wm) = stack_of(&[33_241, 33_242]);
|
|
|
|
let error = send(&fake, &mut wm, SocketMessage::FocusStackWindow(5)).unwrap_err();
|
|
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"there is no window in this container at index 5"
|
|
);
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_242);
|
|
}
|
|
|
|
#[test]
|
|
fn focus_stack_window_on_a_window_that_is_alone_takes_index_0_only() {
|
|
let (fake, mut wm) = desktop_with(&[33_251]);
|
|
|
|
send(&fake, &mut wm, SocketMessage::FocusStackWindow(0)).unwrap();
|
|
let error = send(&fake, &mut wm, SocketMessage::FocusStackWindow(1)).unwrap_err();
|
|
|
|
assert_eq!(
|
|
error.to_string(),
|
|
"there is only one window in this container"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_window_the_user_focuses_in_the_back_of_a_stack_comes_to_the_front() {
|
|
let (fake, mut wm) = stack_of(&[33_261, 33_262]);
|
|
let ids = [33_261, 33_262];
|
|
assert_eq!(hidden(&fake, &ids), [33_261]);
|
|
|
|
// the user raises the hidden window (a click in the task manager): KWin gives it the focus
|
|
fake.set_foreground(Some(33_261));
|
|
process(&fake, &mut wm, activated(33_261)).unwrap();
|
|
|
|
assert_eq!(wm.focused_window().unwrap().id, 33_261);
|
|
assert_eq!(hidden(&fake, &ids), [33_262]);
|
|
}
|