feat(borders): add border manager module

This commit removes all border-related code from process_command,
process_event etc. and centralizes it in the new border_manager module.

Instead of trying to figure out where in process_event and
process_command we should make border-related changes, a notification
gets sent to a channel that border_manager listens to whenever an event
or command has finished processing.

The border_manager listener, upon receiving a notification, acquires a
lock on the WindowManager instance and updates borders for the focused
workspace on every monitor; this allows us to centralize all edge case
handling within the border_manager listener's loop.

Borders on workspaces that lose focus are now destroyed and recreated
when those workspaces regain focus, instead of trying to share
individual border instances across workspaces.

A number of common edge cases that have been addressed in this commit
are:

* Paused window manager
* Floating workspaces
* Maximized windows
* Fullscreen videos
* Monocle containers
* Ghost borders on workspace switching
* Incorrect focused window border colours

Global state related to borders has also been moved into the
border_manager module, which also tracks the state of border objects
(BORDER_STATE), their rects (RECT_STATE) and their focus kinds
(FOCUS_STATE).

This allows us to now track multiple borders per-container, enabling
unfocused border windows for the first time.

Additionally, the Z-Order for border windows is now also configurable.

ActiveWindowBorderColours has been expanded to include Unfocused, but in
order to not introduce a breaking configuration change for end users,
all members of this struct have been made Option<Colour>.

justfile

@@ -28,6 +28,7 @@ install:
     just install-target komorebi
 
 run:
+    just install-target komorebic
     cargo +stable run --bin komorebi --locked
 
 warn $RUST_LOG="warn":
@@ -43,6 +44,7 @@ trace $RUST_LOG="trace":
     just run
 
 deadlock $RUST_LOG="trace":
+    just install-komorebic
     cargo +stable run --bin komorebi --locked --features deadlock_detection
 
 docgen:

komorebi-core/src/arrangement.rs

@@ -26,7 +26,7 @@ pub trait Arrangement {
 }
 
 impl Arrangement for DefaultLayout {
-    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
+    #[allow(clippy::too_many_lines)]
     fn calculate(
         &self,
         area: &Rect,
@@ -58,13 +58,12 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        columns_reverse(&mut layouts);
-                    }
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => columns_reverse(&mut layouts),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -83,13 +82,12 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        rows_reverse(&mut layouts);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        2.. => rows_reverse(&mut layouts),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -137,28 +135,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];
 
-                        for rect in rest.iter_mut() {
-                            rect.left = primary.left;
+                            for rect in rest.iter_mut() {
+                                rect.left = primary.left;
+                            }
+                            primary.left = rest[0].left + rest[0].right;
                         }
-                        primary.left = rest[0].left + rest[0].right;
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        rows_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        3.. => rows_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -209,28 +207,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];
 
-                        primary.left = rest[0].left;
-                        for rect in rest.iter_mut() {
-                            rect.left = primary.left + primary.right;
+                            primary.left = rest[0].left;
+                            for rect in rest.iter_mut() {
+                                rect.left = primary.left + primary.right;
+                            }
                         }
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        rows_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        3.. => rows_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -278,28 +276,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];
 
-                        for rect in rest.iter_mut() {
-                            rect.top = primary.top;
+                            for rect in rest.iter_mut() {
+                                rect.top = primary.top;
+                            }
+                            primary.top = rest[0].top + rest[0].bottom;
                         }
-                        primary.top = rest[0].top + rest[0].bottom;
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        columns_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        3.. => columns_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -376,11 +374,8 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    match len {
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
                         2 => {
                             let (primary, secondary) = layouts.split_at_mut(1);
                             let primary = &mut primary[0];
@@ -402,20 +397,20 @@ impl Arrangement for DefaultLayout {
                             secondary.left = primary.left + primary.right;
                         }
                         _ => {}
-                    }
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 4.. = len {
-                        rows_reverse(&mut layouts[2..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        4.. => rows_reverse(&mut layouts[2..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
-            }
+            },
             #[allow(
                 clippy::cast_precision_loss,
                 clippy::cast_possible_truncation,

komorebi-core/src/lib.rs

@@ -283,8 +283,6 @@ pub enum MoveBehaviour {
     Swap,
     /// Insert the window container into the focused workspace on the adjacent monitor
     Insert,
-    /// Do nothing if trying to move a window container in the direction of an adjacent monitor
-    NoOp,
 }
 
 #[derive(

komorebi/src/border_manager/border.rs

@@ -17,8 +17,8 @@ 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;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -47,29 +47,10 @@ use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 
-pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
-
-    if let Ok(class) = WindowsApi::real_window_class_w(hwnd) {
-        if class.starts_with("komoborder") {
-            hwnds.push(hwnd.0);
-        }
-    }
-
-    true.into()
-}
-
-#[derive(Debug)]
 pub struct Border {
     pub hwnd: isize,
 }
 
-impl From<isize> for Border {
-    fn from(value: isize) -> Self {
-        Self { hwnd: value }
-    }
-}
-
 impl Border {
     pub const fn hwnd(&self) -> HWND {
         HWND(self.hwnd)
@@ -103,6 +84,7 @@ impl Border {
                 while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
                     TranslateMessage(&message);
                     DispatchMessageW(&message);
+                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 
@@ -115,7 +97,7 @@ impl Border {
     }
 
     pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd())
+        WindowsApi::destroy_window(self.hwnd())
     }
 
     pub fn update(&self, rect: &Rect) -> color_eyre::Result<()> {
@@ -130,10 +112,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/border_manager/mod.rs

@@ -1,5 +1,3 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
 mod border;
 
 use crossbeam_channel::Receiver;
@@ -11,24 +9,19 @@ use parking_lot::Mutex;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 use std::sync::OnceLock;
-use std::time::Duration;
-use std::time::Instant;
 use windows::Win32::Foundation::HWND;
 
-use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::Colour;
 use crate::Rect;
 use crate::Rgb;
 use crate::WindowManager;
 use crate::WindowsApi;
-use border::border_hwnds;
 use border::Border;
 use komorebi_core::WindowKind;
 
@@ -73,273 +66,206 @@ pub fn event_rx() -> Receiver<Notification> {
     channel().1.clone()
 }
 
-pub fn destroy_all_borders() -> color_eyre::Result<()> {
-    let mut borders = BORDER_STATE.lock();
-    tracing::info!(
-        "purging known borders: {:?}",
-        borders.iter().map(|b| b.1.hwnd).collect::<Vec<_>>()
-    );
-
-    for (_, border) in borders.iter() {
-        border.destroy()?;
-    }
-
-    borders.clear();
-    RECT_STATE.lock().clear();
-    BORDERS_MONITORS.lock().clear();
-    FOCUS_STATE.lock().clear();
-
-    let mut remaining_hwnds = vec![];
-
-    WindowsApi::enum_windows(
-        Some(border_hwnds),
-        &mut remaining_hwnds as *mut Vec<isize> as isize,
-    )?;
-
-    if !remaining_hwnds.is_empty() {
-        tracing::info!("purging unknown borders: {:?}", remaining_hwnds);
-
-        for hwnd in remaining_hwnds {
-            Border::from(hwnd).destroy()?;
-        }
-    }
-
-    Ok(())
-}
-
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                tracing::warn!("restarting failed thread: {}", error);
-            }
-        }
-    });
-}
-
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
     tracing::info!("listening");
-
     let receiver = event_rx();
-    let mut instant: Option<Instant> = None;
-    event_tx().send(Notification)?;
 
-    'receiver: for _ in receiver {
-        if let Some(instant) = instant {
-            if instant.elapsed().lt(&Duration::from_millis(50)) {
+    std::thread::spawn(move || -> color_eyre::Result<()> {
+        'receiver: for _ in receiver {
+            let mut borders = BORDER_STATE.lock();
+            let mut borders_monitors = BORDERS_MONITORS.lock();
+
+            // Check the wm state every time we receive a notification
+            let state = wm.lock();
+
+            if !BORDER_ENABLED.load_consume() || state.is_paused {
+                if !borders.is_empty() {
+                    for (_, border) in borders.iter() {
+                        border.destroy()?;
+                    }
+
+                    borders.clear();
+                }
+
                 continue 'receiver;
             }
-        }
 
-        instant = Some(Instant::now());
+            let focused_monitor_idx = state.focused_monitor_idx();
 
-        let mut borders = BORDER_STATE.lock();
-        let mut borders_monitors = BORDERS_MONITORS.lock();
-
-        // Check the wm state every time we receive a notification
-        let state = wm.lock();
-
-        // If borders are disabled
-        if !BORDER_ENABLED.load_consume()
-           // Or if the wm is paused
-            || state.is_paused
-            // Or if we are handling an alt-tab across workspaces
-            || ALT_TAB_HWND.load().is_some()
-        {
-            // Destroy the borders we know about
-            for (_, border) in borders.iter() {
-                border.destroy()?;
-            }
-
-            borders.clear();
-            continue 'receiver;
-        }
-
-        let focused_monitor_idx = state.focused_monitor_idx();
-
-        for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
-            // Only operate on the focused workspace of each monitor
-            if let Some(ws) = m.focused_workspace() {
-                // Workspaces with tiling disabled don't have borders
-                if !ws.tile() {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                // Handle the monocle container separately
-                if let Some(monocle) = ws.monocle_container() {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    let border = match borders.entry(monocle.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(border) = Border::create(monocle.id()) {
-                                entry.insert(border)
-                            } else {
-                                continue 'receiver;
-                            }
-                        }
-                    };
-
-                    borders_monitors.insert(monocle.id().clone(), monitor_idx);
-
-                    {
-                        let mut focus_state = FOCUS_STATE.lock();
-                        focus_state.insert(border.hwnd, WindowKind::Monocle);
-                    }
-
-                    let rect = WindowsApi::window_rect(
-                        monocle.focused_window().copied().unwrap_or_default().hwnd(),
-                    )?;
-
-                    border.update(&rect)?;
-                    continue 'receiver;
-                }
-
-                let is_maximized = WindowsApi::is_zoomed(HWND(
-                    WindowsApi::foreground_window().unwrap_or_default(),
-                ));
-
-                if is_maximized {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                // Destroy any borders not associated with the focused workspace
-                let container_ids = ws
-                    .containers()
-                    .iter()
-                    .map(|c| c.id().clone())
-                    .collect::<Vec<_>>();
-
-                let mut to_remove = vec![];
-                for (id, border) in borders.iter() {
-                    if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                        && !container_ids.contains(id)
-                    {
-                        border.destroy()?;
-                        to_remove.push(id.clone());
-                    }
-                }
-
-                for id in &to_remove {
-                    borders.remove(id);
-                }
-
-                for (idx, c) in ws.containers().iter().enumerate() {
-                    // Update border when moving or resizing with mouse
-                    if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
-                        let restore_z_order = *Z_ORDER.lock();
-                        *Z_ORDER.lock() = ZOrder::TopMost;
-
-                        let mut rect = WindowsApi::window_rect(
-                            c.focused_window().copied().unwrap_or_default().hwnd(),
-                        )?;
-
-                        while WindowsApi::lbutton_is_pressed() {
-                            let border = match borders.entry(c.id().clone()) {
-                                Entry::Occupied(entry) => entry.into_mut(),
-                                Entry::Vacant(entry) => {
-                                    if let Ok(border) = Border::create(c.id()) {
-                                        entry.insert(border)
-                                    } else {
-                                        continue 'receiver;
-                                    }
-                                }
-                            };
-
-                            let new_rect = WindowsApi::window_rect(
-                                c.focused_window().copied().unwrap_or_default().hwnd(),
-                            )?;
-
-                            if rect != new_rect {
-                                rect = new_rect;
-                                border.update(&rect)?;
+            for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
+                // Only operate on the focused workspace of each monitor
+                if let Some(ws) = m.focused_workspace() {
+                    // Workspaces with tiling disabled don't have borders
+                    if !ws.tile() {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
                             }
                         }
 
-                        *Z_ORDER.lock() = restore_z_order;
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
 
                         continue 'receiver;
                     }
 
-                    // Get the border entry for this container from the map or create one
-                    let border = match borders.entry(c.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(border) = Border::create(c.id()) {
-                                entry.insert(border)
-                            } else {
-                                continue 'receiver;
+                    // Handle the monocle container separately
+                    if let Some(monocle) = ws.monocle_container() {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
                             }
                         }
-                    };
 
-                    borders_monitors.insert(c.id().clone(), monitor_idx);
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
 
-                    // Update the focused state for all containers on this workspace
-                    {
-                        let mut focus_state = FOCUS_STATE.lock();
-                        focus_state.insert(
-                            border.hwnd,
-                            if idx != ws.focused_container_idx()
-                                || monitor_idx != focused_monitor_idx
-                            {
-                                WindowKind::Unfocused
-                            } else if c.windows().len() > 1 {
-                                WindowKind::Stack
-                            } else {
-                                WindowKind::Single
-                            },
-                        );
+                        let border = borders.entry(monocle.id().clone()).or_insert_with(|| {
+                            Border::create(monocle.id()).expect("border creation failed")
+                        });
+
+                        borders_monitors.insert(monocle.id().clone(), monitor_idx);
+
+                        {
+                            let mut focus_state = FOCUS_STATE.lock();
+                            focus_state.insert(border.hwnd, WindowKind::Monocle);
+                        }
+
+                        let rect = WindowsApi::window_rect(
+                            monocle
+                                .focused_window()
+                                .expect("monocle container has no focused window")
+                                .hwnd(),
+                        )?;
+
+                        border.update(&rect)?;
+                        continue 'receiver;
                     }
 
-                    let rect = WindowsApi::window_rect(
-                        c.focused_window().copied().unwrap_or_default().hwnd(),
-                    )?;
+                    let is_maximized = WindowsApi::is_zoomed(HWND(
+                        WindowsApi::foreground_window().unwrap_or_default(),
+                    ));
 
-                    border.update(&rect)?;
+                    if is_maximized {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
+
+                        continue 'receiver;
+                    }
+
+                    // Destroy any borders not associated with the focused workspace
+                    let container_ids = ws
+                        .containers()
+                        .iter()
+                        .map(|c| c.id().clone())
+                        .collect::<Vec<_>>();
+
+                    let mut to_remove = vec![];
+                    for (id, border) in borders.iter() {
+                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
+                            if !container_ids.contains(id) {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+                    }
+
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
+
+                    for (idx, c) in ws.containers().iter().enumerate() {
+                        // Update border when moving or resizing with mouse
+                        if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                            let restore_z_order = *Z_ORDER.lock();
+                            *Z_ORDER.lock() = ZOrder::TopMost;
+
+                            let mut rect = WindowsApi::window_rect(
+                                c.focused_window()
+                                    .expect("container has no focused window")
+                                    .hwnd(),
+                            )?;
+
+                            while WindowsApi::lbutton_is_pressed() {
+                                let border = borders.entry(c.id().clone()).or_insert_with(|| {
+                                    Border::create(c.id()).expect("border creation failed")
+                                });
+
+                                let new_rect = WindowsApi::window_rect(
+                                    c.focused_window()
+                                        .expect("container has no focused window")
+                                        .hwnd(),
+                                )?;
+
+                                if rect != new_rect {
+                                    rect = new_rect;
+                                    border.update(&rect)?;
+                                }
+                            }
+
+                            *Z_ORDER.lock() = restore_z_order;
+
+                            continue 'receiver;
+                        }
+
+                        // Get the border entry for this container from the map or create one
+                        let border = borders.entry(c.id().clone()).or_insert_with(|| {
+                            Border::create(c.id()).expect("border creation failed")
+                        });
+
+                        borders_monitors.insert(c.id().clone(), monitor_idx);
+
+                        // Update the focused state for all containers on this workspace
+                        {
+                            let mut focus_state = FOCUS_STATE.lock();
+                            focus_state.insert(
+                                border.hwnd,
+                                if idx != ws.focused_container_idx()
+                                    || monitor_idx != focused_monitor_idx
+                                {
+                                    WindowKind::Unfocused
+                                } else {
+                                    if c.windows().len() > 1 {
+                                        WindowKind::Stack
+                                    } else {
+                                        WindowKind::Single
+                                    }
+                                },
+                            );
+                        }
+
+                        let rect = WindowsApi::window_rect(
+                            c.focused_window()
+                                .expect("container has no focused window")
+                                .hwnd(),
+                        )?;
+
+                        border.update(&rect)?;
+                    }
                 }
             }
         }
-    }
 
-    Ok(())
+        Ok(())
+    });
 }
 
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
@@ -350,9 +276,9 @@ pub enum ZOrder {
     TopMost,
 }
 
-impl From<ZOrder> for isize {
-    fn from(val: ZOrder) -> Self {
-        match val {
+impl Into<isize> for ZOrder {
+    fn into(self) -> isize {
+        match self {
             ZOrder::Top => 0,
             ZOrder::NoTopMost => -2,
             ZOrder::Bottom => 1,

komorebi/src/lib.rs

@@ -21,7 +21,6 @@ pub mod windows_callbacks;
 pub mod winevent;
 pub mod winevent_listener;
 pub mod workspace;
-pub mod workspace_reconciliator;
 
 use lazy_static::lazy_static;
 use std::collections::HashMap;

komorebi/src/main.rs

@@ -34,7 +34,6 @@ use komorebi::static_config::StaticConfig;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
-use komorebi::workspace_reconciliator;
 use komorebi::CUSTOM_FFM;
 use komorebi::DATA_DIR;
 use komorebi::HOME_DIR;
@@ -256,7 +255,6 @@ fn main() -> Result<()> {
     }
 
     border_manager::listen_for_notifications(wm.clone());
-    workspace_reconciliator::listen_for_notifications(wm.clone());
 
     let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
     ctrlc::set_handler(move || {

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;
                 }
             }
         }
@@ -503,10 +492,7 @@ impl WindowManager {
                 self.focus_monitor(monitor_idx)?;
                 self.update_focused_workspace(self.mouse_follows_focus, true)?;
             }
-            SocketMessage::Retile => {
-                border_manager::destroy_all_borders()?;
-                self.retile_all(false)?
-            }
+            SocketMessage::Retile => self.retile_all(false)?,
             SocketMessage::FlipLayout(layout_flip) => self.flip_layout(layout_flip)?,
             SocketMessage::ChangeLayout(layout) => self.change_workspace_layout_default(layout)?,
             SocketMessage::CycleLayout(direction) => self.cycle_layout(direction)?,
@@ -661,9 +647,7 @@ impl WindowManager {
                     self.focus_monitor(monitor_idx)?;
                 }
 
-                if self.focused_workspace_idx().unwrap_or_default() != workspace_idx {
-                    self.focus_workspace(workspace_idx)?;
-                }
+                self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::FocusWorkspaceNumbers(workspace_idx) => {
                 // This is to ensure that even on an empty workspace on a secondary monitor, the
@@ -685,15 +669,8 @@ impl WindowManager {
                 self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx = self.focused_workspace_idx().unwrap_or_default();
-
-                let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                if focused_pair != (monitor_idx, workspace_idx) {
-                    self.focus_monitor(monitor_idx)?;
-                    self.focus_workspace(workspace_idx)?;
-                }
+                self.focus_monitor(monitor_idx)?;
+                self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::FocusNamedWorkspace(ref name) => {
                 if let Some((monitor_idx, workspace_idx)) =
@@ -1207,7 +1184,6 @@ impl WindowManager {
                     MoveBehaviour::Insert => {
                         self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
                     }
-                    _ => {}
                 }
             }
             SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {

komorebi/src/process_event.rs

@@ -1,8 +1,6 @@
 use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::time::Duration;
-use std::time::Instant;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -23,9 +21,7 @@ use crate::window::RuleDebug;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::workspace_reconciliator;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
+use crate::winevent::WinEvent;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::DATA_DIR;
@@ -35,17 +31,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 +121,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 +134,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,
@@ -265,86 +259,74 @@ impl WindowManager {
             WindowManagerEvent::Show(_, window)
             | WindowManagerEvent::Manage(window)
             | WindowManagerEvent::Uncloak(_, window) => {
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx =
-                    self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
-
-                let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                let mut needs_reconciliation = false;
-
+                let mut switch_to = None;
                 for (i, monitors) in self.monitors().iter().enumerate() {
                     for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                        if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
-                            // At this point we know we are going to send a notification to the workspace reconciliator
-                            // So we get the topmost window returned by EnumWindows, which is almost always the window
-                            // that has been selected by alt-tab
-                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                if let Some(first) =
-                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                {
-                                    // If our record of this HWND hasn't been updated in over a minute
-                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                        // Update our record with the HWND we just found
-                                        ALT_TAB_HWND.store(Some(first.hwnd));
-                                        // Update the timestamp of our record
-                                        *instant = Instant::now();
-                                    }
-                                }
-                            }
-
-                            workspace_reconciliator::event_tx().send(
-                                workspace_reconciliator::Notification {
-                                    monitor_idx: i,
-                                    workspace_idx: j,
-                                },
-                            )?;
-
-                            needs_reconciliation = true;
+                        if workspace.contains_window(window.hwnd) {
+                            switch_to = Some((i, j));
                         }
                     }
                 }
 
-                // There are some applications such as Firefox where, if they are focused when a
-                // workspace switch takes place, it will fire an additional Show event, which will
-                // result in them being associated with both the original workspace and the workspace
-                // being switched to. This loop is to try to ensure that we don't end up with
-                // duplicates across multiple workspaces, as it results in ghost layout tiles.
-                let mut proceed = true;
+                match switch_to {
+                    Some((known_monitor_idx, known_workspace_idx)) => {
+                        if !matches!(event, WindowManagerEvent::Uncloak(_, _)) {
+                            if self.focused_monitor_idx() != known_monitor_idx
+                                || self
+                                    .focused_monitor()
+                                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                                    .focused_workspace_idx()
+                                    != known_workspace_idx
+                            {
+                                self.focus_monitor(known_monitor_idx)?;
+                                self.focus_workspace(known_workspace_idx)?;
+                            }
+                        }
+                    }
+                    None => {
+                        // There are some applications such as Firefox where, if they are focused when a
+                        // workspace switch takes place, it will fire an additional Show event, which will
+                        // result in them being associated with both the original workspace and the workspace
+                        // being switched to. This loop is to try to ensure that we don't end up with
+                        // duplicates across multiple workspaces, as it results in ghost layout tiles.
+                        let mut proceed = true;
 
-                for (i, monitor) in self.monitors().iter().enumerate() {
-                    for (j, workspace) in monitor.workspaces().iter().enumerate() {
-                        if workspace.container_for_window(window.hwnd).is_some()
-                            && i != self.focused_monitor_idx()
-                            && j != monitor.focused_workspace_idx()
-                        {
-                            tracing::debug!(
+                        for (i, monitor) in self.monitors().iter().enumerate() {
+                            for (j, workspace) in monitor.workspaces().iter().enumerate() {
+                                if workspace.container_for_window(window.hwnd).is_some()
+                                    && i != self.focused_monitor_idx()
+                                    && j != monitor.focused_workspace_idx()
+                                {
+                                    tracing::debug!(
                                 "ignoring show event for window already associated with another workspace"
                             );
 
-                            window.hide();
-                            proceed = false;
-                        }
-                    }
-                }
-
-                if proceed {
-                    let behaviour = self.window_container_behaviour;
-                    let workspace = self.focused_workspace_mut()?;
-
-                    if !workspace.contains_window(window.hwnd) && !needs_reconciliation {
-                        match behaviour {
-                            WindowContainerBehaviour::Create => {
-                                workspace.new_container_for_window(window);
-                                self.update_focused_workspace(false, false)?;
+                                    window.hide();
+                                    proceed = false;
+                                }
                             }
-                            WindowContainerBehaviour::Append => {
-                                workspace
-                                    .focused_container_mut()
-                                    .ok_or_else(|| anyhow!("there is no focused container"))?
-                                    .add_window(window);
-                                self.update_focused_workspace(true, false)?;
+                        }
+
+                        if proceed {
+                            let behaviour = self.window_container_behaviour;
+                            let workspace = self.focused_workspace_mut()?;
+
+                            if !workspace.contains_window(window.hwnd) && switch_to.is_none() {
+                                match behaviour {
+                                    WindowContainerBehaviour::Create => {
+                                        workspace.new_container_for_window(window);
+                                        self.update_focused_workspace(false, false)?;
+                                    }
+                                    WindowContainerBehaviour::Append => {
+                                        workspace
+                                            .focused_container_mut()
+                                            .ok_or_else(|| {
+                                                anyhow!("there is no focused container")
+                                            })?
+                                            .add_window(window);
+                                        self.update_focused_workspace(true, false)?;
+                                    }
+                                }
                             }
                         }
                     }
@@ -619,8 +601,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

@@ -38,7 +38,7 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
     pub hwnd: isize,
 }
@@ -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(())
@@ -1338,11 +1333,6 @@ impl WindowManager {
             // If there is nowhere to move on the current workspace, try to move it onto the monitor
             // in that direction if there is one
             None => {
-                // Don't do anything if the user has set the MoveBehaviour to NoOp
-                if matches!(self.cross_monitor_move_behaviour, MoveBehaviour::NoOp) {
-                    return Ok(());
-                }
-
                 let target_monitor_idx = self
                     .monitor_idx_in_direction(direction)
                     .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
@@ -1948,11 +1938,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 +1957,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 +1986,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 +2007,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 +2031,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 +2048,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 +2073,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 +2089,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 +2117,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 +2134,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)?)
@@ -2342,13 +2307,6 @@ impl WindowManager {
         None
     }
 
-    pub fn focused_workspace_idx(&self) -> Result<usize> {
-        Ok(self
-            .focused_monitor()
-            .ok_or_else(|| anyhow!("there is no monitor"))?
-            .focused_workspace_idx())
-    }
-
     pub fn focused_workspace(&self) -> Result<&Workspace> {
         self.focused_monitor()
             .ok_or_else(|| anyhow!("there is no monitor"))?

komorebi/src/windows_api.rs

@@ -121,6 +121,7 @@ use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
 use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
 use windows::Win32::UI::WindowsAndMessaging::WM_CLOSE;
+use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 use windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
 use windows::Win32::UI::WindowsAndMessaging::WS_DISABLED;
@@ -139,7 +140,6 @@ use crate::monitor::Monitor;
 use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
-use crate::Window;
 
 pub enum WindowsResult<T, E> {
     Err(E),
@@ -433,6 +433,13 @@ impl WindowsApi {
         }
     }
 
+    pub fn destroy_window(hwnd: HWND) -> Result<()> {
+        match Self::post_message(hwnd, WM_DESTROY, WPARAM(0), LPARAM(0)) {
+            Ok(()) => Ok(()),
+            Err(_) => Err(anyhow!("could not close window")),
+        }
+    }
+
     pub fn hide_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_HIDE);
     }
@@ -494,16 +501,6 @@ impl WindowsApi {
         unsafe { GetWindow(hwnd, GW_HWNDNEXT) }.process()
     }
 
-    pub fn alt_tab_windows() -> Result<Vec<Window>> {
-        let mut hwnds = vec![];
-        Self::enum_windows(
-            Some(windows_callbacks::alt_tab_windows),
-            &mut hwnds as *mut Vec<Window> as isize,
-        )?;
-
-        Ok(hwnds)
-    }
-
     #[allow(dead_code)]
     pub fn top_visible_window() -> Result<isize> {
         let hwnd = Self::top_window()?;

komorebi/src/windows_callbacks.rs

@@ -152,26 +152,6 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     true.into()
 }
 
-pub extern "system" fn alt_tab_windows(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
-
-    let is_visible = WindowsApi::is_window_visible(hwnd);
-    let is_window = WindowsApi::is_window(hwnd);
-    let is_minimized = WindowsApi::is_iconic(hwnd);
-
-    if is_visible && is_window && !is_minimized {
-        let window = Window { hwnd: hwnd.0 };
-
-        if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
-            if should_manage {
-                windows.push(window);
-            }
-        }
-    }
-
-    true.into()
-}
-
 pub extern "system" fn win_event_hook(
     _h_win_event_hook: HWINEVENTHOOK,
     event: u32,

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();

komorebi/src/workspace_reconciliator.rs

@@ -1,116 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crate::border_manager;
-use crate::WindowManager;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
-use lazy_static::lazy_static;
-use parking_lot::Mutex;
-use std::sync::Arc;
-use std::sync::OnceLock;
-use std::time::Duration;
-use std::time::Instant;
-
-#[derive(Copy, Clone)]
-pub struct Notification {
-    pub monitor_idx: usize,
-    pub workspace_idx: usize,
-}
-
-pub static ALT_TAB_HWND: AtomicCell<Option<isize>> = AtomicCell::new(None);
-
-lazy_static! {
-    pub static ref ALT_TAB_HWND_INSTANT: Arc<Mutex<Instant>> = Arc::new(Mutex::new(Instant::now()));
-}
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
-}
-
-pub fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-pub fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                if cfg!(debug_assertions) {
-                    tracing::error!("restarting failed thread: {:?}", error)
-                } else {
-                    tracing::error!("restarting failed thread: {}", error)
-                }
-            }
-        }
-    });
-}
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-    let arc = wm.clone();
-
-    for notification in receiver {
-        tracing::info!("running reconciliation");
-
-        let mut wm = wm.lock();
-        let focused_monitor_idx = wm.focused_monitor_idx();
-        let focused_workspace_idx =
-            wm.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
-
-        let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-        let updated_pair = (notification.monitor_idx, notification.workspace_idx);
-
-        if focused_pair != updated_pair {
-            wm.focus_monitor(notification.monitor_idx)?;
-            let mouse_follows_focus = wm.mouse_follows_focus;
-
-            if let Some(monitor) = wm.focused_monitor_mut() {
-                monitor.focus_workspace(notification.workspace_idx)?;
-                monitor.load_focused_workspace(mouse_follows_focus)?;
-            }
-
-            // Drop our lock on the window manager state here to not slow down updates
-            drop(wm);
-
-            // Check if there was an alt-tab across workspaces in the last second
-            if let Some(hwnd) = ALT_TAB_HWND.load() {
-                if ALT_TAB_HWND_INSTANT
-                    .lock()
-                    .elapsed()
-                    .lt(&Duration::from_secs(1))
-                {
-                    // Sleep for 100 millis to let other events pass
-                    std::thread::sleep(Duration::from_millis(100));
-                    tracing::info!("focusing alt-tabbed window");
-
-                    // Take a new lock on the wm and try to focus the container with
-                    // the recorded HWND from the alt-tab
-                    let mut wm = arc.lock();
-                    if let Ok(workspace) = wm.focused_workspace_mut() {
-                        // Regardless of if this fails, we need to get past this part
-                        // to unblock the border manager below
-                        let _ = workspace.focus_container_by_window(hwnd);
-                    }
-
-                    // Unblock the border manager
-                    ALT_TAB_HWND.store(None);
-                    // Send a notification to the border manager to update the borders
-                    border_manager::event_tx().send(border_manager::Notification)?;
-                }
-            }
-        }
-    }
-
-    Ok(())
-}