feat(wm): add alt-tab heuristics to wsr

This commit adds some rough heuristics to workspace_reconciliator which
should help with having the correct window focused after reconciliation
in the majority of, but probably not all, cases.

EnumWindows generally returns HWNDs according to z order, and a window
selected by alt-tab will almost always be put on the top of the z order.
Before sending a workspace_reconciliator::Notification, we store this
HWND along with an Instant and an AtomicBool telling us that we have a
candidate to focus after the workspace switch.

komorebi/src/border_manager/border.rs

@@ -17,6 +17,7 @@ use komorebi_core::Rect;
 
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
+use std::time::Duration;
 use windows::core::PCWSTR;
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
@@ -103,6 +104,7 @@ impl Border {
                 while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
                     TranslateMessage(&message);
                     DispatchMessageW(&message);
+                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 
@@ -130,10 +132,8 @@ impl Border {
             rects.insert(self.hwnd, rect);
         }
 
-        // Update the position of the border if required
-        if !WindowsApi::window_rect(self.hwnd())?.eq(&rect) {
-            WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((*Z_ORDER.lock()).into()))?;
-        }
+        // Update the position of the border
+        WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((*Z_ORDER.lock()).into()))?;
 
         // Invalidate the rect to trigger the callback to update colours etc.
         self.invalidate();

komorebi/src/monitor.rs

@@ -36,10 +36,6 @@ pub struct Monitor {
     work_area_size: Rect,
     #[getset(get_copy = "pub", set = "pub")]
     work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset_limit: isize,
     workspaces: Ring<Workspace>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
@@ -62,8 +58,6 @@ pub fn new(id: isize, size: Rect, work_area_size: Rect, name: String) -> Monitor
         size,
         work_area_size,
         work_area_offset: None,
-        window_based_work_area_offset: None,
-        window_based_work_area_offset_limit: 1,
         workspaces,
         last_focused_workspace: None,
         workspace_names: HashMap::default(),
@@ -200,11 +194,6 @@ impl Monitor {
 
     pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> Result<()> {
         let work_area = *self.work_area_size();
-        let window_based_work_area_offset = (
-            self.window_based_work_area_offset_limit(),
-            self.window_based_work_area_offset(),
-        );
-
         let offset = if self.work_area_offset().is_some() {
             self.work_area_offset()
         } else {
@@ -213,7 +202,7 @@ impl Monitor {
 
         self.focused_workspace_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?
-            .update(&work_area, offset, window_based_work_area_offset)?;
+            .update(&work_area, offset)?;
 
         Ok(())
     }

komorebi/src/process_command.rs

@@ -78,34 +78,23 @@ use crate::WORKSPACE_RULES;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        let listener = wm
-            .lock()
-            .command_listener
-            .try_clone()
-            .expect("could not clone unix listener");
+    let listener = wm
+        .lock()
+        .command_listener
+        .try_clone()
+        .expect("could not clone unix listener");
 
+    std::thread::spawn(move || {
         tracing::info!("listening on komorebi.sock");
-
-        // client is unique for every komorebic command
         for client in listener.incoming() {
             match client {
                 Ok(stream) => match read_commands_uds(&wm, stream) {
                     Ok(()) => {}
-                    Err(error) => {
-                        if cfg!(debug_assertions) {
-                            tracing::error!("{:?}", error)
-                        } else {
-                            tracing::error!("{}", error)
-                        }
-                    }
+                    Err(error) => tracing::error!("{}", error),
                 },
                 Err(error) => {
-                    if cfg!(debug_assertions) {
-                        tracing::error!("{:?}", error)
-                    } else {
-                        tracing::error!("{}", error)
-                    }
+                    tracing::error!("{}", error);
+                    break;
                 }
             }
         }

komorebi/src/process_event.rs

@@ -23,6 +23,7 @@ use crate::window::RuleDebug;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
+use crate::winevent::WinEvent;
 use crate::workspace_reconciliator;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
@@ -35,17 +36,20 @@ use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
+    let receiver = wm.lock().incoming_events.clone();
+
+    std::thread::spawn(move || {
         tracing::info!("listening");
-        let receiver = wm.lock().incoming_events.clone();
-        for event in receiver {
-            match wm.lock().process_event(event) {
-                Ok(()) => {}
-                Err(error) => {
-                    if cfg!(debug_assertions) {
-                        tracing::error!("{:?}", error)
-                    } else {
-                        tracing::error!("{}", error)
+        loop {
+            if let Ok(event) = receiver.recv() {
+                match wm.lock().process_event(event) {
+                    Ok(()) => {}
+                    Err(error) => {
+                        if cfg!(debug_assertions) {
+                            tracing::error!("{:?}", error)
+                        } else {
+                            tracing::error!("{}", error)
+                        }
                     }
                 }
             }
@@ -122,11 +126,6 @@ impl WindowManager {
 
         for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
             let work_area = *monitor.work_area_size();
-            let window_based_work_area_offset = (
-                monitor.window_based_work_area_offset_limit(),
-                monitor.window_based_work_area_offset(),
-            );
-
             let offset = if monitor.work_area_offset().is_some() {
                 monitor.work_area_offset()
             } else {
@@ -140,7 +139,7 @@ impl WindowManager {
 
                 let reaped_orphans = workspace.reap_orphans()?;
                 if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
-                    workspace.update(&work_area, offset, window_based_work_area_offset)?;
+                    workspace.update(&work_area, offset)?;
                     tracing::info!(
                         "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                         reaped_orphans.0,
@@ -619,8 +618,15 @@ impl WindowManager {
             state: self.as_ref().into(),
         };
 
-        notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::event_tx().send(border_manager::Notification)?;
+        // Avoid unnecessary updates, this fires every single time you interact
+        // with something on JetBrains IDEs
+        if !matches!(
+            event,
+            WindowManagerEvent::Show(WinEvent::ObjectNameChange, _)
+        ) {
+            notify_subscribers(&serde_json::to_string(&notification)?)?;
+            border_manager::event_tx().send(border_manager::Notification)?;
+        }
 
         tracing::info!("processed: {}", event.window().to_string());
         Ok(())

komorebi/src/stackbar.rs

@@ -1,5 +1,6 @@
 use std::collections::VecDeque;
 use std::sync::atomic::Ordering;
+use std::time::Duration;
 
 use color_eyre::eyre::Result;
 use schemars::JsonSchema;
@@ -162,6 +163,7 @@ impl Stackbar {
                 while GetMessageW(&mut msg, hwnd, 0, 0).into() {
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
+                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 

komorebi/src/static_config.rs

@@ -201,12 +201,6 @@ pub struct MonitorConfig {
     /// Monitor-specific work area offset (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub work_area_offset: Option<Rect>,
-    /// Window based work area offset (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_based_work_area_offset: Option<Rect>,
-    /// Open window limit after which the window based work area offset will no longer be applied (default: 1)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_based_work_area_offset_limit: Option<isize>,
 }
 
 impl From<&Monitor> for MonitorConfig {
@@ -219,8 +213,6 @@ impl From<&Monitor> for MonitorConfig {
         Self {
             workspaces,
             work_area_offset: value.work_area_offset(),
-            window_based_work_area_offset: value.window_based_work_area_offset(),
-            window_based_work_area_offset_limit: Some(value.window_based_work_area_offset_limit()),
         }
     }
 }
@@ -702,10 +694,6 @@ impl StaticConfig {
                 if let Some(m) = wm.monitors_mut().get_mut(i) {
                     m.ensure_workspace_count(monitor.workspaces.len());
                     m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );
 
                     for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
                         ws.load_static_config(
@@ -761,10 +749,6 @@ impl StaticConfig {
                 if let Some(m) = wm.monitors_mut().get_mut(i) {
                     m.ensure_workspace_count(monitor.workspaces.len());
                     m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );
 
                     for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
                         ws.load_static_config(

komorebi/src/window.rs

@@ -139,10 +139,6 @@ impl Window {
     }
 
     pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
-        if WindowsApi::window_rect(self.hwnd())?.eq(layout) {
-            return Ok(());
-        }
-
         let rect = *layout;
         WindowsApi::position_window(self.hwnd(), &rect, top)
     }

komorebi/src/window_manager.rs

@@ -713,11 +713,6 @@ impl WindowManager {
 
         for monitor in self.monitors_mut() {
             let work_area = *monitor.work_area_size();
-            let window_based_work_area_offset = (
-                monitor.window_based_work_area_offset_limit(),
-                monitor.window_based_work_area_offset(),
-            );
-
             let offset = if monitor.work_area_offset().is_some() {
                 monitor.work_area_offset()
             } else {
@@ -735,7 +730,7 @@ impl WindowManager {
                 }
             }
 
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
         }
 
         Ok(())
@@ -1278,6 +1273,11 @@ impl WindowManager {
 
         let workspace = self.focused_workspace()?;
 
+        // Do not proceed if we have a monocle container or maximized window
+        if workspace.monocle_container().is_some() || workspace.maximized_window().is_some() {
+            return Ok(());
+        }
+
         tracing::info!("focusing container");
 
         let new_idx = workspace.new_idx_for_direction(direction);
@@ -1948,11 +1948,6 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
         let focused_workspace_idx = monitor.focused_workspace_idx();
         let offset = if monitor.work_area_offset().is_some() {
             monitor.work_area_offset()
@@ -1972,7 +1967,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2001,11 +1996,6 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
         let focused_workspace_idx = monitor.focused_workspace_idx();
         let offset = if monitor.work_area_offset().is_some() {
             monitor.work_area_offset()
@@ -2027,7 +2017,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2051,11 +2041,6 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
         let focused_workspace_idx = monitor.focused_workspace_idx();
         let offset = if monitor.work_area_offset().is_some() {
             monitor.work_area_offset()
@@ -2073,7 +2058,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2098,11 +2083,6 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
         let focused_workspace_idx = monitor.focused_workspace_idx();
         let offset = if monitor.work_area_offset().is_some() {
             monitor.work_area_offset()
@@ -2119,7 +2099,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2147,11 +2127,6 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
         let focused_workspace_idx = monitor.focused_workspace_idx();
         let offset = if monitor.work_area_offset().is_some() {
             monitor.work_area_offset()
@@ -2169,7 +2144,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)

komorebi/src/workspace.rs

@@ -219,21 +219,13 @@ impl Workspace {
         Ok(())
     }
 
-    pub fn update(
-        &mut self,
-        work_area: &Rect,
-        work_area_offset: Option<Rect>,
-        window_based_work_area_offset: (isize, Option<Rect>),
-    ) -> Result<()> {
+    pub fn update(&mut self, work_area: &Rect, offset: Option<Rect>) -> Result<()> {
         if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
             return Ok(());
         }
 
-        let (window_based_work_area_offset_limit, window_based_work_area_offset) =
-            window_based_work_area_offset;
-
         let container_padding = self.container_padding();
-        let mut adjusted_work_area = work_area_offset.map_or_else(
+        let mut adjusted_work_area = offset.map_or_else(
             || *work_area,
             |offset| {
                 let mut with_offset = *work_area;
@@ -246,21 +238,6 @@ impl Workspace {
             },
         );
 
-        if self.containers().len() <= window_based_work_area_offset_limit as usize {
-            adjusted_work_area = window_based_work_area_offset.map_or_else(
-                || adjusted_work_area,
-                |offset| {
-                    let mut with_offset = adjusted_work_area;
-                    with_offset.left += offset.left;
-                    with_offset.top += offset.top;
-                    with_offset.right -= offset.right;
-                    with_offset.bottom -= offset.bottom;
-
-                    with_offset
-                },
-            );
-        }
-
         adjusted_work_area.add_padding(self.workspace_padding().unwrap_or_default());
 
         self.enforce_resize_constraints();