diff --git a/komorebi/src/container.rs b/komorebi/src/container.rs index 9c7833b9..07690891 100644 --- a/komorebi/src/container.rs +++ b/komorebi/src/container.rs @@ -6,7 +6,7 @@ use color_eyre::eyre; impl_ring_elements!(Container, Window); -#[derive(Debug, Default)] +#[derive(Debug, Default, Clone)] pub struct Container { pub windows: Ring, pub locked: bool, @@ -91,4 +91,31 @@ impl Container { self.focus_window(idx.saturating_sub(1)); window } + + pub fn hide(&mut self, omit: Option) -> eyre::Result<()> { + for window in self.windows_mut().iter_mut().rev() { + let mut should_hide = omit.is_none(); + + if !should_hide + && let Some(omit) = omit + && omit != window.id + { + should_hide = true + } + + if should_hide { + window.hide()?; + } + } + + Ok(()) + } + + pub fn restore(&mut self) -> eyre::Result<()> { + if let Some(window) = self.focused_window_mut() { + window.restore()?; + } + + Ok(()) + } } diff --git a/komorebi/src/core/mod.rs b/komorebi/src/core/mod.rs index 16fd7a71..fbf48322 100644 --- a/komorebi/src/core/mod.rs +++ b/komorebi/src/core/mod.rs @@ -34,6 +34,9 @@ pub enum SocketMessage { UnstackWindow, ChangeLayout(DefaultLayout), TogglePause, + FocusWorkspaceNumber(usize), + MoveContainerToWorkspaceNumber(usize), + SendContainerToWorkspaceNumber(usize), } impl SocketMessage { diff --git a/komorebi/src/core_graphics/mod.rs b/komorebi/src/core_graphics/mod.rs index 660cd589..34503769 100644 --- a/komorebi/src/core_graphics/mod.rs +++ b/komorebi/src/core_graphics/mod.rs @@ -5,6 +5,7 @@ use objc2_core_foundation::CGFloat; use objc2_core_foundation::CGPoint; use objc2_core_foundation::CGRect; use objc2_core_graphics::CGDisplayBounds; +use objc2_core_graphics::CGGetDisplaysWithPoint; use objc2_core_graphics::CGGetOnlineDisplayList; use objc2_core_graphics::CGRectIntersectsRect; use objc2_core_graphics::CGWarpMouseCursorPosition; @@ -56,6 +57,32 @@ impl CoreGraphicsApi { unsafe { CGDisplayBounds(display_id) } } + pub fn display_bounds_for_window_rect(window_rect: CGRect) -> Option { + let mut displays: Vec = Vec::with_capacity(1); + let mut display_count = 0; + + unsafe { + match CoreGraphicsError::from(CGGetDisplaysWithPoint( + window_rect.origin, + displays.capacity() as u32, + displays.as_mut_ptr(), + &mut display_count, + )) { + CoreGraphicsError::Success => { + displays.set_len(display_count as usize); + } + error => { + tracing::error!("failed to find display for point: {error}"); + return None; + } + } + } + + displays + .first() + .map(|display| CoreGraphicsApi::display_bounds(*display)) + } + pub fn window_list_info() -> Option> { unsafe { CGWindowListCopyWindowInfo( diff --git a/komorebi/src/lib.rs b/komorebi/src/lib.rs index 72a7db55..f6903de4 100644 --- a/komorebi/src/lib.rs +++ b/komorebi/src/lib.rs @@ -11,6 +11,9 @@ use objc2_core_foundation::CFDictionary; use objc2_core_foundation::CFRetained; use objc2_core_foundation::CFRunLoop; use objc2_core_foundation::CFString; +use objc2_core_foundation::CGPoint; +use objc2_core_foundation::CGRect; +use objc2_core_foundation::CGSize; use std::ops::Deref; use std::path::PathBuf; use std::ptr::NonNull; @@ -113,3 +116,11 @@ pub enum LibraryError { #[error(transparent)] CoreGraphics(#[from] CoreGraphicsError), } + +pub fn hidden_frame_bottom_left(screen_frame: CGRect, window_size: CGSize) -> CGRect { + let visible_sliver: f64 = 1.0; + let origin_x = screen_frame.origin.x - (window_size.width - visible_sliver); + let origin_y = screen_frame.origin.y - (window_size.height - visible_sliver); + + CGRect::new(CGPoint::new(origin_x, origin_y), window_size) +} diff --git a/komorebi/src/macos_api.rs b/komorebi/src/macos_api.rs index eaf37dd1..2bbba371 100644 --- a/komorebi/src/macos_api.rs +++ b/komorebi/src/macos_api.rs @@ -125,7 +125,7 @@ impl MacosApi { )?) } - pub fn window_rect(element: &AXUIElement) -> Result { + pub fn window_rect(element: &AXUIElement) -> Result { let mut position_receiver = std::ptr::null(); let mut size_receiver = std::ptr::null(); @@ -168,7 +168,7 @@ impl MacosApi { NonNull::from_mut(&mut rect.size).cast::(), ); - Ok(Rect::from(rect)) + Ok(rect) } } } diff --git a/komorebi/src/monitor.rs b/komorebi/src/monitor.rs index 17288f5d..8e742986 100644 --- a/komorebi/src/monitor.rs +++ b/komorebi/src/monitor.rs @@ -1,5 +1,9 @@ use crate::DEFAULT_CONTAINER_PADDING; use crate::DEFAULT_WORKSPACE_PADDING; +use crate::container::Container; +use crate::core::default_layout::DefaultLayout; +use crate::core::layout::Layout; +use crate::core::operation_direction::OperationDirection; use crate::core::rect::Rect; use crate::ring::Ring; use crate::workspace::Workspace; @@ -21,6 +25,7 @@ pub struct Monitor { pub window_based_work_area_offset_limit: isize, pub container_padding: Option, pub workspace_padding: Option, + pub last_focused_workspace: Option, } impl Monitor { @@ -39,6 +44,7 @@ impl Monitor { window_based_work_area_offset_limit: 0, container_padding: None, workspace_padding: None, + last_focused_workspace: None, } } @@ -85,4 +91,147 @@ impl Monitor { } } } + + #[tracing::instrument(skip(self))] + pub fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { + tracing::info!("focusing workspace"); + + { + let workspaces = self.workspaces_mut(); + + if workspaces.get(idx).is_none() { + workspaces.resize(idx + 1, Workspace::default()); + } + self.last_focused_workspace = Some(self.workspaces.focused_idx()); + self.workspaces.focus(idx); + } + + Ok(()) + } + + pub fn load_focused_workspace(&mut self, mouse_follows_focus: bool) -> eyre::Result<()> { + let focused_idx = self.focused_workspace_idx(); + for (i, workspace) in self.workspaces_mut().iter_mut().enumerate() { + if i == focused_idx { + workspace.restore(mouse_follows_focus)?; + } else { + workspace.hide(None)?; + } + } + + Ok(()) + } + + #[tracing::instrument(skip(self))] + pub fn move_container_to_workspace( + &mut self, + target_workspace_idx: usize, + follow: bool, + direction: Option, + ) -> eyre::Result<()> { + let workspace = self + .focused_workspace_mut() + .ok_or_else(|| eyre!("there is no workspace"))?; + + let container = workspace + .remove_focused_container() + .ok_or_else(|| eyre!("there is no container"))?; + + let workspaces = self.workspaces_mut(); + + #[allow(clippy::option_if_let_else)] + let target_workspace = match workspaces.get_mut(target_workspace_idx) { + None => { + workspaces.resize(target_workspace_idx + 1, Workspace::default()); + workspaces.get_mut(target_workspace_idx).unwrap() + } + Some(workspace) => workspace, + }; + + if let Some(direction) = direction { + self.add_container_with_direction(container, Some(target_workspace_idx), direction)?; + } else { + target_workspace.add_container_to_back(container); + } + + if follow { + self.focus_workspace(target_workspace_idx)?; + } + + Ok(()) + } + + /// Adds a container to this `Monitor` using the move direction to calculate if the container + /// should be added in front of all containers, in the back or in place of the focused + /// container, moving the rest along. The move direction should be from the origin monitor + /// towards the target monitor or from the origin workspace towards the target workspace. + pub fn add_container_with_direction( + &mut self, + container: Container, + workspace_idx: Option, + direction: OperationDirection, + ) -> eyre::Result<()> { + let workspace = if let Some(idx) = workspace_idx { + self.workspaces_mut() + .get_mut(idx) + .ok_or_else(|| eyre!("there is no workspace at index {}", idx))? + } else { + self.focused_workspace_mut() + .ok_or_else(|| eyre!("there is no workspace"))? + }; + + match direction { + OperationDirection::Left => { + // insert the container into the workspace on the monitor at the back (or rightmost position) + // if we are moving across a boundary to the left (back = right side of the target) + match workspace.layout { + Layout::Default(layout) => match layout { + DefaultLayout::RightMainVerticalStack => { + workspace.add_container_to_front(container); + } + DefaultLayout::UltrawideVerticalStack => { + if workspace.containers().len() == 1 { + workspace.insert_container_at_idx(0, container); + } else { + workspace.add_container_to_back(container); + } + } + _ => { + workspace.add_container_to_back(container); + } + }, + } + } + OperationDirection::Right => { + // insert the container into the workspace on the monitor at the front (or leftmost position) + // if we are moving across a boundary to the right (front = left side of the target) + match workspace.layout { + Layout::Default(layout) => { + let target_index = layout.leftmost_index(workspace.containers().len()); + + match layout { + DefaultLayout::RightMainVerticalStack + | DefaultLayout::UltrawideVerticalStack => { + if workspace.containers().len() == 1 { + workspace.add_container_to_back(container); + } else { + workspace.insert_container_at_idx(target_index, container); + } + } + _ => { + workspace.insert_container_at_idx(target_index, container); + } + } + } + } + } + OperationDirection::Up | OperationDirection::Down => { + // insert the container into the workspace on the monitor at the position + // where the currently focused container on that workspace is + workspace.insert_container_at_idx(workspace.focused_container_idx(), container); + } + }; + + Ok(()) + } } diff --git a/komorebi/src/process_command.rs b/komorebi/src/process_command.rs index e97294b2..9c98db1b 100644 --- a/komorebi/src/process_command.rs +++ b/komorebi/src/process_command.rs @@ -79,6 +79,17 @@ impl WindowManager { self.is_paused = !self.is_paused; } + SocketMessage::FocusWorkspaceNumber(workspace_idx) => { + if self.focused_workspace_idx().unwrap_or_default() != workspace_idx { + self.focus_workspace(workspace_idx)?; + } + } + SocketMessage::MoveContainerToWorkspaceNumber(workspace_idx) => { + self.move_container_to_workspace(workspace_idx, true, None)?; + } + SocketMessage::SendContainerToWorkspaceNumber(workspace_idx) => { + self.move_container_to_workspace(workspace_idx, false, None)?; + } } Ok(()) diff --git a/komorebi/src/window.rs b/komorebi/src/window.rs index f6a5a576..f570f9f0 100644 --- a/komorebi/src/window.rs +++ b/komorebi/src/window.rs @@ -19,6 +19,8 @@ use crate::application::Application; use crate::ax_event_listener::event_tx; use crate::cf_dictionary_value; use crate::core::rect::Rect; +use crate::core_graphics::CoreGraphicsApi; +use crate::hidden_frame_bottom_left; use crate::macos_api::MacosApi; use crate::window_manager_event::WindowManagerEvent; use objc2_app_kit::NSApplicationActivationOptions; @@ -206,20 +208,24 @@ impl Window { #[tracing::instrument(skip_all)] pub fn hide(&mut self) -> Result<(), AccessibilityError> { + // I don't love this, but it's basically what Aerospace does in lieu of an actual "Hide" API if self.restore_point.is_none() { let rect = MacosApi::window_rect(&self.element)?; - self.restore_point = Some((rect.left as f32, rect.top as f32)); + if let Some(monitor_size) = CoreGraphicsApi::display_bounds_for_window_rect(rect) { + self.restore_point = Some((rect.origin.x as f32, rect.origin.y as f32)); + let hidden_rect = hidden_frame_bottom_left(monitor_size, rect.size); - tracing::debug!( - "hiding {} and setting restore point to {},{}", - self.title() - .unwrap_or_else(|| String::from("")), - rect.left, - rect.top, - ); + tracing::debug!( + "hiding {} and setting restore point to {},{}", + self.title() + .unwrap_or_else(|| String::from("")), + rect.origin.x, + rect.origin.y, + ); - // todo: this doesn't really do what I want - self.set_point(CGPoint::new(-5000.0 as CGFloat, rect.top as CGFloat))?; + self.set_point(hidden_rect.origin)?; + self.set_size(hidden_rect.size)?; + } } Ok(()) diff --git a/komorebi/src/window_manager.rs b/komorebi/src/window_manager.rs index 07b7dfbc..7bde432c 100644 --- a/komorebi/src/window_manager.rs +++ b/komorebi/src/window_manager.rs @@ -418,4 +418,40 @@ impl WindowManager { self.update_focused_workspace(mouse_follows_focus, true) } + #[tracing::instrument(skip(self))] + pub fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { + tracing::info!("focusing workspace"); + + let mouse_follows_focus = self.mouse_follows_focus; + let monitor = self + .focused_monitor_mut() + .ok_or_else(|| eyre!("there is no workspace"))?; + + monitor.focus_workspace(idx)?; + monitor.load_focused_workspace(mouse_follows_focus)?; + + self.update_focused_workspace(false, true) + } + + #[tracing::instrument(skip(self))] + pub fn move_container_to_workspace( + &mut self, + idx: usize, + follow: bool, + direction: Option, + ) -> eyre::Result<()> { + tracing::info!("moving container"); + + let mouse_follows_focus = self.mouse_follows_focus; + let monitor = self + .focused_monitor_mut() + .ok_or_else(|| eyre!("there is no monitor"))?; + + monitor.move_container_to_workspace(idx, follow, direction)?; + monitor.load_focused_workspace(mouse_follows_focus)?; + + self.update_focused_workspace(mouse_follows_focus, true)?; + + Ok(()) + } } diff --git a/komorebi/src/workspace.rs b/komorebi/src/workspace.rs index cf8d810e..966d5560 100644 --- a/komorebi/src/workspace.rs +++ b/komorebi/src/workspace.rs @@ -14,7 +14,7 @@ use std::num::NonZeroUsize; impl_ring_elements!(Workspace, Container); -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct Workspace { pub containers: Ring, pub workspace_padding: Option, @@ -376,4 +376,65 @@ impl Workspace { container.add_window(&window)?; Ok(()) } + + pub fn hide(&mut self, omit: Option) -> eyre::Result<()> { + for container in self.containers_mut() { + container.hide(omit)?; + } + + Ok(()) + } + + pub fn restore(&mut self, mouse_follows_focus: bool) -> eyre::Result<()> { + let idx = self.focused_container_idx(); + let mut to_focus = None; + + for (i, container) in self.containers().iter().enumerate() { + if let Some(window) = container.focused_window() + && idx == i + { + to_focus = Option::from(window.clone()); + } + } + + for container in self.containers_mut() { + container.restore()?; + } + + if let Some(container) = self.focused_container_mut() { + container.focus_window(container.focused_window_idx()); + } + + if let Some(window) = to_focus { + window.focus(mouse_follows_focus)?; + } + + Ok(()) + } + + pub fn remove_focused_container(&mut self) -> Option { + let focused_idx = self.focused_container_idx(); + let container = self.remove_container_by_idx(focused_idx); + self.focus_previous_container(); + + container + } + + pub fn add_container_to_back(&mut self, container: Container) { + self.containers_mut().push_back(container); + self.focus_last_container(); + } + + pub fn add_container_to_front(&mut self, container: Container) { + self.containers_mut().push_front(container); + self.focus_first_container(); + } + + fn focus_last_container(&mut self) { + self.focus_container(self.containers().len().saturating_sub(1)); + } + + fn focus_first_container(&mut self) { + self.focus_container(0); + } } diff --git a/komorebic/src/main.rs b/komorebic/src/main.rs index e8c3d2d7..288759c7 100644 --- a/komorebic/src/main.rs +++ b/komorebic/src/main.rs @@ -59,6 +59,25 @@ gen_enum_subcommand_args! { CycleStack: CycleDirection, } +macro_rules! gen_target_subcommand_args { + // SubCommand Pattern + ( $( $name:ident ),+ $(,)? ) => { + $( + #[derive(clap::Parser)] + pub struct $name { + /// Target index (zero-indexed) + target: usize, + } + )+ + }; +} + +gen_target_subcommand_args! { + FocusWorkspace, + MoveToWorkspace, + SendToWorkspace +} + #[derive(Parser)] #[clap(author, about, version)] struct Opts { @@ -87,6 +106,15 @@ enum SubCommand { /// Set the layout on the focused workspace #[clap(arg_required_else_help = true)] ChangeLayout(ChangeLayout), + /// Focus the specified workspace on the focused monitor + #[clap(arg_required_else_help = true)] + FocusWorkspace(FocusWorkspace), + /// Move the focused window to the specified workspace + #[clap(arg_required_else_help = true)] + MoveToWorkspace(MoveToWorkspace), + /// Send the focused window to the specified workspace + #[clap(arg_required_else_help = true)] + SendToWorkspace(SendToWorkspace), } fn main() -> eyre::Result<()> { @@ -114,6 +142,15 @@ fn main() -> eyre::Result<()> { SubCommand::CycleStack(arg) => { send_message(&SocketMessage::CycleStack(arg.cycle_direction))?; } + SubCommand::FocusWorkspace(arg) => { + send_message(&SocketMessage::FocusWorkspaceNumber(arg.target))?; + } + SubCommand::MoveToWorkspace(arg) => { + send_message(&SocketMessage::MoveContainerToWorkspaceNumber(arg.target))?; + } + SubCommand::SendToWorkspace(arg) => { + send_message(&SocketMessage::SendContainerToWorkspaceNumber(arg.target))?; + } } Ok(())