feat(wm): add workspace reconciliator module

This commit adds the workspace_reconciliator module which uses a tightly
bounded channel (cap: 1) to update the focused workspace in situations
where the user or another process has foregrounded a window that is on a
different workspace.

This most often happens via Alt-Tab, or by clicking a link which opens
in another application.

workspace_reconciliator::Notification contains the target monitor and
workspace indices, which when received allows for the correct workspace to
be focused.

These notifications are sent in process_event.rs when handling
WindowManagerEvent::Show, Manage and Uncloak events.

All previous logic pertaining to workspace reconciliation which lived in
the handler for these events has been removed and replaced with
notifications sent to the reconciliator.

As the notifications channel is tightly capped and any notifications
which overflow the cap will never be delivered, we are able to avoid the
infinite workspace switching loops which happened when using the
previous logic, which ran on every single event.

justfile

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

komorebi-core/src/arrangement.rs

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

komorebi-core/src/lib.rs

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

komorebi/src/border_manager/border.rs

@@ -19,7 +19,6 @@ 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;
@@ -48,29 +47,10 @@ use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 
-pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
-
-    if let Ok(class) = WindowsApi::real_window_class_w(hwnd) {
-        if class.starts_with("komoborder") {
-            hwnds.push(hwnd.0);
-        }
-    }
-
-    true.into()
-}
-
-#[derive(Debug)]
 pub struct Border {
     pub hwnd: isize,
 }
 
-impl From<isize> for Border {
-    fn from(value: isize) -> Self {
-        Self { hwnd: value }
-    }
-}
-
 impl Border {
     pub const fn hwnd(&self) -> HWND {
         HWND(self.hwnd)
@@ -117,7 +97,7 @@ impl Border {
     }
 
     pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd())
+        WindowsApi::destroy_window(self.hwnd())
     }
 
     pub fn update(&self, rect: &Rect) -> color_eyre::Result<()> {

komorebi/src/border_manager/mod.rs

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

komorebi/src/process_command.rs

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

komorebi/src/process_event.rs

@@ -1,8 +1,6 @@
 use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::time::Duration;
-use std::time::Instant;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -25,8 +23,6 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::workspace_reconciliator;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::DATA_DIR;
@@ -274,33 +270,17 @@ impl WindowManager {
 
                 for (i, monitors) in self.monitors().iter().enumerate() {
                     for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                        if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
-                            // At this point we know we are going to send a notification to the workspace reconciliator
-                            // So we get the topmost window returned by EnumWindows, which is almost always the window
-                            // that has been selected by alt-tab
-                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                if let Some(first) =
-                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                {
-                                    // If our record of this HWND hasn't been updated in over a minute
-                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                        // Update our record with the HWND we just found
-                                        ALT_TAB_HWND.store(Some(first.hwnd));
-                                        // Update the timestamp of our record
-                                        *instant = Instant::now();
-                                    }
-                                }
+                        if workspace.contains_window(window.hwnd) {
+                            if focused_pair != (i, j) {
+                                workspace_reconciliator::event_tx().send(
+                                    workspace_reconciliator::Notification {
+                                        monitor_idx: i,
+                                        workspace_idx: j,
+                                    },
+                                )?;
+
+                                needs_reconciliation = true;
                             }
-
-                            workspace_reconciliator::event_tx().send(
-                                workspace_reconciliator::Notification {
-                                    monitor_idx: i,
-                                    workspace_idx: j,
-                                },
-                            )?;
-
-                            needs_reconciliation = true;
                         }
                     }
                 }

komorebi/src/window.rs

@@ -38,7 +38,7 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
     pub hwnd: isize,
 }

komorebi/src/window_manager.rs

@@ -1273,11 +1273,6 @@ 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);
@@ -1338,11 +1333,6 @@ impl WindowManager {
             // If there is nowhere to move on the current workspace, try to move it onto the monitor
             // in that direction if there is one
             None => {
-                // Don't do anything if the user has set the MoveBehaviour to NoOp
-                if matches!(self.cross_monitor_move_behaviour, MoveBehaviour::NoOp) {
-                    return Ok(());
-                }
-
                 let target_monitor_idx = self
                     .monitor_idx_in_direction(direction)
                     .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
@@ -2317,13 +2307,6 @@ impl WindowManager {
         None
     }
 
-    pub fn focused_workspace_idx(&self) -> Result<usize> {
-        Ok(self
-            .focused_monitor()
-            .ok_or_else(|| anyhow!("there is no monitor"))?
-            .focused_workspace_idx())
-    }
-
     pub fn focused_workspace(&self) -> Result<&Workspace> {
         self.focused_monitor()
             .ok_or_else(|| anyhow!("there is no monitor"))?

komorebi/src/windows_api.rs

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

komorebi/src/windows_callbacks.rs

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

komorebi/src/workspace_reconciliator.rs

@@ -1,16 +1,9 @@
-#![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 {
@@ -18,12 +11,6 @@ pub struct Notification {
     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>) {
@@ -39,78 +26,31 @@ pub fn event_rx() -> Receiver<Notification> {
 }
 
 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)
+    tracing::info!("listening");
+    let receiver = event_rx();
+
+    std::thread::spawn(move || -> color_eyre::Result<()> {
+        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(())
     });
 }
-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(())
-}