feat(wm): add monitor reconciliator module

This commit adds the monitor_reconciliator module which uses a tightly
bounded channel (cap: 1) to handle monitor connection and disconnection
events, as well as resolution and work area change events.

Before, all this logic lived in a the WindowManager.reconcile_monitors
function, which ran on pretty much every process_event iteration, and
sometimes led to undesirable behaviour, but now the logic is split up to
only run when the appropriate notifications are dispatched from the
hidden window which listens for monitor and display-related events.

The monitor cache has been moved out of WindowManager and into the
monitor_reconciliator module, and in addition to the previous behaviour
of attempting to cache monitors which had been identified as
disconnected, now when the static configuration file is loaded, if the
user has set display_index_preferences, the device IDs will be used to
pre-populate the cache for the event where a known monitor is connected
later in a session.

The monitor cache itself now uses the unique device ID as a key rather
than the hmonitor which is known to be inconsistent.

This commit also delegates all display monitor-related Win32 calls to
the "win32-display-data" crate, which was extracted from the larger
"brightness" crate for its use in komorebi.

As a result of these changes, "device" and "device_id" on Monitor have
been changed from Option<String> to String types, as failures in
retrieving these values with directly attached monitors has not been
possible to reproduce. However, it remains to be seen if this will
adversely impact users who use display docks which may prevent display
monitor device IDs from being read and stored by the operating system.

WindowManagerEvent::DisplayChange has been removed in favour of
the monitor_reconciliator::Notification enum, as these events are no
longer being handled in process_events.

Attempts are now made to eagerly update hmonitors both within the
monitor_reconciliator loop on DisplayConnectionChange notifications and
when failing to find a matching hmonitor in functions like
monitor_idx_from_current_pos and monitor_idx_from_window.

komorebi/src/container.rs

@@ -7,13 +7,20 @@ use serde::Deserialize;
 use serde::Serialize;
 
 use crate::ring::Ring;
+use crate::stackbar::Stackbar;
 use crate::window::Window;
+use crate::WindowsApi;
+use crate::STACKBAR_MODE;
+use komorebi_core::StackbarMode;
 
 #[derive(Debug, Clone, Serialize, Deserialize, Getters, JsonSchema)]
 pub struct Container {
     #[getset(get = "pub")]
     id: String,
     windows: Ring<Window>,
+    #[serde(skip)]
+    #[getset(get = "pub", get_mut = "pub")]
+    stackbar: Option<Stackbar>,
 }
 
 impl_ring_elements!(Container, Window);
@@ -23,6 +30,10 @@ impl Default for Container {
         Self {
             id: nanoid!(),
             windows: Ring::default(),
+            stackbar: match STACKBAR_MODE.load() {
+                StackbarMode::Always => Stackbar::create().ok(),
+                StackbarMode::Never | StackbarMode::OnStack => None,
+            },
         }
     }
 }
@@ -35,6 +46,10 @@ impl PartialEq for Container {
 
 impl Container {
     pub fn hide(&self, omit: Option<isize>) {
+        if let Some(stackbar) = self.stackbar() {
+            stackbar.hide();
+        }
+
         for window in self.windows().iter().rev() {
             let mut should_hide = omit.is_none();
 
@@ -53,6 +68,10 @@ impl Container {
     }
 
     pub fn restore(&self) {
+        if let Some(stackbar) = self.stackbar() {
+            stackbar.restore();
+        }
+
         if let Some(window) = self.focused_window() {
             window.restore();
         }
@@ -105,6 +124,13 @@ impl Container {
     pub fn remove_window_by_idx(&mut self, idx: usize) -> Option<Window> {
         let window = self.windows_mut().remove(idx);
 
+        if matches!(STACKBAR_MODE.load(), StackbarMode::OnStack) && self.windows().len() <= 1 {
+            if let Some(stackbar) = &self.stackbar {
+                let _ = WindowsApi::close_window(stackbar.hwnd());
+                self.stackbar = None;
+            }
+        }
+
         if idx != 0 {
             self.focus_window(idx - 1);
         };
@@ -119,6 +145,14 @@ impl Container {
 
     pub fn add_window(&mut self, window: Window) {
         self.windows_mut().push_back(window);
+
+        if matches!(STACKBAR_MODE.load(), StackbarMode::OnStack)
+            && self.windows().len() > 1
+            && self.stackbar.is_none()
+        {
+            self.stackbar = Stackbar::create().ok();
+        }
+
         self.focus_window(self.windows().len() - 1);
     }
 
@@ -127,4 +161,41 @@ impl Container {
         tracing::info!("focusing window");
         self.windows.focus(idx);
     }
+
+    pub fn set_stackbar_mode(&mut self, mode: StackbarMode) {
+        match mode {
+            StackbarMode::Always => {
+                if self.stackbar.is_none() {
+                    self.stackbar = Stackbar::create().ok();
+                }
+            }
+            StackbarMode::Never => {
+                if let Some(stackbar) = &self.stackbar {
+                    let _ = WindowsApi::close_window(stackbar.hwnd());
+                }
+
+                self.stackbar = None
+            }
+            StackbarMode::OnStack => {
+                if self.windows().len() > 1 && self.stackbar().is_none() {
+                    self.stackbar = Stackbar::create().ok();
+                }
+
+                if let Some(stackbar) = &self.stackbar {
+                    if self.windows().len() == 1 {
+                        let _ = WindowsApi::close_window(stackbar.hwnd());
+                        self.stackbar = None;
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn renew_stackbar(&mut self) {
+        if let Some(stackbar) = &self.stackbar {
+            if !WindowsApi::is_window(stackbar.hwnd()) {
+                self.stackbar = Stackbar::create().ok()
+            }
+        }
+    }
 }

komorebi/src/lib.rs

@@ -10,7 +10,7 @@ pub mod process_command;
 pub mod process_event;
 pub mod process_movement;
 pub mod set_window_position;
-pub mod stackbar_manager;
+pub mod stackbar;
 pub mod static_config;
 pub mod styles;
 pub mod window;
@@ -40,6 +40,7 @@ use std::sync::Arc;
 pub use colour::*;
 pub use process_command::*;
 pub use process_event::*;
+pub use stackbar::*;
 pub use static_config::*;
 pub use window::*;
 pub use window_manager::*;
@@ -48,6 +49,7 @@ pub use windows_api::WindowsApi;
 pub use windows_api::*;
 
 use color_eyre::Result;
+use crossbeam_utils::atomic::AtomicCell;
 use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
@@ -55,6 +57,8 @@ use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 use komorebi_core::SocketMessage;
+use komorebi_core::StackbarLabel;
+use komorebi_core::StackbarMode;
 use os_info::Version;
 use parking_lot::Mutex;
 use regex::Regex;
@@ -211,6 +215,14 @@ pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
 
 pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
 
+pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
+pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947); // gray text
+pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
+pub static STACKBAR_TAB_HEIGHT: AtomicI32 = AtomicI32::new(40);
+pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
+pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
+pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::Never);
+
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     let hkcu = RegKey::predef(HKEY_CURRENT_USER);

komorebi/src/main.rs

@@ -30,7 +30,6 @@ use komorebi::process_command::listen_for_commands;
 use komorebi::process_command::listen_for_commands_tcp;
 use komorebi::process_event::listen_for_events;
 use komorebi::process_movement::listen_for_movements;
-use komorebi::stackbar_manager;
 use komorebi::static_config::StaticConfig;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
@@ -255,7 +254,6 @@ fn main() -> Result<()> {
     }
 
     border_manager::listen_for_notifications(wm.clone());
-    stackbar_manager::listen_for_notifications(wm.clone());
     workspace_reconciliator::listen_for_notifications(wm.clone());
     monitor_reconciliator::listen_for_notifications(wm.clone())?;
 

komorebi/src/process_command.rs

@@ -43,7 +43,6 @@ use crate::border_manager::STYLE;
 use crate::colour::Rgb;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
-use crate::stackbar_manager;
 use crate::static_config::StaticConfig;
 use crate::window::RuleDebug;
 use crate::window::Window;
@@ -65,18 +64,18 @@ use crate::MONITOR_INDEX_PREFERENCES;
 use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REMOVE_TITLEBARS;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_LABEL;
+use crate::STACKBAR_MODE;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::SUBSCRIPTION_PIPES;
 use crate::SUBSCRIPTION_SOCKETS;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
-use stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use stackbar_manager::STACKBAR_LABEL;
-use stackbar_manager::STACKBAR_MODE;
-use stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
-use stackbar_manager::STACKBAR_TAB_HEIGHT;
-use stackbar_manager::STACKBAR_TAB_WIDTH;
-use stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
@@ -1246,6 +1245,14 @@ impl WindowManager {
             }
             SocketMessage::StackbarMode(mode) => {
                 STACKBAR_MODE.store(mode);
+
+                for m in self.monitors_mut() {
+                    for w in m.workspaces_mut() {
+                        for c in w.containers_mut() {
+                            c.set_stackbar_mode(mode);
+                        }
+                    }
+                }
             }
             SocketMessage::StackbarLabel(label) => {
                 STACKBAR_LABEL.store(label);
@@ -1335,7 +1342,6 @@ impl WindowManager {
 
         notify_subscribers(&serde_json::to_string(&notification)?)?;
         border_manager::event_tx().send(border_manager::Notification)?;
-        stackbar_manager::event_tx().send(stackbar_manager::Notification)?;
 
         tracing::info!("processed");
         Ok(())

komorebi/src/process_event.rs

@@ -11,6 +11,7 @@ use parking_lot::Mutex;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
+use komorebi_core::StackbarLabel;
 use komorebi_core::WindowContainerBehaviour;
 
 use crate::border_manager;
@@ -18,12 +19,12 @@ use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
-use crate::stackbar_manager;
 use crate::window::should_act;
 use crate::window::RuleDebug;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
+use crate::winevent::WinEvent;
 use crate::workspace_reconciliator;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
@@ -32,6 +33,7 @@ use crate::NotificationEvent;
 use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
+use crate::STACKBAR_LABEL;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
@@ -267,6 +269,23 @@ impl WindowManager {
             WindowManagerEvent::Show(_, window)
             | WindowManagerEvent::Manage(window)
             | WindowManagerEvent::Uncloak(_, window) => {
+                if matches!(
+                    event,
+                    WindowManagerEvent::Show(WinEvent::ObjectNameChange, _)
+                ) {
+                    if matches!(STACKBAR_LABEL.load(), StackbarLabel::Title) {
+                        for m in self.monitors() {
+                            for ws in m.workspaces() {
+                                if let Some(container) = ws.container_for_window(window.hwnd) {
+                                    if let Some(stackbar) = container.stackbar() {
+                                        stackbar.update(container.windows(), window.hwnd)?;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
                 let focused_monitor_idx = self.focused_monitor_idx();
                 let focused_workspace_idx =
                     self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
@@ -334,10 +353,8 @@ impl WindowManager {
                 if proceed {
                     let behaviour = self.window_container_behaviour;
                     let workspace = self.focused_workspace_mut()?;
-                    let workspace_contains_window = workspace.contains_window(window.hwnd);
-                    let workspace_has_monocle_container = workspace.monocle_container().is_some();
 
-                    if !workspace_contains_window && !needs_reconciliation {
+                    if !workspace.contains_window(window.hwnd) && !needs_reconciliation {
                         match behaviour {
                             WindowContainerBehaviour::Create => {
                                 workspace.new_container_for_window(window);
@@ -352,13 +369,6 @@ impl WindowManager {
                             }
                         }
                     }
-
-                    if matches!(event, WindowManagerEvent::Uncloak(_, _)) {
-                        if workspace_contains_window && workspace_has_monocle_container {
-                            self.toggle_monocle()?;
-                            window.focus(self.mouse_follows_focus)?;
-                        }
-                    }
                 }
             }
             WindowManagerEvent::MoveResizeStart(_, window) => {
@@ -451,7 +461,10 @@ impl WindowManager {
 
                     // If we have moved across the monitors, use that override, otherwise determine
                     // if a move has taken place by ruling out a resize
-                    let right_bottom_constant = 0;
+                    let right_bottom_constant = ((BORDER_WIDTH.load(Ordering::SeqCst)
+                        + BORDER_OFFSET.load(Ordering::SeqCst))
+                        * 2)
+                    .abs();
 
                     let is_move = moved_across_monitors
                         || resize.right.abs() == right_bottom_constant
@@ -627,7 +640,6 @@ impl WindowManager {
 
         notify_subscribers(&serde_json::to_string(&notification)?)?;
         border_manager::event_tx().send(border_manager::Notification)?;
-        stackbar_manager::event_tx().send(stackbar_manager::Notification)?;
 
         tracing::info!("processed: {}", event.window().to_string());
         Ok(())

komorebi/src/stackbar.rs

@@ -0,0 +1,275 @@
+use std::collections::VecDeque;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use color_eyre::eyre::Result;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use windows::core::PCWSTR;
+use windows::Win32::Foundation::COLORREF;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::Foundation::LPARAM;
+use windows::Win32::Foundation::LRESULT;
+use windows::Win32::Foundation::WPARAM;
+use windows::Win32::Graphics::Gdi::CreateFontIndirectW;
+use windows::Win32::Graphics::Gdi::CreatePen;
+use windows::Win32::Graphics::Gdi::CreateSolidBrush;
+use windows::Win32::Graphics::Gdi::DrawTextW;
+use windows::Win32::Graphics::Gdi::GetDC;
+use windows::Win32::Graphics::Gdi::ReleaseDC;
+use windows::Win32::Graphics::Gdi::SelectObject;
+use windows::Win32::Graphics::Gdi::SetBkColor;
+use windows::Win32::Graphics::Gdi::SetTextColor;
+use windows::Win32::Graphics::Gdi::DT_CENTER;
+use windows::Win32::Graphics::Gdi::DT_END_ELLIPSIS;
+use windows::Win32::Graphics::Gdi::DT_SINGLELINE;
+use windows::Win32::Graphics::Gdi::DT_VCENTER;
+use windows::Win32::Graphics::Gdi::FONT_QUALITY;
+use windows::Win32::Graphics::Gdi::FW_BOLD;
+use windows::Win32::Graphics::Gdi::LOGFONTW;
+use windows::Win32::Graphics::Gdi::PROOF_QUALITY;
+use windows::Win32::Graphics::Gdi::PS_SOLID;
+use windows::Win32::UI::WindowsAndMessaging::CreateWindowExW;
+use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
+use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
+use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
+use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
+use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::SW_SHOW;
+use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
+use windows::Win32::UI::WindowsAndMessaging::WM_LBUTTONDOWN;
+use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
+use windows::Win32::UI::WindowsAndMessaging::WS_VISIBLE;
+
+use komorebi_core::Rect;
+
+use crate::window::Window;
+use crate::windows_api::WindowsApi;
+use crate::StackbarLabel;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_LABEL;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
+use crate::WINDOWS_BY_BAR_HWNDS;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct Stackbar {
+    pub hwnd: isize,
+}
+
+impl Stackbar {
+    unsafe extern "system" fn window_proc(
+        hwnd: HWND,
+        msg: u32,
+        w_param: WPARAM,
+        l_param: LPARAM,
+    ) -> LRESULT {
+        match msg {
+            WM_LBUTTONDOWN => {
+                let win_hwnds_by_topbar = WINDOWS_BY_BAR_HWNDS.lock();
+                if let Some(win_hwnds) = win_hwnds_by_topbar.get(&hwnd.0) {
+                    let x = l_param.0 as i32 & 0xFFFF;
+                    let y = (l_param.0 as i32 >> 16) & 0xFFFF;
+
+                    let width = STACKBAR_TAB_WIDTH.load(Ordering::SeqCst);
+                    let height = STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst);
+                    let gap = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
+
+                    for (index, win_hwnd) in win_hwnds.iter().enumerate() {
+                        let left = gap + (index as i32 * (width + gap));
+                        let right = left + width;
+                        let top = 0;
+                        let bottom = height;
+
+                        if x >= left && x <= right && y >= top && y <= bottom {
+                            let window = Window { hwnd: *win_hwnd };
+                            window.restore();
+                            if let Err(err) = window.focus(false) {
+                                tracing::error!("Stackbar focus error: HWND:{} {}", *win_hwnd, err);
+                            }
+                        }
+                    }
+                }
+
+                WINDOWS_BY_BAR_HWNDS.force_unlock();
+                LRESULT(0)
+            }
+            WM_DESTROY => {
+                PostQuitMessage(0);
+                LRESULT(0)
+            }
+            _ => DefWindowProcW(hwnd, msg, w_param, l_param),
+        }
+    }
+
+    pub const fn hwnd(&self) -> HWND {
+        HWND(self.hwnd)
+    }
+
+    pub fn create() -> Result<Stackbar> {
+        let name: Vec<u16> = "komorebi_stackbar\0".encode_utf16().collect();
+        let class_name = PCWSTR(name.as_ptr());
+
+        let h_module = WindowsApi::module_handle_w()?;
+
+        let wnd_class = WNDCLASSW {
+            style: CS_HREDRAW | CS_VREDRAW,
+            lpfnWndProc: Some(Self::window_proc),
+            hInstance: h_module.into(),
+            lpszClassName: class_name,
+            hbrBackground: WindowsApi::create_solid_brush(0),
+            ..Default::default()
+        };
+
+        unsafe {
+            RegisterClassW(&wnd_class);
+        }
+
+        let (hwnd_sender, hwnd_receiver) = crossbeam_channel::bounded::<HWND>(1);
+
+        let name_cl = name.clone();
+        std::thread::spawn(move || -> Result<()> {
+            unsafe {
+                let hwnd = CreateWindowExW(
+                    WS_EX_TOOLWINDOW | WS_EX_LAYERED,
+                    PCWSTR(name_cl.as_ptr()),
+                    PCWSTR(name_cl.as_ptr()),
+                    WS_POPUP | WS_VISIBLE,
+                    0,
+                    0,
+                    0,
+                    0,
+                    None,
+                    None,
+                    h_module,
+                    None,
+                );
+
+                SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
+                hwnd_sender.send(hwnd)?;
+
+                let mut msg = MSG::default();
+                while GetMessageW(&mut msg, hwnd, 0, 0).into() {
+                    TranslateMessage(&msg);
+                    DispatchMessageW(&msg);
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+            }
+
+            Ok(())
+        });
+
+        Ok(Self {
+            hwnd: hwnd_receiver.recv()?.0,
+        })
+    }
+
+    pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
+        WindowsApi::position_window(self.hwnd(), layout, top)
+    }
+
+    pub fn get_position_from_container_layout(&self, layout: &Rect) -> Rect {
+        Rect {
+            bottom: STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst),
+            ..*layout
+        }
+    }
+
+    pub fn update(&self, windows: &VecDeque<Window>, focused_hwnd: isize) -> Result<()> {
+        let width = STACKBAR_TAB_WIDTH.load(Ordering::SeqCst);
+        let height = STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst);
+        let gap = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
+        let background = STACKBAR_TAB_BACKGROUND_COLOUR.load(Ordering::SeqCst);
+        let focused_text_colour = STACKBAR_FOCUSED_TEXT_COLOUR.load(Ordering::SeqCst);
+        let unfocused_text_colour = STACKBAR_UNFOCUSED_TEXT_COLOUR.load(Ordering::SeqCst);
+
+        unsafe {
+            let hdc = GetDC(self.hwnd());
+
+            let hpen = CreatePen(PS_SOLID, 0, COLORREF(background));
+            let hbrush = CreateSolidBrush(COLORREF(background));
+
+            SelectObject(hdc, hpen);
+            SelectObject(hdc, hbrush);
+            SetBkColor(hdc, COLORREF(background));
+
+            let hfont = CreateFontIndirectW(&LOGFONTW {
+                lfWeight: FW_BOLD.0 as i32,
+                lfQuality: FONT_QUALITY(PROOF_QUALITY.0),
+                ..Default::default()
+            });
+
+            SelectObject(hdc, hfont);
+
+            for (i, window) in windows.iter().enumerate() {
+                if window.hwnd == focused_hwnd {
+                    SetTextColor(hdc, COLORREF(focused_text_colour));
+                } else {
+                    SetTextColor(hdc, COLORREF(unfocused_text_colour));
+                }
+
+                let left = gap + (i as i32 * (width + gap));
+                let mut tab_box = Rect {
+                    top: 0,
+                    left,
+                    right: left + width,
+                    bottom: height,
+                };
+
+                WindowsApi::round_rect(hdc, &tab_box, 8);
+
+                let label = match STACKBAR_LABEL.load() {
+                    StackbarLabel::Process => {
+                        let exe = window.exe()?;
+                        exe.trim_end_matches(".exe").to_string()
+                    }
+                    StackbarLabel::Title => window.title()?,
+                };
+
+                let mut tab_title: Vec<u16> = label.encode_utf16().collect();
+
+                tab_box.left_padding(10);
+                tab_box.right_padding(10);
+
+                DrawTextW(
+                    hdc,
+                    &mut tab_title,
+                    &mut tab_box.into(),
+                    DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_END_ELLIPSIS,
+                );
+            }
+
+            ReleaseDC(self.hwnd(), hdc);
+        }
+
+        let mut windows_hwdns: VecDeque<isize> = VecDeque::new();
+        for window in windows {
+            windows_hwdns.push_back(window.hwnd);
+        }
+
+        WINDOWS_BY_BAR_HWNDS.lock().insert(self.hwnd, windows_hwdns);
+
+        Ok(())
+    }
+
+    pub fn hide(&self) {
+        WindowsApi::hide_window(self.hwnd())
+    }
+
+    pub fn restore(&self) {
+        WindowsApi::show_window(self.hwnd(), SW_SHOW)
+    }
+}

komorebi/src/stackbar_manager/mod.rs

@@ -1,189 +0,0 @@
-mod stackbar;
-
-use crate::container::Container;
-use crate::stackbar_manager::stackbar::Stackbar;
-use crate::WindowManager;
-use crate::WindowsApi;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
-use crossbeam_utils::atomic::AtomicConsume;
-use komorebi_core::StackbarLabel;
-use komorebi_core::StackbarMode;
-use lazy_static::lazy_static;
-use parking_lot::Mutex;
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::AtomicU32;
-use std::sync::Arc;
-use std::sync::OnceLock;
-use windows::Win32::Foundation::HWND;
-
-pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
-pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947); // gray text
-pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
-pub static STACKBAR_TAB_HEIGHT: AtomicI32 = AtomicI32::new(40);
-pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
-pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
-pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::OnStack);
-
-lazy_static! {
-    pub static ref STACKBAR_STATE: Mutex<HashMap<String, Stackbar>> = Mutex::new(HashMap::new());
-    static ref STACKBARS_MONITORS: Mutex<HashMap<String, usize>> = Mutex::new(HashMap::new());
-    static ref STACKBARS_CONTAINERS: Mutex<HashMap<isize, Container>> = Mutex::new(HashMap::new());
-}
-
-pub struct Notification;
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(crossbeam_channel::unbounded)
-}
-
-pub fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-pub fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-pub fn should_have_stackbar(window_count: usize) -> bool {
-    match STACKBAR_MODE.load() {
-        StackbarMode::Always => true,
-        StackbarMode::OnStack => window_count > 1,
-        StackbarMode::Never => false,
-    }
-}
-
-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();
-
-    'receiver: for _ in receiver {
-        let mut stackbars = STACKBAR_STATE.lock();
-        let mut stackbars_monitors = STACKBARS_MONITORS.lock();
-
-        // Check the wm state every time we receive a notification
-        let mut state = wm.lock();
-
-        // If stackbars are disabled
-        if matches!(STACKBAR_MODE.load(), StackbarMode::Never) {
-            for (_, stackbar) in stackbars.iter() {
-                stackbar.destroy()?;
-            }
-
-            stackbars.clear();
-            continue 'receiver;
-        }
-
-        for (monitor_idx, m) in state.monitors_mut().iter_mut().enumerate() {
-            // Only operate on the focused workspace of each monitor
-            if let Some(ws) = m.focused_workspace_mut() {
-                // Workspaces with tiling disabled don't have stackbars
-                if !ws.tile() {
-                    let mut to_remove = vec![];
-                    for (id, border) in stackbars.iter() {
-                        if stackbars_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        stackbars.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                let is_maximized = WindowsApi::is_zoomed(HWND(
-                    WindowsApi::foreground_window().unwrap_or_default(),
-                ));
-
-                // Handle the monocle container separately
-                if ws.monocle_container().is_some() || is_maximized {
-                    // Destroy any stackbars associated with the focused workspace
-                    let mut to_remove = vec![];
-                    for (id, stackbar) in stackbars.iter() {
-                        if stackbars_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            stackbar.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        stackbars.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                let container_padding = ws
-                    .container_padding()
-                    .unwrap_or_else(|| DEFAULT_CONTAINER_PADDING.load_consume());
-
-                'containers: for container in ws.containers_mut() {
-                    let should_add_stackbar = match STACKBAR_MODE.load() {
-                        StackbarMode::Always => true,
-                        StackbarMode::OnStack => container.windows().len() > 1,
-                        StackbarMode::Never => false,
-                    };
-
-                    if !should_add_stackbar {
-                        if let Some(stackbar) = stackbars.get(container.id()) {
-                            stackbar.destroy()?
-                        }
-
-                        stackbars.remove(container.id());
-                        stackbars_monitors.remove(container.id());
-                        continue 'containers;
-                    }
-
-                    // Get the stackbar entry for this container from the map or create one
-                    let stackbar = match stackbars.entry(container.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(stackbar) = Stackbar::create(container.id()) {
-                                entry.insert(stackbar)
-                            } else {
-                                continue 'receiver;
-                            }
-                        }
-                    };
-
-                    stackbars_monitors.insert(container.id().clone(), monitor_idx);
-
-                    let rect = WindowsApi::window_rect(
-                        container
-                            .focused_window()
-                            .copied()
-                            .unwrap_or_default()
-                            .hwnd(),
-                    )?;
-
-                    stackbar.update(container_padding, container, &rect)?;
-                }
-            }
-        }
-    }
-
-    Ok(())
-}

komorebi/src/stackbar_manager/stackbar.rs

@@ -1,328 +0,0 @@
-use crate::border_manager::BORDER_OFFSET;
-use crate::border_manager::BORDER_WIDTH;
-use crate::border_manager::STYLE;
-use crate::container::Container;
-use crate::stackbar_manager::STACKBARS_CONTAINERS;
-use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_LABEL;
-use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
-use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
-use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
-use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::WindowsApi;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::WINDOWS_11;
-use crossbeam_utils::atomic::AtomicConsume;
-use komorebi_core::BorderStyle;
-use komorebi_core::Rect;
-use komorebi_core::StackbarLabel;
-use std::sync::mpsc;
-use std::time::Duration;
-use windows::core::PCWSTR;
-use windows::Win32::Foundation::COLORREF;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::Foundation::LPARAM;
-use windows::Win32::Foundation::LRESULT;
-use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Gdi::CreateFontIndirectW;
-use windows::Win32::Graphics::Gdi::CreatePen;
-use windows::Win32::Graphics::Gdi::CreateSolidBrush;
-use windows::Win32::Graphics::Gdi::DrawTextW;
-use windows::Win32::Graphics::Gdi::GetDC;
-use windows::Win32::Graphics::Gdi::Rectangle;
-use windows::Win32::Graphics::Gdi::ReleaseDC;
-use windows::Win32::Graphics::Gdi::RoundRect;
-use windows::Win32::Graphics::Gdi::SelectObject;
-use windows::Win32::Graphics::Gdi::SetBkColor;
-use windows::Win32::Graphics::Gdi::SetTextColor;
-use windows::Win32::Graphics::Gdi::DT_CENTER;
-use windows::Win32::Graphics::Gdi::DT_END_ELLIPSIS;
-use windows::Win32::Graphics::Gdi::DT_SINGLELINE;
-use windows::Win32::Graphics::Gdi::DT_VCENTER;
-use windows::Win32::Graphics::Gdi::FONT_QUALITY;
-use windows::Win32::Graphics::Gdi::FW_BOLD;
-use windows::Win32::Graphics::Gdi::LOGFONTW;
-use windows::Win32::Graphics::Gdi::PROOF_QUALITY;
-use windows::Win32::Graphics::Gdi::PS_SOLID;
-use windows::Win32::UI::WindowsAndMessaging::CreateWindowExW;
-use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
-use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
-use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
-use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
-use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
-use windows::Win32::UI::WindowsAndMessaging::WM_LBUTTONDOWN;
-use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
-use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
-use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
-use windows::Win32::UI::WindowsAndMessaging::WS_VISIBLE;
-
-#[derive(Debug)]
-pub struct Stackbar {
-    pub hwnd: isize,
-}
-
-impl From<isize> for Stackbar {
-    fn from(value: isize) -> Self {
-        Self { hwnd: value }
-    }
-}
-
-impl Stackbar {
-    pub const fn hwnd(&self) -> HWND {
-        HWND(self.hwnd)
-    }
-
-    pub fn create(id: &str) -> color_eyre::Result<Self> {
-        let name: Vec<u16> = format!("komostackbar-{id}\0").encode_utf16().collect();
-        let class_name = PCWSTR(name.as_ptr());
-
-        let h_module = WindowsApi::module_handle_w()?;
-
-        let window_class = WNDCLASSW {
-            style: CS_HREDRAW | CS_VREDRAW,
-            lpfnWndProc: Some(Self::callback),
-            hInstance: h_module.into(),
-            lpszClassName: class_name,
-            hbrBackground: WindowsApi::create_solid_brush(0),
-            ..Default::default()
-        };
-
-        let _ = WindowsApi::register_class_w(&window_class);
-
-        let (hwnd_sender, hwnd_receiver) = mpsc::channel();
-
-        let name_cl = name.clone();
-        std::thread::spawn(move || -> color_eyre::Result<()> {
-            unsafe {
-                let hwnd = CreateWindowExW(
-                    WS_EX_TOOLWINDOW | WS_EX_LAYERED,
-                    PCWSTR(name_cl.as_ptr()),
-                    PCWSTR(name_cl.as_ptr()),
-                    WS_POPUP | WS_VISIBLE,
-                    0,
-                    0,
-                    0,
-                    0,
-                    None,
-                    None,
-                    h_module,
-                    None,
-                );
-
-                SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
-                hwnd_sender.send(hwnd)?;
-
-                let mut msg = MSG::default();
-                while GetMessageW(&mut msg, hwnd, 0, 0).into() {
-                    TranslateMessage(&msg);
-                    DispatchMessageW(&msg);
-                    std::thread::sleep(Duration::from_millis(10));
-                }
-            }
-
-            Ok(())
-        });
-
-        Ok(Self {
-            hwnd: hwnd_receiver.recv()?.0,
-        })
-    }
-
-    pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd())
-    }
-
-    pub fn update(
-        &self,
-        container_padding: i32,
-        container: &mut Container,
-        layout: &Rect,
-    ) -> color_eyre::Result<()> {
-        let width = STACKBAR_TAB_WIDTH.load_consume();
-        let height = STACKBAR_TAB_HEIGHT.load_consume();
-        let gap = DEFAULT_CONTAINER_PADDING.load_consume();
-        let background = STACKBAR_TAB_BACKGROUND_COLOUR.load_consume();
-        let focused_text_colour = STACKBAR_FOCUSED_TEXT_COLOUR.load_consume();
-        let unfocused_text_colour = STACKBAR_UNFOCUSED_TEXT_COLOUR.load_consume();
-
-        let mut stackbars_containers = STACKBARS_CONTAINERS.lock();
-        stackbars_containers.insert(self.hwnd, container.clone());
-
-        let mut layout = *layout;
-        let workspace_specific_offset =
-            BORDER_WIDTH.load_consume() + BORDER_OFFSET.load_consume() + container_padding;
-
-        layout.top -= workspace_specific_offset + STACKBAR_TAB_HEIGHT.load_consume();
-        layout.left -= workspace_specific_offset;
-
-        WindowsApi::position_window(self.hwnd(), &layout, false)?;
-
-        unsafe {
-            let hdc = GetDC(self.hwnd());
-
-            let hpen = CreatePen(PS_SOLID, 0, COLORREF(background));
-            let hbrush = CreateSolidBrush(COLORREF(background));
-
-            SelectObject(hdc, hpen);
-            SelectObject(hdc, hbrush);
-            SetBkColor(hdc, COLORREF(background));
-
-            let hfont = CreateFontIndirectW(&LOGFONTW {
-                lfWeight: FW_BOLD.0 as i32,
-                lfQuality: FONT_QUALITY(PROOF_QUALITY.0),
-                ..Default::default()
-            });
-
-            SelectObject(hdc, hfont);
-
-            for (i, window) in container.windows().iter().enumerate() {
-                if window.hwnd == container.focused_window().copied().unwrap_or_default().hwnd {
-                    SetTextColor(hdc, COLORREF(focused_text_colour));
-                } else {
-                    SetTextColor(hdc, COLORREF(unfocused_text_colour));
-                }
-
-                let left = gap + (i as i32 * (width + gap));
-                let mut rect = Rect {
-                    top: 0,
-                    left,
-                    right: left + width,
-                    bottom: height,
-                };
-
-                match *STYLE.lock() {
-                    BorderStyle::System => {
-                        if *WINDOWS_11 {
-                            RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
-                        } else {
-                            Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
-                        }
-                    }
-                    BorderStyle::Rounded => {
-                        RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
-                    }
-                    BorderStyle::Square => {
-                        Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
-                    }
-                }
-
-                let label = match STACKBAR_LABEL.load() {
-                    StackbarLabel::Process => {
-                        let exe = window.exe()?;
-                        exe.trim_end_matches(".exe").to_string()
-                    }
-                    StackbarLabel::Title => window.title()?,
-                };
-
-                let mut tab_title: Vec<u16> = label.encode_utf16().collect();
-
-                rect.left_padding(10);
-                rect.right_padding(10);
-
-                DrawTextW(
-                    hdc,
-                    &mut tab_title,
-                    &mut rect.into(),
-                    DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_END_ELLIPSIS,
-                );
-            }
-
-            ReleaseDC(self.hwnd(), hdc);
-        }
-
-        Ok(())
-    }
-
-    pub fn get_position_from_container_layout(&self, layout: &Rect) -> Rect {
-        Rect {
-            bottom: STACKBAR_TAB_HEIGHT.load_consume(),
-            ..*layout
-        }
-    }
-
-    unsafe extern "system" fn callback(
-        hwnd: HWND,
-        msg: u32,
-        w_param: WPARAM,
-        l_param: LPARAM,
-    ) -> LRESULT {
-        unsafe {
-            match msg {
-                WM_LBUTTONDOWN => {
-                    let stackbars_containers = STACKBARS_CONTAINERS.lock();
-                    if let Some(container) = stackbars_containers.get(&hwnd.0) {
-                        let x = l_param.0 as i32 & 0xFFFF;
-                        let y = (l_param.0 as i32 >> 16) & 0xFFFF;
-
-                        let width = STACKBAR_TAB_WIDTH.load_consume();
-                        let height = STACKBAR_TAB_HEIGHT.load_consume();
-                        let gap = DEFAULT_CONTAINER_PADDING.load_consume();
-
-                        let focused_window_idx = container.focused_window_idx();
-                        let focused_window_rect = WindowsApi::window_rect(
-                            container
-                                .focused_window()
-                                .cloned()
-                                .unwrap_or_default()
-                                .hwnd(),
-                        )
-                        .unwrap_or_default();
-
-                        for (index, window) in container.windows().iter().enumerate() {
-                            let left = gap + (index as i32 * (width + gap));
-                            let right = left + width;
-                            let top = 0;
-                            let bottom = height;
-
-                            if x >= left && x <= right && y >= top && y <= bottom {
-                                // If we are focusing a window that isn't currently focused in the
-                                // stackbar, make sure we update its location so that it doesn't render
-                                // on top of other tiles before eventually ending up in the correct
-                                // tile
-                                if index != focused_window_idx {
-                                    if let Err(err) =
-                                        window.set_position(&focused_window_rect, false)
-                                    {
-                                        tracing::error!(
-                                        "stackbar WM_LBUTTONDOWN repositioning error: hwnd {} ({})",
-                                        *window,
-                                        err
-                                    );
-                                    }
-                                }
-
-                                // Restore the window corresponding to the tab we have clicked
-                                window.restore();
-                                if let Err(err) = window.focus(false) {
-                                    tracing::error!(
-                                        "stackbar WMLBUTTONDOWN focus error: hwnd {} ({})",
-                                        *window,
-                                        err
-                                    );
-                                }
-                            } else {
-                                // Hide any windows in the stack that don't correspond to the window
-                                // we have clicked
-                                window.hide();
-                            }
-                        }
-                    }
-
-                    LRESULT(0)
-                }
-                WM_DESTROY => {
-                    PostQuitMessage(0);
-                    LRESULT(0)
-                }
-                _ => DefWindowProcW(hwnd, msg, w_param, l_param),
-            }
-        }
-    }
-}

komorebi/src/static_config.rs

@@ -7,13 +7,6 @@ use crate::current_virtual_desktop;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator;
 use crate::ring::Ring;
-use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_LABEL;
-use crate::stackbar_manager::STACKBAR_MODE;
-use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
-use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
-use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
-use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -29,6 +22,13 @@ use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_LABEL;
+use crate::STACKBAR_MODE;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
 use komorebi_core::StackbarLabel;
@@ -760,6 +760,16 @@ impl StaticConfig {
 
         value.apply_globals()?;
 
+        let stackbar_mode = STACKBAR_MODE.load();
+
+        for m in wm.monitors_mut() {
+            for w in m.workspaces_mut() {
+                for c in w.containers_mut() {
+                    c.set_stackbar_mode(stackbar_mode);
+                }
+            }
+        }
+
         if let Some(monitors) = value.monitors {
             for (i, monitor) in monitors.iter().enumerate() {
                 if let Some(m) = wm.monitors_mut().get_mut(i) {

komorebi/src/window_manager.rs

@@ -46,12 +46,6 @@ use crate::current_virtual_desktop;
 use crate::load_configuration;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
-use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_MODE;
-use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
-use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
-use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
-use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::static_config::StaticConfig;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
@@ -74,6 +68,12 @@ use crate::MONITOR_INDEX_PREFERENCES;
 use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REMOVE_TITLEBARS;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_MODE;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
 use komorebi_core::StackbarMode;
@@ -1129,12 +1129,9 @@ impl WindowManager {
 
         tracing::info!("focusing container");
 
-        let new_idx = if workspace.monocle_container().is_some() {
-            None
-        } else {
-            workspace.new_idx_for_direction(direction)
-        };
+        let new_idx = workspace.new_idx_for_direction(direction);
 
+        // TODO: clean this up, this is awful
         let mut cross_monitor_monocle = false;
 
         // if there is no container in that direction for this workspace
@@ -1165,9 +1162,22 @@ impl WindowManager {
             }
         }
 
+        // When switching workspaces and landing focus on a window that is not stack, but a stack
+        // exists, and there is a stackbar visible, when changing focus to that container stack,
+        // the focused text colour will not be applied until the stack has been cycled at least once
+        //
+        // With this piece of code, we check if we have changed focus to a container stack with
+        // a stackbar, and if we have, we run a quick update to make sure the focused text colour
+        // has been applied
         if !cross_monitor_monocle {
             if let Ok(focused_window) = self.focused_window_mut() {
+                let focused_window_hwnd = focused_window.hwnd;
                 focused_window.focus(self.mouse_follows_focus)?;
+
+                let focused_container = self.focused_container()?;
+                if let Some(stackbar) = focused_container.stackbar() {
+                    stackbar.update(focused_container.windows(), focused_window_hwnd)?;
+                }
             }
         }
 
@@ -1570,6 +1580,16 @@ impl WindowManager {
 
         self.update_focused_workspace(true, true)?;
 
+        // TODO: fix this ugly hack to restore stackbar after monocle is toggled off
+        let workspace = self.focused_workspace()?;
+        if workspace.monocle_container().is_none() {
+            if let Some(container) = workspace.focused_container() {
+                if container.stackbar().is_some() {
+                    self.retile_all(true)?;
+                };
+            }
+        };
+
         Ok(())
     }
 
@@ -1580,7 +1600,12 @@ impl WindowManager {
         let workspace = self.focused_workspace_mut()?;
         workspace.new_monocle_container()?;
 
+        if let Some(monocle) = workspace.monocle_container_mut() {
+            monocle.set_stackbar_mode(StackbarMode::Never);
+        }
+
         for container in workspace.containers_mut() {
+            container.set_stackbar_mode(StackbarMode::Never);
             container.hide(None);
         }
 
@@ -1593,7 +1618,12 @@ impl WindowManager {
 
         let workspace = self.focused_workspace_mut()?;
 
+        if let Some(monocle) = workspace.monocle_container_mut() {
+            monocle.set_stackbar_mode(STACKBAR_MODE.load());
+        }
+
         for container in workspace.containers_mut() {
+            container.set_stackbar_mode(STACKBAR_MODE.load());
             container.restore();
         }
 

komorebi/src/workspace.rs

@@ -24,8 +24,6 @@ use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::container::Container;
 use crate::ring::Ring;
-use crate::stackbar_manager;
-use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
 use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::window::WindowDetails;
@@ -35,6 +33,7 @@ use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::NO_TITLEBAR;
 use crate::REMOVE_TITLEBARS;
+use crate::STACKBAR_TAB_HEIGHT;
 
 #[allow(clippy::struct_field_names)]
 #[derive(
@@ -305,7 +304,7 @@ impl Workspace {
             } else if let Some(window) = self.maximized_window_mut() {
                 window.maximize();
             } else if !self.containers().is_empty() {
-                let mut layouts = self.layout().as_boxed_arrangement().calculate(
+                let layouts = self.layout().as_boxed_arrangement().calculate(
                     &adjusted_work_area,
                     NonZeroUsize::new(self.containers().len()).ok_or_else(|| {
                         anyhow!(
@@ -320,14 +319,24 @@ impl Workspace {
                 let should_remove_titlebars = REMOVE_TITLEBARS.load(Ordering::SeqCst);
                 let no_titlebar = NO_TITLEBAR.lock().clone();
 
+                let focused_hwnd = self
+                    .focused_container()
+                    .ok_or_else(|| anyhow!("couldn't find a focused container"))?
+                    .focused_window()
+                    .ok_or_else(|| anyhow!("couldn't find a focused window"))?
+                    .hwnd;
+
                 let container_padding = self.container_padding().unwrap_or(0);
                 let containers = self.containers_mut();
 
                 for (i, container) in containers.iter_mut().enumerate() {
-                    let window_count = container.windows().len();
+                    container.renew_stackbar();
+
+                    let container_windows = container.windows().clone();
+                    let container_stackbar = container.stackbar().clone();
 
                     if let (Some(window), Some(layout)) =
-                        (container.focused_window_mut(), layouts.get_mut(i))
+                        (container.focused_window_mut(), layouts.get(i))
                     {
                         if should_remove_titlebars && no_titlebar.contains(&window.exe()?) {
                             window.remove_title_bar()?;
@@ -341,23 +350,33 @@ impl Workspace {
                             WindowsApi::restore_window(window.hwnd());
                         }
 
+                        let mut rect = *layout;
                         {
                             let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
-                            layout.add_padding(border_offset);
+                            rect.add_padding(border_offset);
 
                             let width = BORDER_WIDTH.load(Ordering::SeqCst);
-                            layout.add_padding(width);
+                            rect.add_padding(width);
                         }
 
-                        if stackbar_manager::should_have_stackbar(window_count) {
-                            let tab_height = STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst);
-                            let total_height = tab_height + container_padding;
+                        if let Some(stackbar) = container_stackbar {
+                            if stackbar
+                                .set_position(
+                                    &stackbar.get_position_from_container_layout(layout),
+                                    false,
+                                )
+                                .is_ok()
+                            {
+                                stackbar.update(&container_windows, focused_hwnd)?;
+                                let tab_height = STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst);
+                                let total_height = tab_height + container_padding;
 
-                            layout.top += total_height;
-                            layout.bottom -= total_height;
+                                rect.top += total_height;
+                                rect.bottom -= total_height;
+                            }
                         }
 
-                        window.set_position(&layout, false)?;
+                        window.set_position(&rect, false)?;
                     }
                 }
 
@@ -386,10 +405,17 @@ impl Workspace {
         let containers = self.containers_mut();
 
         for container in containers.iter_mut() {
+            let container_windows = container.windows().clone();
+            let container_topbar = container.stackbar().clone();
+
             if let Some(idx) = container.idx_for_window(hwnd) {
                 container.focus_window(idx);
                 container.restore();
             }
+
+            if let Some(stackbar) = container_topbar {
+                stackbar.update(&container_windows, hwnd)?;
+            }
         }
         Ok(())
     }