fix(wm): restart cmd processing thread on fail

This commit makes some changes to process_command and process_event to
bring them more in line with newer modules, while primarily making sure
that the thread spawned in process_command will be restarted if
necessary.

In the future I might pull out the process_command and process_event fns
from the WindowManager struct and have them take an
Arc<Mutex<WindowManager>> instead which acquires the lock on every call
like the reconciliators and border_manager do.

Cargo.toml

@@ -18,6 +18,8 @@ dirs = "5"
 color-eyre = "0.6"
 serde_json = { package = "serde_json_lenient", version = "0.1" }
 sysinfo = "0.30"
+serde = { version = "1", features = ["derive"] }
+uds_windows = "1"
 
 [workspace.dependencies.windows]
 version = "0.54"

justfile

@@ -28,7 +28,6 @@ install:
     just install-target komorebi
 
 run:
-    just install-target komorebic
     cargo +stable run --bin komorebi --locked
 
 warn $RUST_LOG="warn":
@@ -44,7 +43,6 @@ 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)]
+    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
     fn calculate(
         &self,
         area: &Rect,
@@ -58,12 +58,13 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                match layout_flip {
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
-                        2.. => columns_reverse(&mut layouts),
-                        _ => {}
-                    },
-                    _ => {}
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
+                ) {
+                    if let 2.. = len {
+                        columns_reverse(&mut layouts);
+                    }
                 }
 
                 layouts
@@ -82,12 +83,13 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                match layout_flip {
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
-                        2.. => rows_reverse(&mut layouts),
-                        _ => {}
-                    },
-                    _ => {}
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
+                ) {
+                    if let 2.. = len {
+                        rows_reverse(&mut layouts);
+                    }
                 }
 
                 layouts
@@ -135,28 +137,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                match layout_flip {
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
-                        2.. => {
-                            let (primary, rest) = layouts.split_at_mut(1);
-                            let primary = &mut primary[0];
+                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];
 
-                            for rect in rest.iter_mut() {
-                                rect.left = primary.left;
-                            }
-                            primary.left = rest[0].left + rest[0].right;
+                        for rect in rest.iter_mut() {
+                            rect.left = primary.left;
                         }
-                        _ => {}
-                    },
-                    _ => {}
+                        primary.left = rest[0].left + rest[0].right;
+                    }
                 }
 
-                match layout_flip {
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
-                        3.. => rows_reverse(&mut layouts[1..]),
-                        _ => {}
-                    },
-                    _ => {}
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
+                ) {
+                    if let 3.. = len {
+                        rows_reverse(&mut layouts[1..]);
+                    }
                 }
 
                 layouts
@@ -207,28 +209,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                match layout_flip {
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
-                        2.. => {
-                            let (primary, rest) = layouts.split_at_mut(1);
-                            let primary = &mut primary[0];
+                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];
 
-                            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;
                         }
-                        _ => {}
-                    },
-                    _ => {}
+                    }
                 }
 
-                match layout_flip {
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
-                        3.. => rows_reverse(&mut layouts[1..]),
-                        _ => {}
-                    },
-                    _ => {}
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
+                ) {
+                    if let 3.. = len {
+                        rows_reverse(&mut layouts[1..]);
+                    }
                 }
 
                 layouts
@@ -276,28 +278,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                match layout_flip {
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
-                        2.. => {
-                            let (primary, rest) = layouts.split_at_mut(1);
-                            let primary = &mut primary[0];
+                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];
 
-                            for rect in rest.iter_mut() {
-                                rect.top = primary.top;
-                            }
-                            primary.top = rest[0].top + rest[0].bottom;
+                        for rect in rest.iter_mut() {
+                            rect.top = primary.top;
                         }
-                        _ => {}
-                    },
-                    _ => {}
+                        primary.top = rest[0].top + rest[0].bottom;
+                    }
                 }
 
-                match layout_flip {
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
-                        3.. => columns_reverse(&mut layouts[1..]),
-                        _ => {}
-                    },
-                    _ => {}
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
+                ) {
+                    if let 3.. = len {
+                        columns_reverse(&mut layouts[1..]);
+                    }
                 }
 
                 layouts
@@ -374,8 +376,11 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                match layout_flip {
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
+                ) {
+                    match len {
                         2 => {
                             let (primary, secondary) = layouts.split_at_mut(1);
                             let primary = &mut primary[0];
@@ -397,20 +402,20 @@ impl Arrangement for DefaultLayout {
                             secondary.left = primary.left + primary.right;
                         }
                         _ => {}
-                    },
-                    _ => {}
+                    }
                 }
 
-                match layout_flip {
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
-                        4.. => rows_reverse(&mut layouts[2..]),
-                        _ => {}
-                    },
-                    _ => {}
+                if matches!(
+                    layout_flip,
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
+                ) {
+                    if let 4.. = len {
+                        rows_reverse(&mut layouts[2..]);
+                    }
                 }
 
                 layouts
-            },
+            }
             #[allow(
                 clippy::cast_precision_loss,
                 clippy::cast_possible_truncation,

komorebi-core/src/lib.rs

@@ -218,6 +218,7 @@ pub enum WindowKind {
     Single,
     Stack,
     Monocle,
+    Unfocused,
 }
 
 #[derive(
@@ -282,6 +283,8 @@ 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.rs

@@ -1,108 +0,0 @@
-use std::sync::atomic::Ordering;
-
-use color_eyre::Result;
-use windows::core::PCWSTR;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::FindWindowW;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-
-use crate::window::Window;
-use crate::windows_callbacks;
-use crate::WindowsApi;
-use crate::BORDER_HWND;
-use crate::BORDER_OFFSET;
-use crate::BORDER_RECT;
-use crate::BORDER_WIDTH;
-use crate::TRANSPARENCY_COLOUR;
-
-#[derive(Debug, Clone, Copy)]
-pub struct Border {
-    pub(crate) hwnd: isize,
-}
-
-impl From<isize> for Border {
-    fn from(hwnd: isize) -> Self {
-        Self { hwnd }
-    }
-}
-
-impl Border {
-    pub const fn hwnd(self) -> HWND {
-        HWND(self.hwnd)
-    }
-
-    pub fn create(name: &str) -> Result<()> {
-        let name: Vec<u16> = format!("{name}\0").encode_utf16().collect();
-        let instance = WindowsApi::module_handle_w()?;
-        let class_name = PCWSTR(name.as_ptr());
-        let brush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
-        let window_class = WNDCLASSW {
-            hInstance: instance.into(),
-            lpszClassName: class_name,
-            style: CS_HREDRAW | CS_VREDRAW,
-            lpfnWndProc: Some(windows_callbacks::border_window),
-            hbrBackground: brush,
-            ..Default::default()
-        };
-
-        let _atom = WindowsApi::register_class_w(&window_class)?;
-
-        let name_cl = name.clone();
-        std::thread::spawn(move || -> Result<()> {
-            let hwnd = WindowsApi::create_border_window(PCWSTR(name_cl.as_ptr()), instance)?;
-            let border = Self::from(hwnd);
-
-            let mut message = MSG::default();
-
-            unsafe {
-                while GetMessageW(&mut message, border.hwnd(), 0, 0).into() {
-                    DispatchMessageW(&message);
-                }
-            }
-
-            Ok(())
-        });
-
-        let mut hwnd = HWND(0);
-        while hwnd == HWND(0) {
-            hwnd = unsafe { FindWindowW(PCWSTR(name.as_ptr()), PCWSTR::null()) };
-        }
-
-        BORDER_HWND.store(hwnd.0, Ordering::SeqCst);
-
-        Ok(())
-    }
-
-    pub fn hide(self) -> Result<()> {
-        if self.hwnd == 0 {
-            Ok(())
-        } else {
-            WindowsApi::hide_border_window(self.hwnd())
-        }
-    }
-
-    pub fn set_position(self, window: Window, activate: bool) -> Result<()> {
-        if self.hwnd == 0 {
-            Ok(())
-        } else {
-            if !WindowsApi::is_window(self.hwnd()) {
-                Self::create("komorebi-border-window")?;
-            }
-
-            let mut rect = WindowsApi::window_rect(window.hwnd())?;
-            rect.add_padding(-BORDER_OFFSET.load(Ordering::SeqCst));
-
-            let border_width = BORDER_WIDTH.load(Ordering::SeqCst);
-            rect.add_margin(border_width);
-
-            *BORDER_RECT.lock() = rect;
-
-            WindowsApi::position_border_window(self.hwnd(), &rect, activate)
-        }
-    }
-}

komorebi/src/border_manager/border.rs

@@ -0,0 +1,224 @@
+use crate::border_manager::WindowKind;
+use crate::border_manager::BORDER_OFFSET;
+use crate::border_manager::BORDER_WIDTH;
+use crate::border_manager::FOCUSED;
+use crate::border_manager::FOCUS_STATE;
+use crate::border_manager::MONOCLE;
+use crate::border_manager::RECT_STATE;
+use crate::border_manager::STACK;
+use crate::border_manager::STYLE;
+use crate::border_manager::UNFOCUSED;
+use crate::border_manager::Z_ORDER;
+use crate::WindowsApi;
+use crate::WINDOWS_11;
+
+use komorebi_core::ActiveWindowBorderStyle;
+use komorebi_core::Rect;
+
+use std::sync::atomic::Ordering;
+use std::sync::mpsc;
+use windows::core::PCWSTR;
+use windows::Win32::Foundation::BOOL;
+use windows::Win32::Foundation::COLORREF;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::Foundation::LPARAM;
+use windows::Win32::Foundation::LRESULT;
+use windows::Win32::Foundation::WPARAM;
+use windows::Win32::Graphics::Gdi::BeginPaint;
+use windows::Win32::Graphics::Gdi::CreatePen;
+use windows::Win32::Graphics::Gdi::EndPaint;
+use windows::Win32::Graphics::Gdi::InvalidateRect;
+use windows::Win32::Graphics::Gdi::Rectangle;
+use windows::Win32::Graphics::Gdi::RoundRect;
+use windows::Win32::Graphics::Gdi::SelectObject;
+use windows::Win32::Graphics::Gdi::ValidateRect;
+use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
+use windows::Win32::Graphics::Gdi::PS_INSIDEFRAME;
+use windows::Win32::Graphics::Gdi::PS_SOLID;
+use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
+use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
+use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+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)
+    }
+
+    pub fn create(id: &str) -> color_eyre::Result<Self> {
+        let name: Vec<u16> = format!("komoborder-{id}\0").encode_utf16().collect();
+        let class_name = PCWSTR(name.as_ptr());
+
+        let h_module = WindowsApi::module_handle_w()?;
+
+        let window_class = WNDCLASSW {
+            hInstance: h_module.into(),
+            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
+            lpfnWndProc: Some(Self::callback),
+            hbrBackground: WindowsApi::create_solid_brush(0),
+            ..Default::default()
+        };
+
+        let _ = WindowsApi::register_class_w(&window_class);
+
+        let (hwnd_sender, hwnd_receiver) = mpsc::channel();
+
+        std::thread::spawn(move || -> color_eyre::Result<()> {
+            let hwnd = WindowsApi::create_border_window(PCWSTR(name.as_ptr()), h_module)?;
+            hwnd_sender.send(hwnd)?;
+
+            let mut message = MSG::default();
+            unsafe {
+                while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
+                    TranslateMessage(&message);
+                    DispatchMessageW(&message);
+                }
+            }
+
+            Ok(())
+        });
+
+        Ok(Self {
+            hwnd: hwnd_receiver.recv()?,
+        })
+    }
+
+    pub fn destroy(&self) -> color_eyre::Result<()> {
+        WindowsApi::close_window(self.hwnd())
+    }
+
+    pub fn update(&self, rect: &Rect) -> color_eyre::Result<()> {
+        // Make adjustments to the border
+        let mut rect = *rect;
+        rect.add_margin(BORDER_WIDTH.load(Ordering::SeqCst));
+        rect.add_padding(-BORDER_OFFSET.load(Ordering::SeqCst));
+
+        // Store the border rect so that it can be used by the callback
+        {
+            let mut rects = RECT_STATE.lock();
+            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()))?;
+        }
+
+        // Invalidate the rect to trigger the callback to update colours etc.
+        self.invalidate();
+
+        Ok(())
+    }
+
+    pub fn invalidate(&self) {
+        let _ = unsafe { InvalidateRect(self.hwnd(), None, false) };
+    }
+
+    pub extern "system" fn callback(
+        window: HWND,
+        message: u32,
+        wparam: WPARAM,
+        lparam: LPARAM,
+    ) -> LRESULT {
+        unsafe {
+            match message {
+                WM_PAINT => {
+                    let rects = RECT_STATE.lock();
+
+                    // With the rect that we stored in Self::update
+                    if let Some(rect) = rects.get(&window.0).copied() {
+                        // Grab the focus kind for this border
+                        let focus_kind = {
+                            FOCUS_STATE
+                                .lock()
+                                .get(&window.0)
+                                .copied()
+                                .unwrap_or(WindowKind::Unfocused)
+                        };
+
+                        // Set up the brush to draw the border
+                        let mut ps = PAINTSTRUCT::default();
+                        let hdc = BeginPaint(window, &mut ps);
+                        let hpen = CreatePen(
+                            PS_SOLID | PS_INSIDEFRAME,
+                            BORDER_WIDTH.load(Ordering::SeqCst),
+                            COLORREF(match focus_kind {
+                                WindowKind::Unfocused => UNFOCUSED.load(Ordering::SeqCst),
+                                WindowKind::Single => FOCUSED.load(Ordering::SeqCst),
+                                WindowKind::Stack => STACK.load(Ordering::SeqCst),
+                                WindowKind::Monocle => MONOCLE.load(Ordering::SeqCst),
+                            }),
+                        );
+
+                        let hbrush = WindowsApi::create_solid_brush(0);
+
+                        // Draw the border
+                        SelectObject(hdc, hpen);
+                        SelectObject(hdc, hbrush);
+                        // TODO(raggi): this is approximately the correct curvature for
+                        // the top left of a Windows 11 window (DWMWCP_DEFAULT), but
+                        // often the bottom right has a different shape. Furthermore if
+                        // the window was made with DWMWCP_ROUNDSMALL then this is the
+                        // wrong size.  In the future we should read the DWM properties
+                        // of windows and attempt to match appropriately.
+                        match *STYLE.lock() {
+                            ActiveWindowBorderStyle::System => {
+                                if *WINDOWS_11 {
+                                    RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                                } else {
+                                    Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                                }
+                            }
+                            ActiveWindowBorderStyle::Rounded => {
+                                RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                            }
+                            ActiveWindowBorderStyle::Square => {
+                                Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                            }
+                        }
+                        EndPaint(window, &ps);
+                        ValidateRect(window, None);
+                    }
+
+                    LRESULT(0)
+                }
+                WM_DESTROY => {
+                    PostQuitMessage(0);
+                    LRESULT(0)
+                }
+                _ => DefWindowProcW(window, message, wparam, lparam),
+            }
+        }
+    }
+}

komorebi/src/border_manager/mod.rs

@@ -0,0 +1,362 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
+
+mod border;
+
+use crossbeam_channel::Receiver;
+use crossbeam_channel::Sender;
+use crossbeam_utils::atomic::AtomicConsume;
+use komorebi_core::ActiveWindowBorderStyle;
+use lazy_static::lazy_static;
+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;
+
+pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
+pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
+
+pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(true);
+
+lazy_static! {
+    pub static ref Z_ORDER: Arc<Mutex<ZOrder>> = Arc::new(Mutex::new(ZOrder::Bottom));
+    pub static ref STYLE: Arc<Mutex<ActiveWindowBorderStyle>> =
+        Arc::new(Mutex::new(ActiveWindowBorderStyle::System));
+    pub static ref FOCUSED: AtomicU32 =
+        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
+    pub static ref UNFOCUSED: AtomicU32 =
+        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(128, 128, 128))));
+    pub static ref MONOCLE: AtomicU32 =
+        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(255, 51, 153))));
+    pub static ref STACK: AtomicU32 = AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(0, 165, 66))));
+}
+
+lazy_static! {
+    static ref BORDERS_MONITORS: Mutex<HashMap<String, usize>> = Mutex::new(HashMap::new());
+    static ref BORDER_STATE: Mutex<HashMap<String, Border>> = Mutex::new(HashMap::new());
+    static ref RECT_STATE: Mutex<HashMap<isize, Rect>> = Mutex::new(HashMap::new());
+    static ref FOCUS_STATE: Mutex<HashMap<isize, WindowKind>> = Mutex::new(HashMap::new());
+}
+
+pub struct Notification;
+
+static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
+
+pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
+    CHANNEL.get_or_init(crossbeam_channel::unbounded)
+}
+
+pub fn event_tx() -> Sender<Notification> {
+    channel().0.clone()
+}
+
+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)) {
+                continue 'receiver;
+            }
+        }
+
+        instant = Some(Instant::now());
+
+        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)?;
+                            }
+                        }
+
+                        *Z_ORDER.lock() = restore_z_order;
+
+                        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;
+                            }
+                        }
+                    };
+
+                    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().copied().unwrap_or_default().hwnd(),
+                    )?;
+
+                    border.update(&rect)?;
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+pub enum ZOrder {
+    Top,
+    NoTopMost,
+    Bottom,
+    TopMost,
+}
+
+impl From<ZOrder> for isize {
+    fn from(val: ZOrder) -> Self {
+        match val {
+            ZOrder::Top => 0,
+            ZOrder::NoTopMost => -2,
+            ZOrder::Bottom => 1,
+            ZOrder::TopMost => -1,
+        }
+    }
+}

komorebi/src/colour.rs

@@ -65,7 +65,7 @@ pub struct Rgb {
 }
 
 impl Rgb {
-    pub fn new(r: u32, g: u32, b: u32) -> Self {
+    pub const fn new(r: u32, g: u32, b: u32) -> Self {
         Self { r, g, b }
     }
 }

komorebi/src/hidden.rs

@@ -14,7 +14,6 @@ use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 use crate::windows_callbacks;
 use crate::WindowsApi;
 use crate::HIDDEN_HWND;
-use crate::TRANSPARENCY_COLOUR;
 
 #[derive(Debug, Clone, Copy)]
 pub struct Hidden {
@@ -36,7 +35,7 @@ impl Hidden {
         let name: Vec<u16> = format!("{name}\0").encode_utf16().collect();
         let instance = WindowsApi::module_handle_w()?;
         let class_name = PCWSTR(name.as_ptr());
-        let brush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
+        let brush = WindowsApi::create_solid_brush(0);
         let window_class = WNDCLASSW {
             hInstance: instance.into(),
             lpszClassName: class_name,

komorebi/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod border;
+pub mod border_manager;
 pub mod com;
 #[macro_use]
 pub mod ring;
@@ -21,6 +21,7 @@ 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;
@@ -53,7 +54,6 @@ use color_eyre::Result;
 use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
-use komorebi_core::ActiveWindowBorderStyle;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
@@ -197,13 +197,6 @@ lazy_static! {
         )
     };
 
-    static ref ACTIVE_WINDOW_BORDER_STYLE: Arc<Mutex<ActiveWindowBorderStyle>> =
-        Arc::new(Mutex::new(ActiveWindowBorderStyle::System));
-
-    static ref BORDER_RECT: Arc<Mutex<Rect>> =
-        Arc::new(Mutex::new(Rect::default()));
-
-
     // Use app-specific titlebar removal options where possible
     // eg. Windows Terminal, IntelliJ IDEA, Firefox
     static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
@@ -220,18 +213,7 @@ pub static DEFAULT_CONTAINER_PADDING: AtomicI32 = AtomicI32::new(10);
 pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(false);
-pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
-pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);
-pub static BORDER_COLOUR_SINGLE: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_COLOUR_STACK: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_COLOUR_MONOCLE: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_COLOUR_CURRENT: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
-pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
 
-// 0 0 0 aka pure black, I doubt anyone will want this as a border colour
-pub const TRANSPARENCY_COLOUR: u32 = 0;
 pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
 
 pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);

komorebi/src/main.rs

@@ -23,6 +23,7 @@ use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
 
+use komorebi::border_manager;
 use komorebi::hidden::Hidden;
 use komorebi::load_configuration;
 use komorebi::process_command::listen_for_commands;
@@ -33,6 +34,7 @@ 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;
@@ -253,6 +255,9 @@ fn main() -> Result<()> {
         listen_for_movements(wm.clone());
     }
 
+    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 || {
         ctrlc_sender

komorebi/src/monitor.rs

@@ -36,6 +36,10 @@ 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")]
@@ -58,6 +62,8 @@ 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(),
@@ -194,6 +200,11 @@ 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 {
@@ -202,7 +213,7 @@ impl Monitor {
 
         self.focused_workspace_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?
-            .update(&work_area, offset)?;
+            .update(&work_area, offset, window_based_work_area_offset)?;
 
         Ok(())
     }

komorebi/src/process_command.rs

@@ -13,7 +13,6 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use color_eyre::eyre::anyhow;
-use color_eyre::eyre::bail;
 use color_eyre::Result;
 use miow::pipe::connect;
 use net2::TcpStreamExt;
@@ -39,7 +38,8 @@ use komorebi_core::StateQuery;
 use komorebi_core::WindowContainerBehaviour;
 use komorebi_core::WindowKind;
 
-use crate::border::Border;
+use crate::border_manager;
+use crate::border_manager::STYLE;
 use crate::colour::Rgb;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
@@ -52,16 +52,6 @@ use crate::windows_api::WindowsApi;
 use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
-use crate::ACTIVE_WINDOW_BORDER_STYLE;
-use crate::BORDER_COLOUR_CURRENT;
-use crate::BORDER_COLOUR_MONOCLE;
-use crate::BORDER_COLOUR_SINGLE;
-use crate::BORDER_COLOUR_STACK;
-use crate::BORDER_ENABLED;
-use crate::BORDER_HIDDEN;
-use crate::BORDER_HWND;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
@@ -88,23 +78,34 @@ use crate::WORKSPACE_RULES;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    let listener = wm
-        .lock()
-        .command_listener
-        .try_clone()
-        .expect("could not clone unix listener");
+    std::thread::spawn(move || loop {
+        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) => tracing::error!("{}", error),
+                    Err(error) => {
+                        if cfg!(debug_assertions) {
+                            tracing::error!("{:?}", error)
+                        } else {
+                            tracing::error!("{}", error)
+                        }
+                    }
                 },
                 Err(error) => {
-                    tracing::error!("{}", error);
-                    break;
+                    if cfg!(debug_assertions) {
+                        tracing::error!("{:?}", error)
+                    } else {
+                        tracing::error!("{}", error)
+                    }
                 }
             }
         }
@@ -175,21 +176,6 @@ impl WindowManager {
             }
         }
 
-        match message {
-            SocketMessage::CycleFocusMonitor(_)
-            | SocketMessage::CycleFocusWorkspace(_)
-            | SocketMessage::FocusMonitorNumber(_)
-            | SocketMessage::FocusMonitorWorkspaceNumber(_, _)
-            | SocketMessage::FocusWorkspaceNumber(_) => {
-                if self.focused_workspace()?.visible_windows().is_empty() {
-                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-                    border.hide()?;
-                    BORDER_HIDDEN.store(true, Ordering::SeqCst);
-                }
-            }
-            _ => {}
-        };
-
         match message {
             SocketMessage::CycleFocusWorkspace(_) | SocketMessage::FocusWorkspaceNumber(_) => {
                 if let Some(monitor) = self.focused_monitor_mut() {
@@ -517,7 +503,10 @@ impl WindowManager {
                 self.focus_monitor(monitor_idx)?;
                 self.update_focused_workspace(self.mouse_follows_focus, true)?;
             }
-            SocketMessage::Retile => self.retile_all(false)?,
+            SocketMessage::Retile => {
+                border_manager::destroy_all_borders()?;
+                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)?,
@@ -640,10 +629,6 @@ impl WindowManager {
                 );
 
                 self.focus_workspace(workspace_idx)?;
-
-                if BORDER_ENABLED.load(Ordering::SeqCst) {
-                    self.show_border()?;
-                };
             }
             SocketMessage::FocusLastWorkspace => {
                 // This is to ensure that even on an empty workspace on a secondary monitor, the
@@ -667,10 +652,6 @@ impl WindowManager {
                 self.focused_monitor_mut()
                     .ok_or_else(|| anyhow!("there is no monitor"))?
                     .set_last_focused_workspace(Option::from(idx));
-
-                if BORDER_ENABLED.load(Ordering::SeqCst) {
-                    self.show_border()?;
-                };
             }
             SocketMessage::FocusWorkspaceNumber(workspace_idx) => {
                 // This is to ensure that even on an empty workspace on a secondary monitor, the
@@ -680,11 +661,9 @@ impl WindowManager {
                     self.focus_monitor(monitor_idx)?;
                 }
 
-                self.focus_workspace(workspace_idx)?;
-
-                if BORDER_ENABLED.load(Ordering::SeqCst) {
-                    self.show_border()?;
-                };
+                if self.focused_workspace_idx().unwrap_or_default() != 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
@@ -704,14 +683,17 @@ impl WindowManager {
                 }
 
                 self.focus_workspace(workspace_idx)?;
-
-                if BORDER_ENABLED.load(Ordering::SeqCst) {
-                    self.show_border()?;
-                };
             }
             SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
-                self.focus_monitor(monitor_idx)?;
-                self.focus_workspace(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)?;
+                }
             }
             SocketMessage::FocusNamedWorkspace(ref name) => {
                 if let Some((monitor_idx, workspace_idx)) =
@@ -720,10 +702,6 @@ impl WindowManager {
                     self.focus_monitor(monitor_idx)?;
                     self.focus_workspace(workspace_idx)?;
                 }
-
-                if BORDER_ENABLED.load(Ordering::SeqCst) {
-                    self.show_border()?;
-                };
             }
             SocketMessage::Stop => {
                 tracing::info!(
@@ -1229,6 +1207,7 @@ impl WindowManager {
                     MoveBehaviour::Insert => {
                         self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
                     }
+                    _ => {}
                 }
             }
             SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {
@@ -1238,47 +1217,31 @@ impl WindowManager {
                 self.unmanaged_window_operation_behaviour = behaviour;
             }
             SocketMessage::ActiveWindowBorder(enable) => {
-                if enable {
-                    if BORDER_HWND.load(Ordering::SeqCst) == 0 {
-                        Border::create("komorebi-border-window")?;
-                    }
-
-                    BORDER_ENABLED.store(true, Ordering::SeqCst);
-                    self.show_border()?;
-                } else {
-                    BORDER_ENABLED.store(false, Ordering::SeqCst);
-                    self.hide_border()?;
-                }
+                border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst);
             }
-            SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => {
-                match kind {
-                    WindowKind::Single => {
-                        BORDER_COLOUR_SINGLE.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
-                        BORDER_COLOUR_CURRENT.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
-                    }
-                    WindowKind::Stack => {
-                        BORDER_COLOUR_STACK.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
-                    }
-                    WindowKind::Monocle => {
-                        BORDER_COLOUR_MONOCLE.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
-                    }
+            SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => match kind {
+                WindowKind::Single => {
+                    border_manager::FOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
-
-                WindowsApi::invalidate_border_rect()?;
-            }
+                WindowKind::Stack => {
+                    border_manager::STACK.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                }
+                WindowKind::Monocle => {
+                    border_manager::MONOCLE.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                }
+                WindowKind::Unfocused => {
+                    border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                }
+            },
             SocketMessage::ActiveWindowBorderStyle(style) => {
-                let mut active_window_border_style = ACTIVE_WINDOW_BORDER_STYLE.lock();
+                let mut active_window_border_style = STYLE.lock();
                 *active_window_border_style = style;
-
-                WindowsApi::invalidate_border_rect()?;
             }
             SocketMessage::BorderWidth(width) => {
-                BORDER_WIDTH.store(width, Ordering::SeqCst);
-                WindowsApi::invalidate_border_rect()?;
+                border_manager::BORDER_WIDTH.store(width, Ordering::SeqCst);
             }
             SocketMessage::BorderOffset(offset) => {
-                BORDER_OFFSET.store(offset, Ordering::SeqCst);
-                WindowsApi::invalidate_border_rect()?;
+                border_manager::BORDER_OFFSET.store(offset, Ordering::SeqCst);
             }
             SocketMessage::StackbarMode(mode) => {
                 let mut stackbar_mode = STACKBAR_MODE.lock();
@@ -1370,155 +1333,14 @@ impl WindowManager {
             | SocketMessage::IdentifyBorderOverflowApplication(_, _) => {}
         };
 
-        match message {
-            SocketMessage::ToggleMonocle => {
-                let current = BORDER_COLOUR_CURRENT.load(Ordering::SeqCst);
-                let monocle = BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst);
-
-                if monocle != 0 {
-                    if current == monocle {
-                        BORDER_COLOUR_CURRENT.store(
-                            BORDER_COLOUR_SINGLE.load(Ordering::SeqCst),
-                            Ordering::SeqCst,
-                        );
-                    } else {
-                        BORDER_COLOUR_CURRENT.store(
-                            BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst),
-                            Ordering::SeqCst,
-                        );
-                    }
-                }
-            }
-            SocketMessage::StackWindow(_) => {
-                let stack = BORDER_COLOUR_STACK.load(Ordering::SeqCst);
-                if stack != 0 {
-                    BORDER_COLOUR_CURRENT
-                        .store(BORDER_COLOUR_STACK.load(Ordering::SeqCst), Ordering::SeqCst);
-                }
-            }
-            SocketMessage::UnstackWindow => {
-                BORDER_COLOUR_CURRENT.store(
-                    BORDER_COLOUR_SINGLE.load(Ordering::SeqCst),
-                    Ordering::SeqCst,
-                );
-            }
-            _ => {}
-        }
-
-        match message {
-            SocketMessage::ChangeLayout(_)
-            | SocketMessage::CycleLayout(_)
-            | SocketMessage::ChangeLayoutCustom(_)
-            | SocketMessage::FlipLayout(_)
-            | SocketMessage::ManageFocusedWindow
-            | SocketMessage::MoveWorkspaceToMonitorNumber(_)
-            | SocketMessage::MoveContainerToMonitorNumber(_)
-            | SocketMessage::MoveContainerToWorkspaceNumber(_)
-            | SocketMessage::MoveContainerToMonitorWorkspaceNumber(_, _)
-            | SocketMessage::MoveContainerToNamedWorkspace(_)
-            | SocketMessage::ResizeWindowEdge(_, _)
-            | SocketMessage::ResizeWindowAxis(_, _)
-            | SocketMessage::ToggleFloat
-            | SocketMessage::ToggleMonocle
-            | SocketMessage::ToggleMaximize
-            | SocketMessage::Promote
-            | SocketMessage::PromoteFocus
-            | SocketMessage::StackWindow(_)
-            | SocketMessage::UnstackWindow
-            | SocketMessage::Retile
-            // Adding this one so that changes can be seen instantly after
-            // modifying the active window border offset
-            | SocketMessage::BorderOffset(_)
-            // Adding this one because sometimes EVENT_SYSTEM_FOREGROUND isn't
-            // getting sent on FocusWindow, meaning the border won't be set
-            // when processing events
-            | SocketMessage::FocusWindow(_)
-            | SocketMessage::InvisibleBorders(_)
-            | SocketMessage::WorkAreaOffset(_)
-            | SocketMessage::CycleMoveWindow(_)
-            | SocketMessage::MoveWindow(_)
-            | SocketMessage::CycleFocusMonitor(_)
-            | SocketMessage::CycleFocusWorkspace(_)
-            | SocketMessage::FocusMonitorNumber(_)
-            | SocketMessage::FocusMonitorWorkspaceNumber(_, _)
-            | SocketMessage::FocusWorkspaceNumber(_) => {
-                // The foreground window might be de-activating if we've just
-                // set it as a result of our own actions, so wait until the new
-                // one returns. This particularly happens when switching monitors.
-                //
-                // TODO(raggi): re-evaluate this branch. I checked the
-                // suggestion from the comment above, that we don't get
-                // EVENT_SYSTEM_FOREGROUND, but if I print out trace events I
-                // see that we do.
-                // XXX(raggi) We drop FocusChange events though for windows that
-                // we're not managing, so that's one of the ways that the border
-                // window gets stuck. We should stop overloading `should_manage`
-                // as an event filter, and separately filter events that we want
-                // to handle, and windows that we want to handle, as some events
-                // must be handled even if we're not managing the target window.
-                let mut attempts = 0;
-                let foreground = loop {
-                    match WindowsApi::foreground_window() {
-                        Ok(foreground) => break foreground,
-                        Err(_) => {
-                            std::thread::sleep(std::time::Duration::from_millis(10));
-                            attempts+=1;
-                            if attempts == 10 {
-                                bail!("failed to get foreground window after 100ms")
-                            }
-                        }
-                    };
-                };
-                let foreground_window = Window { hwnd: foreground };
-
-                let monocle = BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst);
-                if monocle != 0 && self.focused_workspace()?.monocle_container().is_some() {
-                    BORDER_COLOUR_CURRENT.store(
-                        monocle,
-                        Ordering::SeqCst,
-                    );
-                }
-
-                // it is not acceptable to fail here; we need to be able to send the event to
-                // subscribers
-                if self.focused_container().is_ok() {
-                    let stack = BORDER_COLOUR_STACK.load(Ordering::SeqCst);
-                    if stack != 0 && self.focused_container()?.windows().len() > 1 {
-                        BORDER_COLOUR_CURRENT
-                            .store(stack, Ordering::SeqCst);
-                    }
-                }
-
-                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-                border.set_position(foreground_window, false)?;
-            }
-            SocketMessage::TogglePause => {
-                let is_paused = self.is_paused;
-                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-
-                if is_paused {
-                    border.hide()?;
-                } else {
-                    let focused = self.focused_window()?;
-                    border.set_position(*focused, true)?;
-                    focused.focus(false)?;
-                }
-            }
-            SocketMessage::ToggleTiling | SocketMessage::WorkspaceTiling(..) => {
-                let tiling_enabled = *self.focused_workspace_mut()?.tile();
-                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-
-                if tiling_enabled {
-                    let focused = self.focused_window()?;
-                    border.set_position(*focused, true)?;
-                    focused.focus(false)?;
-                } else {
-                    border.hide()?;
-                }
-            }
-            _ => {}
+        let notification = Notification {
+            event: NotificationEvent::Socket(message.clone()),
+            state: self.as_ref().into(),
         };
 
+        notify_subscribers(&serde_json::to_string(&notification)?)?;
+        border_manager::event_tx().send(border_manager::Notification)?;
+
         tracing::info!("processed");
         Ok(())
     }
@@ -1594,10 +1416,6 @@ pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, mut stream: UnixStream)
         }
 
         wm.process_command(message.clone(), &mut stream)?;
-        notify_subscribers(&serde_json::to_string(&Notification {
-            event: NotificationEvent::Socket(message.clone()),
-            state: wm.as_ref().into(),
-        })?)?;
     }
 
     Ok(())
@@ -1644,10 +1462,6 @@ pub fn read_commands_tcp(
                 }
 
                 wm.process_command(message.clone(), &mut *stream)?;
-                notify_subscribers(&serde_json::to_string(&Notification {
-                    event: NotificationEvent::Socket(message.clone()),
-                    state: wm.as_ref().into(),
-                })?)?;
             }
         }
     }

komorebi/src/process_event.rs

@@ -1,6 +1,8 @@
 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;
@@ -11,7 +13,9 @@ use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::WindowContainerBehaviour;
 
-use crate::border::Border;
+use crate::border_manager;
+use crate::border_manager::BORDER_OFFSET;
+use crate::border_manager::BORDER_WIDTH;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::window::should_act;
@@ -19,17 +23,11 @@ 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::Notification;
 use crate::NotificationEvent;
-use crate::BORDER_COLOUR_CURRENT;
-use crate::BORDER_COLOUR_MONOCLE;
-use crate::BORDER_COLOUR_SINGLE;
-use crate::BORDER_COLOUR_STACK;
-use crate::BORDER_ENABLED;
-use crate::BORDER_HIDDEN;
-use crate::BORDER_HWND;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
@@ -37,20 +35,17 @@ use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
-    let receiver = wm.lock().incoming_events.clone();
-
-    std::thread::spawn(move || {
+    std::thread::spawn(move || loop {
         tracing::info!("listening");
-        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)
-                        }
+        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)
                     }
                 }
             }
@@ -71,28 +66,6 @@ impl WindowManager {
 
         let should_manage = event.window().should_manage(Some(event), &mut rule_debug)?;
 
-        // Hide or reposition the window based on whether the target is managed.
-        if BORDER_ENABLED.load(Ordering::SeqCst) {
-            if let WindowManagerEvent::FocusChange(_, window) = event {
-                let border_window = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-
-                if should_manage {
-                    border_window.set_position(window, true)?;
-                } else {
-                    let mut stackbar = false;
-                    if let Ok(class) = window.class() {
-                        if class == "komorebi_stackbar" {
-                            stackbar = true;
-                        }
-                    }
-
-                    if !stackbar {
-                        border_window.hide()?;
-                    }
-                }
-            }
-        }
-
         // All event handlers below this point should only be processed if the event is
         // related to a window that should be managed by the WindowManager.
         if !should_manage && !matches!(event, WindowManagerEvent::DisplayChange(_)) {
@@ -149,6 +122,11 @@ 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 {
@@ -162,7 +140,7 @@ impl WindowManager {
 
                 let reaped_orphans = workspace.reap_orphans()?;
                 if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
-                    workspace.update(&work_area, offset)?;
+                    workspace.update(&work_area, offset, window_based_work_area_offset)?;
                     tracing::info!(
                         "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                         reaped_orphans.0,
@@ -287,74 +265,86 @@ impl WindowManager {
             WindowManagerEvent::Show(_, window)
             | WindowManagerEvent::Manage(window)
             | WindowManagerEvent::Uncloak(_, window) => {
-                let mut switch_to = None;
+                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;
+
                 for (i, monitors) in self.monitors().iter().enumerate() {
                     for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                        if workspace.contains_window(window.hwnd) {
-                            switch_to = Some((i, j));
+                        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;
                         }
                     }
                 }
 
-                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;
+                // 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;
-                                }
-                            }
+                            window.hide();
+                            proceed = false;
                         }
+                    }
+                }
 
-                        if proceed {
-                            let behaviour = self.window_container_behaviour;
-                            let workspace = self.focused_workspace_mut()?;
+                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)?;
-                                    }
-                                }
+                    if !workspace.contains_window(window.hwnd) && !needs_reconciliation {
+                        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)?;
                             }
                         }
                     }
@@ -598,106 +588,11 @@ impl WindowManager {
             | WindowManagerEvent::Cloak(..) => {}
         };
 
-        if !self.focused_workspace()?.tile() {
-            let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-            border.hide()?;
-            BORDER_HIDDEN.store(true, Ordering::SeqCst);
-        }
-
-        if *self.focused_workspace()?.tile() && BORDER_ENABLED.load(Ordering::SeqCst) {
-            match event {
-                WindowManagerEvent::MoveResizeStart(_, _) => {
-                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-                    border.hide()?;
-                    BORDER_HIDDEN.store(true, Ordering::SeqCst);
-                }
-                WindowManagerEvent::MoveResizeEnd(_, window)
-                | WindowManagerEvent::Show(_, window)
-                | WindowManagerEvent::FocusChange(_, window)
-                | WindowManagerEvent::Hide(_, window)
-                | WindowManagerEvent::Uncloak(_, window)
-                | WindowManagerEvent::Minimize(_, window) => {
-                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-                    let mut target_window = None;
-                    let mut target_window_is_monocle = false;
-                    if self
-                        .focused_workspace()?
-                        .floating_windows()
-                        .iter()
-                        .any(|w| w.hwnd == window.hwnd)
-                    {
-                        target_window = Option::from(window);
-                        WindowsApi::raise_window(border.hwnd())?;
-                    };
-
-                    if let Some(monocle_container) = self.focused_workspace()?.monocle_container() {
-                        if let Some(window) = monocle_container.focused_window() {
-                            target_window = Option::from(*window);
-                            target_window_is_monocle = true;
-                        }
-                    }
-
-                    if target_window.is_none() {
-                        match self.focused_container() {
-                            // if there is no focused container, the desktop is empty
-                            Err(..) => {
-                                WindowsApi::hide_border_window(border.hwnd())?;
-                            }
-                            Ok(container) => {
-                                if !(matches!(event, WindowManagerEvent::Minimize(_, _))
-                                    && container.windows().len() == 1)
-                                {
-                                    let container_size = self.focused_container()?.windows().len();
-                                    target_window = Option::from(*self.focused_window()?);
-
-                                    if target_window_is_monocle {
-                                        BORDER_COLOUR_CURRENT.store(
-                                            BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst),
-                                            Ordering::SeqCst,
-                                        );
-                                    } else if container_size > 1 {
-                                        BORDER_COLOUR_CURRENT.store(
-                                            BORDER_COLOUR_STACK.load(Ordering::SeqCst),
-                                            Ordering::SeqCst,
-                                        );
-                                    } else {
-                                        BORDER_COLOUR_CURRENT.store(
-                                            BORDER_COLOUR_SINGLE.load(Ordering::SeqCst),
-                                            Ordering::SeqCst,
-                                        );
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    if let Some(target_window) = target_window {
-                        let activate = BORDER_HIDDEN.load(Ordering::SeqCst);
-
-                        WindowsApi::invalidate_border_rect()?;
-                        border.set_position(target_window, activate)?;
-
-                        if activate {
-                            BORDER_HIDDEN.store(false, Ordering::SeqCst);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-
         // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
         if let WindowManagerEvent::Unmanage(window) = event {
             window.center(&self.focused_monitor_work_area()?)?;
         }
 
-        // If there are no more windows on the workspace, we shouldn't show the border window
-        if self.focused_workspace()?.containers().is_empty() {
-            let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-            border.hide()?;
-            BORDER_HIDDEN.store(true, Ordering::SeqCst);
-        }
-
         tracing::trace!("updating list of known hwnds");
         let mut known_hwnds = vec![];
         for monitor in self.monitors() {
@@ -718,10 +613,14 @@ impl WindowManager {
             .open(hwnd_json)?;
 
         serde_json::to_writer_pretty(&file, &known_hwnds)?;
-        notify_subscribers(&serde_json::to_string(&Notification {
+
+        let notification = Notification {
             event: NotificationEvent::WindowManager(event),
             state: self.as_ref().into(),
-        })?)?;
+        };
+
+        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,6 +1,5 @@
 use std::collections::VecDeque;
 use std::sync::atomic::Ordering;
-use std::time::Duration;
 
 use color_eyre::eyre::Result;
 use schemars::JsonSchema;
@@ -61,7 +60,6 @@ use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::STACKBAR_TAB_HEIGHT;
 use crate::STACKBAR_TAB_WIDTH;
 use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::TRANSPARENCY_COLOUR;
 use crate::WINDOWS_BY_BAR_HWNDS;
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
@@ -129,7 +127,7 @@ impl Stackbar {
             lpfnWndProc: Some(Self::window_proc),
             hInstance: h_module.into(),
             lpszClassName: class_name,
-            hbrBackground: WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR),
+            hbrBackground: WindowsApi::create_solid_brush(0),
             ..Default::default()
         };
 
@@ -157,14 +155,13 @@ impl Stackbar {
                     None,
                 );
 
-                SetLayeredWindowAttributes(hwnd, COLORREF(TRANSPARENCY_COLOUR), 0, LWA_COLORKEY)?;
+                SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
                 hwnd_sender.send(hwnd)?;
 
                 let mut msg = MSG::default();
                 while GetMessageW(&mut msg, hwnd, 0, 0).into() {
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
-                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 

komorebi/src/static_config.rs

@@ -1,4 +1,7 @@
-use crate::border::Border;
+use crate::border_manager;
+use crate::border_manager::ZOrder;
+use crate::border_manager::STYLE;
+use crate::border_manager::Z_ORDER;
 use crate::colour::Colour;
 use crate::current_virtual_desktop;
 use crate::monitor::Monitor;
@@ -7,15 +10,6 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
-use crate::ACTIVE_WINDOW_BORDER_STYLE;
-use crate::BORDER_COLOUR_CURRENT;
-use crate::BORDER_COLOUR_MONOCLE;
-use crate::BORDER_COLOUR_SINGLE;
-use crate::BORDER_COLOUR_STACK;
-use crate::BORDER_ENABLED;
-use crate::BORDER_HWND;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::DATA_DIR;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
@@ -77,11 +71,13 @@ use uds_windows::UnixStream;
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ActiveWindowBorderColours {
     /// Border colour when the container contains a single window
-    pub single: Colour,
+    pub single: Option<Colour>,
     /// Border colour when the container contains multiple windows
-    pub stack: Colour,
+    pub stack: Option<Colour>,
     /// Border colour when the container is in monocle mode
-    pub monocle: Colour,
+    pub monocle: Option<Colour>,
+    /// Border colour when the container is unfocused
+    pub unfocused: Option<Colour>,
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -205,6 +201,12 @@ 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 {
@@ -217,6 +219,8 @@ 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()),
         }
     }
 }
@@ -265,6 +269,9 @@ pub struct StaticConfig {
     /// Active window border style (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub active_window_border_style: Option<ActiveWindowBorderStyle>,
+    /// Active window border z-order (default: System)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border_z_order: Option<ZOrder>,
     /// Global default workspace padding (default: 10)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub default_workspace_padding: Option<i32>,
@@ -384,21 +391,16 @@ impl From<&WindowManager> for StaticConfig {
             }
         }
 
-        let border_colours = if BORDER_COLOUR_SINGLE.load(Ordering::SeqCst) == 0 {
+        let border_colours = if border_manager::FOCUSED.load(Ordering::SeqCst) == 0 {
             None
         } else {
             Option::from(ActiveWindowBorderColours {
-                single: Colour::from(BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)),
-                stack: Colour::from(if BORDER_COLOUR_STACK.load(Ordering::SeqCst) == 0 {
-                    BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)
-                } else {
-                    BORDER_COLOUR_STACK.load(Ordering::SeqCst)
-                }),
-                monocle: Colour::from(if BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst) == 0 {
-                    BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)
-                } else {
-                    BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst)
-                }),
+                single: Option::from(Colour::from(border_manager::FOCUSED.load(Ordering::SeqCst))),
+                stack: Option::from(Colour::from(border_manager::STACK.load(Ordering::SeqCst))),
+                monocle: Option::from(Colour::from(border_manager::MONOCLE.load(Ordering::SeqCst))),
+                unfocused: Option::from(Colour::from(
+                    border_manager::UNFOCUSED.load(Ordering::SeqCst),
+                )),
             })
         };
 
@@ -413,11 +415,14 @@ impl From<&WindowManager> for StaticConfig {
             focus_follows_mouse: value.focus_follows_mouse,
             mouse_follows_focus: Option::from(value.mouse_follows_focus),
             app_specific_configuration_path: None,
-            border_width: Option::from(BORDER_WIDTH.load(Ordering::SeqCst)),
-            border_offset: Option::from(BORDER_OFFSET.load(Ordering::SeqCst)),
-            active_window_border: Option::from(BORDER_ENABLED.load(Ordering::SeqCst)),
+            border_width: Option::from(border_manager::BORDER_WIDTH.load(Ordering::SeqCst)),
+            border_offset: Option::from(border_manager::BORDER_OFFSET.load(Ordering::SeqCst)),
+            active_window_border: Option::from(
+                border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
+            ),
             active_window_border_colours: border_colours,
-            active_window_border_style: Option::from(*ACTIVE_WINDOW_BORDER_STYLE.lock()),
+            active_window_border_style: Option::from(*STYLE.lock()),
+            active_window_border_z_order: Option::from(*Z_ORDER.lock()),
             default_workspace_padding: Option::from(
                 DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
             ),
@@ -466,26 +471,33 @@ impl StaticConfig {
             DEFAULT_WORKSPACE_PADDING.store(workspace, Ordering::SeqCst);
         }
 
-        self.border_width.map_or_else(
-            || {
-                BORDER_WIDTH.store(8, Ordering::SeqCst);
-            },
-            |width| {
-                BORDER_WIDTH.store(width, Ordering::SeqCst);
-            },
-        );
+        border_manager::BORDER_WIDTH.store(self.border_width.unwrap_or(8), Ordering::SeqCst);
+        border_manager::BORDER_OFFSET.store(self.border_offset.unwrap_or(-1), Ordering::SeqCst);
 
-        BORDER_OFFSET.store(self.border_offset.unwrap_or(-1), Ordering::SeqCst);
+        if let Some(enabled) = &self.active_window_border {
+            border_manager::BORDER_ENABLED.store(*enabled, Ordering::SeqCst);
+        }
 
         if let Some(colours) = &self.active_window_border_colours {
-            BORDER_COLOUR_SINGLE.store(u32::from(colours.single), Ordering::SeqCst);
-            BORDER_COLOUR_CURRENT.store(u32::from(colours.single), Ordering::SeqCst);
-            BORDER_COLOUR_STACK.store(u32::from(colours.stack), Ordering::SeqCst);
-            BORDER_COLOUR_MONOCLE.store(u32::from(colours.monocle), Ordering::SeqCst);
+            if let Some(single) = colours.single {
+                border_manager::FOCUSED.store(u32::from(single), Ordering::SeqCst);
+            }
+
+            if let Some(stack) = colours.stack {
+                border_manager::STACK.store(u32::from(stack), Ordering::SeqCst);
+            }
+
+            if let Some(monocle) = colours.monocle {
+                border_manager::MONOCLE.store(u32::from(monocle), Ordering::SeqCst);
+            }
+
+            if let Some(unfocused) = colours.unfocused {
+                border_manager::UNFOCUSED.store(u32::from(unfocused), Ordering::SeqCst);
+            }
         }
 
         let active_window_border_style = self.active_window_border_style.unwrap_or_default();
-        *ACTIVE_WINDOW_BORDER_STYLE.lock() = active_window_border_style;
+        *STYLE.lock() = active_window_border_style;
 
         let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
         let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
@@ -690,6 +702,10 @@ 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(
@@ -718,12 +734,7 @@ impl StaticConfig {
         }
 
         if value.active_window_border == Some(true) {
-            if BORDER_HWND.load(Ordering::SeqCst) == 0 {
-                Border::create("komorebi-border-window")?;
-            }
-
-            BORDER_ENABLED.store(true, Ordering::SeqCst);
-            wm.show_border()?;
+            border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
         }
 
         Ok(())
@@ -750,6 +761,10 @@ 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(
@@ -777,16 +792,8 @@ impl StaticConfig {
             }
         }
 
-        if value.active_window_border == Some(true) {
-            if BORDER_HWND.load(Ordering::SeqCst) == 0 {
-                Border::create("komorebi-border-window")?;
-            }
-
-            BORDER_ENABLED.store(true, Ordering::SeqCst);
-            wm.show_border()?;
-        } else {
-            BORDER_ENABLED.store(false, Ordering::SeqCst);
-            wm.hide_border()?;
+        if let Some(enabled) = value.active_window_border {
+            border_manager::BORDER_ENABLED.store(enabled, Ordering::SeqCst);
         }
 
         if let Some(val) = value.window_container_behaviour {

komorebi/src/window.rs

@@ -38,7 +38,7 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-#[derive(Debug, Clone, Copy, Deserialize, JsonSchema)]
+#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
     pub hwnd: isize,
 }
@@ -139,6 +139,10 @@ 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

@@ -39,7 +39,8 @@ use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::WindowContainerBehaviour;
 
-use crate::border::Border;
+use crate::border_manager;
+use crate::border_manager::STYLE;
 use crate::container::Container;
 use crate::current_virtual_desktop;
 use crate::load_configuration;
@@ -55,14 +56,6 @@ use crate::ActiveWindowBorderColours;
 use crate::Colour;
 use crate::Rgb;
 use crate::WorkspaceRule;
-use crate::ACTIVE_WINDOW_BORDER_STYLE;
-use crate::BORDER_COLOUR_MONOCLE;
-use crate::BORDER_COLOUR_SINGLE;
-use crate::BORDER_COLOUR_STACK;
-use crate::BORDER_ENABLED;
-use crate::BORDER_HWND;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
@@ -153,15 +146,24 @@ pub struct GlobalState {
 impl Default for GlobalState {
     fn default() -> Self {
         Self {
-            active_window_border_enabled: BORDER_ENABLED.load(Ordering::SeqCst),
+            active_window_border_enabled: border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
             active_window_border_colours: ActiveWindowBorderColours {
-                single: Colour::Rgb(Rgb::from(BORDER_COLOUR_SINGLE.load(Ordering::SeqCst))),
-                stack: Colour::Rgb(Rgb::from(BORDER_COLOUR_STACK.load(Ordering::SeqCst))),
-                monocle: Colour::Rgb(Rgb::from(BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst))),
+                single: Option::from(Colour::Rgb(Rgb::from(
+                    border_manager::FOCUSED.load(Ordering::SeqCst),
+                ))),
+                stack: Option::from(Colour::Rgb(Rgb::from(
+                    border_manager::STACK.load(Ordering::SeqCst),
+                ))),
+                monocle: Option::from(Colour::Rgb(Rgb::from(
+                    border_manager::MONOCLE.load(Ordering::SeqCst),
+                ))),
+                unfocused: Option::from(Colour::Rgb(Rgb::from(
+                    border_manager::UNFOCUSED.load(Ordering::SeqCst),
+                ))),
             },
-            active_window_border_style: *ACTIVE_WINDOW_BORDER_STYLE.lock(),
-            border_offset: BORDER_OFFSET.load(Ordering::SeqCst),
-            border_width: BORDER_WIDTH.load(Ordering::SeqCst),
+            active_window_border_style: *STYLE.lock(),
+            border_offset: border_manager::BORDER_OFFSET.load(Ordering::SeqCst),
+            border_width: border_manager::BORDER_WIDTH.load(Ordering::SeqCst),
             stackbar_mode: *STACKBAR_MODE.lock(),
             stackbar_focused_text_colour: Colour::Rgb(Rgb::from(
                 STACKBAR_FOCUSED_TEXT_COLOUR.load(Ordering::SeqCst),
@@ -286,28 +288,6 @@ impl WindowManager {
         WindowsApi::load_workspace_information(&mut self.monitors)
     }
 
-    #[tracing::instrument(skip(self))]
-    pub fn show_border(&self) -> Result<()> {
-        if self.focused_container().is_ok() {
-            let foreground = WindowsApi::foreground_window()?;
-            let foreground_window = Window { hwnd: foreground };
-
-            let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-            border.set_position(foreground_window, true)?;
-            WindowsApi::invalidate_border_rect()?;
-        }
-
-        Ok(())
-    }
-
-    #[tracing::instrument(skip(self))]
-    pub fn hide_border(&self) -> Result<()> {
-        let focused = self.focused_window()?;
-        let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-        border.hide()?;
-        focused.focus(false)
-    }
-
     #[tracing::instrument]
     pub fn reload_configuration() {
         tracing::info!("reloading configuration");
@@ -733,6 +713,11 @@ 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 {
@@ -750,7 +735,7 @@ impl WindowManager {
                 }
             }
 
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, window_based_work_area_offset)?;
         }
 
         Ok(())
@@ -1353,6 +1338,11 @@ 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"))?;
@@ -1366,6 +1356,8 @@ impl WindowManager {
                             anyhow!("could not remove container at given origin index")
                         })?;
 
+                    self.focused_workspace_mut()?.focus_previous_container();
+
                     // focus the target monitor
                     self.focus_monitor(target_monitor_idx)?;
 
@@ -1956,6 +1948,11 @@ 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()
@@ -1975,7 +1972,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)?;
+            workspace.update(&work_area, offset, window_based_work_area_offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2004,6 +2001,11 @@ 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()
@@ -2025,7 +2027,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)?;
+            workspace.update(&work_area, offset, window_based_work_area_offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2049,6 +2051,11 @@ 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()
@@ -2066,7 +2073,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)?;
+            workspace.update(&work_area, offset, window_based_work_area_offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2091,6 +2098,11 @@ 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()
@@ -2107,7 +2119,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)?;
+            workspace.update(&work_area, offset, window_based_work_area_offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2135,6 +2147,11 @@ 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()
@@ -2152,7 +2169,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)?;
+            workspace.update(&work_area, offset, window_based_work_area_offset)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false, false)?)
@@ -2325,6 +2342,13 @@ 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

@@ -2,7 +2,6 @@ use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::ffi::c_void;
 use std::mem::size_of;
-use std::sync::atomic::Ordering;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::Error;
@@ -34,7 +33,6 @@ use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::EnumDisplayDevicesW;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
-use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use windows::Win32::Graphics::Gdi::Rectangle;
@@ -101,7 +99,6 @@ use windows::Win32::UI::WindowsAndMessaging::EDD_GET_DEVICE_INTERFACE_NAME;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
-use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
 use windows::Win32::UI::WindowsAndMessaging::HWND_TOP;
 use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
 use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
@@ -142,8 +139,7 @@ use crate::monitor::Monitor;
 use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
-use crate::BORDER_HWND;
-use crate::TRANSPARENCY_COLOUR;
+use crate::Window;
 
 pub enum WindowsResult<T, E> {
     Err(E),
@@ -395,33 +391,9 @@ impl WindowsApi {
         Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
     }
 
-    pub fn position_border_window(hwnd: HWND, layout: &Rect, activate: bool) -> Result<()> {
-        let flags = if activate {
-            SetWindowPosition::SHOW_WINDOW | SetWindowPosition::NO_ACTIVATE
-        } else {
-            SetWindowPosition::NO_ACTIVATE
-        };
-
-        // TODO(raggi): This leaves the window behind the active window, which
-        // can result e.g. single pixel window borders being invisible in the
-        // case of opaque window borders (e.g. EPIC Games Launcher). Ideally
-        // we'd be able to pass a parent window to place ourselves just in front
-        // of, however the SetWindowPos API explicitly ignores that parameter
-        // unless the window being positioned is being activated - and we don't
-        // want to activate the border window here. We can hopefully find a
-        // better workaround in the future.
-        // The trade-off chosen prevents the border window from sitting over the
-        // top of other pop-up dialogs such as a file picker dialog from
-        // Firefox. When adjusting this in the future, it's important to check
-        // those dialog cases.
-        Self::set_window_pos(hwnd, layout, HWND_TOP, flags.bits())
-    }
-
-    pub fn hide_border_window(hwnd: HWND) -> Result<()> {
-        let flags = SetWindowPosition::HIDE_WINDOW;
-
-        let position = HWND_BOTTOM;
-        Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
+    pub fn set_border_pos(hwnd: HWND, layout: &Rect, position: HWND) -> Result<()> {
+        let flags = { SetWindowPosition::SHOW_WINDOW | SetWindowPosition::NO_ACTIVATE };
+        Self::set_window_pos(hwnd, layout, position, flags.bits())
     }
 
     /// set_window_pos calls SetWindowPos without any accounting for Window decorations.
@@ -522,6 +494,16 @@ 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()?;
@@ -963,7 +945,7 @@ impl WindowsApi {
                 None,
             );
 
-            SetLayeredWindowAttributes(hwnd, COLORREF(TRANSPARENCY_COLOUR), 0, LWA_COLORKEY)?;
+            SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
 
             hwnd
         }
@@ -1000,12 +982,6 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn invalidate_border_rect() -> Result<()> {
-        unsafe { InvalidateRect(HWND(BORDER_HWND.load(Ordering::SeqCst)), None, false) }
-            .ok()
-            .process()
-    }
-
     pub fn alt_is_pressed() -> bool {
         let state = unsafe { GetKeyState(i32::from(VK_MENU.0)) };
         #[allow(clippy::cast_sign_loss)]

komorebi/src/windows_callbacks.rs

@@ -1,36 +1,21 @@
 use std::collections::VecDeque;
-use std::sync::atomic::Ordering;
 use widestring::U16CStr;
 
 use windows::Win32::Foundation::BOOL;
-use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Gdi::BeginPaint;
-use windows::Win32::Graphics::Gdi::CreatePen;
-use windows::Win32::Graphics::Gdi::EndPaint;
-use windows::Win32::Graphics::Gdi::Rectangle;
-use windows::Win32::Graphics::Gdi::RoundRect;
-use windows::Win32::Graphics::Gdi::SelectObject;
-use windows::Win32::Graphics::Gdi::ValidateRect;
 use windows::Win32::Graphics::Gdi::HDC;
 use windows::Win32::Graphics::Gdi::HMONITOR;
-use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
-use windows::Win32::Graphics::Gdi::PS_INSIDEFRAME;
-use windows::Win32::Graphics::Gdi::PS_SOLID;
 use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
-use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
 use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
 use windows::Win32::UI::WindowsAndMessaging::SPI_ICONVERTICALSPACING;
 use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
-use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WM_SETTINGCHANGE;
 
 use crate::container::Container;
@@ -42,15 +27,8 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::winevent_listener;
-use crate::ACTIVE_WINDOW_BORDER_STYLE;
-use crate::BORDER_COLOUR_CURRENT;
-use crate::BORDER_RECT;
-use crate::BORDER_WIDTH;
 use crate::DISPLAY_INDEX_PREFERENCES;
 use crate::MONITOR_INDEX_PREFERENCES;
-use crate::TRANSPARENCY_COLOUR;
-use crate::WINDOWS_11;
-use komorebi_core::ActiveWindowBorderStyle;
 
 pub extern "system" fn valid_display_monitors(
     hmonitor: HMONITOR,
@@ -174,6 +152,26 @@ 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,
@@ -204,62 +202,6 @@ pub extern "system" fn win_event_hook(
         .expect("could not send message on winevent_listener::event_tx");
 }
 
-pub extern "system" fn border_window(
-    window: HWND,
-    message: u32,
-    wparam: WPARAM,
-    lparam: LPARAM,
-) -> LRESULT {
-    unsafe {
-        match message {
-            WM_PAINT => {
-                let border_rect = *BORDER_RECT.lock();
-                let mut ps = PAINTSTRUCT::default();
-                let hdc = BeginPaint(window, &mut ps);
-                let hpen = CreatePen(
-                    PS_SOLID | PS_INSIDEFRAME,
-                    BORDER_WIDTH.load(Ordering::SeqCst),
-                    COLORREF(BORDER_COLOUR_CURRENT.load(Ordering::SeqCst)),
-                );
-                let hbrush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
-
-                SelectObject(hdc, hpen);
-                SelectObject(hdc, hbrush);
-                // TODO(raggi): this is approximately the correct curvature for
-                // the top left of a Windows 11 window (DWMWCP_DEFAULT), but
-                // often the bottom right has a different shape. Furthermore if
-                // the window was made with DWMWCP_ROUNDSMALL then this is the
-                // wrong size.  In the future we should read the DWM properties
-                // of windows and attempt to match appropriately.
-                match *ACTIVE_WINDOW_BORDER_STYLE.lock() {
-                    ActiveWindowBorderStyle::System => {
-                        if *WINDOWS_11 {
-                            RoundRect(hdc, 0, 0, border_rect.right, border_rect.bottom, 20, 20);
-                        } else {
-                            Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
-                        }
-                    }
-                    ActiveWindowBorderStyle::Rounded => {
-                        RoundRect(hdc, 0, 0, border_rect.right, border_rect.bottom, 20, 20);
-                    }
-                    ActiveWindowBorderStyle::Square => {
-                        Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
-                    }
-                }
-                EndPaint(window, &ps);
-                ValidateRect(window, None);
-
-                LRESULT(0)
-            }
-            WM_DESTROY => {
-                PostQuitMessage(0);
-                LRESULT(0)
-            }
-            _ => DefWindowProcW(window, message, wparam, lparam),
-        }
-    }
-}
-
 pub extern "system" fn hidden_window(
     window: HWND,
     message: u32,

komorebi/src/workspace.rs

@@ -20,14 +20,14 @@ use komorebi_core::Layout;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 
+use crate::border_manager::BORDER_OFFSET;
+use crate::border_manager::BORDER_WIDTH;
 use crate::container::Container;
 use crate::ring::Ring;
 use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::window::WindowDetails;
 use crate::windows_api::WindowsApi;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::INITIAL_CONFIGURATION_LOADED;
@@ -219,13 +219,21 @@ impl Workspace {
         Ok(())
     }
 
-    pub fn update(&mut self, work_area: &Rect, offset: Option<Rect>) -> Result<()> {
+    pub fn update(
+        &mut self,
+        work_area: &Rect,
+        work_area_offset: Option<Rect>,
+        window_based_work_area_offset: (isize, 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 = offset.map_or_else(
+        let mut adjusted_work_area = work_area_offset.map_or_else(
             || *work_area,
             |offset| {
                 let mut with_offset = *work_area;
@@ -238,6 +246,21 @@ 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();
@@ -1376,7 +1399,7 @@ impl Workspace {
         vec
     }
 
-    fn focus_previous_container(&mut self) {
+    pub fn focus_previous_container(&mut self) {
         let focused_idx = self.focused_container_idx();
 
         if focused_idx != 0 {

komorebi/src/workspace_reconciliator.rs

@@ -0,0 +1,116 @@
+#![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(())
+}