chore(release): v0.1.27

This commit ensures that message handling threads for windows that are
created by komorebi are exited properly when the windows are destroyed.

For some reason, passing the HWND returned by CreateWindowExW to
GetMessageW continues returning TRUE even after the window has been
destroyed.

If HWND::NULL (via the Default trait) is passed to GetMessageW, which
retrieves messages for any window belonging to the current thread (our
threads here only own a single window), GetMessageW returns FALSE as
expected after the window is destroyed.

re #862

.github/workflows/windows.yaml

@@ -93,9 +93,10 @@ jobs:
             target/${{ matrix.target }}/release/komorebi.exe
             target/${{ matrix.target }}/release/komorebic.exe
             target/${{ matrix.target }}/release/komorebic-no-console.exe
+            target/${{ matrix.target }}/release/komorebi-gui.exe
             target/${{ matrix.target }}/release/komorebi.pdb
             target/${{ matrix.target }}/release/komorebic.pdb
-            target/${{ matrix.target }}/release/komorebic-no-console.pdb
+            target/${{ matrix.target }}/release/komorebi-gui.pdb
             target/wix/komorebi-*.msi
           retention-days: 7
       - name: Check GoReleaser

.gitignore

@@ -3,5 +3,4 @@
 /target
 CHANGELOG.md
 dummy.go
-komorebi.ahk
-komorebic/applications.yaml
+komorebic/applications.yaml

.goreleaser.yml

@@ -35,6 +35,15 @@ builds:
       post:
         - mkdir -p dist/windows_amd64
         - cp ".\target\x86_64-pc-windows-msvc\release\komorebic-no-console.exe" ".\dist\komorebic-no-console_windows_amd64_v1\komorebic-no-console.exe"
+  - id: komorebi-gui
+    main: dummy.go
+    goos: [ "windows" ]
+    goarch: [ "amd64" ]
+    binary: komorebi-gui
+    hooks:
+      post:
+        - mkdir -p dist/windows_amd64
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi-gui.exe" ".\dist\komorebi-gui_windows_amd64_v1\komorebi-gui.exe"
 
 archives:
   - name_template: "{{ .ProjectName }}-{{ .Version }}-x86_64-pc-windows-msvc"

Cargo.toml

@@ -2,24 +2,25 @@
 
 resolver = "2"
 members = [
-    "derive-ahk",
     "komorebi",
     "komorebi-client",
     "komorebi-core",
+    "komorebi-gui",
     "komorebic",
     "komorebic-no-console",
 ]
 
 [workspace.dependencies]
-windows-interface = { version = "0.53" }
-windows-implement = { version = "0.53" }
-dunce = "1"
-dirs = "5"
 color-eyre = "0.6"
-serde_json = { package = "serde_json_lenient", version = "0.1" }
-sysinfo = "0.30"
+dirs = "5"
+dunce = "1"
 serde = { version = "1", features = ["derive"] }
+serde_json = { package = "serde_json_lenient", version = "0.2" }
+sysinfo = "0.30"
 uds_windows = "1"
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "2a0f7166da154880a1750b91829b1186d9c6a00c" }
+windows-implement = { version = "0.53" }
+windows-interface = { version = "0.53" }
 
 [workspace.dependencies.windows]
 version = "0.54"

derive-ahk/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "derive-ahk"
-version = "0.1.1"
-edition = "2021"
-
-[lib]
-proc-macro = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-proc-macro2 = "1.0"
-syn = "1.0"
-quote = "1.0"

derive-ahk/src/lib.rs

@@ -1,225 +0,0 @@
-#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc)]
-#![no_implicit_prelude]
-
-use ::std::clone::Clone;
-use ::std::convert::From;
-use ::std::convert::Into;
-use ::std::format;
-use ::std::iter::Extend;
-use ::std::iter::Iterator;
-use ::std::matches;
-use ::std::option::Option::Some;
-use ::std::string::String;
-use ::std::string::ToString;
-use ::std::unreachable;
-use ::std::vec::Vec;
-
-use ::quote::quote;
-use ::syn::parse_macro_input;
-use ::syn::Data;
-use ::syn::DataEnum;
-use ::syn::DeriveInput;
-use ::syn::Fields;
-use ::syn::FieldsNamed;
-use ::syn::FieldsUnnamed;
-use ::syn::Meta;
-use ::syn::NestedMeta;
-
-#[allow(clippy::too_many_lines)]
-#[proc_macro_derive(AhkFunction)]
-pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    let name = input.ident;
-
-    match input.data {
-        Data::Struct(s) => match s.fields {
-            Fields::Named(FieldsNamed { named, .. }) => {
-                let argument_idents = named
-                    .iter()
-                    // Filter out the flags
-                    .filter(|&f| {
-                        let mut include = true;
-                        for attribute in &f.attrs {
-                            if let ::std::result::Result::Ok(Meta::List(list)) =
-                                attribute.parse_meta()
-                            {
-                                for nested in list.nested {
-                                    if let NestedMeta::Meta(Meta::Path(path)) = nested {
-                                        if path.is_ident("long") {
-                                            include = false;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        include
-                    })
-                    .map(|f| &f.ident);
-
-                let argument_idents_clone = argument_idents.clone();
-
-                let called_arguments = quote! {#(%#argument_idents_clone%) *}
-                    .to_string()
-                    .replace(" %", "%")
-                    .replace("% ", "%")
-                    .replace("%%", "% %");
-
-                let flag_idents = named
-                    .iter()
-                    // Filter only the flags
-                    .filter(|f| {
-                        let mut include = false;
-
-                        for attribute in &f.attrs {
-                            if let ::std::result::Result::Ok(Meta::List(list)) =
-                                attribute.parse_meta()
-                            {
-                                for nested in list.nested {
-                                    if let NestedMeta::Meta(Meta::Path(path)) = nested {
-                                        // Identify them using the --long flag name
-                                        if path.is_ident("long") {
-                                            include = true;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        include
-                    })
-                    .map(|f| &f.ident);
-
-                let has_flags = flag_idents.clone().count() != 0;
-
-                if has_flags {
-                    let flag_idents_concat = flag_idents.clone();
-                    let argument_idents_concat = argument_idents.clone();
-
-                    // Concat the args and flag args if there are flags
-                    let all_arguments =
-                        quote! {#(#argument_idents_concat,) * #(#flag_idents_concat), *}
-                            .to_string();
-
-                    let flag_idents_clone = flag_idents.clone();
-                    let flags = quote! {#(--#flag_idents_clone) *}
-                        .to_string()
-                        .replace("- - ", "--")
-                        .replace('_', "-");
-
-                    let called_flag_arguments = quote! {#(%#flag_idents%) *}
-                        .to_string()
-                        .replace(" %", "%")
-                        .replace("% ", "%")
-                        .replace("%%", "% %");
-
-                    let flags_split: Vec<_> = flags.split(' ').collect();
-                    let flag_args_split: Vec<_> = called_flag_arguments.split(' ').collect();
-                    let mut consolidated_flags: Vec<String> = Vec::new();
-
-                    for (idx, flag) in flags_split.iter().enumerate() {
-                        consolidated_flags.push(format!("{} {}", flag, flag_args_split[idx]));
-                    }
-
-                    let all_flags = consolidated_flags.join(" ");
-
-                    quote! {
-                        impl AhkFunction for #name {
-                            fn generate_ahk_function() -> String {
-                                ::std::format!(r#"
-{}({}) {{
-    RunWait, komorebic.exe {} {} {}, , Hide
-}}"#,
-                                    ::std::stringify!(#name),
-                                    #all_arguments,
-                                    ::std::stringify!(#name).to_kebab_case(),
-                                    #called_arguments,
-                                    #all_flags,
-                                )
-                           }
-                        }
-                    }
-                } else {
-                    let arguments = quote! {#(#argument_idents), *}.to_string();
-
-                    quote! {
-                        impl AhkFunction for #name {
-                            fn generate_ahk_function() -> String {
-                                ::std::format!(r#"
-{}({}) {{
-    RunWait, komorebic.exe {} {}, , Hide
-}}"#, 
-                                    ::std::stringify!(#name),
-                                    #arguments,
-                                    ::std::stringify!(#name).to_kebab_case(),
-                                    #called_arguments
-                                )
-                           }
-                        }
-                    }
-                }
-            }
-            _ => unreachable!("only to be used on structs with named fields"),
-        },
-        _ => unreachable!("only to be used on structs"),
-    }
-    .into()
-}
-
-#[proc_macro_derive(AhkLibrary)]
-pub fn ahk_library(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    let name = input.ident;
-
-    match input.data {
-        Data::Enum(DataEnum { variants, .. }) => {
-            let enums = variants.iter().filter(|&v| {
-                matches!(v.fields, Fields::Unit) || matches!(v.fields, Fields::Unnamed(..))
-            });
-
-            let mut stream = ::proc_macro2::TokenStream::new();
-
-            for variant in enums.clone() {
-                match &variant.fields {
-                    Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
-                        for field in unnamed {
-                            stream.extend(quote! {
-                                v.push(#field::generate_ahk_function());
-                            });
-                        }
-                    }
-                    Fields::Unit => {
-                        let name = &variant.ident;
-                        stream.extend(quote! {
-                            v.push(::std::format!(r#"
-{}() {{
-    RunWait, komorebic.exe {}, , Hide
-}}"#, 
-                                ::std::stringify!(#name),
-                                ::std::stringify!(#name).to_kebab_case()
-                            ));
-                        });
-                    }
-                    Fields::Named(_) => {
-                        unreachable!("only to be used with unnamed and unit fields");
-                    }
-                }
-            }
-
-            quote! {
-                impl #name {
-                    fn generate_ahk_library() -> String {
-                        let mut v: Vec<String> = vec![String::from("; Generated by komorebic.exe")];
-
-                        #stream
-
-                        v.join("\n")
-                    }
-               }
-            }
-        }
-        _ => unreachable!("only to be used on enums"),
-    }
-    .into()
-}

docs/cli/ahk-library.md

@@ -3,7 +3,7 @@
 ```
 Generate a library of AutoHotKey helper functions
 
-Usage: komorebic.exe ahk-library
+Usage: komorebic.exe komorebic.exe ahk-library
 
 Options:
   -h, --help

docs/cli/cycle-move-workspace-to-monitor.md

@@ -0,0 +1,16 @@
+# cycle-move-workspace-to-monitor
+
+```
+Move the focused workspace monitor in the given cycle direction
+
+Usage: komorebic.exe cycle-move-workspace-to-monitor <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/gui.md

@@ -0,0 +1,12 @@
+# gui
+
+```
+Launch the komorebi-gui debugging tool
+
+Usage: komorebic.exe gui
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/monitor-information.md

@@ -0,0 +1,12 @@
+# monitor-information
+
+```
+Show information about connected monitors
+
+Usage: komorebic.exe monitor-information
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/promote-window.md

@@ -0,0 +1,16 @@
+# promote-window
+
+```
+Promote the window in the specified direction
+
+Usage: komorebic.exe promote-window <OPERATION_DIRECTION>
+
+Arguments:
+  <OPERATION_DIRECTION>
+          [possible values: left, right, up, down]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/stack-all.md

@@ -0,0 +1,12 @@
+# stack-all
+
+```
+Stack all windows on the focused workspace
+
+Usage: komorebic.exe stack-all
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/transparency-alpha.md

@@ -0,0 +1,16 @@
+# transparency-alpha
+
+```
+Set the alpha value for unfocused window transparency
+
+Usage: komorebic.exe transparency-alpha <ALPHA>
+
+Arguments:
+  <ALPHA>
+          Alpha
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/transparency.md

@@ -0,0 +1,16 @@
+# transparency
+
+```
+Enable or disable transparency for unfocused windows
+
+Usage: komorebic.exe transparency <BOOLEAN_STATE>
+
+Arguments:
+  <BOOLEAN_STATE>
+          [possible values: enable, disable]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/unstack-all.md

@@ -0,0 +1,12 @@
+# unstack-all
+
+```
+Unstack all windows in the focused container
+
+Usage: komorebic.exe unstack-all
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/common-workflows/autohotkey.md

@@ -1,4 +1,4 @@
-# AutoHotKey
+# AutoHotkey
 
 If you would like to use Autohotkey, please make sure you have AutoHotKey v2
 installed.
@@ -10,8 +10,8 @@ able to craft their own configuration files.
 If you would like to try out AHK, here is a simple sample configuration which
 largely matches the `whkdrc` sample configuration.
 
-```
-{% include "../komorebi.ahk" %}
+```autohotkey
+{% include "./komorebi.ahk.txt" %}
 ```
 
 By default, the `komorebi.ahk` file should be located in the `$Env:USERPROFILE`
@@ -19,4 +19,4 @@ directory, however, if `$Env:KOMOREBI_CONFIG_HOME` is set, it should be located
 there.
 
 Once the file is in place, you can stop komorebi and whkd by running `komorebic stop --whkd`,
-and then start komorebi with Autohotkey by running `komorebic start --ahk`.
+and then start komorebi with Autohotkey by running `komorebic start --ahk`.

docs/common-workflows/dynamic-layout-switching.md

@@ -1,4 +1,4 @@
-# Dynamically Layout Switching
+# Dynamic Layout Switching
 
 With `komorebi` it is possible to define rules to automatically change the
 layout on a specified workspace when a threshold of window containers is met.

docs/common-workflows/set-display-index.md

@@ -0,0 +1,17 @@
+# Setting a Given Display to a Specific Index
+
+If you would like `komorebi` to remember monitor index positions, you will need to set the `display_index_preferences`
+configuration option in the static configuration file.
+
+Display IDs can be found using `komorebic monitor-information`.
+
+Then, in `komorebi.json`, you simply need to specify the preferred index position for each display ID:
+
+```json
+{
+  "display_index_preferences": {
+    "0": "DEL4310-5&1a6c0954&0&UID209155",
+    "1": "<another-display_id>"
+  }
+}
+```

docs/installation.md

@@ -1,11 +1,11 @@
 # Getting started
 
-`komorebi` is a tiling window manager for Windows that is comprised comprised
-of two main binaries, `komorebi.exe`, which contains the window manager itself,
+`komorebi` is a tiling window manager for Windows that is comprised of two 
+main binaries, `komorebi.exe`, which contains the window manager itself,
 and `komorebic.exe`, which is the main way to send commands to the tiling
 window manager.
 
-It is important to note that neither `komorebi.exe` or `komorebic.exe` handle
+It is important to note that neither `komorebi.exe` nor `komorebic.exe` handle
 key bindings, because `komorebi` is a tiling window manager and not a hotkey
 daemon.
 
@@ -27,7 +27,7 @@ to manipulate the window manager, you use
 
 `komorebi` is available pre-built to install via
 [Scoop](https://scoop.sh/#/apps?q=komorebi) and
-[WinGet](https://winget.run/pkg/LGUG2Z/komorebi), and you may also built
+[WinGet](https://winget.run/pkg/LGUG2Z/komorebi), and you may also build
 it from [source](https://github.com/LGUG2Z/komorebi) if you would prefer.
 
 - [Scoop](#scoop)
@@ -37,7 +37,7 @@ it from [source](https://github.com/LGUG2Z/komorebi) if you would prefer.
 
 ## Long path support
 
-It highly recommended that you enable support for long paths in Windows by
+It is highly recommended that you enable support for long paths in Windows by
 running the following command in an Administrator Terminal before installing
 `komorebi`.
 
@@ -45,7 +45,7 @@ running the following command in an Administrator Terminal before installing
 Set-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem' -Name 'LongPathsEnabled' -Value 1
 ```
 
-## Disabling Unnecessary System Animations
+## Disabling unnecessary system animations
 
 It is highly recommended that you enable the "Turn off all unnecessary animations (when possible)" option in
 "Control Panel > Ease of Access > Ease of Access Centre / Make the computer easier to see" for the best performance with
@@ -114,6 +114,7 @@ Clone the git repository, enter the directory, and build the following binaries:
 cargo +stable install --path komorebi --locked
 cargo +stable install --path komorebic --locked
 cargo +stable install --path komorebic-no-console --locked
+cargo +stable install --path komorebi-gui --locked
 ```
 
 If the binaries have been built and added to your `$PATH` correctly, you should
@@ -127,3 +128,21 @@ an offline machine to install.
 
 Once installed, proceed to get the [example configurations](example-configurations.md) (none of the commands for
 first-time set up and running komorebi require an internet connection).
+
+## Uninstallation
+
+Before uninstalling, first run `komorebic stop --whkd` to make sure that both
+the `komorebi` and `whkd` processes have been stopped.
+
+Then, depending on whether you installed with Scoop or WinGet, run `scoop
+uninstall komorebi whkd` or `winget uninstall LGUG2Z.komorebi LGUG2Z.whkd`.
+
+Finally, you can run the following commands in a PowerShell prompt to clean up
+files created by the `quickstart` command and any other runtime files:
+
+```powershell
+rm $Env:USERPROFILE\komorebi.json
+rm $Env:USERPROFILE\applications.yaml
+rm $Env:USERPROFILE\.config\whkdrc
+rm -r -Force $Env:LOCALAPPDATA\komorebi
+```

docs/komorebi.ahk.txt

@@ -0,0 +1,71 @@
+#Requires AutoHotkey v2.0.2
+#SingleInstance Force
+
+Komorebic(cmd) {
+    RunWait(format("komorebic.exe {}", cmd), , "Hide")
+}
+
+!q::Komorebic("close")
+!m::Komorebic("minimize")
+
+; Focus windows
+!h::Komorebic("focus left")
+!j::Komorebic("focus down")
+!k::Komorebic("focus up")
+!l::Komorebic("focus right")
+
+!+[::Komorebic("cycle-focus previous")
+!+]::Komorebic("cycle-focus next")
+
+; Move windows
+!+h::Komorebic("move left")
+!+j::Komorebic("move down")
+!+k::Komorebic("move up")
+!+l::Komorebic("move right")
+
+; Stack windows
+!Left::Komorebic("stack left")
+!Down::Komorebic("stack down")
+!Up::Komorebic("stack up")
+!Right::Komorebic("stack right")
+!;::Komorebic("unstack")
+![::Komorebic("cycle-stack previous")
+!]::Komorebic("cycle-stack next")
+
+; Resize
+!=::Komorebic("resize-axis horizontal increase")
+!-::Komorebic("resize-axis horizontal decrease")
+!+=::Komorebic("resize-axis vertical increase")
+!+_::Komorebic("resize-axis vertical decrease")
+
+; Manipulate windows
+!t::Komorebic("toggle-float")
+!f::Komorebic("toggle-monocle")
+
+; Window manager options
+!+r::Komorebic("retile")
+!p::Komorebic("toggle-pause")
+
+; Layouts
+!x::Komorebic("flip-layout horizontal")
+!y::Komorebic("flip-layout vertical")
+
+; Workspaces
+!1::Komorebic("focus-workspace 0")
+!2::Komorebic("focus-workspace 1")
+!3::Komorebic("focus-workspace 2")
+!4::Komorebic("focus-workspace 3")
+!5::Komorebic("focus-workspace 4")
+!6::Komorebic("focus-workspace 5")
+!7::Komorebic("focus-workspace 6")
+!8::Komorebic("focus-workspace 7")
+
+; Move windows across workspaces
+!+1::Komorebic("move-to-workspace 0")
+!+2::Komorebic("move-to-workspace 1")
+!+3::Komorebic("move-to-workspace 2")
+!+4::Komorebic("move-to-workspace 3")
+!+5::Komorebic("move-to-workspace 4")
+!+6::Komorebic("move-to-workspace 5")
+!+7::Komorebic("move-to-workspace 6")
+!+8::Komorebic("move-to-workspace 7")

docs/release/v0-1-22.md

@@ -1,3 +1,5 @@
+# v0.1.22
+
 In addition to the [changelog](https://github.com/LGUG2Z/komorebi/releases/tag/v0.1.22) of new features and fixes,
 please note the following changes from `v0.1.21` to adjust your configuration files accordingly.
 
@@ -49,8 +51,8 @@ A 1px border is drawn around the window edge. Users may see a gap for a single p
 transparent edge - this is the windows themed edge, and is not present for all applications.
 
 ```json
-  {
+{
   "border_offset": 0,
   "border_width": 1
 }
-```
+```

komorebi-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-client"
-version = "0.1.26-dev.0"
+version = "0.1.27"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

komorebi-client/src/lib.rs

@@ -1,4 +1,4 @@
-#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![warn(clippy::all)]
 #![allow(clippy::missing_errors_doc)]
 
 pub use komorebi::colour::Colour;
@@ -29,6 +29,7 @@ pub use komorebi_core::Layout;
 pub use komorebi_core::OperationDirection;
 pub use komorebi_core::Rect;
 pub use komorebi_core::SocketMessage;
+pub use komorebi_core::StackbarLabel;
 pub use komorebi_core::StackbarMode;
 pub use komorebi_core::WindowKind;
 

komorebi-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.26-dev.0"
+version = "0.1.27"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

komorebi-core/src/arrangement.rs

@@ -604,7 +604,16 @@ impl Arrangement for CustomLayout {
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Clone,
+    Copy,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
 pub enum Axis {
     Horizontal,

komorebi-core/src/custom_layout.rs

@@ -14,7 +14,7 @@ use serde::Serialize;
 
 use crate::Rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct CustomLayout(Vec<Column>);
 
 impl Deref for CustomLayout {
@@ -250,7 +250,7 @@ impl CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(tag = "column", content = "configuration")]
 pub enum Column {
     Primary(Option<ColumnWidth>),
@@ -258,18 +258,18 @@ pub enum Column {
     Tertiary(ColumnSplit),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ColumnWidth {
     WidthPercentage(f32),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ColumnSplit {
     Horizontal,
     Vertical,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ColumnSplitWithCapacity {
     Horizontal(usize),
     Vertical(usize),

komorebi-core/src/direction.rs

@@ -90,9 +90,13 @@ impl Direction for DefaultLayout {
         idx: usize,
         count: usize,
     ) -> bool {
+        if count < 2 {
+            return false;
+        }
+
         match op_direction {
             OperationDirection::Up => match self {
-                Self::BSP => count > 2 && idx != 0 && idx != 1,
+                Self::BSP => idx != 0 && idx != 1,
                 Self::Columns => false,
                 Self::Rows | Self::HorizontalStack => idx != 0,
                 Self::VerticalStack | Self::RightMainVerticalStack => idx != 0 && idx != 1,
@@ -100,7 +104,7 @@ impl Direction for DefaultLayout {
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Down => match self {
-                Self::BSP => count > 2 && idx != count - 1 && idx % 2 != 0,
+                Self::BSP => idx != count - 1 && idx % 2 != 0,
                 Self::Columns => false,
                 Self::Rows => idx != count - 1,
                 Self::VerticalStack | Self::RightMainVerticalStack => idx != 0 && idx != count - 1,
@@ -109,23 +113,22 @@ impl Direction for DefaultLayout {
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Left => match self {
-                Self::BSP => count > 1 && idx != 0,
+                Self::BSP => idx != 0,
                 Self::Columns | Self::VerticalStack => idx != 0,
                 Self::RightMainVerticalStack => idx == 0,
                 Self::Rows => false,
                 Self::HorizontalStack => idx != 0 && idx != 1,
-                Self::UltrawideVerticalStack => count > 1 && idx != 1,
+                Self::UltrawideVerticalStack => idx != 1,
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Right => match self {
-                Self::BSP => count > 1 && idx % 2 == 0 && idx != count - 1,
+                Self::BSP => idx % 2 == 0 && idx != count - 1,
                 Self::Columns => idx != count - 1,
                 Self::Rows => false,
                 Self::VerticalStack => idx == 0,
                 Self::RightMainVerticalStack => idx != 0,
                 Self::HorizontalStack => idx != 0 && idx != count - 1,
                 Self::UltrawideVerticalStack => match count {
-                    0 | 1 => false,
                     2 => idx != 0,
                     _ => idx < 2,
                 },

komorebi-core/src/layout.rs

@@ -7,7 +7,7 @@ use crate::CustomLayout;
 use crate::DefaultLayout;
 use crate::Direction;
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum Layout {
     Default(DefaultLayout),
     Custom(CustomLayout),

komorebi-core/src/lib.rs

@@ -1,5 +1,5 @@
-#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc, clippy::use_self)]
+#![warn(clippy::all)]
+#![allow(clippy::missing_errors_doc, clippy::use_self, clippy::doc_markdown)]
 
 use std::path::Path;
 use std::path::PathBuf;
@@ -43,6 +43,8 @@ pub enum SocketMessage {
     CycleFocusWindow(CycleDirection),
     CycleMoveWindow(CycleDirection),
     StackWindow(OperationDirection),
+    StackAll,
+    UnstackAll,
     ResizeWindowEdge(OperationDirection, Sizing),
     ResizeWindowAxis(Axis, Sizing),
     UnstackWindow,
@@ -140,6 +142,8 @@ pub enum SocketMessage {
     BorderStyle(BorderStyle),
     BorderWidth(i32),
     BorderOffset(i32),
+    Transparency(bool),
+    TransparencyAlpha(u8),
     InvisibleBorders(Rect),
     StackbarMode(StackbarMode),
     StackbarLabel(StackbarLabel),
@@ -164,6 +168,7 @@ pub enum SocketMessage {
     State,
     GlobalState,
     VisibleWindows,
+    MonitorInformation,
     Query(StateQuery),
     FocusFollowsMouse(FocusFollowsMouseImplementation, bool),
     ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
@@ -227,7 +232,16 @@ pub enum BorderStyle {
 }
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
 pub enum WindowKind {
     Single,

komorebi-gui/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "komorebi-gui"
+version = "0.1.27"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+egui_extras = { version = "0.27" }
+eframe = "0.27"
+komorebi-client = { path = "../komorebi-client" }
+serde_json = "1"
+random_word = { version = "0.4.3", features = ["en"] }
+windows = { workspace = true }

komorebi-gui/src/main.rs

@@ -0,0 +1,807 @@
+#![warn(clippy::all)]
+
+use eframe::egui;
+use eframe::egui::color_picker::Alpha;
+use eframe::egui::Color32;
+use eframe::egui::ViewportBuilder;
+use komorebi_client::BorderStyle;
+use komorebi_client::Colour;
+use komorebi_client::DefaultLayout;
+use komorebi_client::GlobalState;
+use komorebi_client::Layout;
+use komorebi_client::Rect;
+use komorebi_client::Rgb;
+use komorebi_client::RuleDebug;
+use komorebi_client::SocketMessage;
+use komorebi_client::StackbarLabel;
+use komorebi_client::StackbarMode;
+use komorebi_client::State;
+use komorebi_client::Window;
+use komorebi_client::WindowKind;
+use std::collections::HashMap;
+use std::time::Duration;
+use windows::Win32::UI::WindowsAndMessaging::EnumWindows;
+
+fn main() {
+    let native_options = eframe::NativeOptions {
+        viewport: ViewportBuilder::default()
+            .with_always_on_top()
+            .with_inner_size([320.0, 500.0]),
+        follow_system_theme: true,
+        ..Default::default()
+    };
+
+    let _ = eframe::run_native(
+        "komorebi-gui",
+        native_options,
+        Box::new(|cc| Box::new(KomorebiGui::new(cc))),
+    );
+}
+
+struct BorderColours {
+    single: Color32,
+    stack: Color32,
+    monocle: Color32,
+    unfocused: Color32,
+}
+
+struct BorderConfig {
+    border_enabled: bool,
+    border_colours: BorderColours,
+    border_style: BorderStyle,
+    border_offset: i32,
+    border_width: i32,
+}
+
+struct StackbarConfig {
+    mode: StackbarMode,
+    label: StackbarLabel,
+    height: i32,
+    width: i32,
+    focused_text_colour: Color32,
+    unfocused_text_colour: Color32,
+    background_colour: Color32,
+}
+
+struct MonitorConfig {
+    size: Rect,
+    work_area_offset: Rect,
+    workspaces: Vec<WorkspaceConfig>,
+}
+
+impl From<&komorebi_client::Monitor> for MonitorConfig {
+    fn from(value: &komorebi_client::Monitor) -> Self {
+        let mut workspaces = vec![];
+        for ws in value.workspaces() {
+            workspaces.push(WorkspaceConfig::from(ws));
+        }
+
+        Self {
+            size: *value.size(),
+            work_area_offset: value.work_area_offset().unwrap_or_default(),
+            workspaces,
+        }
+    }
+}
+
+struct WorkspaceConfig {
+    name: String,
+    tile: bool,
+    layout: DefaultLayout,
+    container_padding: i32,
+    workspace_padding: i32,
+}
+
+impl From<&komorebi_client::Workspace> for WorkspaceConfig {
+    fn from(value: &komorebi_client::Workspace) -> Self {
+        let layout = match value.layout() {
+            Layout::Default(layout) => *layout,
+            Layout::Custom(_) => DefaultLayout::BSP,
+        };
+
+        let name = value
+            .name()
+            .to_owned()
+            .unwrap_or_else(|| random_word::gen(random_word::Lang::En).to_string());
+
+        Self {
+            layout,
+            name,
+            tile: *value.tile(),
+            workspace_padding: value.workspace_padding().unwrap_or(20),
+            container_padding: value.container_padding().unwrap_or(20),
+        }
+    }
+}
+
+struct KomorebiGui {
+    border_config: BorderConfig,
+    stackbar_config: StackbarConfig,
+    mouse_follows_focus: bool,
+    monitors: Vec<MonitorConfig>,
+    workspace_names: HashMap<usize, Vec<String>>,
+    debug_hwnd: isize,
+    debug_windows: Vec<Window>,
+    debug_rule: Option<RuleDebug>,
+}
+
+fn colour32(colour: Option<Colour>) -> Color32 {
+    match colour {
+        Some(Colour::Rgb(rgb)) => Color32::from_rgb(rgb.r as u8, rgb.g as u8, rgb.b as u8),
+        Some(Colour::Hex(hex)) => {
+            let rgb = Rgb::from(hex);
+            Color32::from_rgb(rgb.r as u8, rgb.g as u8, rgb.b as u8)
+        }
+        None => Color32::from_rgb(0, 0, 0),
+    }
+}
+
+impl KomorebiGui {
+    fn new(_cc: &eframe::CreationContext<'_>) -> Self {
+        // Customize egui here with cc.egui_ctx.set_fonts and cc.egui_ctx.set_visuals.
+        // Restore app state using cc.storage (requires the "persistence" feature).
+        // Use the cc.gl (a glow::Context) to create graphics shaders and buffers that you can use
+        // for e.g. egui::PaintCallback.
+        let global_state: GlobalState = serde_json::from_str(
+            &komorebi_client::send_query(&SocketMessage::GlobalState).unwrap(),
+        )
+        .unwrap();
+
+        let state: State =
+            serde_json::from_str(&komorebi_client::send_query(&SocketMessage::State).unwrap())
+                .unwrap();
+
+        let border_colours = BorderColours {
+            single: colour32(global_state.border_colours.single),
+            stack: colour32(global_state.border_colours.stack),
+            monocle: colour32(global_state.border_colours.monocle),
+            unfocused: colour32(global_state.border_colours.unfocused),
+        };
+
+        let border_config = BorderConfig {
+            border_enabled: global_state.border_enabled,
+            border_colours,
+            border_style: global_state.border_style,
+            border_offset: global_state.border_offset,
+            border_width: global_state.border_width,
+        };
+
+        let mut monitors = vec![];
+        for m in state.monitors.elements() {
+            monitors.push(MonitorConfig::from(m));
+        }
+
+        let mut workspace_names = HashMap::new();
+
+        for (monitor_idx, m) in monitors.iter().enumerate() {
+            for ws in &m.workspaces {
+                let names = workspace_names.entry(monitor_idx).or_insert_with(Vec::new);
+                names.push(ws.name.clone());
+            }
+        }
+
+        let stackbar_config = StackbarConfig {
+            mode: global_state.stackbar_mode,
+            height: global_state.stackbar_height,
+            width: global_state.stackbar_tab_width,
+            label: global_state.stackbar_label,
+            focused_text_colour: colour32(Some(global_state.stackbar_focused_text_colour)),
+            unfocused_text_colour: colour32(Some(global_state.stackbar_unfocused_text_colour)),
+            background_colour: colour32(Some(global_state.stackbar_tab_background_colour)),
+        };
+
+        let mut debug_windows = vec![];
+
+        unsafe {
+            EnumWindows(
+                Some(enum_window),
+                windows::Win32::Foundation::LPARAM(&mut debug_windows as *mut Vec<Window> as isize),
+            )
+            .unwrap();
+        };
+
+        Self {
+            border_config,
+            mouse_follows_focus: state.mouse_follows_focus,
+            monitors,
+            workspace_names,
+            debug_hwnd: 0,
+            debug_windows,
+            stackbar_config,
+            debug_rule: None,
+        }
+    }
+}
+
+extern "system" fn enum_window(
+    hwnd: windows::Win32::Foundation::HWND,
+    lparam: windows::Win32::Foundation::LPARAM,
+) -> windows::Win32::Foundation::BOOL {
+    let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
+    let window = Window { hwnd: hwnd.0 };
+
+    if window.is_window()
+        && !window.is_miminized()
+        && window.is_visible()
+        && window.title().is_ok()
+        && window.exe().is_ok()
+    {
+        windows.push(window);
+    }
+
+    true.into()
+}
+
+fn json_view_ui(ui: &mut egui::Ui, code: &str) {
+    let language = "json";
+    let theme = egui_extras::syntax_highlighting::CodeTheme::from_memory(ui.ctx());
+    egui_extras::syntax_highlighting::code_view_ui(ui, &theme, code, language);
+}
+
+impl eframe::App for KomorebiGui {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ctx.set_pixels_per_point(2.0);
+            egui::ScrollArea::vertical().show(ui, |ui| {
+                ui.set_width(ctx.screen_rect().width());
+                ui.collapsing("Debugging", |ui| {
+                    ui.collapsing("Window Rules", |ui| {
+                        let window = Window {
+                            hwnd: self.debug_hwnd,
+                        };
+
+                        let label = if let (Ok(title), Ok(exe)) = (window.title(), window.exe()) {
+                            format!("{title} ({exe})")
+                        } else {
+                            String::from("Select a Window")
+                        };
+
+                        if ui.button("Refresh Windows").clicked() {
+                            let mut debug_windows = vec![];
+
+                            unsafe {
+                                EnumWindows(
+                                    Some(enum_window),
+                                    windows::Win32::Foundation::LPARAM(
+                                        &mut debug_windows as *mut Vec<Window> as isize,
+                                    ),
+                                )
+                                .unwrap();
+                            };
+
+                            self.debug_windows = debug_windows;
+                        }
+
+                        egui::ComboBox::from_label("Select a Window")
+                            .selected_text(label)
+                            .show_ui(ui, |ui| {
+                                for w in &self.debug_windows {
+                                    if ui
+                                        .selectable_value(
+                                            &mut self.debug_hwnd,
+                                            w.hwnd,
+                                            format!(
+                                                "{} ({})",
+                                                w.title().unwrap(),
+                                                w.exe().unwrap()
+                                            ),
+                                        )
+                                        .changed()
+                                    {
+                                        let debug_rule: RuleDebug = serde_json::from_str(
+                                            &komorebi_client::send_query(
+                                                &SocketMessage::DebugWindow(self.debug_hwnd),
+                                            )
+                                            .unwrap(),
+                                        )
+                                        .unwrap();
+
+                                        self.debug_rule = Some(debug_rule)
+                                    }
+                                }
+                            });
+
+                        if let Some(debug_rule) = &self.debug_rule {
+                            json_view_ui(ui, &serde_json::to_string_pretty(debug_rule).unwrap())
+                        }
+                    });
+                });
+
+                ui.collapsing("Mouse", |ui| {
+                    if ui
+                        .toggle_value(&mut self.mouse_follows_focus, "Mouse Follows Focus")
+                        .changed()
+                    {
+                        komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
+                            self.mouse_follows_focus,
+                        ))
+                        .unwrap();
+                    }
+                });
+
+                ui.collapsing("Border", |ui| {
+                    if ui
+                        .toggle_value(&mut self.border_config.border_enabled, "Border")
+                        .changed()
+                    {
+                        komorebi_client::send_message(&SocketMessage::Border(
+                            self.border_config.border_enabled,
+                        ))
+                        .unwrap();
+                    }
+
+                    ui.collapsing("Colours", |ui| {
+                        ui.collapsing("Single", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.border_config.border_colours.single,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(&SocketMessage::BorderColour(
+                                    WindowKind::Single,
+                                    self.border_config.border_colours.single.r() as u32,
+                                    self.border_config.border_colours.single.g() as u32,
+                                    self.border_config.border_colours.single.b() as u32,
+                                ))
+                                .unwrap();
+                            }
+                        });
+
+                        ui.collapsing("Stack", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.border_config.border_colours.stack,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(&SocketMessage::BorderColour(
+                                    WindowKind::Stack,
+                                    self.border_config.border_colours.stack.r() as u32,
+                                    self.border_config.border_colours.stack.g() as u32,
+                                    self.border_config.border_colours.stack.b() as u32,
+                                ))
+                                .unwrap();
+                            }
+                        });
+
+                        ui.collapsing("Monocle", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.border_config.border_colours.monocle,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(&SocketMessage::BorderColour(
+                                    WindowKind::Monocle,
+                                    self.border_config.border_colours.monocle.r() as u32,
+                                    self.border_config.border_colours.monocle.g() as u32,
+                                    self.border_config.border_colours.monocle.b() as u32,
+                                ))
+                                .unwrap();
+                            }
+                        });
+
+                        ui.collapsing("Unfocused", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.border_config.border_colours.unfocused,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(&SocketMessage::BorderColour(
+                                    WindowKind::Unfocused,
+                                    self.border_config.border_colours.unfocused.r() as u32,
+                                    self.border_config.border_colours.unfocused.g() as u32,
+                                    self.border_config.border_colours.unfocused.b() as u32,
+                                ))
+                                .unwrap();
+                            }
+                        })
+                    });
+
+                    ui.collapsing("Style", |ui| {
+                        for option in [
+                            BorderStyle::System,
+                            BorderStyle::Rounded,
+                            BorderStyle::Square,
+                        ] {
+                            if ui
+                                .add(egui::SelectableLabel::new(
+                                    self.border_config.border_style == option,
+                                    option.to_string(),
+                                ))
+                                .clicked()
+                            {
+                                self.border_config.border_style = option;
+                                komorebi_client::send_message(&SocketMessage::BorderStyle(
+                                    self.border_config.border_style,
+                                ))
+                                .unwrap();
+
+                                std::thread::sleep(Duration::from_secs(1));
+
+                                komorebi_client::send_message(&SocketMessage::Retile).unwrap();
+                            }
+                        }
+                    });
+
+                    ui.collapsing("Width", |ui| {
+                        if ui
+                            .add(egui::Slider::new(
+                                &mut self.border_config.border_width,
+                                -50..=50,
+                            ))
+                            .changed()
+                        {
+                            komorebi_client::send_message(&SocketMessage::BorderWidth(
+                                self.border_config.border_width,
+                            ))
+                            .unwrap();
+                        };
+                    });
+
+                    ui.collapsing("Offset", |ui| {
+                        if ui
+                            .add(egui::Slider::new(
+                                &mut self.border_config.border_offset,
+                                -50..=50,
+                            ))
+                            .changed()
+                        {
+                            komorebi_client::send_message(&SocketMessage::BorderOffset(
+                                self.border_config.border_offset,
+                            ))
+                            .unwrap();
+                        };
+                    });
+                });
+
+                ui.collapsing("Stackbar", |ui| {
+                    for option in [
+                        StackbarMode::Never,
+                        StackbarMode::OnStack,
+                        StackbarMode::Always,
+                    ] {
+                        if ui
+                            .add(egui::SelectableLabel::new(
+                                self.stackbar_config.mode == option,
+                                option.to_string(),
+                            ))
+                            .clicked()
+                        {
+                            self.stackbar_config.mode = option;
+                            komorebi_client::send_message(&SocketMessage::StackbarMode(
+                                self.stackbar_config.mode,
+                            ))
+                            .unwrap();
+
+                            komorebi_client::send_message(&SocketMessage::Retile).unwrap()
+                        }
+                    }
+
+                    ui.collapsing("Label", |ui| {
+                        for option in [StackbarLabel::Process, StackbarLabel::Title] {
+                            if ui
+                                .add(egui::SelectableLabel::new(
+                                    self.stackbar_config.label == option,
+                                    option.to_string(),
+                                ))
+                                .clicked()
+                            {
+                                self.stackbar_config.label = option;
+                                komorebi_client::send_message(&SocketMessage::StackbarLabel(
+                                    self.stackbar_config.label,
+                                ))
+                                .unwrap();
+                            }
+                        }
+                    });
+
+                    ui.collapsing("Colours", |ui| {
+                        ui.collapsing("Focused Text", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.stackbar_config.focused_text_colour,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(
+                                    &SocketMessage::StackbarFocusedTextColour(
+                                        self.stackbar_config.focused_text_colour.r() as u32,
+                                        self.stackbar_config.focused_text_colour.g() as u32,
+                                        self.stackbar_config.focused_text_colour.b() as u32,
+                                    ),
+                                )
+                                .unwrap();
+                            }
+                        });
+
+                        ui.collapsing("Unfocused Text", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.stackbar_config.unfocused_text_colour,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(
+                                    &SocketMessage::StackbarUnfocusedTextColour(
+                                        self.stackbar_config.unfocused_text_colour.r() as u32,
+                                        self.stackbar_config.unfocused_text_colour.g() as u32,
+                                        self.stackbar_config.unfocused_text_colour.b() as u32,
+                                    ),
+                                )
+                                .unwrap();
+                            }
+                        });
+
+                        ui.collapsing("Background", |ui| {
+                            if egui::color_picker::color_picker_color32(
+                                ui,
+                                &mut self.stackbar_config.background_colour,
+                                Alpha::Opaque,
+                            ) {
+                                komorebi_client::send_message(
+                                    &SocketMessage::StackbarBackgroundColour(
+                                        self.stackbar_config.background_colour.r() as u32,
+                                        self.stackbar_config.background_colour.g() as u32,
+                                        self.stackbar_config.background_colour.b() as u32,
+                                    ),
+                                )
+                                .unwrap();
+                            }
+                        })
+                    });
+
+                    ui.collapsing("Width", |ui| {
+                        if ui
+                            .add(egui::Slider::new(&mut self.stackbar_config.width, 0..=500))
+                            .drag_stopped()
+                        {
+                            komorebi_client::send_message(&SocketMessage::StackbarTabWidth(
+                                self.stackbar_config.width,
+                            ))
+                            .unwrap();
+
+                            komorebi_client::send_message(&SocketMessage::Retile).unwrap()
+                        };
+                    });
+
+                    ui.collapsing("Height", |ui| {
+                        if ui
+                            .add(egui::Slider::new(&mut self.stackbar_config.height, 0..=100))
+                            .drag_stopped()
+                        {
+                            komorebi_client::send_message(&SocketMessage::StackbarHeight(
+                                self.stackbar_config.height,
+                            ))
+                            .unwrap();
+
+                            komorebi_client::send_message(&SocketMessage::Retile).unwrap()
+                        };
+                    });
+                });
+
+                for (monitor_idx, monitor) in self.monitors.iter_mut().enumerate() {
+                    ui.collapsing(
+                        format!(
+                            "Monitor {monitor_idx} ({}x{})",
+                            monitor.size.right, monitor.size.bottom
+                        ),
+                        |ui| {
+                            ui.collapsing("Work Area Offset", |ui| {
+                                if ui
+                                    .add(
+                                        egui::Slider::new(
+                                            &mut monitor.work_area_offset.left,
+                                            0..=500,
+                                        )
+                                        .text("Left"),
+                                    )
+                                    .drag_stopped()
+                                {
+                                    komorebi_client::send_message(
+                                        &SocketMessage::MonitorWorkAreaOffset(
+                                            monitor_idx,
+                                            monitor.work_area_offset,
+                                        ),
+                                    )
+                                    .unwrap();
+                                };
+
+                                if ui
+                                    .add(
+                                        egui::Slider::new(
+                                            &mut monitor.work_area_offset.top,
+                                            0..=500,
+                                        )
+                                        .text("Top"),
+                                    )
+                                    .drag_stopped()
+                                {
+                                    komorebi_client::send_message(
+                                        &SocketMessage::MonitorWorkAreaOffset(
+                                            monitor_idx,
+                                            monitor.work_area_offset,
+                                        ),
+                                    )
+                                    .unwrap();
+                                };
+
+                                if ui
+                                    .add(
+                                        egui::Slider::new(
+                                            &mut monitor.work_area_offset.right,
+                                            0..=500,
+                                        )
+                                        .text("Right"),
+                                    )
+                                    .drag_stopped()
+                                {
+                                    komorebi_client::send_message(
+                                        &SocketMessage::MonitorWorkAreaOffset(
+                                            monitor_idx,
+                                            monitor.work_area_offset,
+                                        ),
+                                    )
+                                    .unwrap();
+                                };
+
+                                if ui
+                                    .add(
+                                        egui::Slider::new(
+                                            &mut monitor.work_area_offset.bottom,
+                                            0..=500,
+                                        )
+                                        .text("Bottom"),
+                                    )
+                                    .drag_stopped()
+                                {
+                                    komorebi_client::send_message(
+                                        &SocketMessage::MonitorWorkAreaOffset(
+                                            monitor_idx,
+                                            monitor.work_area_offset,
+                                        ),
+                                    )
+                                    .unwrap();
+                                };
+                            });
+
+                            ui.collapsing("Workspaces", |ui| {
+                                for (workspace_idx, workspace) in
+                                    monitor.workspaces.iter_mut().enumerate()
+                                {
+                                    ui.collapsing(
+                                        format!("Workspace {workspace_idx} ({})", workspace.name),
+                                        |ui| {
+                                            if ui.button("Focus").clicked() {
+                                                komorebi_client::send_message(
+                                                    &SocketMessage::MouseFollowsFocus(false),
+                                                )
+                                                .unwrap();
+
+                                                komorebi_client::send_message(
+                                                    &SocketMessage::FocusMonitorWorkspaceNumber(
+                                                        monitor_idx,
+                                                        workspace_idx,
+                                                    ),
+                                                )
+                                                .unwrap();
+
+                                                komorebi_client::send_message(
+                                                    &SocketMessage::MouseFollowsFocus(
+                                                        self.mouse_follows_focus,
+                                                    ),
+                                                )
+                                                .unwrap();
+                                            }
+
+                                            if ui
+                                                .toggle_value(&mut workspace.tile, "Tiling")
+                                                .changed()
+                                            {
+                                                komorebi_client::send_message(
+                                                    &SocketMessage::WorkspaceTiling(
+                                                        monitor_idx,
+                                                        workspace_idx,
+                                                        workspace.tile,
+                                                    ),
+                                                )
+                                                .unwrap();
+                                            }
+
+                                            ui.collapsing("Name", |ui| {
+                                                let monitor_workspaces = self
+                                                    .workspace_names
+                                                    .get_mut(&monitor_idx)
+                                                    .unwrap();
+                                                let workspace_name =
+                                                    &mut monitor_workspaces[workspace_idx];
+                                                if ui
+                                                    .text_edit_singleline(workspace_name)
+                                                    .lost_focus()
+                                                {
+                                                    workspace.name.clone_from(workspace_name);
+                                                    komorebi_client::send_message(
+                                                        &SocketMessage::WorkspaceName(
+                                                            monitor_idx,
+                                                            workspace_idx,
+                                                            workspace.name.clone(),
+                                                        ),
+                                                    )
+                                                    .unwrap();
+                                                }
+                                            });
+
+                                            ui.collapsing("Layout", |ui| {
+                                                for option in [
+                                                    DefaultLayout::BSP,
+                                                    DefaultLayout::Columns,
+                                                    DefaultLayout::Rows,
+                                                    DefaultLayout::VerticalStack,
+                                                    DefaultLayout::HorizontalStack,
+                                                    DefaultLayout::UltrawideVerticalStack,
+                                                    DefaultLayout::Grid,
+                                                ] {
+                                                    if ui
+                                                        .add(egui::SelectableLabel::new(
+                                                            workspace.layout == option,
+                                                            option.to_string(),
+                                                        ))
+                                                        .clicked()
+                                                    {
+                                                        workspace.layout = option;
+                                                        komorebi_client::send_message(
+                                                            &SocketMessage::WorkspaceLayout(
+                                                                monitor_idx,
+                                                                workspace_idx,
+                                                                workspace.layout,
+                                                            ),
+                                                        )
+                                                        .unwrap();
+                                                    }
+                                                }
+                                            });
+
+                                            ui.collapsing("Container Padding", |ui| {
+                                                if ui
+                                                    .add(egui::Slider::new(
+                                                        &mut workspace.container_padding,
+                                                        0..=100,
+                                                    ))
+                                                    .drag_stopped()
+                                                {
+                                                    komorebi_client::send_message(
+                                                        &SocketMessage::ContainerPadding(
+                                                            monitor_idx,
+                                                            workspace_idx,
+                                                            workspace.container_padding,
+                                                        ),
+                                                    )
+                                                    .unwrap();
+                                                };
+                                            });
+
+                                            ui.collapsing("Workspace Padding", |ui| {
+                                                if ui
+                                                    .add(egui::Slider::new(
+                                                        &mut workspace.workspace_padding,
+                                                        0..=100,
+                                                    ))
+                                                    .drag_stopped()
+                                                {
+                                                    komorebi_client::send_message(
+                                                        &SocketMessage::WorkspacePadding(
+                                                            monitor_idx,
+                                                            workspace_idx,
+                                                            workspace.workspace_padding,
+                                                        ),
+                                                    )
+                                                    .unwrap();
+                                                };
+                                            });
+                                        },
+                                    );
+                                }
+                            });
+                        },
+                    );
+                }
+            });
+        });
+    }
+}

komorebi.sample.ahk

@@ -1,56 +0,0 @@
-#SingleInstance Force
-
-; Load library
-#Include komorebic.lib.ahk
-
-; Focus windows
-!h::Focus("left")
-!j::Focus("down")
-!k::Focus("up")
-!l::Focus("right")
-!+[::CycleFocus("previous")
-!+]::CycleFocus("next")
-
-; Move windows
-!+h::Move("left")
-!+j::Move("down")
-!+k::Move("up")
-!+l::Move("right")
-!+Enter::Promote()
-
-; Stack windows
-!Left::Stack("left")
-!Right::Stack("right")
-!Up::Stack("up")
-!Down::Stack("down")
-!;::Unstack()
-![::CycleStack("previous")
-!]::CycleStack("next")
-
-; Resize
-!=::ResizeAxis("horizontal", "increase")
-!-::ResizeAxis("horizontal", "decrease")
-!+=::ResizeAxis("vertical", "increase")
-!+-::ResizeAxis("vertical", "decrease")
-
-; Manipulate windows
-!t::ToggleFloat()
-!+f::ToggleMonocle()
-
-; Window manager options
-!+r::Retile()
-!p::TogglePause()
-
-; Layouts
-!x::FlipLayout("horizontal")
-!y::FlipLayout("vertical")
-
-; Workspaces
-!1::FocusWorkspace(0)
-!2::FocusWorkspace(1)
-!3::FocusWorkspace(2)
-
-; Move windows across workspaces
-!+1::MoveToWorkspace(0)
-!+2::MoveToWorkspace(1)
-!+3::MoveToWorkspace(2)

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.26-dev.0"
+version = "0.1.27"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -18,7 +18,7 @@ clap = { version = "4", features = ["derive"] }
 color-eyre = { workspace = true }
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
-ctrlc = "3"
+ctrlc = { version = "3", features = ["termination"] }
 dirs = { workspace = true }
 getset = "0.1"
 hex_color = { version = "3", features = ["serde"] }
@@ -28,7 +28,7 @@ miow = "0.6"
 nanoid = "0.4"
 net2 = "0.2"
 os_info = "3.8"
-parking_lot = { version = "0.12", features = ["deadlock_detection"] }
+parking_lot = "0.12"
 paste = "1"
 regex = "1"
 schemars = "0.8"
@@ -42,13 +42,12 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uds_windows = "1"
 which = "6"
 widestring = "1"
+win32-display-data = { workspace = true }
 windows = { workspace = true }
 windows-implement = { workspace = true }
 windows-interface = { workspace = true }
 winput = "0.2"
 winreg = "0.52"
 
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data" }
-
 [features]
-deadlock_detection = []
+deadlock_detection = ["parking_lot/deadlock_detection"]

komorebi/src/border_manager/border.rs

@@ -4,7 +4,6 @@ use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::FOCUSED;
 use crate::border_manager::FOCUS_STATE;
 use crate::border_manager::MONOCLE;
-use crate::border_manager::RECT_STATE;
 use crate::border_manager::STACK;
 use crate::border_manager::STYLE;
 use crate::border_manager::UNFOCUSED;
@@ -27,12 +26,12 @@ use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::WPARAM;
 use windows::Win32::Graphics::Gdi::BeginPaint;
 use windows::Win32::Graphics::Gdi::CreatePen;
+use windows::Win32::Graphics::Gdi::DeleteObject;
 use windows::Win32::Graphics::Gdi::EndPaint;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::RoundRect;
 use windows::Win32::Graphics::Gdi::SelectObject;
-use windows::Win32::Graphics::Gdi::ValidateRect;
 use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
 use windows::Win32::Graphics::Gdi::PS_INSIDEFRAME;
 use windows::Win32::Graphics::Gdi::PS_SOLID;
@@ -99,13 +98,19 @@ impl Border {
             let hwnd = WindowsApi::create_border_window(PCWSTR(name.as_ptr()), h_module)?;
             hwnd_sender.send(hwnd)?;
 
-            let mut message = MSG::default();
-            unsafe {
-                while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
-                    TranslateMessage(&message);
-                    DispatchMessageW(&message);
-                    std::thread::sleep(Duration::from_millis(10));
+            let mut msg: MSG = MSG::default();
+
+            loop {
+                unsafe {
+                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+                        tracing::debug!("border window event processing thread shutdown");
+                        break;
+                    };
+                    TranslateMessage(&msg);
+                    DispatchMessageW(&msg);
                 }
+
+                std::thread::sleep(Duration::from_millis(10))
             }
 
             Ok(())
@@ -120,25 +125,22 @@ impl Border {
         WindowsApi::close_window(self.hwnd())
     }
 
-    pub fn update(&self, rect: &Rect) -> color_eyre::Result<()> {
+    pub fn update(&self, rect: &Rect, mut should_invalidate: bool) -> color_eyre::Result<()> {
         // Make adjustments to the border
         let mut rect = *rect;
         rect.add_margin(BORDER_WIDTH.load(Ordering::SeqCst));
         rect.add_padding(-BORDER_OFFSET.load(Ordering::SeqCst));
 
-        // Store the border rect so that it can be used by the callback
-        {
-            let mut rects = RECT_STATE.lock();
-            rects.insert(self.hwnd, rect);
-        }
-
         // Update the position of the border if required
         if !WindowsApi::window_rect(self.hwnd())?.eq(&rect) {
-            WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((*Z_ORDER.lock()).into()))?;
+            WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((Z_ORDER.load()).into()))?;
+            should_invalidate = true;
         }
 
         // Invalidate the rect to trigger the callback to update colours etc.
-        self.invalidate();
+        if should_invalidate {
+            self.invalidate();
+        }
 
         Ok(())
     }
@@ -156,63 +158,68 @@ impl Border {
         unsafe {
             match message {
                 WM_PAINT => {
-                    let rects = RECT_STATE.lock();
+                    let mut ps = PAINTSTRUCT::default();
+                    let hdc = BeginPaint(window, &mut ps);
 
-                    // With the rect that we stored in Self::update
-                    if let Some(rect) = rects.get(&window.0).copied() {
-                        // Grab the focus kind for this border
-                        let focus_kind = {
-                            FOCUS_STATE
-                                .lock()
-                                .get(&window.0)
-                                .copied()
-                                .unwrap_or(WindowKind::Unfocused)
-                        };
+                    // With the rect that we set in Self::update
+                    match WindowsApi::window_rect(window) {
+                        Ok(rect) => {
+                            // Grab the focus kind for this border
+                            let focus_kind = {
+                                FOCUS_STATE
+                                    .lock()
+                                    .get(&window.0)
+                                    .copied()
+                                    .unwrap_or(WindowKind::Unfocused)
+                            };
 
-                        // Set up the brush to draw the border
-                        let mut ps = PAINTSTRUCT::default();
-                        let hdc = BeginPaint(window, &mut ps);
-                        let hpen = CreatePen(
-                            PS_SOLID | PS_INSIDEFRAME,
-                            BORDER_WIDTH.load(Ordering::SeqCst),
-                            COLORREF(match focus_kind {
-                                WindowKind::Unfocused => UNFOCUSED.load(Ordering::SeqCst),
-                                WindowKind::Single => FOCUSED.load(Ordering::SeqCst),
-                                WindowKind::Stack => STACK.load(Ordering::SeqCst),
-                                WindowKind::Monocle => MONOCLE.load(Ordering::SeqCst),
-                            }),
-                        );
+                            // Set up the brush to draw the border
+                            let hpen = CreatePen(
+                                PS_SOLID | PS_INSIDEFRAME,
+                                BORDER_WIDTH.load(Ordering::SeqCst),
+                                COLORREF(match focus_kind {
+                                    WindowKind::Unfocused => UNFOCUSED.load(Ordering::SeqCst),
+                                    WindowKind::Single => FOCUSED.load(Ordering::SeqCst),
+                                    WindowKind::Stack => STACK.load(Ordering::SeqCst),
+                                    WindowKind::Monocle => MONOCLE.load(Ordering::SeqCst),
+                                }),
+                            );
 
-                        let hbrush = WindowsApi::create_solid_brush(0);
+                            let hbrush = WindowsApi::create_solid_brush(0);
 
-                        // Draw the border
-                        SelectObject(hdc, hpen);
-                        SelectObject(hdc, hbrush);
-                        // TODO(raggi): this is approximately the correct curvature for
-                        // the top left of a Windows 11 window (DWMWCP_DEFAULT), but
-                        // often the bottom right has a different shape. Furthermore if
-                        // the window was made with DWMWCP_ROUNDSMALL then this is the
-                        // wrong size.  In the future we should read the DWM properties
-                        // of windows and attempt to match appropriately.
-                        match *STYLE.lock() {
-                            BorderStyle::System => {
-                                if *WINDOWS_11 {
+                            // Draw the border
+                            SelectObject(hdc, hpen);
+                            SelectObject(hdc, hbrush);
+                            // TODO(raggi): this is approximately the correct curvature for
+                            // the top left of a Windows 11 window (DWMWCP_DEFAULT), but
+                            // often the bottom right has a different shape. Furthermore if
+                            // the window was made with DWMWCP_ROUNDSMALL then this is the
+                            // wrong size.  In the future we should read the DWM properties
+                            // of windows and attempt to match appropriately.
+                            match STYLE.load() {
+                                BorderStyle::System => {
+                                    if *WINDOWS_11 {
+                                        RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                                    } else {
+                                        Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                                    }
+                                }
+                                BorderStyle::Rounded => {
                                     RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
-                                } else {
+                                }
+                                BorderStyle::Square => {
                                     Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                 }
                             }
-                            BorderStyle::Rounded => {
-                                RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
-                            }
-                            BorderStyle::Square => {
-                                Rectangle(hdc, 0, 0, rect.right, rect.bottom);
-                            }
+                            DeleteObject(hpen);
+                            DeleteObject(hbrush);
+                        }
+                        Err(error) => {
+                            tracing::error!("could not get border rect: {}", error.to_string())
                         }
-                        EndPaint(window, &ps);
-                        ValidateRect(window, None);
                     }
 
+                    EndPaint(window, &ps);
                     LRESULT(0)
                 }
                 WM_DESTROY => {

komorebi/src/border_manager/mod.rs

@@ -4,6 +4,7 @@ mod border;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
+use crossbeam_utils::atomic::AtomicCell;
 use crossbeam_utils::atomic::AtomicConsume;
 use komorebi_core::BorderStyle;
 use lazy_static::lazy_static;
@@ -18,13 +19,11 @@ use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 use std::sync::OnceLock;
-use std::time::Duration;
-use std::time::Instant;
 use windows::Win32::Foundation::HWND;
 
+use crate::ring::Ring;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::Colour;
-use crate::Rect;
 use crate::Rgb;
 use crate::WindowManager;
 use crate::WindowsApi;
@@ -38,8 +37,8 @@ pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
 pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(true);
 
 lazy_static! {
-    pub static ref Z_ORDER: Arc<Mutex<ZOrder>> = Arc::new(Mutex::new(ZOrder::Bottom));
-    pub static ref STYLE: Arc<Mutex<BorderStyle>> = Arc::new(Mutex::new(BorderStyle::System));
+    pub static ref Z_ORDER: AtomicCell<ZOrder> = AtomicCell::new(ZOrder::Bottom);
+    pub static ref STYLE: AtomicCell<BorderStyle> = AtomicCell::new(BorderStyle::System);
     pub static ref FOCUSED: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
     pub static ref UNFOCUSED: AtomicU32 =
@@ -52,7 +51,6 @@ lazy_static! {
 lazy_static! {
     static ref BORDERS_MONITORS: Mutex<HashMap<String, usize>> = Mutex::new(HashMap::new());
     static ref BORDER_STATE: Mutex<HashMap<String, Border>> = Mutex::new(HashMap::new());
-    static ref RECT_STATE: Mutex<HashMap<isize, Rect>> = Mutex::new(HashMap::new());
     static ref FOCUS_STATE: Mutex<HashMap<isize, WindowKind>> = Mutex::new(HashMap::new());
 }
 
@@ -61,17 +59,23 @@ 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)
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
 }
 
-pub fn event_tx() -> Sender<Notification> {
+fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-pub fn event_rx() -> Receiver<Notification> {
+fn event_rx() -> Receiver<Notification> {
     channel().1.clone()
 }
 
+pub fn send_notification() {
+    if event_tx().try_send(Notification).is_err() {
+        tracing::warn!("channel is full; dropping notification")
+    }
+}
+
 pub fn destroy_all_borders() -> color_eyre::Result<()> {
     let mut borders = BORDER_STATE.lock();
     tracing::info!(
@@ -84,7 +88,6 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
     }
 
     borders.clear();
-    RECT_STATE.lock().clear();
     BORDERS_MONITORS.lock().clear();
     FOCUS_STATE.lock().clear();
 
@@ -123,28 +126,57 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
     tracing::info!("listening");
 
     let receiver = event_rx();
-    let mut instant: Option<Instant> = None;
     event_tx().send(Notification)?;
 
+    let mut previous_snapshot = Ring::default();
+    let mut previous_pending_move_op = None;
+    let mut previous_is_paused = false;
+
     'receiver: for _ in receiver {
-        if let Some(instant) = instant {
-            if instant.elapsed().lt(&Duration::from_millis(50)) {
-                continue 'receiver;
-            }
+        // Check the wm state every time we receive a notification
+        let state = wm.lock();
+        let is_paused = state.is_paused;
+        let focused_monitor_idx = state.focused_monitor_idx();
+        let monitors = state.monitors.clone();
+        let pending_move_op = state.pending_move_op;
+        drop(state);
+
+        let mut should_process_notification = true;
+
+        if monitors == previous_snapshot
+            // handle the window dragging edge case
+            && pending_move_op == previous_pending_move_op
+        {
+            should_process_notification = false;
         }
 
-        instant = Some(Instant::now());
+        // handle the pause edge case
+        if is_paused && !previous_is_paused {
+            should_process_notification = true;
+        }
+
+        // handle the unpause edge case
+        if previous_is_paused && !is_paused {
+            should_process_notification = true;
+        }
+
+        // handle the retile edge case
+        if !should_process_notification && BORDER_STATE.lock().is_empty() {
+            should_process_notification = true;
+        }
+
+        if !should_process_notification {
+            tracing::trace!("monitor state matches latest snapshot, skipping notification");
+            continue 'receiver;
+        }
 
         let mut borders = BORDER_STATE.lock();
         let mut borders_monitors = BORDERS_MONITORS.lock();
 
-        // Check the wm state every time we receive a notification
-        let state = wm.lock();
-
         // If borders are disabled
         if !BORDER_ENABLED.load_consume()
            // Or if the wm is paused
-            || state.is_paused
+            || is_paused
             // Or if we are handling an alt-tab across workspaces
             || ALT_TAB_HWND.load().is_some()
         {
@@ -154,12 +186,12 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
             }
 
             borders.clear();
+
+            previous_is_paused = is_paused;
             continue 'receiver;
         }
 
-        let focused_monitor_idx = state.focused_monitor_idx();
-
-        'monitors: for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
+        'monitors: for (monitor_idx, m) in monitors.elements().iter().enumerate() {
             // Only operate on the focused workspace of each monitor
             if let Some(ws) = m.focused_workspace() {
                 // Workspaces with tiling disabled don't have borders
@@ -176,7 +208,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         borders.remove(id);
                     }
 
-                    continue 'receiver;
+                    continue 'monitors;
                 }
 
                 // Handle the monocle container separately
@@ -187,7 +219,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             if let Ok(border) = Border::create(monocle.id()) {
                                 entry.insert(border)
                             } else {
-                                continue 'receiver;
+                                continue 'monitors;
                             }
                         }
                     };
@@ -210,7 +242,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         monocle.focused_window().copied().unwrap_or_default().hwnd(),
                     )?;
 
-                    border.update(&rect)?;
+                    border.update(&rect, true)?;
 
                     let border_hwnd = border.hwnd;
                     let mut to_remove = vec![];
@@ -226,6 +258,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     for id in &to_remove {
                         borders.remove(id);
                     }
+
                     continue 'monitors;
                 }
 
@@ -272,9 +305,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 for (idx, c) in ws.containers().iter().enumerate() {
                     // Update border when moving or resizing with mouse
-                    if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
-                        let restore_z_order = *Z_ORDER.lock();
-                        *Z_ORDER.lock() = ZOrder::TopMost;
+                    if pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                        let restore_z_order = Z_ORDER.load();
+                        Z_ORDER.store(ZOrder::TopMost);
 
                         let mut rect = WindowsApi::window_rect(
                             c.focused_window().copied().unwrap_or_default().hwnd(),
@@ -287,7 +320,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     if let Ok(border) = Border::create(c.id()) {
                                         entry.insert(border)
                                     } else {
-                                        continue 'receiver;
+                                        continue 'monitors;
                                     }
                                 }
                             };
@@ -298,13 +331,13 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                             if rect != new_rect {
                                 rect = new_rect;
-                                border.update(&rect)?;
+                                border.update(&rect, true)?;
                             }
                         }
 
-                        *Z_ORDER.lock() = restore_z_order;
+                        Z_ORDER.store(restore_z_order);
 
-                        continue 'receiver;
+                        continue 'monitors;
                     }
 
                     // Get the border entry for this container from the map or create one
@@ -314,38 +347,49 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             if let Ok(border) = Border::create(c.id()) {
                                 entry.insert(border)
                             } else {
-                                continue 'receiver;
+                                continue 'monitors;
                             }
                         }
                     };
 
                     borders_monitors.insert(c.id().clone(), monitor_idx);
 
+                    #[allow(unused_assignments)]
+                    let mut last_focus_state = None;
+
+                    let new_focus_state = if idx != ws.focused_container_idx()
+                        || monitor_idx != focused_monitor_idx
+                    {
+                        WindowKind::Unfocused
+                    } else if c.windows().len() > 1 {
+                        WindowKind::Stack
+                    } else {
+                        WindowKind::Single
+                    };
+
                     // Update the focused state for all containers on this workspace
                     {
                         let mut focus_state = FOCUS_STATE.lock();
-                        focus_state.insert(
-                            border.hwnd,
-                            if idx != ws.focused_container_idx()
-                                || monitor_idx != focused_monitor_idx
-                            {
-                                WindowKind::Unfocused
-                            } else if c.windows().len() > 1 {
-                                WindowKind::Stack
-                            } else {
-                                WindowKind::Single
-                            },
-                        );
+                        last_focus_state = focus_state.insert(border.hwnd, new_focus_state);
                     }
 
                     let rect = WindowsApi::window_rect(
                         c.focused_window().copied().unwrap_or_default().hwnd(),
                     )?;
 
-                    border.update(&rect)?;
+                    let should_invalidate = match last_focus_state {
+                        None => true,
+                        Some(last_focus_state) => last_focus_state != new_focus_state,
+                    };
+
+                    border.update(&rect, should_invalidate)?;
                 }
             }
         }
+
+        previous_snapshot = monitors;
+        previous_pending_move_op = pending_move_op;
+        previous_is_paused = is_paused;
     }
 
     Ok(())

komorebi/src/container.rs

@@ -104,11 +104,7 @@ impl Container {
 
     pub fn remove_window_by_idx(&mut self, idx: usize) -> Option<Window> {
         let window = self.windows_mut().remove(idx);
-
-        if idx != 0 {
-            self.focus_window(idx - 1);
-        };
-
+        self.focus_window(idx.saturating_sub(1));
         window
     }
 
@@ -119,7 +115,7 @@ impl Container {
 
     pub fn add_window(&mut self, window: Window) {
         self.windows_mut().push_back(window);
-        self.focus_window(self.windows().len() - 1);
+        self.focus_window(self.windows().len().saturating_sub(1));
     }
 
     #[tracing::instrument(skip(self))]

komorebi/src/lib.rs

@@ -1,3 +1,5 @@
+#![warn(clippy::all)]
+
 pub mod border_manager;
 pub mod com;
 #[macro_use]
@@ -9,10 +11,12 @@ pub mod monitor_reconciliator;
 pub mod process_command;
 pub mod process_event;
 pub mod process_movement;
+pub mod reaper;
 pub mod set_window_position;
 pub mod stackbar_manager;
 pub mod static_config;
 pub mod styles;
+pub mod transparency_manager;
 pub mod window;
 pub mod window_manager;
 pub mod window_manager_event;

komorebi/src/main.rs

@@ -1,9 +1,10 @@
-#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![warn(clippy::all)]
 #![allow(
     clippy::missing_errors_doc,
     clippy::redundant_pub_crate,
     clippy::significant_drop_tightening,
-    clippy::significant_drop_in_scrutinee
+    clippy::significant_drop_in_scrutinee,
+    clippy::doc_markdown
 )]
 
 use std::path::PathBuf;
@@ -30,8 +31,10 @@ 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::reaper;
 use komorebi::stackbar_manager;
 use komorebi::static_config::StaticConfig;
+use komorebi::transparency_manager;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
@@ -256,8 +259,10 @@ fn main() -> Result<()> {
 
     border_manager::listen_for_notifications(wm.clone());
     stackbar_manager::listen_for_notifications(wm.clone());
+    transparency_manager::listen_for_notifications(wm.clone());
     workspace_reconciliator::listen_for_notifications(wm.clone());
     monitor_reconciliator::listen_for_notifications(wm.clone())?;
+    reaper::watch_for_orphans(wm.clone());
 
     let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
     ctrlc::set_handler(move || {

komorebi/src/monitor.rs

@@ -19,7 +19,16 @@ use crate::ring::Ring;
 use crate::workspace::Workspace;
 
 #[derive(
-    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema,
+    Debug,
+    Clone,
+    Serialize,
+    Deserialize,
+    Getters,
+    CopyGetters,
+    MutGetters,
+    Setters,
+    JsonSchema,
+    PartialEq,
 )]
 pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
@@ -118,7 +127,7 @@ impl Monitor {
         if idx == 0 {
             self.workspaces_mut().push_back(Workspace::default());
         } else {
-            self.focus_workspace(idx - 1).ok()?;
+            self.focus_workspace(idx.saturating_sub(1)).ok()?;
         };
 
         None

komorebi/src/monitor_reconciliator/hidden.rs

@@ -1,4 +1,5 @@
 use std::sync::mpsc;
+use std::time::Duration;
 
 use windows::core::PCWSTR;
 use windows::Win32::Foundation::HWND;
@@ -68,13 +69,19 @@ impl Hidden {
             let hwnd = WindowsApi::create_hidden_window(PCWSTR(name.as_ptr()), h_module)?;
             hwnd_sender.send(hwnd)?;
 
-            let mut message = MSG::default();
+            let mut msg: MSG = MSG::default();
 
-            unsafe {
-                while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
-                    TranslateMessage(&message);
-                    DispatchMessageW(&message);
+            loop {
+                unsafe {
+                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+                        tracing::debug!("hidden window event processing thread shutdown");
+                        break;
+                    };
+                    TranslateMessage(&msg);
+                    DispatchMessageW(&msg);
                 }
+
+                std::thread::sleep(Duration::from_millis(10))
             }
 
             Ok(())
@@ -103,7 +110,7 @@ impl Hidden {
                             tracing::debug!(
                                 "WM_POWERBROADCAST event received - resume from suspend"
                             );
-                            let _ = monitor_reconciliator::event_tx().send(
+                            monitor_reconciliator::send_notification(
                                 monitor_reconciliator::Notification::ResumingFromSuspendedState,
                             );
                             LRESULT(0)
@@ -113,8 +120,9 @@ impl Hidden {
                             tracing::debug!(
                                 "WM_POWERBROADCAST event received - entering suspended state"
                             );
-                            let _ = monitor_reconciliator::event_tx()
-                                .send(monitor_reconciliator::Notification::EnteringSuspendedState);
+                            monitor_reconciliator::send_notification(
+                                monitor_reconciliator::Notification::EnteringSuspendedState,
+                            );
                             LRESULT(0)
                         }
                         _ => LRESULT(0),
@@ -125,14 +133,16 @@ impl Hidden {
                         WTS_SESSION_LOCK => {
                             tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_LOCK - screen locked");
 
-                            let _ = monitor_reconciliator::event_tx()
-                                .send(monitor_reconciliator::Notification::SessionLocked);
+                            monitor_reconciliator::send_notification(
+                                monitor_reconciliator::Notification::SessionLocked,
+                            );
                         }
                         WTS_SESSION_UNLOCK => {
                             tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_UNLOCK - screen unlocked");
 
-                            let _ = monitor_reconciliator::event_tx()
-                                .send(monitor_reconciliator::Notification::SessionUnlocked);
+                            monitor_reconciliator::send_notification(
+                                monitor_reconciliator::Notification::SessionUnlocked,
+                            );
                         }
                         _ => {}
                     }
@@ -151,8 +161,9 @@ impl Hidden {
                         "WM_DISPLAYCHANGE event received with wparam: {}- work area or display resolution changed", wparam.0
                     );
 
-                    let _ = monitor_reconciliator::event_tx()
-                        .send(monitor_reconciliator::Notification::ResolutionScalingChanged);
+                    monitor_reconciliator::send_notification(
+                        monitor_reconciliator::Notification::ResolutionScalingChanged,
+                    );
                     LRESULT(0)
                 }
                 // Unfortunately this is the event sent with ButteryTaskbar which I use a lot
@@ -164,8 +175,9 @@ impl Hidden {
                                 "WM_SETTINGCHANGE event received with SPI_SETWORKAREA - work area changed (probably butterytaskbar or something similar)"
                             );
 
-                        let _ = monitor_reconciliator::event_tx()
-                            .send(monitor_reconciliator::Notification::WorkAreaChanged);
+                        monitor_reconciliator::send_notification(
+                            monitor_reconciliator::Notification::WorkAreaChanged,
+                        );
                     }
                     LRESULT(0)
                 }
@@ -177,8 +189,9 @@ impl Hidden {
                         tracing::debug!(
                                 "WM_DEVICECHANGE event received with DBT_DEVNODES_CHANGED - display added or removed"
                             );
-                        let _ = monitor_reconciliator::event_tx()
-                            .send(monitor_reconciliator::Notification::DisplayConnectionChange);
+                        monitor_reconciliator::send_notification(
+                            monitor_reconciliator::Notification::DisplayConnectionChange,
+                        );
                     }
 
                     LRESULT(0)

komorebi/src/monitor_reconciliator/mod.rs

@@ -40,14 +40,20 @@ pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
     CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
 }
 
-pub fn event_tx() -> Sender<Notification> {
+fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-pub fn event_rx() -> Receiver<Notification> {
+fn event_rx() -> Receiver<Notification> {
     channel().1.clone()
 }
 
+pub fn send_notification(notification: Notification) {
+    if event_tx().try_send(notification).is_err() {
+        tracing::warn!("channel is full; dropping notification")
+    }
+}
+
 pub fn insert_in_monitor_cache(device_id: &str, config: MonitorConfig) {
     let mut monitor_cache = MONITOR_CACHE
         .get_or_init(|| Mutex::new(HashMap::new()))
@@ -57,7 +63,7 @@ pub fn insert_in_monitor_cache(device_id: &str, config: MonitorConfig) {
 }
 
 pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
-    Ok(win32_display_data::connected_displays()
+    Ok(win32_display_data::connected_displays_all()
         .flatten()
         .map(|display| {
             let path = display.device_path;
@@ -160,7 +166,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     if should_update {
                         tracing::info!("updated work area for {}", monitor.device_id());
                         monitor.update_focused_workspace(offset)?;
-                        border_manager::event_tx().send(border_manager::Notification)?;
+                        border_manager::send_notification();
                     } else {
                         tracing::debug!(
                             "work areas match, reconciliation not required for {}",
@@ -207,7 +213,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         );
 
                         monitor.update_focused_workspace(offset)?;
-                        border_manager::event_tx().send(border_manager::Notification)?;
+                        border_manager::send_notification();
                     } else {
                         tracing::debug!(
                             "resolutions match, reconciliation not required for {}",
@@ -394,7 +400,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // Second retile to fix DPI/resolution related jank
                     wm.retile_all(true)?;
                     // Border updates to fix DPI/resolution related jank
-                    border_manager::event_tx().send(border_manager::Notification)?;
+                    border_manager::send_notification();
                 }
             }
         }

komorebi/src/process_command.rs

@@ -45,6 +45,7 @@ use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
 use crate::static_config::StaticConfig;
+use crate::transparency_manager;
 use crate::window::RuleDebug;
 use crate::window::Window;
 use crate::window_manager;
@@ -80,26 +81,33 @@ use stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    let listener = wm
-        .lock()
-        .command_listener
-        .try_clone()
-        .expect("could not clone unix listener");
+    std::thread::spawn(move || loop {
+        let wm = wm.clone();
 
-    std::thread::spawn(move || {
-        tracing::info!("listening on komorebi.sock");
-        for client in listener.incoming() {
-            match client {
-                Ok(stream) => match read_commands_uds(&wm, stream) {
-                    Ok(()) => {}
-                    Err(error) => tracing::error!("{}", error),
-                },
-                Err(error) => {
-                    tracing::error!("{}", error);
-                    break;
+        let _ = std::thread::spawn(move || {
+            let listener = wm
+                .lock()
+                .command_listener
+                .try_clone()
+                .expect("could not clone unix listener");
+
+            tracing::info!("listening on komorebi.sock");
+            for client in listener.incoming() {
+                match client {
+                    Ok(stream) => match read_commands_uds(&wm, stream) {
+                        Ok(()) => {}
+                        Err(error) => tracing::error!("{}", error),
+                    },
+                    Err(error) => {
+                        tracing::error!("{}", error);
+                        break;
+                    }
                 }
             }
-        }
+        })
+        .join();
+
+        tracing::error!("restarting failed thread");
     });
 }
 
@@ -205,6 +213,8 @@ impl WindowManager {
             }
             SocketMessage::StackWindow(direction) => self.add_window_to_container(direction)?,
             SocketMessage::UnstackWindow => self.remove_window_from_container()?,
+            SocketMessage::StackAll => self.stack_all()?,
+            SocketMessage::UnstackAll => self.unstack_all()?,
             SocketMessage::CycleStack(direction) => {
                 self.cycle_container_window_in_direction(direction)?;
                 self.focused_window()?.focus(self.mouse_follows_focus)?;
@@ -215,8 +225,12 @@ impl WindowManager {
                 WindowsApi::center_cursor_in_rect(&focused_window_rect)?;
                 WindowsApi::left_click();
             }
-            SocketMessage::Close => self.focused_window()?.close()?,
-            SocketMessage::Minimize => self.focused_window()?.minimize(),
+            SocketMessage::Close => {
+                Window::from(WindowsApi::foreground_window()?).close()?;
+            }
+            SocketMessage::Minimize => {
+                Window::from(WindowsApi::foreground_window()?).minimize();
+            }
             SocketMessage::ToggleFloat => self.toggle_float()?,
             SocketMessage::ToggleMonocle => self.toggle_monocle()?,
             SocketMessage::ToggleMaximize => self.toggle_maximize()?,
@@ -784,15 +798,22 @@ impl WindowManager {
                     }
                 }
 
-                let visible_windows_state =
-                    match serde_json::to_string_pretty(&monitor_visible_windows) {
-                        Ok(state) => state,
-                        Err(error) => error.to_string(),
-                    };
+                let visible_windows_state = serde_json::to_string_pretty(&monitor_visible_windows)
+                    .unwrap_or_else(|error| error.to_string());
 
                 reply.write_all(visible_windows_state.as_bytes())?;
             }
+            SocketMessage::MonitorInformation => {
+                let mut monitors = HashMap::new();
+                for monitor in self.monitors() {
+                    monitors.insert(monitor.device_id(), monitor.size());
+                }
 
+                let monitors_state = serde_json::to_string_pretty(&monitors)
+                    .unwrap_or_else(|error| error.to_string());
+
+                reply.write_all(monitors_state.as_bytes())?;
+            }
             SocketMessage::Query(query) => {
                 let response = match query {
                     StateQuery::FocusedMonitorIndex => self.focused_monitor_idx(),
@@ -1235,8 +1256,7 @@ impl WindowManager {
                 }
             },
             SocketMessage::BorderStyle(style) => {
-                let mut border_style = STYLE.lock();
-                *border_style = style;
+                STYLE.store(style);
             }
             SocketMessage::BorderWidth(width) => {
                 border_manager::BORDER_WIDTH.store(width, Ordering::SeqCst);
@@ -1244,6 +1264,12 @@ impl WindowManager {
             SocketMessage::BorderOffset(offset) => {
                 border_manager::BORDER_OFFSET.store(offset, Ordering::SeqCst);
             }
+            SocketMessage::Transparency(enable) => {
+                transparency_manager::TRANSPARENCY_ENABLED.store(enable, Ordering::SeqCst);
+            }
+            SocketMessage::TransparencyAlpha(alpha) => {
+                transparency_manager::TRANSPARENCY_ALPHA.store(alpha, Ordering::SeqCst);
+            }
             SocketMessage::StackbarMode(mode) => {
                 STACKBAR_MODE.store(mode);
             }
@@ -1316,7 +1342,7 @@ impl WindowManager {
                 self.update_focused_workspace(false, false)?;
             }
             SocketMessage::DebugWindow(hwnd) => {
-                let window = Window { hwnd };
+                let window = Window::from(hwnd);
                 let mut rule_debug = RuleDebug::default();
                 let _ = window.should_manage(None, &mut rule_debug);
                 let schema = serde_json::to_string_pretty(&rule_debug)?;
@@ -1334,8 +1360,9 @@ 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)?;
+        border_manager::send_notification();
+        transparency_manager::send_notification();
+        stackbar_manager::send_notification();
 
         tracing::info!("processed");
         Ok(())

komorebi/src/process_event.rs

@@ -6,6 +6,7 @@ use std::time::Instant;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
 
 use komorebi_core::OperationDirection;
@@ -19,11 +20,13 @@ use crate::border_manager::BORDER_WIDTH;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
+use crate::transparency_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;
@@ -42,7 +45,8 @@ pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
         tracing::info!("listening");
         loop {
             if let Ok(event) = receiver.recv() {
-                match wm.lock().process_event(event) {
+                let mut guard = wm.lock();
+                match guard.process_event(event) {
                     Ok(()) => {}
                     Err(error) => {
                         if cfg!(debug_assertions) {
@@ -73,7 +77,32 @@ impl WindowManager {
         // All event handlers below this point should only be processed if the event is
         // related to a window that should be managed by the WindowManager.
         if !should_manage {
-            return Ok(());
+            let mut transparency_override = false;
+
+            if transparency_manager::TRANSPARENCY_ENABLED.load_consume() {
+                for m in self.monitors() {
+                    for w in m.workspaces() {
+                        let event_hwnd = event.window().hwnd;
+
+                        let visible_hwnds = w
+                            .visible_windows()
+                            .iter()
+                            .flatten()
+                            .map(|w| w.hwnd)
+                            .collect::<Vec<_>>();
+
+                        if w.contains_managed_window(event_hwnd)
+                            && !visible_hwnds.contains(&event_hwnd)
+                        {
+                            transparency_override = true;
+                        }
+                    }
+                }
+            }
+
+            if !transparency_override {
+                return Ok(());
+            }
         }
 
         if let Some(virtual_desktop_id) = &self.virtual_desktop_id {
@@ -120,37 +149,11 @@ impl WindowManager {
             _ => {}
         }
 
-        let offset = self.work_area_offset;
-
-        for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
-            let work_area = *monitor.work_area_size();
-            let window_based_work_area_offset = (
-                monitor.window_based_work_area_offset_limit(),
-                monitor.window_based_work_area_offset(),
-            );
-
-            let offset = if monitor.work_area_offset().is_some() {
-                monitor.work_area_offset()
-            } else {
-                offset
-            };
-
-            for (j, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
+        for monitor in self.monitors_mut() {
+            for workspace in monitor.workspaces_mut() {
                 if let WindowManagerEvent::FocusChange(_, window) = event {
                     let _ = workspace.focus_changed(window.hwnd);
                 }
-
-                let reaped_orphans = workspace.reap_orphans()?;
-                if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
-                    workspace.update(&work_area, offset, window_based_work_area_offset)?;
-                    tracing::info!(
-                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
-                        reaped_orphans.0,
-                        reaped_orphans.1,
-                        i,
-                        j
-                    );
-                }
             }
         }
 
@@ -296,13 +299,7 @@ impl WindowManager {
                                 }
                             }
 
-                            workspace_reconciliator::event_tx().send(
-                                workspace_reconciliator::Notification {
-                                    monitor_idx: i,
-                                    workspace_idx: j,
-                                },
-                            )?;
-
+                            workspace_reconciliator::send_notification(i, j);
                             needs_reconciliation = true;
                         }
                     }
@@ -335,7 +332,7 @@ impl WindowManager {
                     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();
+                    let monocle_container = workspace.monocle_container().clone();
 
                     if !workspace_contains_window && !needs_reconciliation {
                         match behaviour {
@@ -353,10 +350,18 @@ impl WindowManager {
                         }
                     }
 
-                    if matches!(event, WindowManagerEvent::Uncloak(_, _)) {
-                        if workspace_contains_window && workspace_has_monocle_container {
-                            self.toggle_monocle()?;
-                            window.focus(self.mouse_follows_focus)?;
+                    if workspace_contains_window {
+                        let mut monocle_window_event = false;
+                        if let Some(ref monocle) = monocle_container {
+                            if let Some(monocle_window) = monocle.focused_window() {
+                                if monocle_window.hwnd == window.hwnd {
+                                    monocle_window_event = true;
+                                }
+                            }
+                        }
+
+                        if !monocle_window_event && monocle_container.is_some() {
+                            window.hide();
                         }
                     }
                 }
@@ -588,10 +593,9 @@ impl WindowManager {
                     }
                 }
             }
-            WindowManagerEvent::ForceUpdate(_) => {
-                self.update_focused_workspace(false, true)?;
-            }
-            WindowManagerEvent::MouseCapture(..) | WindowManagerEvent::Cloak(..) => {}
+            WindowManagerEvent::MouseCapture(..)
+            | WindowManagerEvent::Cloak(..)
+            | WindowManagerEvent::TitleUpdate(..) => {}
         };
 
         // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
@@ -626,10 +630,20 @@ 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)?;
+        border_manager::send_notification();
+        transparency_manager::send_notification();
+        stackbar_manager::send_notification();
+
+        // Too many spammy OBJECT_NAMECHANGE events from JetBrains IDEs
+        if !matches!(
+            event,
+            WindowManagerEvent::Show(WinEvent::ObjectNameChange, _)
+        ) {
+            tracing::info!("processed: {}", event.window().to_string());
+        } else {
+            tracing::trace!("processed: {}", event.window().to_string());
+        }
 
-        tracing::info!("processed: {}", event.window().to_string());
         Ok(())
     }
 }

komorebi/src/reaper.rs

@@ -0,0 +1,66 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
+
+use crate::border_manager;
+use crate::WindowManager;
+use parking_lot::Mutex;
+use std::sync::Arc;
+use std::time::Duration;
+
+pub fn watch_for_orphans(wm: Arc<Mutex<WindowManager>>) {
+    std::thread::spawn(move || loop {
+        match find_orphans(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                if cfg!(debug_assertions) {
+                    tracing::error!("restarting failed thread: {:?}", error)
+                } else {
+                    tracing::error!("restarting failed thread: {}", error)
+                }
+            }
+        }
+    });
+}
+
+pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
+    tracing::info!("watching");
+
+    let arc = wm.clone();
+
+    loop {
+        std::thread::sleep(Duration::from_secs(1));
+
+        let mut wm = arc.lock();
+        let offset = wm.work_area_offset;
+
+        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
+            let work_area = *monitor.work_area_size();
+            let window_based_work_area_offset = (
+                monitor.window_based_work_area_offset_limit(),
+                monitor.window_based_work_area_offset(),
+            );
+
+            let offset = if monitor.work_area_offset().is_some() {
+                monitor.work_area_offset()
+            } else {
+                offset
+            };
+
+            for (j, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
+                let reaped_orphans = workspace.reap_orphans()?;
+                if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
+                    workspace.update(&work_area, offset, window_based_work_area_offset)?;
+                    border_manager::send_notification();
+                    tracing::info!(
+                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
+                        reaped_orphans.0,
+                        reaped_orphans.1,
+                        i,
+                        j
+                    );
+                }
+            }
+        }
+    }
+}

komorebi/src/ring.rs

@@ -4,7 +4,7 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct Ring<T> {
     elements: VecDeque<T>,
     focused: usize,

komorebi/src/stackbar_manager/mod.rs

@@ -40,17 +40,23 @@ 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)
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
 }
 
-pub fn event_tx() -> Sender<Notification> {
+fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-pub fn event_rx() -> Receiver<Notification> {
+fn event_rx() -> Receiver<Notification> {
     channel().1.clone()
 }
 
+pub fn send_notification() {
+    if event_tx().try_send(Notification).is_err() {
+        tracing::warn!("channel is full; dropping notification")
+    }
+}
+
 pub fn should_have_stackbar(window_count: usize) -> bool {
     match STACKBAR_MODE.load() {
         StackbarMode::Always => true,
@@ -136,6 +142,27 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     continue 'receiver;
                 }
 
+                // Destroy any stackbars not associated with the focused workspace
+                let container_ids = ws
+                    .containers()
+                    .iter()
+                    .map(|c| c.id().clone())
+                    .collect::<Vec<_>>();
+
+                let mut to_remove = vec![];
+                for (id, stackbar) in stackbars.iter() {
+                    if stackbars_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                        && !container_ids.contains(id)
+                    {
+                        stackbar.destroy()?;
+                        to_remove.push(id.clone());
+                    }
+                }
+
+                for id in &to_remove {
+                    stackbars.remove(id);
+                }
+
                 let container_padding = ws
                     .container_padding()
                     .unwrap_or_else(|| DEFAULT_CONTAINER_PADDING.load_consume());

komorebi/src/stackbar_manager/stackbar.rs

@@ -27,6 +27,7 @@ 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::DeleteObject;
 use windows::Win32::Graphics::Gdi::DrawTextW;
 use windows::Win32::Graphics::Gdi::GetDC;
 use windows::Win32::Graphics::Gdi::Rectangle;
@@ -119,11 +120,17 @@ impl Stackbar {
                 SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
                 hwnd_sender.send(hwnd)?;
 
-                let mut msg = MSG::default();
-                while GetMessageW(&mut msg, hwnd, 0, 0).into() {
+                let mut msg: MSG = MSG::default();
+
+                loop {
+                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+                        tracing::debug!("stackbar window event processing thread shutdown");
+                        break;
+                    };
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
-                    std::thread::sleep(Duration::from_millis(10));
+
+                    std::thread::sleep(Duration::from_millis(10))
                 }
             }
 
@@ -197,7 +204,7 @@ impl Stackbar {
                     bottom: height,
                 };
 
-                match *STYLE.lock() {
+                match STYLE.load() {
                     BorderStyle::System => {
                         if *WINDOWS_11 {
                             RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
@@ -235,6 +242,9 @@ impl Stackbar {
             }
 
             ReleaseDC(self.hwnd(), hdc);
+            DeleteObject(hpen);
+            DeleteObject(hbrush);
+            DeleteObject(hfont);
         }
 
         Ok(())

komorebi/src/static_config.rs

@@ -14,6 +14,7 @@ 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::transparency_manager;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -229,7 +230,7 @@ impl From<&Monitor> for MonitorConfig {
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.25`
+/// The `komorebi.json` static configuration file reference for `v0.1.27`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -278,6 +279,12 @@ pub struct StaticConfig {
     /// Active window border z-order (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub border_z_order: Option<ZOrder>,
+    /// Add transparency to unfocused windows (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub transparency: Option<bool>,
+    /// Alpha value for unfocused window transparency [[0-255]] (default: 200)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub transparency_alpha: Option<u8>,
     /// Global default workspace padding (default: 10)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub default_workspace_padding: Option<i32>,
@@ -322,6 +329,48 @@ pub struct StaticConfig {
     pub stackbar: Option<StackbarConfig>,
 }
 
+impl StaticConfig {
+    pub fn aliases(raw: &str) {
+        let mut map = HashMap::new();
+        map.insert("border", ["active_window_border"]);
+        map.insert("border_width", ["active_window_border_width"]);
+        map.insert("border_offset", ["active_window_border_offset"]);
+        map.insert("border_colours", ["active_window_border_colours"]);
+        map.insert("border_style", ["active_window_border_style"]);
+
+        let mut display = false;
+
+        for aliases in map.values() {
+            for a in aliases {
+                if raw.contains(a) {
+                    display = true;
+                }
+            }
+        }
+
+        if display {
+            println!("\nYour configuration file contains some options that have been renamed or deprecated:\n");
+            for (canonical, aliases) in map {
+                for alias in aliases {
+                    if raw.contains(alias) {
+                        println!(r#""{alias}" is now "{canonical}""#);
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn deprecated(raw: &str) {
+        let deprecated = ["invisible_borders"];
+
+        for option in deprecated {
+            if raw.contains(option) {
+                println!(r#""{option}" is deprecated and can be removed"#);
+            }
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct TabsConfig {
     /// Width of a stackbar tab
@@ -426,8 +475,14 @@ impl From<&WindowManager> for StaticConfig {
             border_offset: Option::from(border_manager::BORDER_OFFSET.load(Ordering::SeqCst)),
             border: Option::from(border_manager::BORDER_ENABLED.load(Ordering::SeqCst)),
             border_colours,
-            border_style: Option::from(*STYLE.lock()),
-            border_z_order: Option::from(*Z_ORDER.lock()),
+            transparency: Option::from(
+                transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst),
+            ),
+            transparency_alpha: Option::from(
+                transparency_manager::TRANSPARENCY_ALPHA.load(Ordering::SeqCst),
+            ),
+            border_style: Option::from(STYLE.load()),
+            border_z_order: Option::from(Z_ORDER.load()),
             default_workspace_padding: Option::from(
                 DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
             ),
@@ -455,12 +510,12 @@ impl StaticConfig {
     fn apply_globals(&mut self) -> Result<()> {
         if let Some(monitor_index_preferences) = &self.monitor_index_preferences {
             let mut preferences = MONITOR_INDEX_PREFERENCES.lock();
-            *preferences = monitor_index_preferences.clone();
+            preferences.clone_from(monitor_index_preferences);
         }
 
         if let Some(display_index_preferences) = &self.display_index_preferences {
             let mut preferences = DISPLAY_INDEX_PREFERENCES.lock();
-            *preferences = display_index_preferences.clone();
+            preferences.clone_from(display_index_preferences);
         }
 
         if let Some(behaviour) = self.window_hiding_behaviour {
@@ -501,8 +556,12 @@ impl StaticConfig {
             }
         }
 
-        let border_style = self.border_style.unwrap_or_default();
-        *STYLE.lock() = border_style;
+        STYLE.store(self.border_style.unwrap_or_default());
+
+        transparency_manager::TRANSPARENCY_ENABLED
+            .store(self.transparency.unwrap_or(false), Ordering::SeqCst);
+        transparency_manager::TRANSPARENCY_ALPHA
+            .store(self.transparency_alpha.unwrap_or(200), Ordering::SeqCst);
 
         let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
         let mut regex_identifiers = REGEX_IDENTIFIERS.lock();

komorebi/src/transparency_manager.rs

@@ -0,0 +1,179 @@
+#![deny(clippy::unwrap_used, clippy::expect_used)]
+
+use crossbeam_channel::Receiver;
+use crossbeam_channel::Sender;
+use crossbeam_utils::atomic::AtomicConsume;
+use parking_lot::Mutex;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicU8;
+use std::sync::Arc;
+use std::sync::OnceLock;
+use windows::Win32::Foundation::HWND;
+
+use crate::Window;
+use crate::WindowManager;
+use crate::WindowsApi;
+
+pub static TRANSPARENCY_ENABLED: AtomicBool = AtomicBool::new(false);
+pub static TRANSPARENCY_ALPHA: AtomicU8 = AtomicU8::new(200);
+
+static KNOWN_HWNDS: OnceLock<Mutex<Vec<isize>>> = OnceLock::new();
+
+pub struct Notification;
+
+static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
+
+pub fn known_hwnds() -> Vec<isize> {
+    let known = KNOWN_HWNDS.get_or_init(|| Mutex::new(Vec::new())).lock();
+    known.iter().copied().collect()
+}
+
+pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
+}
+
+fn event_tx() -> Sender<Notification> {
+    channel().0.clone()
+}
+
+fn event_rx() -> Receiver<Notification> {
+    channel().1.clone()
+}
+
+pub fn send_notification() {
+    if event_tx().try_send(Notification).is_err() {
+        tracing::warn!("channel is full; dropping notification")
+    }
+}
+
+pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
+            }
+        }
+    });
+}
+
+pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
+    tracing::info!("listening");
+
+    let receiver = event_rx();
+    event_tx().send(Notification)?;
+
+    'receiver: for _ in receiver {
+        let known_hwnds = KNOWN_HWNDS.get_or_init(|| Mutex::new(Vec::new()));
+        if !TRANSPARENCY_ENABLED.load_consume() {
+            for hwnd in known_hwnds.lock().iter() {
+                if let Err(error) = Window::from(*hwnd).opaque() {
+                    tracing::error!("failed to make window {hwnd} opaque: {error}")
+                }
+            }
+
+            continue 'receiver;
+        }
+
+        known_hwnds.lock().clear();
+
+        // Check the wm state every time we receive a notification
+        let state = wm.lock();
+
+        let focused_monitor_idx = state.focused_monitor_idx();
+
+        'monitors: for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
+            let focused_workspace_idx = m.focused_workspace_idx();
+
+            'workspaces: for (workspace_idx, ws) in m.workspaces().iter().enumerate() {
+                // Only operate on the focused workspace of each monitor
+                // Workspaces with tiling disabled don't have transparent windows
+                if !ws.tile() || workspace_idx != focused_workspace_idx {
+                    for window in ws.visible_windows().iter().flatten() {
+                        if let Err(error) = window.opaque() {
+                            let hwnd = window.hwnd;
+                            tracing::error!("failed to make window {hwnd} opaque: {error}")
+                        }
+                    }
+
+                    continue 'workspaces;
+                }
+
+                // Monocle container is never transparent
+                if let Some(monocle) = ws.monocle_container() {
+                    if let Some(window) = monocle.focused_window() {
+                        if let Err(error) = window.opaque() {
+                            let hwnd = window.hwnd;
+                            tracing::error!("failed to make monocle window {hwnd} opaque: {error}")
+                        }
+                    }
+
+                    continue 'monitors;
+                }
+
+                let foreground_hwnd = WindowsApi::foreground_window().unwrap_or_default();
+                let is_maximized = WindowsApi::is_zoomed(HWND(foreground_hwnd));
+
+                if is_maximized {
+                    if let Err(error) = Window::from(foreground_hwnd).opaque() {
+                        let hwnd = foreground_hwnd;
+                        tracing::error!("failed to make maximized window {hwnd} opaque: {error}")
+                    }
+
+                    continue 'monitors;
+                }
+
+                for (idx, c) in ws.containers().iter().enumerate() {
+                    // Update the transparency for all containers on this workspace
+
+                    // If the window is not focused on the current workspace, or isn't on the focused monitor
+                    // make it transparent
+                    #[allow(clippy::collapsible_else_if)]
+                    if idx != ws.focused_container_idx() || monitor_idx != focused_monitor_idx {
+                        let focused_window_idx = c.focused_window_idx();
+                        for (window_idx, window) in c.windows().iter().enumerate() {
+                            if window_idx == focused_window_idx {
+                                match window.transparent() {
+                                    Err(error) => {
+                                        let hwnd = foreground_hwnd;
+                                        tracing::error!(
+                                    "failed to make unfocused window {hwnd} transparent: {error}"
+                                )
+                                    }
+                                    Ok(..) => {
+                                        known_hwnds.lock().push(window.hwnd);
+                                    }
+                                }
+                            } else {
+                                // just in case, this is useful when people are clicking around
+                                // on unfocused stackbar tabs
+                                known_hwnds.lock().push(window.hwnd);
+                            }
+                        }
+                    // Otherwise, make it opaque
+                    } else {
+                        let focused_window_idx = c.focused_window_idx();
+                        for (window_idx, window) in c.windows().iter().enumerate() {
+                            if window_idx != focused_window_idx {
+                                known_hwnds.lock().push(window.hwnd);
+                            } else {
+                                if let Err(error) =
+                                    c.focused_window().copied().unwrap_or_default().opaque()
+                                {
+                                    let hwnd = foreground_hwnd;
+                                    tracing::error!(
+                                        "failed to make focused window {hwnd} opaque: {error}"
+                                    )
+                                }
+                            }
+                        }
+                    };
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

komorebi/src/window.rs

@@ -7,8 +7,8 @@ use std::fmt::Write as _;
 use std::time::Duration;
 
 use color_eyre::eyre;
-use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use crossbeam_utils::atomic::AtomicConsume;
 use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
@@ -26,6 +26,7 @@ use komorebi_core::Rect;
 
 use crate::styles::ExtendedWindowStyle;
 use crate::styles::WindowStyle;
+use crate::transparency_manager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::FLOAT_IDENTIFIERS;
@@ -38,11 +39,23 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema)]
+#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema, PartialEq)]
 pub struct Window {
     pub hwnd: isize,
 }
 
+impl From<isize> for Window {
+    fn from(value: isize) -> Self {
+        Self { hwnd: value }
+    }
+}
+
+impl From<HWND> for Window {
+    fn from(value: HWND) -> Self {
+        Self { hwnd: value.0 }
+    }
+}
+
 #[allow(clippy::module_name_repetitions)]
 #[derive(Debug, Clone, Serialize, JsonSchema)]
 pub struct WindowDetails {
@@ -250,7 +263,10 @@ impl Window {
         let mut ex_style = self.ex_style()?;
         ex_style.insert(ExtendedWindowStyle::LAYERED);
         self.update_ex_style(&ex_style)?;
-        WindowsApi::set_transparent(self.hwnd())
+        WindowsApi::set_transparent(
+            self.hwnd(),
+            transparency_manager::TRANSPARENCY_ALPHA.load_consume(),
+        )
     }
 
     pub fn opaque(self) -> Result<()> {
@@ -270,12 +286,12 @@ impl Window {
 
     pub fn style(self) -> Result<WindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd())?)?;
-        WindowStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
+        Ok(WindowStyle::from_bits_truncate(bits))
     }
 
     pub fn ex_style(self) -> Result<ExtendedWindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd())?)?;
-        ExtendedWindowStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
+        Ok(ExtendedWindowStyle::from_bits_truncate(bits))
     }
 
     pub fn title(self) -> Result<String> {
@@ -375,7 +391,7 @@ impl Window {
                     if let (Ok(style), Ok(ex_style)) = (&self.style(), &self.ex_style()) {
                         debug.window_style = Some(*style);
                         debug.extended_window_style = Some(*ex_style);
-                        let eligible = window_is_eligible(&title, &exe_name, &class, &path, style, ex_style, event, debug);
+                        let eligible = window_is_eligible(self.hwnd, &title, &exe_name, &class, &path, style, ex_style, event, debug);
                         debug.should_manage = eligible;
                         return Ok(eligible);
                     }
@@ -395,6 +411,7 @@ pub struct RuleDebug {
     pub has_title: bool,
     pub is_cloaked: bool,
     pub allow_cloaked: bool,
+    pub allow_layered_transparency: bool,
     pub window_style: Option<WindowStyle>,
     pub extended_window_style: Option<ExtendedWindowStyle>,
     pub title: Option<String>,
@@ -411,6 +428,7 @@ pub struct RuleDebug {
 
 #[allow(clippy::too_many_arguments)]
 fn window_is_eligible(
+    hwnd: isize,
     title: &String,
     exe_name: &String,
     class: &String,
@@ -465,7 +483,7 @@ fn window_is_eligible(
     }
 
     let layered_whitelist = LAYERED_WHITELIST.lock();
-    let allow_layered = if let Some(rule) = should_act(
+    let mut allow_layered = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
@@ -479,8 +497,14 @@ fn window_is_eligible(
         false
     };
 
-    // TODO: might need this for transparency
-    // let allow_layered = true;
+    let known_layered_hwnds = transparency_manager::known_hwnds();
+
+    allow_layered = if known_layered_hwnds.contains(&hwnd) {
+        debug.allow_layered_transparency = true;
+        true
+    } else {
+        allow_layered
+    };
 
     let allow_wsl2_gui = {
         let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();

komorebi/src/window_manager.rs

@@ -37,6 +37,7 @@ use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
+use komorebi_core::StackbarLabel;
 use komorebi_core::WindowContainerBehaviour;
 
 use crate::border_manager;
@@ -47,12 +48,14 @@ 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_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::static_config::StaticConfig;
+use crate::transparency_manager;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -122,6 +125,7 @@ pub struct GlobalState {
     pub border_offset: i32,
     pub border_width: i32,
     pub stackbar_mode: StackbarMode,
+    pub stackbar_label: StackbarLabel,
     pub stackbar_focused_text_colour: Colour,
     pub stackbar_unfocused_text_colour: Colour,
     pub stackbar_tab_background_colour: Colour,
@@ -160,10 +164,11 @@ impl Default for GlobalState {
                     border_manager::UNFOCUSED.load(Ordering::SeqCst),
                 ))),
             },
-            border_style: *STYLE.lock(),
+            border_style: STYLE.load(),
             border_offset: border_manager::BORDER_OFFSET.load(Ordering::SeqCst),
             border_width: border_manager::BORDER_WIDTH.load(Ordering::SeqCst),
             stackbar_mode: STACKBAR_MODE.load(),
+            stackbar_label: STACKBAR_LABEL.load(),
             stackbar_focused_text_colour: Colour::Rgb(Rgb::from(
                 STACKBAR_FOCUSED_TEXT_COLOUR.load(Ordering::SeqCst),
             )),
@@ -515,7 +520,7 @@ impl WindowManager {
 
             // Hide the window we are about to remove if it is on the currently focused workspace
             if op.is_origin(focused_monitor_idx, focused_workspace_idx) {
-                Window { hwnd: op.hwnd }.hide();
+                Window::from(op.hwnd).hide();
                 should_update_focused_workspace = true;
             }
 
@@ -545,7 +550,7 @@ impl WindowManager {
                 .get_mut(op.target_workspace_idx)
                 .ok_or_else(|| anyhow!("there is no workspace with that index"))?;
 
-            target_workspace.new_container_for_window(Window { hwnd: op.hwnd });
+            target_workspace.new_container_for_window(Window::from(op.hwnd));
         }
 
         // Only re-tile the focused workspace if we need to
@@ -593,14 +598,14 @@ impl WindowManager {
     #[tracing::instrument(skip(self))]
     pub fn manage_focused_window(&mut self) -> Result<()> {
         let hwnd = WindowsApi::foreground_window()?;
-        let event = WindowManagerEvent::Manage(Window { hwnd });
+        let event = WindowManagerEvent::Manage(Window::from(hwnd));
         Ok(winevent_listener::event_tx().send(event)?)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn unmanage_focused_window(&mut self) -> Result<()> {
         let hwnd = WindowsApi::foreground_window()?;
-        let event = WindowManagerEvent::Unmanage(Window { hwnd });
+        let event = WindowManagerEvent::Unmanage(Window::from(hwnd));
         Ok(winevent_listener::event_tx().send(event)?)
     }
 
@@ -609,6 +614,7 @@ impl WindowManager {
         let mut hwnd = None;
 
         let workspace = self.focused_workspace()?;
+        // first check the focused workspace
         if let Some(container_idx) = workspace.container_idx_from_current_point() {
             if let Some(container) = workspace.containers().get(container_idx) {
                 if let Some(window) = container.focused_window() {
@@ -617,6 +623,34 @@ impl WindowManager {
             }
         }
 
+        // then check all workspaces
+        if hwnd.is_none() {
+            for monitor in self.monitors() {
+                for ws in monitor.workspaces() {
+                    if let Some(container_idx) = ws.container_idx_from_current_point() {
+                        if let Some(container) = ws.containers().get(container_idx) {
+                            if let Some(window) = container.focused_window() {
+                                hwnd = Some(window.hwnd);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // finally try matching the other way using a hwnd returned from the cursor pos
+        if hwnd.is_none() {
+            let cursor_pos_hwnd = WindowsApi::window_at_cursor_pos()?;
+
+            for monitor in self.monitors() {
+                for ws in monitor.workspaces() {
+                    if ws.container_for_window(cursor_pos_hwnd).is_some() {
+                        hwnd = Some(cursor_pos_hwnd);
+                    }
+                }
+            }
+        }
+
         if let Some(hwnd) = hwnd {
             if self.has_pending_raise_op
                     || self.focused_window()?.hwnd == hwnd
@@ -628,15 +662,13 @@ impl WindowManager {
                 return Ok(());
             }
 
-            let event = WindowManagerEvent::Raise(Window { hwnd });
+            let event = WindowManagerEvent::Raise(Window::from(hwnd));
             self.has_pending_raise_op = true;
             winevent_listener::event_tx().send(event)?;
         } else {
             tracing::debug!(
                 "not raising unknown window: {}",
-                Window {
-                    hwnd: WindowsApi::window_at_cursor_pos()?
-                }
+                Window::from(WindowsApi::window_at_cursor_pos()?)
             );
         }
 
@@ -760,9 +792,7 @@ impl WindowManager {
                     window.focus(self.mouse_follows_focus)?;
                 }
             } else {
-                let desktop_window = Window {
-                    hwnd: WindowsApi::desktop_window()?,
-                };
+                let desktop_window = Window::from(WindowsApi::desktop_window()?);
 
                 let rect = self.focused_monitor_size()?;
                 WindowsApi::center_cursor_in_rect(&rect)?;
@@ -903,6 +933,7 @@ impl WindowManager {
         tracing::info!("restoring all hidden windows");
 
         let no_titlebar = NO_TITLEBAR.lock();
+        let known_transparent_hwnds = transparency_manager::known_hwnds();
 
         for monitor in self.monitors_mut() {
             for workspace in monitor.workspaces_mut() {
@@ -912,6 +943,10 @@ impl WindowManager {
                             window.add_title_bar()?;
                         }
 
+                        if known_transparent_hwnds.contains(&window.hwnd) {
+                            window.opaque()?;
+                        }
+
                         window.restore();
                     }
                 }
@@ -1033,6 +1068,14 @@ impl WindowManager {
 
         tracing::info!("moving container");
 
+        let focused_monitor_idx = self.focused_monitor_idx();
+
+        if focused_monitor_idx == monitor_idx {
+            if let Some(workspace_idx) = workspace_idx {
+                return self.move_container_to_workspace(workspace_idx, follow);
+            }
+        }
+
         let offset = self.work_area_offset;
         let mouse_follows_focus = self.mouse_follows_focus;
 
@@ -1052,6 +1095,12 @@ impl WindowManager {
             .remove_focused_container()
             .ok_or_else(|| anyhow!("there is no container"))?;
 
+        let container_hwnds = container
+            .windows()
+            .iter()
+            .map(|w| w.hwnd)
+            .collect::<Vec<_>>();
+
         monitor.update_focused_workspace(offset)?;
 
         let target_monitor = self
@@ -1065,9 +1114,22 @@ impl WindowManager {
             target_monitor.focus_workspace(workspace_idx)?;
         }
 
+        if let Some(workspace) = target_monitor.focused_workspace() {
+            if !*workspace.tile() {
+                for hwnd in container_hwnds {
+                    Window::from(hwnd).center(target_monitor.work_area_size())?;
+                }
+            }
+        }
+
         target_monitor.load_focused_workspace(mouse_follows_focus)?;
         target_monitor.update_focused_workspace(offset)?;
 
+        // this second one is for DPI changes when the target is another monitor
+        // if we don't do this the layout on the other monitor could look funny
+        // until it is interacted with again
+        target_monitor.update_focused_workspace(offset)?;
+
         if follow {
             self.focus_monitor(monitor_idx)?;
         }
@@ -1113,7 +1175,7 @@ impl WindowManager {
                 .ok_or_else(|| anyhow!("there is no monitor"))?;
 
             target_monitor.workspaces_mut().push_back(workspace);
-            target_monitor.focus_workspace(target_monitor.workspaces().len() - 1)?;
+            target_monitor.focus_workspace(target_monitor.workspaces().len().saturating_sub(1))?;
             target_monitor.load_focused_workspace(mouse_follows_focus)?;
         }
 
@@ -1248,10 +1310,9 @@ impl WindowManager {
                         let origin_workspace =
                             self.focused_workspace_for_monitor_idx_mut(origin_monitor_idx)?;
 
-                        if origin_workspace.focused_container_idx() != 0 {
-                            origin_workspace
-                                .focus_container(origin_workspace.focused_container_idx() - 1);
-                        }
+                        origin_workspace.focus_container(
+                            origin_workspace.focused_container_idx().saturating_sub(1),
+                        );
                     }
                 }
 
@@ -1402,6 +1463,67 @@ impl WindowManager {
         self.update_focused_workspace(self.mouse_follows_focus, true)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn stack_all(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+        tracing::info!("stacking all windows on workspace");
+
+        let workspace = self.focused_workspace_mut()?;
+
+        let mut focused_hwnd = None;
+        if let Some(container) = workspace.focused_container() {
+            if let Some(window) = container.focused_window() {
+                focused_hwnd = Some(window.hwnd);
+            }
+        }
+
+        workspace.focus_container(workspace.containers().len().saturating_sub(1));
+        while workspace.focused_container_idx() > 0 {
+            workspace.move_window_to_container(0)?;
+            workspace.focus_container(workspace.containers().len().saturating_sub(1));
+        }
+
+        if let Some(hwnd) = focused_hwnd {
+            workspace.focus_container_by_window(hwnd)?;
+        }
+
+        self.update_focused_workspace(self.mouse_follows_focus, true)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn unstack_all(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+        tracing::info!("unstacking all windows in container");
+
+        let workspace = self.focused_workspace_mut()?;
+
+        let mut focused_hwnd = None;
+        if let Some(container) = workspace.focused_container() {
+            if let Some(window) = container.focused_window() {
+                focused_hwnd = Some(window.hwnd);
+            }
+        }
+
+        let initial_focused_container_index = workspace.focused_container_idx();
+        let mut focused_container = workspace.focused_container().cloned();
+
+        while let Some(focused) = &focused_container {
+            if focused.windows().len() > 1 {
+                workspace.new_container_for_focused_window()?;
+                workspace.focus_container(initial_focused_container_index);
+                focused_container = workspace.focused_container().cloned();
+            } else {
+                focused_container = None;
+            }
+        }
+
+        if let Some(hwnd) = focused_hwnd {
+            workspace.focus_container_by_window(hwnd)?;
+        }
+
+        self.update_focused_workspace(self.mouse_follows_focus, true)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn add_window_to_container(&mut self, direction: OperationDirection) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
@@ -1433,12 +1555,20 @@ impl WindowManager {
                     Layout::Default(DefaultLayout::Grid)
                         | Layout::Default(DefaultLayout::UltrawideVerticalStack)
                 ) {
-                new_idx - 1
+                new_idx.saturating_sub(1)
             } else {
                 new_idx
             };
 
-            workspace.move_window_to_container(adjusted_new_index)?;
+            if let Some(current) = workspace.focused_container() {
+                if current.windows().len() > 1 {
+                    workspace.focus_container(adjusted_new_index);
+                    workspace.move_window_to_container(current_container_idx)?;
+                } else {
+                    workspace.move_window_to_container(adjusted_new_index)?;
+                }
+            }
+
             self.update_focused_workspace(self.mouse_follows_focus, false)?;
         }
 

komorebi/src/window_manager_event.rs

@@ -27,7 +27,7 @@ pub enum WindowManagerEvent {
     Manage(Window),
     Unmanage(Window),
     Raise(Window),
-    ForceUpdate(Window),
+    TitleUpdate(WinEvent, Window),
 }
 
 impl Display for WindowManagerEvent {
@@ -75,8 +75,8 @@ impl Display for WindowManagerEvent {
             Self::Raise(window) => {
                 write!(f, "Raise (Window: {window})")
             }
-            Self::ForceUpdate(window) => {
-                write!(f, "ForceUpdate (Window: {window})")
+            Self::TitleUpdate(winevent, window) => {
+                write!(f, "TitleUpdate (WinEvent: {winevent}, Window: {window})")
             }
         }
     }
@@ -98,7 +98,7 @@ impl WindowManagerEvent {
             | Self::Raise(window)
             | Self::Manage(window)
             | Self::Unmanage(window)
-            | Self::ForceUpdate(window) => window,
+            | Self::TitleUpdate(_, window) => window,
         }
     }
 
@@ -141,7 +141,7 @@ impl WindowManagerEvent {
                 let class = &window.class().ok()?;
                 let path = &window.path().ok()?;
 
-                let should_trigger = should_act(
+                let should_trigger_show = should_act(
                     title,
                     exe_name,
                     class,
@@ -151,10 +151,10 @@ impl WindowManagerEvent {
                 )
                 .is_some();
 
-                if should_trigger {
+                if should_trigger_show {
                     Option::from(Self::Show(winevent, window))
                 } else {
-                    None
+                    Option::from(Self::TitleUpdate(winevent, window))
                 }
             }
             _ => None,

komorebi/src/windows_api.rs

@@ -220,7 +220,7 @@ impl WindowsApi {
     }
 
     pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
-        Ok(win32_display_data::connected_displays()
+        Ok(win32_display_data::connected_displays_all()
             .flatten()
             .map(|d| {
                 let name = d.device_name.trim_start_matches(r"\\.\").to_string();
@@ -232,7 +232,7 @@ impl WindowsApi {
     }
 
     pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
-        'read: for display in win32_display_data::connected_displays().flatten() {
+        'read: for display in win32_display_data::connected_displays_all().flatten() {
             let path = display.device_path.clone();
             let mut split: Vec<_> = path.split('#').collect();
             split.remove(0);
@@ -276,8 +276,7 @@ impl WindowsApi {
             if monitors.elements().is_empty() {
                 monitors.elements_mut().push_back(m);
             } else if let Some(preference) = index_preference {
-                let current_len = monitors.elements().len();
-                if *preference > current_len {
+                while *preference > monitors.elements().len() {
                     monitors.elements_mut().reserve(1);
                 }
 
@@ -791,7 +790,7 @@ impl WindowsApi {
     }
 
     pub fn monitor(hmonitor: isize) -> Result<Monitor> {
-        for display in win32_display_data::connected_displays().flatten() {
+        for display in win32_display_data::connected_displays_all().flatten() {
             if display.hmonitor == hmonitor {
                 let path = display.device_path;
                 let mut split: Vec<_> = path.split('#').collect();
@@ -980,11 +979,10 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn set_transparent(hwnd: HWND) -> Result<()> {
+    pub fn set_transparent(hwnd: HWND, alpha: u8) -> Result<()> {
         unsafe {
             #[allow(clippy::cast_sign_loss)]
-            // TODO: alpha should be configurable
-            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), 150, LWA_ALPHA)?;
+            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), alpha, LWA_ALPHA)?;
         }
 
         Ok(())

komorebi/src/windows_callbacks.rs

@@ -22,7 +22,7 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let is_maximized = WindowsApi::is_zoomed(hwnd);
 
     if is_visible && is_window && !is_minimized {
-        let window = Window { hwnd: hwnd.0 };
+        let window = Window::from(hwnd);
 
         if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
             if should_manage {
@@ -48,7 +48,7 @@ pub extern "system" fn alt_tab_windows(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let is_minimized = WindowsApi::is_iconic(hwnd);
 
     if is_visible && is_window && !is_minimized {
-        let window = Window { hwnd: hwnd.0 };
+        let window = Window::from(hwnd);
 
         if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
             if should_manage {
@@ -74,14 +74,25 @@ pub extern "system" fn win_event_hook(
         return;
     }
 
-    let window = Window { hwnd: hwnd.0 };
+    let window = Window::from(hwnd);
 
     let winevent = match WinEvent::try_from(event) {
         Ok(event) => event,
         Err(_) => return,
     };
+
     let event_type = match WindowManagerEvent::from_win_event(winevent, window) {
-        None => return,
+        None => {
+            tracing::trace!(
+                "Unhandled WinEvent: {winevent} (hwnd: {}, exe: {}, title: {}, class: {})",
+                window.hwnd,
+                window.exe().unwrap_or_default(),
+                window.title().unwrap_or_default(),
+                window.class().unwrap_or_default()
+            );
+
+            return;
+        }
         Some(event) => event,
     };
 

komorebi/src/winevent_listener.rs

@@ -1,4 +1,5 @@
 use std::sync::OnceLock;
+use std::time::Duration;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
@@ -34,23 +35,26 @@ pub fn start() {
                 )
             };
 
+            let mut msg: MSG = MSG::default();
+
             loop {
-                let mut msg: MSG = MSG::default();
                 unsafe {
                     if !GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {
-                        tracing::info!("windows event processing shutdown");
+                        tracing::debug!("windows event processing thread shutdown");
                         break;
                     };
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
                 }
+
+                std::thread::sleep(Duration::from_millis(10))
             }
         })
     });
 }
 
 fn channel() -> &'static (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) {
-    CHANNEL.get_or_init(crossbeam_channel::unbounded)
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
 }
 
 pub fn event_tx() -> Sender<WindowManagerEvent> {

komorebi/src/workspace.rs

@@ -38,7 +38,16 @@ use crate::REMOVE_TITLEBARS;
 
 #[allow(clippy::struct_field_names)]
 #[derive(
-    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema,
+    Debug,
+    Clone,
+    Serialize,
+    Deserialize,
+    Getters,
+    CopyGetters,
+    MutGetters,
+    Setters,
+    JsonSchema,
+    PartialEq,
 )]
 pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
@@ -357,7 +366,7 @@ impl Workspace {
                             layout.bottom -= total_height;
                         }
 
-                        window.set_position(&layout, false)?;
+                        window.set_position(layout, false)?;
                     }
                 }
 
@@ -397,6 +406,28 @@ impl Workspace {
     pub fn reap_orphans(&mut self) -> Result<(usize, usize)> {
         let mut hwnds = vec![];
         let mut floating_hwnds = vec![];
+        let mut remove_monocle = false;
+        let mut remove_maximized = false;
+
+        if let Some(monocle) = &self.monocle_container {
+            let window_count = monocle.windows().len();
+            let mut orphan_count = 0;
+            for window in monocle.windows() {
+                if !window.is_window() {
+                    hwnds.push(window.hwnd);
+                    orphan_count += 1;
+                }
+            }
+
+            remove_monocle = orphan_count == window_count;
+        }
+
+        if let Some(window) = &self.maximized_window {
+            if !window.is_window() {
+                hwnds.push(window.hwnd);
+                remove_maximized = true;
+            }
+        }
 
         for window in self.visible_windows_mut().into_iter().flatten() {
             if !window.is_window() {
@@ -431,6 +462,14 @@ impl Workspace {
         self.containers_mut()
             .retain(|c| !container_ids.contains(c.id()));
 
+        if remove_monocle {
+            self.set_monocle_container(None);
+        }
+
+        if remove_maximized {
+            self.set_maximized_window(None);
+        }
+
         Ok((hwnds.len() + floating_hwnds.len(), container_ids.len()))
     }
 
@@ -660,6 +699,10 @@ impl Workspace {
                     self.set_monocle_container_restore_idx(None);
                 }
 
+                for c in self.containers() {
+                    c.restore();
+                }
+
                 return Ok(());
             }
         }
@@ -759,7 +802,7 @@ impl Workspace {
             self.resize_dimensions_mut().remove(focused_idx);
 
             if focused_idx < target_container_idx {
-                target_container_idx - 1
+                target_container_idx.saturating_sub(1)
             } else {
                 target_container_idx
             }
@@ -881,8 +924,8 @@ impl Workspace {
                 self.containers_mut().remove(focused_idx);
                 self.resize_dimensions_mut().remove(focused_idx);
 
-                if focused_idx == self.containers().len() && focused_idx != 0 {
-                    self.focus_container(focused_idx - 1);
+                if focused_idx == self.containers().len() {
+                    self.focus_container(focused_idx.saturating_sub(1));
                 }
             } else {
                 container.load_focused_window();
@@ -1290,7 +1333,8 @@ impl Workspace {
             .ok_or_else(|| anyhow!("there is no monocle container"))?;
 
         let window = *window;
-        if !self.containers().is_empty() && restore_idx > self.containers().len() - 1 {
+        if !self.containers().is_empty() && restore_idx > self.containers().len().saturating_sub(1)
+        {
             self.containers_mut()
                 .resize(restore_idx, Container::default());
         }
@@ -1379,13 +1423,10 @@ impl Workspace {
 
     pub fn focus_previous_container(&mut self) {
         let focused_idx = self.focused_container_idx();
-
-        if focused_idx != 0 {
-            self.focus_container(focused_idx - 1);
-        }
+        self.focus_container(focused_idx.saturating_sub(1));
     }
 
     fn focus_last_container(&mut self) {
-        self.focus_container(self.containers().len() - 1);
+        self.focus_container(self.containers().len().saturating_sub(1));
     }
 }

komorebi/src/workspace_reconciliator.rs

@@ -30,14 +30,26 @@ pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
     CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
 }
 
-pub fn event_tx() -> Sender<Notification> {
+fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-pub fn event_rx() -> Receiver<Notification> {
+fn event_rx() -> Receiver<Notification> {
     channel().1.clone()
 }
 
+pub fn send_notification(monitor_idx: usize, workspace_idx: usize) {
+    if event_tx()
+        .try_send(Notification {
+            monitor_idx,
+            workspace_idx,
+        })
+        .is_err()
+    {
+        tracing::warn!("channel is full; dropping notification")
+    }
+}
+
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
     std::thread::spawn(move || loop {
         match handle_notifications(wm.clone()) {
@@ -106,7 +118,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // Unblock the border manager
                     ALT_TAB_HWND.store(None);
                     // Send a notification to the border manager to update the borders
-                    border_manager::event_tx().send(border_manager::Notification)?;
+                    border_manager::send_notification();
                 }
             }
         }

komorebic-no-console/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.26-dev.0"
+version = "0.1.27"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.26-dev.0"
+version = "0.1.27"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
@@ -11,7 +11,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-derive-ahk = { path = "../derive-ahk" }
 komorebi-core = { path = "../komorebi-core" }
 komorebi-client = { path = "../komorebi-client" }
 
@@ -21,7 +20,6 @@ color-eyre = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 fs-tail = "0.1"
-heck = "0.5"
 lazy_static = "1"
 miette = { version = "7", features = ["fancy"] }
 paste = "1"
@@ -34,6 +32,7 @@ sysinfo = { workspace = true }
 thiserror = "1"
 uds_windows = "1"
 which = "6"
+win32-display-data = { workspace = true }
 windows = { workspace = true }
 
 [build-dependencies]

komorebic/src/main.rs

@@ -1,7 +1,7 @@
-#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc)]
+#![warn(clippy::all)]
+#![allow(clippy::missing_errors_doc, clippy::doc_markdown)]
 
-use chrono::Local;
+use chrono::Utc;
 use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
@@ -24,7 +24,6 @@ use color_eyre::eyre::bail;
 use color_eyre::Result;
 use dirs::data_local_dir;
 use fs_tail::TailedFile;
-use heck::ToKebabCase;
 use komorebi_core::resolve_home_path;
 use lazy_static::lazy_static;
 use miette::NamedSource;
@@ -39,8 +38,7 @@ use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
 
-use derive_ahk::AhkFunction;
-use derive_ahk::AhkLibrary;
+use komorebi_client::StaticConfig;
 use komorebi_core::config_generation::ApplicationConfigurationGenerator;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
@@ -101,14 +99,6 @@ lazy_static! {
     };
 }
 
-trait AhkLibrary {
-    fn generate_ahk_library() -> String;
-}
-
-trait AhkFunction {
-    fn generate_ahk_function() -> String;
-}
-
 #[derive(thiserror::Error, Debug, miette::Diagnostic)]
 #[error("{message}")]
 #[diagnostic(code(komorebi::configuration), help("try fixing this syntax error"))]
@@ -140,7 +130,7 @@ macro_rules! gen_enum_subcommand_args {
     ( $( $name:ident: $element:ty ),+ $(,)? ) => {
         $(
             paste! {
-                #[derive(clap::Parser, derive_ahk::AhkFunction)]
+                #[derive(clap::Parser)]
                 pub struct $name {
                     #[clap(value_enum)]
                     [<$element:snake>]: $element
@@ -180,7 +170,7 @@ macro_rules! gen_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 /// Target index (zero-indexed)
                 target: usize,
@@ -205,7 +195,7 @@ macro_rules! gen_named_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 /// Target workspace name
                 workspace: String,
@@ -229,7 +219,7 @@ macro_rules! gen_workspace_subcommand_args {
     ( $( $name:ident: $(#[enum] $(@$value_enum:tt)?)? $value:ty ),+ $(,)? ) => (
         paste! {
             $(
-                #[derive(clap::Parser, derive_ahk::AhkFunction)]
+                #[derive(clap::Parser)]
                 pub struct [<Workspace $name>] {
                     /// Monitor index (zero-indexed)
                     monitor: usize,
@@ -261,7 +251,7 @@ macro_rules! gen_named_workspace_subcommand_args {
     ( $( $name:ident: $(#[enum] $(@$value_enum:tt)?)? $value:ty ),+ $(,)? ) => (
         paste! {
             $(
-                #[derive(clap::Parser, derive_ahk::AhkFunction)]
+                #[derive(clap::Parser)]
                 pub struct [<NamedWorkspace $name>] {
                     /// Target workspace name
                     workspace: String,
@@ -283,7 +273,7 @@ gen_named_workspace_subcommand_args! {
     Tiling: #[enum] BooleanState,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct ClearWorkspaceLayoutRules {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -292,7 +282,7 @@ pub struct ClearWorkspaceLayoutRules {
     workspace: usize,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct WorkspaceCustomLayout {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -304,7 +294,7 @@ pub struct WorkspaceCustomLayout {
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct NamedWorkspaceCustomLayout {
     /// Target workspace name
     workspace: String,
@@ -313,7 +303,7 @@ pub struct NamedWorkspaceCustomLayout {
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct WorkspaceLayoutRule {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -328,7 +318,7 @@ pub struct WorkspaceLayoutRule {
     layout: DefaultLayout,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct NamedWorkspaceLayoutRule {
     /// Target workspace name
     workspace: String,
@@ -340,7 +330,7 @@ pub struct NamedWorkspaceLayoutRule {
     layout: DefaultLayout,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct WorkspaceCustomLayoutRule {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -355,7 +345,7 @@ pub struct WorkspaceCustomLayoutRule {
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct NamedWorkspaceCustomLayoutRule {
     /// Target workspace name
     workspace: String,
@@ -367,7 +357,7 @@ pub struct NamedWorkspaceCustomLayoutRule {
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct Resize {
     #[clap(value_enum)]
     edge: OperationDirection,
@@ -375,7 +365,7 @@ struct Resize {
     sizing: Sizing,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct ResizeAxis {
     #[clap(value_enum)]
     axis: Axis,
@@ -383,13 +373,13 @@ struct ResizeAxis {
     sizing: Sizing,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct ResizeDelta {
     /// The delta of pixels by which to increase or decrease window dimensions when resizing
     pixels: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct InvisibleBorders {
     /// Size of the left invisible border
     left: i32,
@@ -401,7 +391,7 @@ struct InvisibleBorders {
     bottom: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct GlobalWorkAreaOffset {
     /// Size of the left work area offset (set right to left * 2 to maintain right padding)
     left: i32,
@@ -413,7 +403,7 @@ struct GlobalWorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct MonitorWorkAreaOffset {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -427,7 +417,7 @@ struct MonitorWorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct MonitorIndexPreference {
     /// Preferred monitor index (zero-indexed)
     index_preference: usize,
@@ -441,7 +431,7 @@ struct MonitorIndexPreference {
     bottom: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct DisplayIndexPreference {
     /// Preferred monitor index (zero-indexed)
     index_preference: usize,
@@ -449,7 +439,7 @@ struct DisplayIndexPreference {
     display: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct EnsureWorkspaces {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -457,7 +447,7 @@ struct EnsureWorkspaces {
     workspace_count: usize,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct EnsureNamedWorkspaces {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -465,7 +455,7 @@ struct EnsureNamedWorkspaces {
     names: Vec<String>,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct FocusMonitorWorkspace {
     /// Target monitor index (zero-indexed)
     target_monitor: usize,
@@ -473,7 +463,7 @@ struct FocusMonitorWorkspace {
     target_workspace: usize,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct SendToMonitorWorkspace {
     /// Target monitor index (zero-indexed)
     target_monitor: usize,
@@ -481,7 +471,7 @@ pub struct SendToMonitorWorkspace {
     target_workspace: usize,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 pub struct MoveToMonitorWorkspace {
     /// Target monitor index (zero-indexed)
     target_monitor: usize,
@@ -493,7 +483,7 @@ macro_rules! gen_focused_workspace_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 /// Pixels size to set as an integer
                 size: i32,
@@ -511,7 +501,7 @@ macro_rules! gen_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 /// Monitor index (zero-indexed)
                 monitor: usize,
@@ -533,7 +523,7 @@ macro_rules! gen_named_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 /// Target workspace name
                 workspace: String,
@@ -554,7 +544,7 @@ macro_rules! gen_padding_adjustment_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 #[clap(value_enum)]
                 sizing: Sizing,
@@ -574,7 +564,7 @@ macro_rules! gen_application_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser)]
             pub struct $name {
                 #[clap(value_enum)]
                 identifier: ApplicationIdentifier,
@@ -595,7 +585,7 @@ gen_application_target_subcommand_args! {
     RemoveTitleBar,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct InitialWorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -607,7 +597,7 @@ struct InitialWorkspaceRule {
     workspace: usize,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct InitialNamedWorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -617,7 +607,7 @@ struct InitialNamedWorkspaceRule {
     workspace: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct WorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -629,7 +619,7 @@ struct WorkspaceRule {
     workspace: usize,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct NamedWorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -639,13 +629,13 @@ struct NamedWorkspaceRule {
     workspace: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct ToggleFocusFollowsMouse {
     #[clap(value_enum, short, long, default_value = "windows")]
     implementation: FocusFollowsMouseImplementation,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct FocusFollowsMouse {
     #[clap(value_enum, short, long, default_value = "windows")]
     implementation: FocusFollowsMouseImplementation,
@@ -653,13 +643,25 @@ struct FocusFollowsMouse {
     boolean_state: BooleanState,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct Border {
     #[clap(value_enum)]
     boolean_state: BooleanState,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
+struct Transparency {
+    #[clap(value_enum)]
+    boolean_state: BooleanState,
+}
+
+#[derive(Parser)]
+struct TransparencyAlpha {
+    /// Alpha
+    alpha: u8,
+}
+
+#[derive(Parser)]
 struct BorderColour {
     #[clap(value_enum, short, long, default_value = "single")]
     window_kind: WindowKind,
@@ -671,19 +673,19 @@ struct BorderColour {
     b: u32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct BorderWidth {
     /// Desired width of the window border
     width: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct BorderOffset {
     /// Desired offset of the window border
     offset: i32,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 #[allow(clippy::struct_excessive_bools)]
 struct Start {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
@@ -706,56 +708,56 @@ struct Start {
     ahk: bool,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct Stop {
     /// Stop whkd if it is running as a background process
     #[clap(long)]
     whkd: bool,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct SaveResize {
     /// File to which the resize layout dimensions should be saved
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct LoadResize {
     /// File from which the resize layout dimensions should be loaded
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct LoadCustomLayout {
     /// JSON or YAML file from which the custom layout definition should be loaded
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct SubscribeSocket {
     /// Name of the socket to send event notifications to
     socket: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct UnsubscribeSocket {
     /// Name of the socket to stop sending event notifications to
     socket: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct SubscribePipe {
     /// Name of the pipe to send event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct UnsubscribePipe {
     /// Name of the pipe to stop sending event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct AhkAppSpecificConfiguration {
     /// YAML file from which the application-specific configurations should be loaded
     path: PathBuf,
@@ -763,7 +765,7 @@ struct AhkAppSpecificConfiguration {
     override_path: Option<PathBuf>,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct PwshAppSpecificConfiguration {
     /// YAML file from which the application-specific configurations should be loaded
     path: PathBuf,
@@ -771,19 +773,19 @@ struct PwshAppSpecificConfiguration {
     override_path: Option<PathBuf>,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct FormatAppSpecificConfiguration {
     /// YAML file from which the application-specific configurations should be loaded
     path: PathBuf,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct AltFocusHack {
     #[clap(value_enum)]
     boolean_state: BooleanState,
 }
 
-#[derive(Parser, AhkFunction)]
+#[derive(Parser)]
 struct EnableAutostart {
     /// Path to a static configuration JSON file
     #[clap(action, short, long)]
@@ -806,7 +808,7 @@ struct Opts {
     subcmd: SubCommand,
 }
 
-#[derive(Parser, AhkLibrary)]
+#[derive(Parser)]
 enum SubCommand {
     #[clap(hide = true)]
     Docgen,
@@ -828,8 +830,13 @@ enum SubCommand {
     State,
     /// Show a JSON representation of the current global state
     GlobalState,
+    /// Launch the komorebi-gui debugging tool
+    Gui,
     /// Show a JSON representation of visible windows
     VisibleWindows,
+    /// Show information about connected monitors
+    #[clap(alias = "monitor-info")]
+    MonitorInformation,
     /// Query the current window manager state
     #[clap(arg_required_else_help = true)]
     Query(Query),
@@ -884,6 +891,10 @@ enum SubCommand {
     /// Stack the focused window in the specified direction
     #[clap(arg_required_else_help = true)]
     Stack(Stack),
+    /// Stack all windows on the focused workspace
+    StackAll,
+    /// Unstack all windows in the focused container
+    UnstackAll,
     /// Resize the focused window in the specified direction
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "resize")]
@@ -1165,6 +1176,12 @@ enum SubCommand {
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "active-window-border-offset")]
     BorderOffset(BorderOffset),
+    /// Enable or disable transparency for unfocused windows
+    #[clap(arg_required_else_help = true)]
+    Transparency(Transparency),
+    /// Set the alpha value for unfocused window transparency
+    #[clap(arg_required_else_help = true)]
+    TransparencyAlpha(TransparencyAlpha),
     /// Enable or disable focus follows mouse for the operating system
     #[clap(arg_required_else_help = true)]
     FocusFollowsMouse(FocusFollowsMouse),
@@ -1176,8 +1193,6 @@ enum SubCommand {
     MouseFollowsFocus(MouseFollowsFocus),
     /// Toggle mouse follows focus on all workspaces
     ToggleMouseFollowsFocus,
-    /// Generate a library of AutoHotKey helper functions
-    AhkLibrary,
     /// Generate common app-specific configurations and fixes to use in komorebi.ahk
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "ahk-asc")]
@@ -1287,21 +1302,25 @@ fn main() -> Result<()> {
             }
         }
         SubCommand::Quickstart => {
-            let home_dir = dirs::home_dir().expect("could not find home dir");
-            let config_dir = home_dir.join(".config");
             let local_appdata_dir = data_local_dir().expect("could not find localdata dir");
             let data_dir = local_appdata_dir.join("komorebi");
-            std::fs::create_dir_all(&config_dir)?;
+            std::fs::create_dir_all(&*WHKD_CONFIG_DIR)?;
+            std::fs::create_dir_all(&*HOME_DIR)?;
             std::fs::create_dir_all(data_dir)?;
 
-            let komorebi_json = include_str!("../../docs/komorebi.example.json");
+            let mut komorebi_json = include_str!("../../docs/komorebi.example.json").to_string();
+            if std::env::var("KOMOREBI_CONFIG_HOME").is_ok() {
+                komorebi_json =
+                    komorebi_json.replace("Env:USERPROFILE", "Env:KOMOREBI_CONFIG_HOME");
+            }
+
             std::fs::write(HOME_DIR.join("komorebi.json"), komorebi_json)?;
 
             let applications_yaml = include_str!("../applications.yaml");
             std::fs::write(HOME_DIR.join("applications.yaml"), applications_yaml)?;
 
             let whkdrc = include_str!("../../docs/whkdrc.sample");
-            std::fs::write(config_dir.join("whkdrc"), whkdrc)?;
+            std::fs::write(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;
 
             println!("Example ~/komorebi.json, ~/.config/whkdrc and latest ~/applications.yaml files downloaded");
             println!("You can now run komorebic start --whkd");
@@ -1461,37 +1480,8 @@ fn main() -> Result<()> {
                 println!("{}", whkdrc.display());
             }
         }
-        SubCommand::AhkLibrary => {
-            let library = HOME_DIR.join("komorebic.lib.ahk");
-            let mut file = OpenOptions::new()
-                .write(true)
-                .create(true)
-                .truncate(true)
-                .open(library.clone())?;
-
-            let output: String = SubCommand::generate_ahk_library();
-            let fixed_id = output.replace("%id%", "\"%id%\"");
-            let fixed_stop_def = fixed_id.replace("Stop(whkd)", "Stop()");
-            let fixed_output =
-                fixed_stop_def.replace("komorebic.exe stop  --whkd %whkd%", "komorebic.exe stop");
-
-            file.write_all(fixed_output.as_bytes())?;
-
-            println!(
-                "\nAHKv1 helper library for komorebic written to {}",
-                library.to_string_lossy()
-            );
-
-            println!("\nYou can convert this file to AHKv2 syntax using https://github.com/mmikeww/AHK-v2-script-converter");
-
-            println!(
-                "\nYou can include the converted library at the top of your komorebi.ahk config with this line:"
-            );
-
-            println!("\n#Include komorebic.lib.ahk");
-        }
         SubCommand::Log => {
-            let timestamp = Local::now().format("%Y-%m-%d").to_string();
+            let timestamp = Utc::now().format("%Y-%m-%d").to_string();
             let color_log = std::env::temp_dir().join(format!("komorebi.log.{timestamp}"));
             let file = TailedFile::new(File::open(color_log)?);
             let locked = file.lock();
@@ -1952,6 +1942,25 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
             );
             println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
             println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");
+
+            let static_config = arg.config.map_or_else(
+                || {
+                    let komorebi_json = HOME_DIR.join("komorebi.json");
+                    if komorebi_json.is_file() {
+                        Option::from(komorebi_json)
+                    } else {
+                        None
+                    }
+                },
+                Option::from,
+            );
+
+            if let Some(config) = static_config {
+                let path = resolve_home_path(config)?;
+                let raw = std::fs::read_to_string(path)?;
+                StaticConfig::aliases(&raw);
+                StaticConfig::deprecated(&raw);
+            }
         }
         SubCommand::Stop(arg) => {
             if arg.whkd {
@@ -2036,9 +2045,15 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         SubCommand::Stack(arg) => {
             send_message(&SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
         }
+        SubCommand::StackAll => {
+            send_message(&SocketMessage::StackAll.as_bytes()?)?;
+        }
         SubCommand::Unstack => {
             send_message(&SocketMessage::UnstackWindow.as_bytes()?)?;
         }
+        SubCommand::UnstackAll => {
+            send_message(&SocketMessage::UnstackAll.as_bytes()?)?;
+        }
         SubCommand::CycleStack(arg) => {
             send_message(&SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
         }
@@ -2130,9 +2145,15 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         SubCommand::GlobalState => {
             print_query(&SocketMessage::GlobalState.as_bytes()?);
         }
+        SubCommand::Gui => {
+            Command::new("komorebi-gui").spawn()?;
+        }
         SubCommand::VisibleWindows => {
             print_query(&SocketMessage::VisibleWindows.as_bytes()?);
         }
+        SubCommand::MonitorInformation => {
+            print_query(&SocketMessage::MonitorInformation.as_bytes()?);
+        }
         SubCommand::Query(arg) => {
             print_query(&SocketMessage::Query(arg.state_query).as_bytes()?);
         }
@@ -2248,6 +2269,12 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         SubCommand::BorderOffset(arg) => {
             send_message(&SocketMessage::BorderOffset(arg.offset).as_bytes()?)?;
         }
+        SubCommand::Transparency(arg) => {
+            send_message(&SocketMessage::Transparency(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::TransparencyAlpha(arg) => {
+            send_message(&SocketMessage::TransparencyAlpha(arg.alpha).as_bytes()?)?;
+        }
         SubCommand::ResizeDelta(arg) => {
             send_message(&SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
         }
@@ -2390,6 +2417,11 @@ fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
     unsafe { ShowWindow(hwnd, command) };
 }
 
+fn remove_transparency(hwnd: HWND) {
+    let _ = komorebi_client::Window::from(hwnd.0).opaque();
+}
+
 fn restore_window(hwnd: HWND) {
     show_window(hwnd, SW_RESTORE);
+    remove_transparency(hwnd);
 }

mkdocs.yml

@@ -57,6 +57,7 @@ nav:
       - Troubleshooting: troubleshooting.md
   - Common workflows:
       - common-workflows/komorebi-config-home.md
+      - common-workflows/autohotkey.md
       - common-workflows/borders.md
       - common-workflows/stackbar.md
       - common-workflows/remove-gaps.md
@@ -67,7 +68,7 @@ nav:
       - common-workflows/mouse-follows-focus.md
       - common-workflows/custom-layouts.md
       - common-workflows/dynamic-layout-switching.md
-      - common-workflows/autohotkey.md
+      - common-workflows/set-display-index.md
   - Release notes:
       - release/v0-1-22.md
   - Configuration reference: https://komorebi.lgug2z.com/schema
@@ -80,7 +81,9 @@ nav:
       - cli/whkdrc.md
       - cli/state.md
       - cli/global-state.md
+      - cli/gui.md
       - cli/visible-windows.md
+      - cli/monitor-information.md
       - cli/query.md
       - cli/subscribe-socket.md
       - cli/unsubscribe-socket.md
@@ -99,6 +102,8 @@ nav:
       - cli/cycle-focus.md
       - cli/cycle-move.md
       - cli/stack.md
+      - cli/stack-all.md
+      - cli/unstack-all.md
       - cli/resize-edge.md
       - cli/resize-axis.md
       - cli/unstack.md
@@ -124,6 +129,7 @@ nav:
       - cli/cycle-monitor.md
       - cli/cycle-workspace.md
       - cli/move-workspace-to-monitor.md
+      - cli/cycle-move-workspace-to-monitor.md
       - cli/swap-workspaces-with-monitor.md
       - cli/new-workspace.md
       - cli/resize-delta.md
@@ -140,6 +146,7 @@ nav:
       - cli/flip-layout.md
       - cli/promote.md
       - cli/promote-focus.md
+      - cli/promote-window.md
       - cli/retile.md
       - cli/monitor-index-preference.md
       - cli/display-index-preference.md
@@ -193,11 +200,12 @@ nav:
       - cli/border-colour.md
       - cli/border-width.md
       - cli/border-offset.md
+      - cli/transparency.md
+      - cli/transparency-alpha.md
       - cli/focus-follows-mouse.md
       - cli/toggle-focus-follows-mouse.md
       - cli/mouse-follows-focus.md
       - cli/toggle-mouse-follows-focus.md
-      - cli/ahk-library.md
       - cli/ahk-app-specific-configuration.md
       - cli/pwsh-app-specific-configuration.md
       - cli/format-app-specific-configuration.md

schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "StaticConfig",
-  "description": "The `komorebi.json` static configuration file reference for `v0.1.25`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.27`",
   "type": "object",
   "properties": {
     "app_specific_configuration_path": {
@@ -1039,6 +1039,14 @@
           "type": "integer",
           "format": "int32"
         },
+        "label": {
+          "description": "Stackbar height",
+          "type": "string",
+          "enum": [
+            "Process",
+            "Title"
+          ]
+        },
         "mode": {
           "description": "Stackbar mode",
           "type": "string",
@@ -1175,6 +1183,16 @@
         }
       }
     },
+    "transparency": {
+      "description": "Add transparency to unfocused windows (default: false)",
+      "type": "boolean"
+    },
+    "transparency_alpha": {
+      "description": "Alpha value for unfocused window transparency [[0-255]] (default: 200)",
+      "type": "integer",
+      "format": "uint8",
+      "minimum": 0.0
+    },
     "tray_and_multi_window_applications": {
       "description": "Identify tray and multi-window applications",
       "type": "array",

wix/main.wxs

@@ -95,6 +95,9 @@
             <Component Id='binary2' Guid='*'>
               <File Id='exe2' Name='komorebic-no-console.exe' DiskId='1' Source='$(var.CargoTargetBinDir)\komorebic-no-console.exe' KeyPath='yes' />
             </Component>
+            <Component Id='binary3' Guid='*'>
+              <File Id='exe3' Name='komorebi-gui.exe' DiskId='1' Source='$(var.CargoTargetBinDir)\komorebi-gui.exe' KeyPath='yes' />
+            </Component>
           </Directory>
         </Directory>
       </Directory>
@@ -113,6 +116,8 @@
 
       <ComponentRef Id='binary2' />
 
+      <ComponentRef Id='binary3' />
+
       <Feature Id='Environment' Title='PATH Environment Variable' Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.' Level='1' Absent='allow'>
         <ComponentRef Id='Path' />
       </Feature>