feat(config): add active window border style opt

docs(cli): add support + community links to start cmd
chore(deps): bump heck from 0.4.1 to 0.5.0
2026-02-27 15:37:38 +01:00 · 2024-03-26 16:28:57 -07:00 · 2024-03-25 17:55:28 -07:00 · 2024-03-25 17:27:02 -07:00 · 2024-03-25 17:26:43 -07:00 · 2024-03-25 14:30:30 -07:00
16 changed files with 686 additions and 95 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,9 +19,9 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"

 [[package]]
 name = "aho-corasick"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
 "memchr",
 ]
@@ -82,15 +82,15 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"

 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"

 [[package]]
 name = "backtrace"
-version = "0.3.69"
+version = "0.3.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
 dependencies = [
 "addr2line",
 "cc",
@@ -124,9 +124,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
 name = "bitflags"
-version = "2.4.2"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"

 [[package]]
 name = "bumpalo"
@@ -136,9 +136,9 @@ checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"

 [[package]]
 name = "bytes"
-version = "1.5.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"

 [[package]]
 name = "cc"
@@ -166,9 +166,9 @@ checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"

 [[package]]
 name = "clap"
-version = "4.5.3"
+version = "4.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "949626d00e063efc93b6dca932419ceb5432f99769911c0b995f7e884c778813"
+checksum = "90bc066a67923782aa8515dbaea16946c5bcc5addbd668bb80af688e53e548a0"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -189,14 +189,14 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.5.3"
+version = "4.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90239a040c80f5e14809ca132ddc4176ab33d5e17e49691793296e3fcb34d72f"
+checksum = "528131438037fd55894f62d6e9f068b8f45ac57ffa77517819645d10aed04f64"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -392,9 +392,9 @@ dependencies = [

 [[package]]
 name = "fastrand"
-version = "2.0.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"

 [[package]]
 name = "file-id"
@@ -705,9 +705,9 @@ checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"

 [[package]]
 name = "indexmap"
-version = "2.2.5"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b0b929d511467233429c45a44ac1dcaa21ba0f5ba11e4879e6ed28ddb4f9df4"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
 "equivalent",
 "hashbrown",
@@ -764,7 +764,7 @@ dependencies = [
 name = "komorebi"
 version = "0.1.23-dev.0"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
 "clap",
 "color-eyre",
 "crossbeam-channel",
@@ -837,7 +837,7 @@ dependencies = [
 "dirs",
 "dunce",
 "fs-tail",
- "heck 0.4.1",
+ "heck 0.5.0",
 "komorebi-core",
 "lazy_static",
 "miette",
@@ -896,7 +896,7 @@ version = "0.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
 "libc",
 "redox_syscall",
 ]
@@ -975,7 +975,7 @@ checksum = "dcf09caffaac8068c346b6df2a7fc27a177fd20b39421a39ce0a211bde679a6c"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -1058,7 +1058,7 @@ version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
 "cfg-if 1.0.0",
 "cfg_aliases",
 "libc",
@@ -1070,7 +1070,7 @@ version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
 "crossbeam-channel",
 "filetime",
 "fsevent-sys",
@@ -1142,7 +1142,7 @@ version = "0.10.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
 "cfg-if 1.0.0",
 "foreign-types",
 "libc",
@@ -1159,7 +1159,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -1188,9 +1188,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"

 [[package]]
 name = "os_info"
-version = "3.8.1"
+version = "3.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cbb46d5d01695d7a1fb8be5f0d1968bd2b2b8ba1d1b3e7062ce2a0593e57af1"
+checksum = "ae99c7fa6dd38c7cafe1ec085e804f8f555a2f8659b0dbe03f1f9963a9b51092"
 dependencies = [
 "log",
 "serde",
@@ -1373,9 +1373,9 @@ dependencies = [

 [[package]]
 name = "rayon"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
 "either",
 "rayon-core",
@@ -1413,9 +1413,9 @@ dependencies = [

 [[package]]
 name = "regex"
-version = "1.10.3"
+version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -1457,9 +1457,9 @@ checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"

 [[package]]
 name = "reqwest"
-version = "0.11.26"
+version = "0.11.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bf93c4af7a8bb7d879d51cebe797356ff10ae8516ace542b5182d9dcac10b2"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
 dependencies = [
 "base64",
 "bytes",
@@ -1503,11 +1503,11 @@ checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"

 [[package]]
 name = "rustix"
-version = "0.38.31"
+version = "0.38.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
 dependencies = [
- "bitflags 2.4.2",
+ "bitflags 2.5.0",
 "errno",
 "libc",
 "linux-raw-sys",
@@ -1623,7 +1623,7 @@ checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -1673,9 +1673,9 @@ dependencies = [

 [[package]]
 name = "serde_yaml"
-version = "0.9.33"
+version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0623d197252096520c6f2a5e1171ee436e5af99a5d7caa2891e55e61950e6d9"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
 "indexmap",
 "itoa",
@@ -1704,9 +1704,9 @@ dependencies = [

 [[package]]
 name = "smallvec"
-version = "1.13.1"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"

 [[package]]
 name = "smawk"
@@ -1749,7 +1749,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -1786,9 +1786,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.52"
+version = "2.0.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b699d15b36d1f02c3e7c69f8ffef53de37aefae075d8488d4ba1a7788d574a07"
+checksum = "002a1b3dbf967edfafc32655d0f377ab0bb7b994aa1d32c8cc7e9b8bf3ebb8f0"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1887,7 +1887,7 @@ checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -2032,7 +2032,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -2221,7 +2221,7 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 "wasm-bindgen-shared",
 ]

@@ -2255,7 +2255,7 @@ checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@@ -2278,15 +2278,14 @@ dependencies = [

 [[package]]
 name = "which"
-version = "6.0.0"
+version = "6.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fa5e0c10bf77f44aac573e498d1a82d5fbd5e91f6fc0a99e7be4b38e85e101c"
+checksum = "8211e4f58a2b2805adfbefbc07bab82958fc91e3836339b1ab7ae32465dce0d7"
 dependencies = [
 "either",
 "home",
- "once_cell",
 "rustix",
- "windows-sys 0.52.0",
+ "winsafe",
 ]

 [[package]]
@@ -2375,7 +2374,7 @@ checksum = "942ac266be9249c84ca862f0a164a39533dc2f6f33dc98ec89c8da99b82ea0bd"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -2386,7 +2385,7 @@ checksum = "da33557140a288fae4e1d5f8873aaf9eb6613a9cf82c3e070223ff177f598b60"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.52",
+ "syn 2.0.55",
 ]

 [[package]]
@@ -2615,3 +2614,9 @@ dependencies = [
 "cfg-if 1.0.0",
 "windows-sys 0.48.0",
 ]
+
+[[package]]
+name = "winsafe"
+version = "0.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
--- a/komorebi-core/src/rect.rs
+++ b/komorebi-core/src/rect.rs
@@ -26,13 +26,29 @@ impl From<RECT> for Rect {
    }
 }

+impl From<Rect> for RECT {
+    fn from(rect: Rect) -> Self {
+        Self {
+            left: rect.left,
+            top: rect.top,
+            right: rect.right,
+            bottom: rect.bottom,
+        }
+    }
+}
+
 impl Rect {
    /// decrease the size of self by the padding amount.
-    pub fn add_padding(&mut self, padding: i32) {
-        self.left += padding;
-        self.top += padding;
-        self.right -= padding * 2;
-        self.bottom -= padding * 2;
+    pub fn add_padding<T>(&mut self, padding: T)
+    where
+        T: Into<Option<i32>>,
+    {
+        if let Some(padding) = padding.into() {
+            self.left += padding;
+            self.top += padding;
+            self.right -= padding * 2;
+            self.bottom -= padding * 2;
+        }
    }

    /// increase the size of self by the margin amount.
@@ -43,6 +59,14 @@ impl Rect {
        self.bottom += margin * 2;
    }

+    pub fn left_padding(&mut self, padding: i32) {
+        self.left += padding;
+    }
+
+    pub fn right_padding(&mut self, padding: i32) {
+        self.right -= padding;
+    }
+
    #[must_use]
    pub const fn contains_point(&self, point: (i32, i32)) -> bool {
        point.0 >= self.left
--- a/komorebi/src/container.rs
+++ b/komorebi/src/container.rs
@@ -7,13 +7,18 @@ use serde::Deserialize;
 use serde::Serialize;

 use crate::ring::Ring;
+use crate::stackbar::Stackbar;
 use crate::window::Window;
+use crate::StackbarMode;
+use crate::STACKBAR_MODE;

 #[derive(Debug, Clone, Serialize, Deserialize, Getters, JsonSchema)]
 pub struct Container {
    #[getset(get = "pub")]
    id: String,
    windows: Ring<Window>,
+    #[getset(get = "pub", get_mut = "pub")]
+    stackbar: Option<Stackbar>,
 }

 impl_ring_elements!(Container, Window);
@@ -23,6 +28,10 @@ impl Default for Container {
        Self {
            id: nanoid!(),
            windows: Ring::default(),
+            stackbar: match *STACKBAR_MODE.lock() {
+                StackbarMode::Always => Stackbar::create().ok(),
+                StackbarMode::Never | StackbarMode::OnStack => None,
+            },
        }
    }
 }
@@ -34,6 +43,38 @@ 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();
+
+            if !should_hide {
+                if let Some(omit) = omit {
+                    if omit != window.hwnd {
+                        should_hide = true
+                    }
+                }
+            }
+
+            if should_hide {
+                window.hide();
+            }
+        }
+    }
+
+    pub fn restore(&self) {
+        if let Some(stackbar) = self.stackbar() {
+            stackbar.restore();
+        }
+
+        if let Some(window) = self.focused_window() {
+            window.restore();
+        }
+    }
+
    pub fn load_focused_window(&mut self) {
        let focused_idx = self.focused_window_idx();
        for (i, window) in self.windows_mut().iter_mut().enumerate() {
@@ -81,6 +122,10 @@ 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.lock(), StackbarMode::OnStack) && self.windows().len() <= 1 {
+            self.stackbar = None;
+        }
+
        if idx != 0 {
            self.focus_window(idx - 1);
        };
@@ -95,6 +140,14 @@ impl Container {

    pub fn add_window(&mut self, window: Window) {
        self.windows_mut().push_back(window);
+
+        if matches!(*STACKBAR_MODE.lock(), StackbarMode::OnStack)
+            && self.windows().len() > 1
+            && self.stackbar.is_none()
+        {
+            self.stackbar = Stackbar::create().ok();
+        }
+
        self.focus_window(self.windows().len() - 1);
    }

--- a/komorebi/src/lib.rs
+++ b/komorebi/src/lib.rs
@@ -10,6 +10,7 @@ pub mod process_command;
 pub mod process_event;
 pub mod process_movement;
 pub mod set_window_position;
+pub mod stackbar;
 pub mod static_config;
 pub mod styles;
 pub mod window;
@@ -23,6 +24,7 @@ pub mod workspace;

 use lazy_static::lazy_static;
 use std::collections::HashMap;
+use std::collections::VecDeque;
 use std::fs::File;
 use std::io::Write;
 use std::net::TcpStream;
@@ -38,6 +40,7 @@ use std::sync::Arc;
 pub use hidden::*;
 pub use process_command::*;
 pub use process_event::*;
+pub use stackbar::*;
 pub use static_config::*;
 pub use window_manager::*;
 pub use window_manager_event::*;
@@ -191,6 +194,9 @@ lazy_static! {
        )
    };

+    static ref ACTIVE_WINDOW_BORDER_STYLE: Arc<Mutex<ActiveWindowBorderStyle>> =
+        Arc::new(Mutex::new(ActiveWindowBorderStyle::System));
+
    static ref BORDER_RECT: Arc<Mutex<Rect>> =
        Arc::new(Mutex::new(Rect::default()));

@@ -198,6 +204,11 @@ lazy_static! {
    // Use app-specific titlebar removal options where possible
    // eg. Windows Terminal, IntelliJ IDEA, Firefox
    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
+
+    static ref STACKBAR_MODE: Arc<Mutex<StackbarMode >> = Arc::new(Mutex::new(StackbarMode::Never));
+    static ref WINDOWS_BY_BAR_HWNDS: Arc<Mutex<HashMap<isize, VecDeque<isize>>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+
 }

 pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
@@ -222,6 +233,12 @@ pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);

 pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);

+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);
+
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
--- a/komorebi/src/monitor.rs
+++ b/komorebi/src/monitor.rs
@@ -71,7 +71,7 @@ impl Monitor {
            if i == focused_idx {
                workspace.restore(mouse_follows_focus)?;
            } else {
-                workspace.hide();
+                workspace.hide(None);
            }
        }

--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -217,6 +217,7 @@ impl WindowManager {
            SocketMessage::UnstackWindow => self.remove_window_from_container()?,
            SocketMessage::CycleStack(direction) => {
                self.cycle_container_window_in_direction(direction)?;
+                self.focused_window()?.focus(self.mouse_follows_focus)?;
            }
            SocketMessage::ForceFocus => {
                let focused_window = self.focused_window()?;
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -518,6 +518,9 @@ impl WindowManager {
                    }
                }
            }
+            WindowManagerEvent::ForceUpdate(_) => {
+                self.update_focused_workspace(false)?;
+            }
            WindowManagerEvent::DisplayChange(..)
            | WindowManagerEvent::MouseCapture(..)
            | WindowManagerEvent::Cloak(..)
--- a/komorebi/src/stackbar.rs
+++ b/komorebi/src/stackbar.rs
@@ -0,0 +1,294 @@
+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::winevent::WinEvent;
+use crate::winevent_listener;
+use crate::WindowManagerEvent;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
+use crate::TRANSPARENCY_COLOUR;
+use crate::WINDOWS_BY_BAR_HWNDS;
+
+#[derive(Debug, Default, Serialize, Deserialize, JsonSchema)]
+pub struct Stackbar {
+    pub(crate) hwnd: isize,
+    #[serde(skip)]
+    pub is_cloned: bool,
+}
+
+impl Drop for Stackbar {
+    fn drop(&mut self) {
+        if !self.is_cloned {
+            let _ = WindowsApi::close_window(self.hwnd());
+        }
+    }
+}
+
+impl Clone for Stackbar {
+    fn clone(&self) -> Self {
+        Self {
+            hwnd: self.hwnd,
+            is_cloned: true,
+        }
+    }
+}
+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 };
+                            let event_sender = winevent_listener::event_tx();
+                            let _ = event_sender.send(WindowManagerEvent::FocusChange(
+                                WinEvent::ObjectFocus,
+                                window,
+                            ));
+                            let _ = event_sender.send(WindowManagerEvent::ForceUpdate(window));
+                        }
+                    }
+                }
+
+                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(TRANSPARENCY_COLOUR),
+            ..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(TRANSPARENCY_COLOUR), 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,
+            ..Default::default()
+        })
+    }
+
+    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));
+
+                    window.focus(false)?;
+                } 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 exe = window.exe()?;
+                let exe_trimmed = exe.trim_end_matches(".exe");
+                let mut tab_title: Vec<u16> = exe_trimmed.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)
+    }
+}
--- a/komorebi/src/static_config.rs
+++ b/komorebi/src/static_config.rs
@@ -7,6 +7,7 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
+use crate::ACTIVE_WINDOW_BORDER_STYLE;
 use crate::BORDER_COLOUR_CURRENT;
 use crate::BORDER_COLOUR_MONOCLE;
 use crate::BORDER_COLOUR_SINGLE;
@@ -27,6 +28,12 @@ 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_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;

@@ -76,6 +83,17 @@ pub struct ActiveWindowBorderColours {
    pub monocle: Colour,
 }

+#[derive(Default, Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub enum ActiveWindowBorderStyle {
+    #[default]
+    /// Use the system border style
+    System,
+    /// Use the Windows 11-style rounded borders
+    Rounded,
+    /// Use the Windows 10-style square borders
+    Square,
+}
+
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct WorkspaceConfig {
    /// Name
@@ -254,6 +272,9 @@ pub struct StaticConfig {
    /// Active window border colours for different container types
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_window_border_colours: Option<ActiveWindowBorderColours>,
+    /// Active window border style (default: System)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border_style: Option<ActiveWindowBorderStyle>,
    /// Global default workspace padding (default: 10)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_workspace_padding: Option<i32>,
@@ -293,6 +314,30 @@ pub struct StaticConfig {
    /// Set display index preferences
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_index_preferences: Option<HashMap<usize, String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stackbar: Option<StackbarConfig>,
+}
+
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+pub enum StackbarMode {
+    Always,
+    Never,
+    OnStack,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct TabsConfig {
+    width: Option<i32>,
+    focused_text: Option<Colour>,
+    unfocused_text: Option<Colour>,
+    background: Option<Colour>,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct StackbarConfig {
+    height: Option<i32>,
+    mode: Option<StackbarMode>,
+    tabs: Option<TabsConfig>,
 }

 impl From<&WindowManager> for StaticConfig {
@@ -381,6 +426,7 @@ impl From<&WindowManager> for StaticConfig {
            border_offset: Option::from(BORDER_OFFSET.load(Ordering::SeqCst)),
            active_window_border: Option::from(BORDER_ENABLED.load(Ordering::SeqCst)),
            active_window_border_colours: border_colours,
+            active_window_border_style: Option::from(*ACTIVE_WINDOW_BORDER_STYLE.lock()),
            default_workspace_padding: Option::from(
                DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
            ),
@@ -398,6 +444,7 @@ impl From<&WindowManager> for StaticConfig {
            object_name_change_applications: None,
            monitor_index_preferences: Option::from(MONITOR_INDEX_PREFERENCES.lock().clone()),
            display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.lock().clone()),
+            stackbar: None,
        }
    }
 }
@@ -446,6 +493,9 @@ impl StaticConfig {
            BORDER_COLOUR_MONOCLE.store(u32::from(colours.monocle), Ordering::SeqCst);
        }

+        let active_window_border_style = self.active_window_border_style.unwrap_or_default();
+        *ACTIVE_WINDOW_BORDER_STYLE.lock() = active_window_border_style;
+
        let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
        let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
        let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
@@ -490,6 +540,33 @@ impl StaticConfig {
            )?;
        }

+        if let Some(stackbar) = &self.stackbar {
+            if let Some(height) = &stackbar.height {
+                STACKBAR_TAB_HEIGHT.store(*height, Ordering::SeqCst);
+            }
+            if let Some(mode) = &stackbar.mode {
+                let mut stackbar_mode = STACKBAR_MODE.lock();
+                *stackbar_mode = *mode;
+            }
+            if let Some(tabs) = &stackbar.tabs {
+                if let Some(background) = &tabs.background {
+                    STACKBAR_TAB_BACKGROUND_COLOUR.store((*background).into(), Ordering::SeqCst);
+                }
+
+                if let Some(colour) = &tabs.focused_text {
+                    STACKBAR_FOCUSED_TEXT_COLOUR.store((*colour).into(), Ordering::SeqCst);
+                }
+
+                if let Some(colour) = &tabs.unfocused_text {
+                    STACKBAR_UNFOCUSED_TEXT_COLOUR.store((*colour).into(), Ordering::SeqCst);
+                }
+
+                if let Some(width) = &tabs.width {
+                    STACKBAR_TAB_WIDTH.store(*width, Ordering::SeqCst);
+                }
+            }
+        }
+
        if let Some(path) = &self.app_specific_configuration_path {
            let path = resolve_home_path(path)?;
            let content = std::fs::read_to_string(path)?;
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
@@ -841,16 +841,16 @@ impl WindowManager {
        if !follow_focus && self.focused_container_mut().is_ok() {
            // and we have a stack with >1 windows
            if self.focused_container_mut()?.windows().len() > 1
-            // and we don't have a maxed window 
-            && self.focused_workspace()?.maximized_window().is_none()
-            // and we don't have a monocle container
-            && self.focused_workspace()?.monocle_container().is_none()
+                // and we don't have a maxed window 
+                && self.focused_workspace()?.maximized_window().is_none()
+                // and we don't have a monocle container
+                && self.focused_workspace()?.monocle_container().is_none()
            {
                if let Ok(window) = self.focused_window_mut() {
                    window.focus(self.mouse_follows_focus)?;
                }
            }
-        };
+        }

        // This is to correctly restore and focus when switching to a workspace which
        // contains a managed maximized window
@@ -1197,7 +1197,21 @@ impl WindowManager {
            }
        }

-        self.focused_window_mut()?.focus(self.mouse_follows_focus)?;
+        // 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
+        let 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)?;
+        }

        Ok(())
    }
--- a/komorebi/src/window_manager_event.rs
+++ b/komorebi/src/window_manager_event.rs
@@ -28,6 +28,7 @@ pub enum WindowManagerEvent {
    Unmanage(Window),
    Raise(Window),
    DisplayChange(Window),
+    ForceUpdate(Window),
 }

 impl Display for WindowManagerEvent {
@@ -78,6 +79,9 @@ impl Display for WindowManagerEvent {
            Self::DisplayChange(window) => {
                write!(f, "DisplayChange (Window: {window})")
            }
+            Self::ForceUpdate(window) => {
+                write!(f, "ForceUpdate (Window: {window})")
+            }
        }
    }
 }
@@ -98,7 +102,8 @@ impl WindowManagerEvent {
            | Self::Raise(window)
            | Self::Manage(window)
            | Self::DisplayChange(window)
-            | Self::Unmanage(window) => window,
+            | Self::Unmanage(window)
+            | Self::ForceUpdate(window) => window,
        }
    }

--- a/komorebi/src/windows_api.rs
+++ b/komorebi/src/windows_api.rs
@@ -36,6 +36,8 @@ use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
+use windows::Win32::Graphics::Gdi::Rectangle;
+use windows::Win32::Graphics::Gdi::RoundRect;
 use windows::Win32::Graphics::Gdi::DISPLAY_DEVICEW;
 use windows::Win32::Graphics::Gdi::HBRUSH;
 use windows::Win32::Graphics::Gdi::HDC;
@@ -66,6 +68,7 @@ use windows::Win32::UI::Input::KeyboardAndMouse::INPUT_MOUSE;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEEVENTF_LEFTDOWN;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEEVENTF_LEFTUP;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEINPUT;
+use windows::Win32::UI::Input::KeyboardAndMouse::VK_LBUTTON;
 use windows::Win32::UI::Input::KeyboardAndMouse::VK_MENU;
 use windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
 use windows::Win32::UI::WindowsAndMessaging::BringWindowToTop;
@@ -418,7 +421,7 @@ impl WindowsApi {
        .process()
    }

-    fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
+    pub fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
        // BOOL is returned but does not signify whether or not the operation was succesful
        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow
        unsafe { ShowWindow(hwnd, command) };
@@ -527,6 +530,24 @@ impl WindowsApi {
        })
    }

+    pub fn round_rect(hdc: HDC, rect: &Rect, border_radius: i32) {
+        unsafe {
+            RoundRect(
+                hdc,
+                rect.left,
+                rect.top,
+                rect.right,
+                rect.bottom,
+                border_radius,
+                border_radius,
+            );
+        }
+    }
+    pub fn rectangle(hdc: HDC, rect: &Rect) {
+        unsafe {
+            Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
+        }
+    }
    fn set_cursor_pos(x: i32, y: i32) -> Result<()> {
        unsafe { SetCursorPos(x, y) }.process()
    }
@@ -964,6 +985,13 @@ impl WindowsApi {
        actual != 0
    }

+    pub fn lbutton_is_pressed() -> bool {
+        let state = unsafe { GetKeyState(i32::from(VK_LBUTTON.0)) };
+        #[allow(clippy::cast_sign_loss)]
+        let actual = (state as u16) & 0x8000;
+        actual != 0
+    }
+
    pub fn left_click() -> u32 {
        let inputs = [
            INPUT {
--- a/komorebi/src/windows_callbacks.rs
+++ b/komorebi/src/windows_callbacks.rs
@@ -41,6 +41,8 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::winevent_listener;
+use crate::ActiveWindowBorderStyle;
+use crate::ACTIVE_WINDOW_BORDER_STYLE;
 use crate::BORDER_COLOUR_CURRENT;
 use crate::BORDER_RECT;
 use crate::BORDER_WIDTH;
@@ -232,10 +234,20 @@ pub extern "system" fn border_window(
                // the window was made with DWMWCP_ROUNDSMALL then this is the
                // wrong size.  In the future we should read the DWM properties
                // of windows and attempt to match appropriately.
-                if *WINDOWS_11 {
-                    RoundRect(hdc, 0, 0, border_rect.right, border_rect.bottom, 20, 20);
-                } else {
-                    Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
+                match *ACTIVE_WINDOW_BORDER_STYLE.lock() {
+                    ActiveWindowBorderStyle::System => {
+                        if *WINDOWS_11 {
+                            RoundRect(hdc, 0, 0, border_rect.right, border_rect.bottom, 20, 20);
+                        } else {
+                            Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
+                        }
+                    }
+                    ActiveWindowBorderStyle::Rounded => {
+                        RoundRect(hdc, 0, 0, border_rect.right, border_rect.bottom, 20, 20);
+                    }
+                    ActiveWindowBorderStyle::Square => {
+                        Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
+                    }
                }
                EndPaint(window, &ps);
                ValidateRect(window, None);
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -33,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(
@@ -143,55 +144,66 @@ impl Workspace {
        Ok(())
    }

-    pub fn hide(&mut self) {
-        for container in self.containers_mut() {
-            for window in container.windows_mut() {
+    pub fn hide(&mut self, omit: Option<isize>) {
+        for window in self.floating_windows_mut().iter_mut().rev() {
+            let mut should_hide = omit.is_none();
+
+            if !should_hide {
+                if let Some(omit) = omit {
+                    if omit != window.hwnd {
+                        should_hide = true
+                    }
+                }
+            }
+
+            if should_hide {
                window.hide();
            }
        }

+        for container in self.containers_mut() {
+            container.hide(omit)
+        }
+
        if let Some(window) = self.maximized_window() {
            window.hide();
        }

        if let Some(container) = self.monocle_container_mut() {
-            for window in container.windows_mut() {
-                window.hide();
-            }
-        }
-
-        for window in self.floating_windows() {
-            window.hide();
+            container.hide(omit)
        }
    }

    pub fn restore(&mut self, mouse_follows_focus: bool) -> Result<()> {
        let idx = self.focused_container_idx();
        let mut to_focus = None;
+
        for (i, container) in self.containers_mut().iter_mut().enumerate() {
            if let Some(window) = container.focused_window_mut() {
-                window.restore();
-
                if idx == i {
                    to_focus = Option::from(*window);
                }
            }
+
+            container.restore();
        }

-        if let Some(window) = self.maximized_window() {
-            window.maximize();
+        for container in self.containers_mut() {
+            container.restore();
        }

        if let Some(container) = self.monocle_container_mut() {
-            for window in container.windows_mut() {
-                window.restore();
-            }
+            container.restore();
        }

        for window in self.floating_windows() {
            window.restore();
        }

+        if let Some(container) = self.focused_container_mut() {
+            container.focus_window(container.focused_window_idx());
+        }
+
        // Do this here to make sure that an error doesn't stop the restoration of other windows
        // Maximised windows should always be drawn at the top of the Z order
        if let Some(window) = to_focus {
@@ -276,9 +288,23 @@ impl Workspace {
                let should_remove_titlebars = REMOVE_TITLEBARS.load(Ordering::SeqCst);
                let no_titlebar = NO_TITLEBAR.lock().clone();

-                let windows = self.visible_windows_mut();
-                for (i, window) in windows.into_iter().enumerate() {
-                    if let (Some(window), Some(layout)) = (window, layouts.get(i)) {
+                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 container_windows = container.windows().clone();
+                    let container_topbar = container.stackbar().clone();
+
+                    if let (Some(window), Some(layout)) =
+                        (container.focused_window_mut(), layouts.get(i))
+                    {
                        if should_remove_titlebars && no_titlebar.contains(&window.exe()?) {
                            window.remove_title_bar()?;
                        } else if no_titlebar.contains(&window.exe()?) {
@@ -300,6 +326,20 @@ impl Workspace {
                            rect.add_padding(width);
                        }

+                        if let Some(stackbar) = container_topbar {
+                            stackbar.set_position(
+                                &stackbar.get_position_from_container_layout(layout),
+                                false,
+                            )?;
+
+                            stackbar.update(&container_windows, focused_hwnd)?;
+                            let tab_height = STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst);
+                            let total_height = tab_height + container_padding;
+
+                            rect.top += total_height;
+                            rect.bottom -= total_height;
+                        }
+
                        window.set_position(&rect, false)?;
                    }
                }
@@ -375,7 +415,18 @@ impl Workspace {
            .idx_for_window(hwnd)
            .ok_or_else(|| anyhow!("there is no window"))?;

+        let mut should_load = false;
+
+        if container.focused_window_idx() != window_idx {
+            should_load = true
+        }
+
        container.focus_window(window_idx);
+
+        if should_load {
+            container.load_focused_window();
+        }
+
        self.focus_container(container_idx);

        Ok(())
--- a/komorebic/Cargo.toml
+++ b/komorebic/Cargo.toml
@@ -19,7 +19,7 @@ color-eyre = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 fs-tail = "0.1"
-heck = "0.4"
+heck = "0.5"
 lazy_static = "1"
 miette = { version = "7", features = ["fancy"] }
 paste = "1"
--- a/komorebic/src/main.rs
+++ b/komorebic/src/main.rs
@@ -1871,6 +1871,13 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                    }
                }
            }
+
+            println!("\nThank you for using komorebi!\n");
+            println!("* Become a sponsor https://github.com/sponsors/LGUG2Z - Even $1/month makes a big difference");
+            println!(
+                "* Subscribe to https://youtube.com/@LGUG2Z - Live dev videos and feature previews"
+            );
+            println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
        }
        SubCommand::Stop(arg) => {
            if arg.whkd {
Author	SHA1	Message	Date
LGUG2Z	2995891dcc	feat(config): add active window border style opt	2024-03-26 16:28:57 -07:00
LGUG2Z	79fb098d04	docs(cli): add support + community links to start cmd	2024-03-25 17:55:28 -07:00
dependabot[bot]	d0bab4280a	chore(deps): bump heck from 0.4.1 to 0.5.0 Bumps [heck](https://github.com/withoutboats/heck) from 0.4.1 to 0.5.0. - [Changelog](https://github.com/withoutboats/heck/blob/master/CHANGELOG.md) - [Commits](https://github.com/withoutboats/heck/commits) --- updated-dependencies: - dependency-name: heck dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>	2024-03-25 17:27:02 -07:00
dependabot[bot]	e616004da7	chore(deps): bump serde_yaml from 0.9.33 to 0.9.34+deprecated Bumps [serde_yaml](https://github.com/dtolnay/serde-yaml) from 0.9.33 to 0.9.34+deprecated. - [Release notes](https://github.com/dtolnay/serde-yaml/releases) - [Commits](https://github.com/dtolnay/serde-yaml/compare/0.9.33...0.9.34) --- updated-dependencies: - dependency-name: serde_yaml dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-03-25 17:26:43 -07:00
LGUG2Z	c65060fbd9	feat(wm): add stackbar for multi-window containers This commit introduces the stackbar feature through careful extracting and refactoring of code from the Komorebi-UI hard-fork. Unfortunately on the fork, this feature was not implemented using atomic commits, which resulted in the implementation here being more of a "reinterpretation" than a lift-and-shit of the referenced code. Nevertheless, this commit represents a working version of the stackbar feature. resolve #681	2024-03-25 14:30:30 -07:00
dependabot[bot]	50a851a660	chore(deps): bump which from 6.0.0 to 6.0.1 Bumps [which](https://github.com/harryfei/which-rs) from 6.0.0 to 6.0.1. - [Release notes](https://github.com/harryfei/which-rs/releases) - [Changelog](https://github.com/harryfei/which-rs/blob/master/CHANGELOG.md) - [Commits](https://github.com/harryfei/which-rs/compare/6.0.0...6.0.1) --- updated-dependencies: - dependency-name: which dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-03-25 11:20:18 -07:00
dependabot[bot]	8ad6f4be1f	chore(deps): bump regex from 1.10.3 to 1.10.4 Bumps [regex](https://github.com/rust-lang/regex) from 1.10.3 to 1.10.4. - [Release notes](https://github.com/rust-lang/regex/releases) - [Changelog](https://github.com/rust-lang/regex/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-lang/regex/compare/1.10.3...1.10.4) --- updated-dependencies: - dependency-name: regex dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-03-25 11:19:46 -07:00