//! The floating layer of a workspace, against an in-memory desktop: which of the two layers a //! workspace is on, `toggle-workspace-layer`, and what the focus, move and resize commands do to //! the floating windows while it is the layer in front, and which windows float when they open on //! it. The messages go in through //! [`WindowManager::process_command`], the events through [`WindowManager::process_event`]. //! //! Window ids are in the 37_000s. use komorebi::backend::fake::Command; use komorebi::backend::fake::FakeBackend; use komorebi::backend::with_backend; use komorebi::core::CycleDirection; use komorebi::core::FloatingLayerBehaviour; use komorebi::core::OperationDirection; use komorebi::core::Rect; use komorebi::core::Sizing; 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::workspace::WorkspaceLayer; 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, WindowManager) { desktop_on(FakeBackend::with_one_monitor(), ids) } /// A window manager over `fake`, and a window for each of `ids`, opened in that order fn desktop_on(fake: FakeBackend, ids: &[u32]) -> (Arc, WindowManager) { 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(0); let socket = std::path::PathBuf::from(format!( "/tmp/kml-{}-{}.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) } fn try_send( fake: &Arc, 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, wm: &mut WindowManager, message: SocketMessage) { try_send(fake, wm, message).unwrap(); } fn event(fake: &Arc, wm: &mut WindowManager, event: WindowManagerEvent) { with_backend(fake.clone(), || wm.process_event(event)).unwrap(); } /// KWin gives the focus to a window: the window has it, and the window manager is told fn focus(fake: &Arc, wm: &mut WindowManager, id: u32) { fake.set_foreground(Some(id)); event(fake, wm, activated(id)); } fn layer(wm: &WindowManager) -> WorkspaceLayer { wm.focused_workspace().unwrap().layer } fn tiled(wm: &WindowManager) -> Vec { wm.focused_workspace() .unwrap() .containers() .iter() .map(|container| container.focused_window().unwrap().id) .collect() } fn floating(wm: &WindowManager) -> Vec { wm.focused_workspace() .unwrap() .floating_windows() .iter() .map(|window| window.id) .collect() } /// Floats `ids`, in that order, each given the focus first, and puts them side by side along the /// top of the work area, 400 pixels wide, 100 apart, so that the nearest on each side is known. /// The last one has the focus, and the workspace is on its floating layer. fn float_side_by_side(fake: &Arc, wm: &mut WindowManager, ids: &[u32]) { for (i, &id) in ids.iter().enumerate() { focus(fake, wm, id); send(fake, wm, SocketMessage::ToggleFloat); fake.move_window_by_user( id, Rect { left: 100 + 500 * i as i32, top: 200, right: 400, bottom: 300, }, ); } } /// The window the backend was last asked to give the focus to fn last_focused(fake: &FakeBackend) -> Option { fake.commands() .iter() .rev() .find_map(|command| match command { Command::Focus(id, _) => Some(*id), _ => None, }) } #[test] fn floating_a_window_puts_the_workspace_on_the_floating_layer_and_focusing_a_tile_takes_it_back() { let (fake, mut wm) = desktop_with(&[37_001, 37_002]); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); send(&fake, &mut wm, SocketMessage::ToggleFloat); assert_eq!(floating(&wm), [37_002]); assert_eq!(layer(&wm), WorkspaceLayer::Floating); focus(&fake, &mut wm, 37_001); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); focus(&fake, &mut wm, 37_002); assert_eq!(layer(&wm), WorkspaceLayer::Floating); send(&fake, &mut wm, SocketMessage::ToggleFloat); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); assert_eq!(tiled(&wm), [37_002, 37_001]); } #[test] fn toggle_workspace_layer_raises_the_windows_of_the_layer_and_focuses_one_of_them() { let (fake, mut wm) = desktop_with(&[37_011, 37_012, 37_013]); focus(&fake, &mut wm, 37_011); send(&fake, &mut wm, SocketMessage::ToggleFloat); focus(&fake, &mut wm, 37_012); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); fake.clear_commands(); send(&fake, &mut wm, SocketMessage::ToggleWorkspaceLayer); assert_eq!(layer(&wm), WorkspaceLayer::Floating); assert!( fake.commands().contains(&Command::Raise(37_011)), "{:?}", fake.commands() ); assert_eq!(last_focused(&fake), Some(37_011)); fake.clear_commands(); send(&fake, &mut wm, SocketMessage::ToggleWorkspaceLayer); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); for id in [37_012, 37_013] { assert!( fake.commands().contains(&Command::Raise(id)), "the tile of {id} is raised: {:?}", fake.commands() ); } assert_eq!(last_focused(&fake), Some(37_012), "the focused container's"); assert_eq!(floating(&wm), [37_011], "nothing was floated or unfloated"); } #[test] fn focusing_in_a_direction_on_the_floating_layer_goes_to_the_nearest_floating_window() { let (fake, mut wm) = desktop_with(&[37_021, 37_022, 37_023]); float_side_by_side(&fake, &mut wm, &[37_021, 37_022, 37_023]); fake.set_foreground(Some(37_021)); send( &fake, &mut wm, SocketMessage::FocusWindow(OperationDirection::Right), ); assert_eq!(last_focused(&fake), Some(37_022)); fake.set_foreground(Some(37_022)); send( &fake, &mut wm, SocketMessage::FocusWindow(OperationDirection::Right), ); assert_eq!(last_focused(&fake), Some(37_023)); fake.set_foreground(Some(37_023)); send( &fake, &mut wm, SocketMessage::FocusWindow(OperationDirection::Left), ); assert_eq!(last_focused(&fake), Some(37_022)); fake.set_foreground(Some(37_023)); assert_eq!( try_send( &fake, &mut wm, SocketMessage::FocusWindow(OperationDirection::Right) ), Err(String::from( "there is no container or monitor in this direction" )) ); assert_eq!(layer(&wm), WorkspaceLayer::Floating); } #[test] fn cycling_the_focus_on_the_floating_layer_goes_round_the_floating_windows_in_order() { let (fake, mut wm) = desktop_with(&[37_031, 37_032, 37_033]); float_side_by_side(&fake, &mut wm, &[37_031, 37_032, 37_033]); fake.set_foreground(Some(37_031)); let mut visited = vec![]; for direction in [ CycleDirection::Next, CycleDirection::Next, CycleDirection::Next, CycleDirection::Previous, CycleDirection::Previous, ] { send(&fake, &mut wm, SocketMessage::CycleFocusWindow(direction)); visited.push(last_focused(&fake).unwrap()); } assert_eq!(visited, [37_032, 37_033, 37_031, 37_033, 37_032]); } #[test] fn moving_on_the_floating_layer_moves_the_floating_window_by_the_resize_delta() { let (fake, mut wm) = desktop_with(&[37_041, 37_042]); float_side_by_side(&fake, &mut wm, &[37_041]); let before = fake.rect_of(37_041).unwrap(); send( &fake, &mut wm, SocketMessage::MoveWindow(OperationDirection::Right), ); let after = fake.rect_of(37_041).unwrap(); assert_eq!(after.left, before.left + 50); assert_eq!((after.top, after.right, after.bottom), (200, 400, 300)); assert_eq!(floating(&wm), [37_041]); assert_eq!(tiled(&wm), [37_042], "the tiles are not moved"); for _ in 0..40 { send( &fake, &mut wm, SocketMessage::MoveWindow(OperationDirection::Up), ); } assert_eq!( fake.rect_of(37_041).unwrap().top, 0, "never out of the work area" ); } #[test] fn resizing_on_the_floating_layer_changes_the_frame_of_the_floating_window() { let (fake, mut wm) = desktop_with(&[37_051, 37_052]); float_side_by_side(&fake, &mut wm, &[37_051]); let before = fake.rect_of(37_051).unwrap(); let tile = fake.rect_of(37_052).unwrap(); send( &fake, &mut wm, SocketMessage::ResizeWindowEdge(OperationDirection::Right, Sizing::Increase), ); let after = fake.rect_of(37_051).unwrap(); assert_eq!(after.right, before.right + 100, "twice the resize delta"); assert_eq!(after.left, before.left); assert_eq!(fake.rect_of(37_052), Some(tile), "the tile is where it was"); } #[test] fn a_direction_to_preselect_is_ignored_on_the_floating_layer() { let (fake, mut wm) = desktop_with(&[37_061, 37_062]); float_side_by_side(&fake, &mut wm, &[37_061]); send( &fake, &mut wm, SocketMessage::PreselectDirection(OperationDirection::Left), ); assert!( wm.focused_workspace() .unwrap() .preselected_container_idx .is_none() ); assert_eq!(tiled(&wm), [37_062]); } #[test] fn a_floating_window_that_is_maximized_leaves_the_floating_windows_and_comes_back_as_a_tile() { let (fake, mut wm) = desktop_with(&[37_071, 37_072]); float_side_by_side(&fake, &mut wm, &[37_071]); send(&fake, &mut wm, SocketMessage::ToggleMaximize); let workspace = wm.focused_workspace().unwrap(); assert_eq!(workspace.maximized_window.map(|w| w.id), Some(37_071)); assert!(workspace.floating_windows().is_empty()); assert!(fake.is_maximized(37_071)); send(&fake, &mut wm, SocketMessage::ToggleMaximize); assert!(!fake.is_maximized(37_071)); assert!(tiled(&wm).contains(&37_071)); assert!(floating(&wm).is_empty()); } #[test] fn the_state_shows_the_layer() { let (fake, mut wm) = desktop_with(&[37_081, 37_082]); let layer_in_state = |fake: &Arc, wm: &WindowManager| { let state = with_backend(fake.clone(), || { serde_json::to_value(State::from(wm)).unwrap() }); state["monitors"]["elements"][0]["workspaces"]["elements"][0]["layer"].clone() }; assert_eq!(layer_in_state(&fake, &wm), "Tiling"); send(&fake, &mut wm, SocketMessage::ToggleFloat); assert_eq!(layer_in_state(&fake, &wm), "Floating"); } #[test] fn going_back_to_the_tiles_hides_the_floating_windows_and_going_to_them_shows_them_again() { let (fake, mut wm) = desktop_with(&[37_061, 37_062, 37_063]); focus(&fake, &mut wm, 37_061); send(&fake, &mut wm, SocketMessage::ToggleFloat); focus(&fake, &mut wm, 37_062); assert!(!fake.is_hidden(37_061)); send(&fake, &mut wm, SocketMessage::ToggleWorkspaceLayer); assert_eq!(layer(&wm), WorkspaceLayer::Floating); assert!(!fake.is_hidden(37_061)); send(&fake, &mut wm, SocketMessage::ToggleWorkspaceLayer); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); assert!( fake.is_hidden(37_061), "the floating window is out of sight" ); assert!(!fake.is_hidden(37_062) && !fake.is_hidden(37_063)); send(&fake, &mut wm, SocketMessage::ToggleWorkspaceLayer); assert!(!fake.is_hidden(37_061), "and it is shown again"); } #[test] fn the_floating_layer_behaviour_of_the_workspace_wins_over_the_monitors_and_the_window_managers() { let (fake, mut wm) = desktop_with(&[37_071]); send(&fake, &mut wm, SocketMessage::ToggleFloat); assert_eq!(layer(&wm), WorkspaceLayer::Floating); let overridden = |wm: &WindowManager| wm.window_management_behaviour(0, 0).floating_layer_override; assert!(!overridden(&wm), "windows are tiled by default"); wm.window_management_behaviour.floating_layer_behaviour = FloatingLayerBehaviour::Float; assert!(overridden(&wm), "the window manager's behaviour"); wm.focused_monitor_mut().unwrap().floating_layer_behaviour = Some(FloatingLayerBehaviour::Tile); assert!( !overridden(&wm), "the monitor's wins over the window manager's" ); wm.focused_workspace_mut().unwrap().floating_layer_behaviour = Some(FloatingLayerBehaviour::Float); assert!(overridden(&wm), "the workspace's wins over the monitor's"); wm.focused_workspace_mut().unwrap().layer = WorkspaceLayer::Tiling; assert!( !overridden(&wm), "only a workspace on its floating layer floats new windows" ); } #[test] fn a_window_that_opens_on_the_floating_layer_floats_when_the_behaviour_says_so() { let (fake, mut wm) = desktop_with(&[37_081, 37_082]); send(&fake, &mut wm, SocketMessage::ToggleFloat); wm.focused_workspace_mut().unwrap().floating_layer_behaviour = Some(FloatingLayerBehaviour::Float); fake.open_window(37_083, "foot", "foot", "terminal 37083"); event(&fake, &mut wm, added(37_083)); assert_eq!(floating(&wm), [37_082, 37_083]); assert_eq!(tiled(&wm), [37_081]); assert_eq!(layer(&wm), WorkspaceLayer::Floating); wm.focused_workspace_mut().unwrap().floating_layer_behaviour = Some(FloatingLayerBehaviour::Tile); fake.open_window(37_084, "foot", "foot", "terminal 37084"); event(&fake, &mut wm, added(37_084)); assert_eq!(tiled(&wm), [37_081, 37_084]); assert_eq!(layer(&wm), WorkspaceLayer::Tiling); } #[test] fn a_window_sent_to_another_workspace_puts_that_workspace_on_the_layer_it_arrived_on() { let (fake, mut wm) = desktop_with(&[37_111, 37_112]); focus(&fake, &mut wm, 37_112); send(&fake, &mut wm, SocketMessage::ToggleFloat); assert_eq!(floating(&wm), [37_112]); send( &fake, &mut wm, SocketMessage::SendContainerToWorkspaceNumber(1), ); let target = &wm.focused_monitor().unwrap().workspaces()[1]; assert_eq!(target.floating_windows().len(), 1); assert_eq!(target.layer, WorkspaceLayer::Floating); focus(&fake, &mut wm, 37_111); send( &fake, &mut wm, SocketMessage::SendContainerToWorkspaceNumber(1), ); let target = &wm.focused_monitor().unwrap().workspaces()[1]; assert_eq!(target.containers().len(), 1); assert_eq!(target.layer, WorkspaceLayer::Tiling); } #[test] fn focusing_a_floating_window_towards_a_monitor_crosses_to_it_and_to_its_monocle_window() { let right_half = Rect { left: 1920, top: 0, right: 1920, bottom: 1080, }; let fake = FakeBackend::with_one_monitor(); fake.add_monitor(2, "Virtual-1", right_half, right_half); let (fake, mut wm) = desktop_on(fake, &[37_121]); fake.open_window(37_122, "foot", "foot", "terminal 37122"); fake.move_window_by_user( 37_122, Rect { left: 2020, top: 100, right: 800, bottom: 600, }, ); event(&fake, &mut wm, added(37_122)); focus(&fake, &mut wm, 37_122); send(&fake, &mut wm, SocketMessage::ToggleMonocle); focus(&fake, &mut wm, 37_121); send(&fake, &mut wm, SocketMessage::ToggleFloat); assert_eq!(wm.focused_monitor_idx(), 0); assert_eq!(layer(&wm), WorkspaceLayer::Floating); send( &fake, &mut wm, SocketMessage::FocusWindow(OperationDirection::Right), ); assert_eq!(wm.focused_monitor_idx(), 1); assert_eq!( last_focused(&fake), Some(37_122), "the monocle window of the monitor" ); }