fix(wm): restart bm and wsr notif handlers on fail

This commit ensures that if and when either the border_manager or
workspace_reconciliator notification handlers crash in their respective
threads, they will be restarted instead of killing the whole thread.

This is acheived via a loop running in the spawned threads of both
listeners, which will report whichever error killed the notification
handler functions.

Clippy annotations to deny expect and unwrap calls have been added to
these two modules.

Calls to DestroyWindow for expired borders were sporadically failing in
unpredictable circumstances, so these have been switched out with calls
to CloseWindow which has been working well so far with the stackbar
feature.

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

@@ -283,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_manager/border.rs

@@ -19,6 +19,7 @@ use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::time::Duration;
 use windows::core::PCWSTR;
+use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -47,10 +48,29 @@ 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)
@@ -97,7 +117,7 @@ impl Border {
     }
 
     pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::destroy_window(self.hwnd())
+        WindowsApi::close_window(self.hwnd())
     }
 
     pub fn update(&self, rect: &Rect) -> color_eyre::Result<()> {

komorebi/src/border_manager/mod.rs

@@ -1,3 +1,5 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
+
 mod border;
 
 use crossbeam_channel::Receiver;
@@ -9,6 +11,7 @@ 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;
@@ -22,6 +25,7 @@ use crate::Rect;
 use crate::Rgb;
 use crate::WindowManager;
 use crate::WindowsApi;
+use border::border_hwnds;
 use border::Border;
 use komorebi_core::WindowKind;
 
@@ -66,125 +70,89 @@ 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();
 
-    std::thread::spawn(move || -> color_eyre::Result<()> {
-        'receiver: for _ in receiver {
-            let mut borders = BORDER_STATE.lock();
-            let mut borders_monitors = BORDERS_MONITORS.lock();
+    'receiver: for _ in receiver {
+        let mut borders = BORDER_STATE.lock();
+        let mut borders_monitors = BORDERS_MONITORS.lock();
 
-            // Check the wm state every time we receive a notification
-            let state = wm.lock();
+        // Check the wm state every time we receive a notification
+        let state = wm.lock();
 
-            if !BORDER_ENABLED.load_consume() || state.is_paused {
-                if !borders.is_empty() {
-                    for (_, border) in borders.iter() {
-                        border.destroy()?;
-                    }
-
-                    borders.clear();
+        if !BORDER_ENABLED.load_consume() || state.is_paused {
+            if !borders.is_empty() {
+                for (_, border) in borders.iter() {
+                    border.destroy()?;
                 }
 
-                continue 'receiver;
+                borders.clear();
             }
 
-            let focused_monitor_idx = state.focused_monitor_idx();
+            continue 'receiver;
+        }
 
-            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 = borders.entry(monocle.id().clone()).or_insert_with(|| {
-                            Border::create(monocle.id()).expect("border creation failed")
-                        });
-
-                        borders_monitors.insert(monocle.id().clone(), monitor_idx);
-
-                        {
-                            let mut focus_state = FOCUS_STATE.lock();
-                            focus_state.insert(border.hwnd, WindowKind::Monocle);
-                        }
-
-                        let rect = WindowsApi::window_rect(
-                            monocle
-                                .focused_window()
-                                .expect("monocle container has no focused window")
-                                .hwnd(),
-                        )?;
-
-                        border.update(&rect)?;
-                        continue 'receiver;
-                    }
-
-                    let 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 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 {
-                            if !container_ids.contains(id) {
-                                border.destroy()?;
-                                to_remove.push(id.clone());
-                            }
+                            border.destroy()?;
+                            to_remove.push(id.clone());
                         }
                     }
 
@@ -192,80 +160,169 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
                         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;
+                    continue 'receiver;
+                }
 
-                            let mut rect = WindowsApi::window_rect(
-                                c.focused_window()
-                                    .expect("container has no focused window")
-                                    .hwnd(),
-                            )?;
+                // 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());
+                        }
+                    }
 
-                            while WindowsApi::lbutton_is_pressed() {
-                                let border = borders.entry(c.id().clone()).or_insert_with(|| {
-                                    Border::create(c.id()).expect("border creation failed")
-                                });
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
 
-                                let new_rect = WindowsApi::window_rect(
-                                    c.focused_window()
-                                        .expect("container has no focused window")
-                                        .hwnd(),
-                                )?;
-
-                                if rect != new_rect {
-                                    rect = new_rect;
-                                    border.update(&rect)?;
-                                }
+                    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;
                             }
-
-                            *Z_ORDER.lock() = restore_z_order;
-
-                            continue 'receiver;
                         }
+                    };
 
-                        // Get the border entry for this container from the map or create one
-                        let border = borders.entry(c.id().clone()).or_insert_with(|| {
-                            Border::create(c.id()).expect("border creation failed")
-                        });
+                    borders_monitors.insert(monocle.id().clone(), monitor_idx);
 
-                        borders_monitors.insert(c.id().clone(), monitor_idx);
+                    {
+                        let mut focus_state = FOCUS_STATE.lock();
+                        focus_state.insert(border.hwnd, WindowKind::Monocle);
+                    }
 
-                        // 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(
+                        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());
                         }
+                    }
 
-                        let rect = WindowsApi::window_rect(
-                            c.focused_window()
-                                .expect("container has no focused window")
-                                .hwnd(),
+                    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(),
                         )?;
 
-                        border.update(&rect)?;
+                        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(())
-    });
+    Ok(())
 }
 
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
@@ -276,9 +333,9 @@ pub enum ZOrder {
     TopMost,
 }
 
-impl Into<isize> for ZOrder {
-    fn into(self) -> isize {
-        match self {
+impl From<ZOrder> for isize {
+    fn from(val: ZOrder) -> Self {
+        match val {
             ZOrder::Top => 0,
             ZOrder::NoTopMost => -2,
             ZOrder::Bottom => 1,

komorebi/src/lib.rs

@@ -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;

komorebi/src/main.rs

@@ -34,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;
@@ -255,6 +256,7 @@ fn main() -> Result<()> {
     }
 
     border_manager::listen_for_notifications(wm.clone());
+    workspace_reconciliator::listen_for_notifications(wm.clone());
 
     let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
     ctrlc::set_handler(move || {

komorebi/src/process_command.rs

@@ -492,7 +492,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)?,
@@ -647,7 +650,9 @@ impl WindowManager {
                     self.focus_monitor(monitor_idx)?;
                 }
 
-                self.focus_workspace(workspace_idx)?;
+                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
@@ -669,8 +674,15 @@ impl WindowManager {
                 self.focus_workspace(workspace_idx)?;
             }
             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)) =
@@ -1184,6 +1196,7 @@ impl WindowManager {
                     MoveBehaviour::Insert => {
                         self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
                     }
+                    _ => {}
                 }
             }
             SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {

komorebi/src/process_event.rs

@@ -22,6 +22,7 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
+use crate::workspace_reconciliator;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::DATA_DIR;
@@ -259,74 +260,68 @@ 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) {
+                            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)?;
                             }
                         }
                     }

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,
 }

komorebi/src/window_manager.rs

@@ -1273,6 +1273,11 @@ impl WindowManager {
 
         let workspace = self.focused_workspace()?;
 
+        // Do not proceed if we have a monocle container or maximized window
+        if workspace.monocle_container().is_some() || workspace.maximized_window().is_some() {
+            return Ok(());
+        }
+
         tracing::info!("focusing container");
 
         let new_idx = workspace.new_idx_for_direction(direction);
@@ -1333,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"))?;
@@ -2307,6 +2317,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

@@ -121,7 +121,6 @@ use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
 use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
 use windows::Win32::UI::WindowsAndMessaging::WM_CLOSE;
-use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 use windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
 use windows::Win32::UI::WindowsAndMessaging::WS_DISABLED;
@@ -433,13 +432,6 @@ impl WindowsApi {
         }
     }
 
-    pub fn destroy_window(hwnd: HWND) -> Result<()> {
-        match Self::post_message(hwnd, WM_DESTROY, WPARAM(0), LPARAM(0)) {
-            Ok(()) => Ok(()),
-            Err(_) => Err(anyhow!("could not close window")),
-        }
-    }
-
     pub fn hide_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_HIDE);
     }

komorebi/src/workspace_reconciliator.rs

@@ -0,0 +1,69 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
+
+use crate::WindowManager;
+use crossbeam_channel::Receiver;
+use crossbeam_channel::Sender;
+use parking_lot::Mutex;
+use std::sync::Arc;
+use std::sync::OnceLock;
+
+#[derive(Copy, Clone)]
+pub struct Notification {
+    pub monitor_idx: usize,
+    pub workspace_idx: usize,
+}
+
+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) => {
+                tracing::warn!("restarting failed thread: {}", error);
+            }
+        }
+    });
+}
+pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
+    tracing::info!("listening");
+
+    let receiver = event_rx();
+
+    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)?;
+            }
+        }
+    }
+
+    Ok(())
+}