fix(wm): dynamically reserve monitor ring space

This commit makes a small change to dynamically keep reserving space in
the VecDeque that backs Ring<Monitor> until an index preference can be
contained within the current length.

.github/workflows/windows.yaml

@@ -14,16 +14,14 @@ on:
     tags:
       - v*
   schedule:
-    - cron: "30 0 * * 0" # Every day at 00:30 UTC
+    - cron: "30 0 * * 1" # Every Monday at half past midnight UTC
 
 jobs:
   build:
     name: Build
     runs-on: windows-latest
-    permissions: write-all
     env:
       RUSTFLAGS: -Ctarget-feature=+crt-static
-      GH_TOKEN: ${{ github.token }}
     strategy:
       fail-fast: false
       matrix:
@@ -98,36 +96,15 @@ jobs:
             target/${{ matrix.target }}/release/komorebi-gui.exe
             target/${{ matrix.target }}/release/komorebi.pdb
             target/${{ matrix.target }}/release/komorebic.pdb
-            target/${{ matrix.target }}/release/komorebi_gui.pdb
+            target/${{ matrix.target }}/release/komorebi-gui.pdb
             target/wix/komorebi-*.msi
           retention-days: 7
       - name: Check GoReleaser
         uses: goreleaser/goreleaser-action@v3
-        env:
-          GORELEASER_CURRENT_TAG: v0.1.28
         with:
           version: latest
           args: build --skip=validate --clean
-      - name: Prepare nightly artifacts
-        if: ${{ github.ref == 'refs/heads/master' && github.event_name == 'schedule' }}
-        run: |
-          Compress-Archive .\target\${{ matrix.target }}\release\*.exe komorebi-nightly-x86_64-pc-windows-msvc.zip
-          Copy-Item ./target/wix/*.msi -Destination ./komorebi-nightly-x86_64.msi
-          echo "$((Get-FileHash komorebi-nightly-x86_64-pc-windows-msvc.zip).Hash.ToLower())  komorebi-nightly-x86_64-pc-windows-msvc.zip" >checksums.txt
-      - name: Update nightly
-        if: ${{ github.ref == 'refs/heads/master' && github.event_name == 'schedule' }}
-        shell: bash
-        run: |
-          gh release delete nightly --yes || true
-          git push origin :nightly || true
-          gh release create nightly \
-            --target $GITHUB_SHA \
-            --prerelease \
-            --title "komorebi nightly (${GITHUB_SHA})" \
-            --notes "This nightly release of komorebi corresponds to [this commit](https://github.com/LGUG2Z/komorebi/commit/${GITHUB_SHA})." \
-            komorebi-nightly-x86_64-pc-windows-msvc.zip \
-            komorebi-nightly-x86_64.msi \
-            checksums.txt
+
       # Release
       - name: Generate changelog
         if: startsWith(github.ref, 'refs/tags/v')

.gitignore

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

Cargo.toml

@@ -2,6 +2,7 @@
 
 resolver = "2"
 members = [
+    "derive-ahk",
     "komorebi",
     "komorebi-client",
     "komorebi-core",
@@ -11,17 +12,15 @@ members = [
 ]
 
 [workspace.dependencies]
-color-eyre = "0.6"
-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" }
-shadow-rs = "0.29"
+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"
+serde = { version = "1", features = ["derive"] }
+uds_windows = "1"
 
 [workspace.dependencies.windows]
 version = "0.54"
@@ -41,6 +40,5 @@ features = [
     "Win32_UI_Shell",
     "Win32_UI_Shell_Common",
     "Win32_UI_WindowsAndMessaging",
-    "Win32_System_SystemServices",
-    "Win32_System_WindowsProgramming"
+    "Win32_System_SystemServices"
 ]

README.md

@@ -60,7 +60,7 @@ channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
 _komorebi_ development videos. If you would like to be notified of upcoming
 videos please subscribe and turn on notifications.
 
-_komorebi_ is a free and source-available project, and one that encourages you to
+_komorebi_ is a free and open-source project, and one that encourages you to
 make charitable donations if you find the software to be useful and have the
 financial means.
 
@@ -99,13 +99,6 @@ video will answer the majority of your questions.
 
 # Demonstrations
 
-[@amnweb](https://github.com/amnweb) showing _komorebi_ `v0.1.28-dev.0` running on Windows 11 with window borders,
-unfocused window transparency and animations enabled, using a custom status bar integrated using
-_komorebi_'s [Window Manager Event Subscriptions](https://github.com/LGUG2Z/komorebi?tab=readme-ov-file#window-manager-event-subscriptions).
-
-https://github.com/LGUG2Z/komorebi/assets/13164844/21be8dc4-fa76-4f70-9b37-1d316f4b40c2
-
-
 [@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
 11 with a terminal emulator, a web browser and a code editor. The original
 video can be viewed

derive-ahk/Cargo.toml

@@ -0,0 +1,14 @@
+[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

@@ -0,0 +1,225 @@
+#![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 komorebic.exe ahk-library
+Usage: komorebic.exe ahk-library
 
 Options:
   -h, --help

docs/cli/monitor-information.md

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

docs/cli/stack-all.md

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

docs/cli/transparency-alpha.md

@@ -1,16 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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.
 
-```autohotkey
-{% include "./komorebi.ahk.txt" %}
+```
+{% include "../komorebi.ahk" %}
 ```
 
 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 @@
-# Dynamic Layout Switching
+# Dynamically 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

@@ -1,17 +0,0 @@
-# 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 of two 
-main binaries, `komorebi.exe`, which contains the window manager itself,
+`komorebi` is a tiling window manager for Windows that is comprised 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` nor `komorebic.exe` handle
+It is important to note that neither `komorebi.exe` or `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 build
+[WinGet](https://winget.run/pkg/LGUG2Z/komorebi), and you may also built
 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 is highly recommended that you enable support for long paths in Windows by
+It 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
@@ -128,21 +128,3 @@ 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

@@ -1,71 +0,0 @@
-#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,5 +1,3 @@
-# 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.
 
@@ -51,8 +49,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.28-dev.0"
+version = "0.1.27-dev.0"
 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)]
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(clippy::missing_errors_doc)]
 
 pub use komorebi::colour::Colour;

komorebi-core/Cargo.toml

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

komorebi-core/src/animation.rs

@@ -1,42 +0,0 @@
-use clap::ValueEnum;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use strum::Display;
-use strum::EnumString;
-
-#[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
-pub enum AnimationStyle {
-    Linear,
-    EaseInSine,
-    EaseOutSine,
-    EaseInOutSine,
-    EaseInQuad,
-    EaseOutQuad,
-    EaseInOutQuad,
-    EaseInCubic,
-    EaseInOutCubic,
-    EaseInQuart,
-    EaseOutQuart,
-    EaseInOutQuart,
-    EaseInQuint,
-    EaseOutQuint,
-    EaseInOutQuint,
-    EaseInExpo,
-    EaseOutExpo,
-    EaseInOutExpo,
-    EaseInCirc,
-    EaseOutCirc,
-    EaseInOutCirc,
-    EaseInBack,
-    EaseOutBack,
-    EaseInOutBack,
-    EaseInElastic,
-    EaseOutElastic,
-    EaseInOutElastic,
-    EaseInBounce,
-    EaseOutBounce,
-    EaseInOutBounce,
-}

komorebi-core/src/arrangement.rs

@@ -604,16 +604,7 @@ impl Arrangement for CustomLayout {
 }
 
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
+    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
 )]
 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, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CustomLayout(Vec<Column>);
 
 impl Deref for CustomLayout {
@@ -250,7 +250,7 @@ impl CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 #[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, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnWidth {
     WidthPercentage(f32),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnSplit {
     Horizontal,
     Vertical,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnSplitWithCapacity {
     Horizontal(usize),
     Vertical(usize),

komorebi-core/src/direction.rs

@@ -90,13 +90,9 @@ impl Direction for DefaultLayout {
         idx: usize,
         count: usize,
     ) -> bool {
-        if count < 2 {
-            return false;
-        }
-
         match op_direction {
             OperationDirection::Up => match self {
-                Self::BSP => idx != 0 && idx != 1,
+                Self::BSP => count > 2 && idx != 0 && idx != 1,
                 Self::Columns => false,
                 Self::Rows | Self::HorizontalStack => idx != 0,
                 Self::VerticalStack | Self::RightMainVerticalStack => idx != 0 && idx != 1,
@@ -104,7 +100,7 @@ impl Direction for DefaultLayout {
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Down => match self {
-                Self::BSP => idx != count - 1 && idx % 2 != 0,
+                Self::BSP => count > 2 && idx != count - 1 && idx % 2 != 0,
                 Self::Columns => false,
                 Self::Rows => idx != count - 1,
                 Self::VerticalStack | Self::RightMainVerticalStack => idx != 0 && idx != count - 1,
@@ -113,22 +109,23 @@ impl Direction for DefaultLayout {
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Left => match self {
-                Self::BSP => idx != 0,
+                Self::BSP => count > 1 && idx != 0,
                 Self::Columns | Self::VerticalStack => idx != 0,
                 Self::RightMainVerticalStack => idx == 0,
                 Self::Rows => false,
                 Self::HorizontalStack => idx != 0 && idx != 1,
-                Self::UltrawideVerticalStack => idx != 1,
+                Self::UltrawideVerticalStack => count > 1 && idx != 1,
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Right => match self {
-                Self::BSP => idx % 2 == 0 && idx != count - 1,
+                Self::BSP => count > 1 && 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, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 pub enum Layout {
     Default(DefaultLayout),
     Custom(CustomLayout),

komorebi-core/src/lib.rs

@@ -1,5 +1,5 @@
-#![warn(clippy::all)]
-#![allow(clippy::missing_errors_doc, clippy::use_self, clippy::doc_markdown)]
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc, clippy::use_self)]
 
 use std::path::Path;
 use std::path::PathBuf;
@@ -14,7 +14,6 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
 pub use custom_layout::CustomLayout;
@@ -25,7 +24,6 @@ pub use layout::Layout;
 pub use operation_direction::OperationDirection;
 pub use rect::Rect;
 
-pub mod animation;
 pub mod arrangement;
 pub mod config_generation;
 pub mod custom_layout;
@@ -45,8 +43,6 @@ pub enum SocketMessage {
     CycleFocusWindow(CycleDirection),
     CycleMoveWindow(CycleDirection),
     StackWindow(OperationDirection),
-    StackAll,
-    UnstackAll,
     ResizeWindowEdge(OperationDirection, Sizing),
     ResizeWindowAxis(Axis, Sizing),
     UnstackWindow,
@@ -136,10 +132,6 @@ pub enum SocketMessage {
     WatchConfiguration(bool),
     CompleteConfiguration,
     AltFocusHack(bool),
-    Animation(bool),
-    AnimationDuration(u64),
-    AnimationFps(u64),
-    AnimationStyle(AnimationStyle),
     #[serde(alias = "ActiveWindowBorder")]
     Border(bool),
     #[serde(alias = "ActiveWindowBorderColour")]
@@ -148,9 +140,6 @@ pub enum SocketMessage {
     BorderStyle(BorderStyle),
     BorderWidth(i32),
     BorderOffset(i32),
-    BorderImplementation(BorderImplementation),
-    Transparency(bool),
-    TransparencyAlpha(u8),
     InvisibleBorders(Rect),
     StackbarMode(StackbarMode),
     StackbarLabel(StackbarLabel),
@@ -159,8 +148,6 @@ pub enum SocketMessage {
     StackbarBackgroundColour(u32, u32, u32),
     StackbarHeight(i32),
     StackbarTabWidth(i32),
-    StackbarFontSize(i32),
-    StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
     ResizeDelta(i32),
@@ -168,9 +155,6 @@ pub enum SocketMessage {
     InitialNamedWorkspaceRule(ApplicationIdentifier, String, String),
     WorkspaceRule(ApplicationIdentifier, String, usize, usize),
     NamedWorkspaceRule(ApplicationIdentifier, String, String),
-    ClearWorkspaceRules(usize, usize),
-    ClearNamedWorkspaceRules(String),
-    ClearAllWorkspaceRules,
     FloatRule(ApplicationIdentifier, String),
     ManageRule(ApplicationIdentifier, String),
     IdentifyObjectNameChangeApplication(ApplicationIdentifier, String),
@@ -180,7 +164,6 @@ pub enum SocketMessage {
     State,
     GlobalState,
     VisibleWindows,
-    MonitorInformation,
     Query(StateQuery),
     FocusFollowsMouse(FocusFollowsMouseImplementation, bool),
     ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
@@ -231,17 +214,7 @@ pub enum StackbarLabel {
 }
 
 #[derive(
-    Default,
-    Copy,
-    Clone,
-    Debug,
-    Eq,
-    PartialEq,
-    Display,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    ValueEnum,
+    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
 )]
 pub enum BorderStyle {
     #[default]
@@ -254,37 +227,7 @@ pub enum BorderStyle {
 }
 
 #[derive(
-    Default,
-    Copy,
-    Clone,
-    Debug,
-    Eq,
-    PartialEq,
-    Display,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    ValueEnum,
-)]
-pub enum BorderImplementation {
-    #[default]
-    /// Use the adjustable komorebi border implementation
-    Komorebi,
-    /// Use the thin Windows accent border implementation
-    Windows,
-}
-
-#[derive(
-    Copy,
-    Clone,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
+    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
 )]
 pub enum WindowKind {
     Single,
@@ -367,7 +310,7 @@ pub enum HidingBehaviour {
     Hide,
     /// Use the SW_MINIMIZE flag to hide windows when switching workspaces (has issues with frequent workspace switching)
     Minimize,
-    /// Use the undocumented SetCloak Win32 function to hide windows when switching workspaces
+    /// Use the undocumented SetCloak Win32 function to hide windows when switching workspaces (has foregrounding issues)
     Cloak,
 }
 

komorebi-core/src/rect.rs

@@ -84,14 +84,4 @@ impl Rect {
             bottom: (self.bottom * rect_dpi) / system_dpi,
         }
     }
-
-    #[must_use]
-    pub const fn rect(&self) -> RECT {
-        RECT {
-            left: self.left,
-            top: self.top,
-            right: self.left + self.right,
-            bottom: self.top + self.bottom,
-        }
-    }
 }

komorebi-gui/Cargo.toml

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

komorebi-gui/src/main.rs

@@ -1,5 +1,3 @@
-#![warn(clippy::all)]
-
 use eframe::egui;
 use eframe::egui::color_picker::Alpha;
 use eframe::egui::Color32;
@@ -34,7 +32,7 @@ fn main() {
     let _ = eframe::run_native(
         "komorebi-gui",
         native_options,
-        Box::new(|cc| Ok(Box::new(KomorebiGui::new(cc)))),
+        Box::new(|cc| Box::new(KomorebiGui::new(cc))),
     );
 }
 
@@ -218,7 +216,7 @@ extern "system" fn enum_window(
     lparam: windows::Win32::Foundation::LPARAM,
 ) -> windows::Win32::Foundation::BOOL {
     let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
-    let window = Window::from(hwnd.0);
+    let window = Window { hwnd: hwnd.0 };
 
     if window.is_window()
         && !window.is_miminized()
@@ -246,7 +244,9 @@ impl eframe::App for KomorebiGui {
                 ui.set_width(ctx.screen_rect().width());
                 ui.collapsing("Debugging", |ui| {
                     ui.collapsing("Window Rules", |ui| {
-                        let window = Window::from(self.debug_hwnd);
+                        let window = Window {
+                            hwnd: self.debug_hwnd,
+                        };
 
                         let label = if let (Ok(title), Ok(exe)) = (window.title(), window.exe()) {
                             format!("{title} ({exe})")
@@ -713,7 +713,7 @@ impl eframe::App for KomorebiGui {
                                                     .text_edit_singleline(workspace_name)
                                                     .lost_focus()
                                                 {
-                                                    workspace.name.clone_from(workspace_name);
+                                                    workspace.name = workspace_name.clone();
                                                     komorebi_client::send_message(
                                                         &SocketMessage::WorkspaceName(
                                                             monitor_idx,

komorebi.sample.ahk

@@ -0,0 +1,56 @@
+#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.28-dev.0"
+version = "0.1.27-dev.0"
 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 = { version = "3", features = ["termination"] }
+ctrlc = "3"
 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 = "0.12"
+parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 paste = "1"
 regex = "1"
 schemars = "0.8"
@@ -42,16 +42,13 @@ 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"
-shadow-rs = { workspace = true }
 
-[build-dependencies]
-shadow-rs = { workspace = true }
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data" }
 
 [features]
-deadlock_detection = ["parking_lot/deadlock_detection"]
+deadlock_detection = []

komorebi/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    shadow_rs::new().unwrap();
-}

komorebi/src/animation.rs

@@ -1,503 +0,0 @@
-use color_eyre::Result;
-use komorebi_core::AnimationStyle;
-use komorebi_core::Rect;
-
-use schemars::JsonSchema;
-
-use serde::Deserialize;
-use serde::Serialize;
-use std::f64::consts::PI;
-use std::sync::atomic::AtomicU64;
-use std::sync::atomic::Ordering;
-use std::time::Duration;
-use std::time::Instant;
-
-use crate::ANIMATION_DURATION;
-use crate::ANIMATION_MANAGER;
-use crate::ANIMATION_STYLE;
-
-pub static ANIMATION_FPS: AtomicU64 = AtomicU64::new(60);
-
-pub trait Ease {
-    fn evaluate(t: f64) -> f64;
-}
-
-pub struct Linear;
-
-impl Ease for Linear {
-    fn evaluate(t: f64) -> f64 {
-        t
-    }
-}
-
-pub struct EaseInSine;
-
-impl Ease for EaseInSine {
-    fn evaluate(t: f64) -> f64 {
-        1.0 - f64::cos((t * PI) / 2.0)
-    }
-}
-
-pub struct EaseOutSine;
-
-impl Ease for EaseOutSine {
-    fn evaluate(t: f64) -> f64 {
-        f64::sin((t * PI) / 2.0)
-    }
-}
-
-pub struct EaseInOutSine;
-
-impl Ease for EaseInOutSine {
-    fn evaluate(t: f64) -> f64 {
-        -(f64::cos(PI * t) - 1.0) / 2.0
-    }
-}
-
-pub struct EaseInQuad;
-
-impl Ease for EaseInQuad {
-    fn evaluate(t: f64) -> f64 {
-        t * t
-    }
-}
-
-pub struct EaseOutQuad;
-
-impl Ease for EaseOutQuad {
-    fn evaluate(t: f64) -> f64 {
-        (1.0 - t).mul_add(-1.0 - t, 1.0)
-    }
-}
-
-pub struct EaseInOutQuad;
-
-impl Ease for EaseInOutQuad {
-    fn evaluate(t: f64) -> f64 {
-        if t < 0.5 {
-            2.0 * t * t
-        } else {
-            1.0 - (-2.0f64).mul_add(t, 2.0).powi(2) / 2.0
-        }
-    }
-}
-
-pub struct EaseInCubic;
-
-impl Ease for EaseInCubic {
-    fn evaluate(t: f64) -> f64 {
-        t * t * t
-    }
-}
-
-pub struct EaseOutCubic;
-
-impl Ease for EaseOutCubic {
-    fn evaluate(t: f64) -> f64 {
-        1.0 - (1.0 - t).powi(3)
-    }
-}
-
-pub struct EaseInOutCubic;
-
-impl Ease for EaseInOutCubic {
-    fn evaluate(t: f64) -> f64 {
-        if t < 0.5 {
-            4.0 * t * t * t
-        } else {
-            1.0 - (-2.0f64).mul_add(t, 2.0).powi(3) / 2.0
-        }
-    }
-}
-
-pub struct EaseInQuart;
-
-impl Ease for EaseInQuart {
-    fn evaluate(t: f64) -> f64 {
-        t * t * t * t
-    }
-}
-
-pub struct EaseOutQuart;
-
-impl Ease for EaseOutQuart {
-    fn evaluate(t: f64) -> f64 {
-        1.0 - (1.0 - t).powi(4)
-    }
-}
-
-pub struct EaseInOutQuart;
-
-impl Ease for EaseInOutQuart {
-    fn evaluate(t: f64) -> f64 {
-        if t < 0.5 {
-            8.0 * t * t * t * t
-        } else {
-            1.0 - (-2.0f64).mul_add(t, 2.0).powi(4) / 2.0
-        }
-    }
-}
-
-pub struct EaseInQuint;
-
-impl Ease for EaseInQuint {
-    fn evaluate(t: f64) -> f64 {
-        t * t * t * t * t
-    }
-}
-
-pub struct EaseOutQuint;
-
-impl Ease for EaseOutQuint {
-    fn evaluate(t: f64) -> f64 {
-        1.0 - (1.0 - t).powi(5)
-    }
-}
-
-pub struct EaseInOutQuint;
-
-impl Ease for EaseInOutQuint {
-    fn evaluate(t: f64) -> f64 {
-        if t < 0.5 {
-            16.0 * t * t * t * t
-        } else {
-            1.0 - (-2.0f64).mul_add(t, 2.0).powi(5) / 2.0
-        }
-    }
-}
-
-pub struct EaseInExpo;
-
-impl Ease for EaseInExpo {
-    fn evaluate(t: f64) -> f64 {
-        if t == 0.0 {
-            return t;
-        }
-
-        10.0f64.mul_add(t, -10.0).exp2()
-    }
-}
-
-pub struct EaseOutExpo;
-
-impl Ease for EaseOutExpo {
-    fn evaluate(t: f64) -> f64 {
-        if (t - 1.0).abs() < f64::EPSILON {
-            return t;
-        }
-
-        1.0 - (-10.0 * t).exp2()
-    }
-}
-
-pub struct EaseInOutExpo;
-
-impl Ease for EaseInOutExpo {
-    fn evaluate(t: f64) -> f64 {
-        if t == 0.0 || (t - 1.0).abs() < f64::EPSILON {
-            return t;
-        }
-
-        if t < 0.5 {
-            20.0f64.mul_add(t, -10.0).exp2() / 2.0
-        } else {
-            (2.0 - (-20.0f64).mul_add(t, 10.0).exp2()) / 2.0
-        }
-    }
-}
-
-pub struct EaseInCirc;
-
-impl Ease for EaseInCirc {
-    fn evaluate(t: f64) -> f64 {
-        1.0 - f64::sqrt(t.mul_add(-t, 1.0))
-    }
-}
-
-pub struct EaseOutCirc;
-
-impl Ease for EaseOutCirc {
-    fn evaluate(t: f64) -> f64 {
-        f64::sqrt((t - 1.0).mul_add(-(t - 1.0), 1.0))
-    }
-}
-
-pub struct EaseInOutCirc;
-
-impl Ease for EaseInOutCirc {
-    fn evaluate(t: f64) -> f64 {
-        if t < 0.5 {
-            (1.0 - f64::sqrt((2.0 * t).mul_add(-(2.0 * t), 1.0))) / 2.0
-        } else {
-            (f64::sqrt(
-                (-2.0f64)
-                    .mul_add(t, 2.0)
-                    .mul_add(-(-2.0f64).mul_add(t, 2.0), 1.0),
-            ) + 1.0)
-                / 2.0
-        }
-    }
-}
-
-pub struct EaseInBack;
-
-impl Ease for EaseInBack {
-    fn evaluate(t: f64) -> f64 {
-        let c1 = 1.70158;
-        let c3 = c1 + 1.0;
-
-        (c3 * t * t).mul_add(t, -c1 * t * t)
-    }
-}
-
-pub struct EaseOutBack;
-
-impl Ease for EaseOutBack {
-    fn evaluate(t: f64) -> f64 {
-        let c1: f64 = 1.70158;
-        let c3: f64 = c1 + 1.0;
-
-        c1.mul_add((t - 1.0).powi(2), c3.mul_add((t - 1.0).powi(3), 1.0))
-    }
-}
-
-pub struct EaseInOutBack;
-
-impl Ease for EaseInOutBack {
-    fn evaluate(t: f64) -> f64 {
-        let c1: f64 = 1.70158;
-        let c2: f64 = c1 * 1.525;
-
-        if t < 0.5 {
-            ((2.0 * t).powi(2) * ((c2 + 1.0) * 2.0).mul_add(t, -c2)) / 2.0
-        } else {
-            ((2.0f64.mul_add(t, -2.0))
-                .powi(2)
-                .mul_add((c2 + 1.0).mul_add(t.mul_add(2.0, -2.0), c2), 2.0))
-                / 2.0
-        }
-    }
-}
-
-pub struct EaseInElastic;
-
-impl Ease for EaseInElastic {
-    fn evaluate(t: f64) -> f64 {
-        if (t - 1.0).abs() < f64::EPSILON || t == 0.0 {
-            return t;
-        }
-
-        let c4 = (2.0 * PI) / 3.0;
-
-        -(10.0f64.mul_add(t, -10.0).exp2()) * f64::sin(t.mul_add(10.0, -10.75) * c4)
-    }
-}
-
-pub struct EaseOutElastic;
-
-impl Ease for EaseOutElastic {
-    fn evaluate(t: f64) -> f64 {
-        if (t - 1.0).abs() < f64::EPSILON || t == 0.0 {
-            return t;
-        }
-
-        let c4 = (2.0 * PI) / 3.0;
-
-        (-10.0 * t)
-            .exp2()
-            .mul_add(f64::sin(t.mul_add(10.0, -0.75) * c4), 1.0)
-    }
-}
-
-pub struct EaseInOutElastic;
-
-impl Ease for EaseInOutElastic {
-    fn evaluate(t: f64) -> f64 {
-        if (t - 1.0).abs() < f64::EPSILON || t == 0.0 {
-            return t;
-        }
-
-        let c5 = (2.0 * PI) / 4.5;
-
-        if t < 0.5 {
-            -(20.0f64.mul_add(t, -10.0).exp2() * f64::sin(20.0f64.mul_add(t, -11.125) * c5)) / 2.0
-        } else {
-            ((-20.0f64).mul_add(t, 10.0).exp2() * f64::sin(20.0f64.mul_add(t, -11.125) * c5)) / 2.0
-                + 1.0
-        }
-    }
-}
-
-pub struct EaseInBounce;
-
-impl Ease for EaseInBounce {
-    fn evaluate(t: f64) -> f64 {
-        1.0 - EaseOutBounce::evaluate(1.0 - t)
-    }
-}
-
-pub struct EaseOutBounce;
-
-impl Ease for EaseOutBounce {
-    fn evaluate(t: f64) -> f64 {
-        let mut time = t;
-        let n1 = 7.5625;
-        let d1 = 2.75;
-
-        if t < 1.0 / d1 {
-            n1 * time * time
-        } else if time < 2.0 / d1 {
-            time -= 1.5 / d1;
-            (n1 * time).mul_add(time, 0.75)
-        } else if time < 2.5 / d1 {
-            time -= 2.25 / d1;
-            (n1 * time).mul_add(time, 0.9375)
-        } else {
-            time -= 2.625 / d1;
-            (n1 * time).mul_add(time, 0.984_375)
-        }
-    }
-}
-
-pub struct EaseInOutBounce;
-
-impl Ease for EaseInOutBounce {
-    fn evaluate(t: f64) -> f64 {
-        if t < 0.5 {
-            (1.0 - EaseOutBounce::evaluate(2.0f64.mul_add(-t, 1.0))) / 2.0
-        } else {
-            (1.0 + EaseOutBounce::evaluate(2.0f64.mul_add(t, -1.0))) / 2.0
-        }
-    }
-}
-fn apply_ease_func(t: f64) -> f64 {
-    let style = *ANIMATION_STYLE.lock();
-
-    match style {
-        AnimationStyle::Linear => Linear::evaluate(t),
-        AnimationStyle::EaseInSine => EaseInSine::evaluate(t),
-        AnimationStyle::EaseOutSine => EaseOutSine::evaluate(t),
-        AnimationStyle::EaseInOutSine => EaseInOutSine::evaluate(t),
-        AnimationStyle::EaseInQuad => EaseInQuad::evaluate(t),
-        AnimationStyle::EaseOutQuad => EaseOutQuad::evaluate(t),
-        AnimationStyle::EaseInOutQuad => EaseInOutQuad::evaluate(t),
-        AnimationStyle::EaseInCubic => EaseInCubic::evaluate(t),
-        AnimationStyle::EaseInOutCubic => EaseInOutCubic::evaluate(t),
-        AnimationStyle::EaseInQuart => EaseInQuart::evaluate(t),
-        AnimationStyle::EaseOutQuart => EaseOutQuart::evaluate(t),
-        AnimationStyle::EaseInOutQuart => EaseInOutQuart::evaluate(t),
-        AnimationStyle::EaseInQuint => EaseInQuint::evaluate(t),
-        AnimationStyle::EaseOutQuint => EaseOutQuint::evaluate(t),
-        AnimationStyle::EaseInOutQuint => EaseInOutQuint::evaluate(t),
-        AnimationStyle::EaseInExpo => EaseInExpo::evaluate(t),
-        AnimationStyle::EaseOutExpo => EaseOutExpo::evaluate(t),
-        AnimationStyle::EaseInOutExpo => EaseInOutExpo::evaluate(t),
-        AnimationStyle::EaseInCirc => EaseInCirc::evaluate(t),
-        AnimationStyle::EaseOutCirc => EaseOutCirc::evaluate(t),
-        AnimationStyle::EaseInOutCirc => EaseInOutCirc::evaluate(t),
-        AnimationStyle::EaseInBack => EaseInBack::evaluate(t),
-        AnimationStyle::EaseOutBack => EaseOutBack::evaluate(t),
-        AnimationStyle::EaseInOutBack => EaseInOutBack::evaluate(t),
-        AnimationStyle::EaseInElastic => EaseInElastic::evaluate(t),
-        AnimationStyle::EaseOutElastic => EaseOutElastic::evaluate(t),
-        AnimationStyle::EaseInOutElastic => EaseInOutElastic::evaluate(t),
-        AnimationStyle::EaseInBounce => EaseInBounce::evaluate(t),
-        AnimationStyle::EaseOutBounce => EaseOutBounce::evaluate(t),
-        AnimationStyle::EaseInOutBounce => EaseInOutBounce::evaluate(t),
-    }
-}
-
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
-pub struct Animation {
-    pub hwnd: isize,
-}
-
-impl Animation {
-    pub fn new(hwnd: isize) -> Self {
-        Self { hwnd }
-    }
-    pub fn cancel(&mut self) {
-        if !ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
-            return;
-        }
-
-        ANIMATION_MANAGER.lock().cancel(self.hwnd);
-        let max_duration = Duration::from_secs(1);
-        let spent_duration = Instant::now();
-
-        while ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
-            if spent_duration.elapsed() >= max_duration {
-                ANIMATION_MANAGER.lock().end(self.hwnd);
-            }
-
-            std::thread::sleep(Duration::from_millis(
-                ANIMATION_DURATION.load(Ordering::SeqCst) / 2,
-            ));
-        }
-    }
-
-    #[allow(clippy::cast_possible_truncation)]
-    pub fn lerp(start: i32, end: i32, t: f64) -> i32 {
-        let time = apply_ease_func(t);
-        f64::from(end - start)
-            .mul_add(time, f64::from(start))
-            .round() as i32
-    }
-
-    pub fn lerp_rect(start_rect: &Rect, end_rect: &Rect, t: f64) -> Rect {
-        Rect {
-            left: Self::lerp(start_rect.left, end_rect.left, t),
-            top: Self::lerp(start_rect.top, end_rect.top, t),
-            right: Self::lerp(start_rect.right, end_rect.right, t),
-            bottom: Self::lerp(start_rect.bottom, end_rect.bottom, t),
-        }
-    }
-
-    #[allow(clippy::cast_precision_loss)]
-    pub fn animate(
-        &mut self,
-        duration: Duration,
-        mut render_callback: impl FnMut(f64) -> Result<()>,
-    ) -> Result<()> {
-        if ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
-            self.cancel();
-        }
-
-        ANIMATION_MANAGER.lock().start(self.hwnd);
-
-        let target_frame_time = Duration::from_millis(1000 / ANIMATION_FPS.load(Ordering::Relaxed));
-        let mut progress = 0.0;
-        let animation_start = Instant::now();
-
-        // start animation
-        while progress < 1.0 {
-            // check if animation is cancelled
-            if ANIMATION_MANAGER.lock().is_cancelled(self.hwnd) {
-                // cancel animation
-                // set all flags
-                ANIMATION_MANAGER.lock().end(self.hwnd);
-                return Ok(());
-            }
-
-            let frame_start = Instant::now();
-            // calculate progress
-            progress = animation_start.elapsed().as_millis() as f64 / duration.as_millis() as f64;
-            render_callback(progress).ok();
-
-            // sleep until next frame
-            if frame_start.elapsed() < target_frame_time {
-                std::thread::sleep(target_frame_time - frame_start.elapsed());
-            }
-        }
-
-        ANIMATION_MANAGER.lock().end(self.hwnd);
-
-        // limit progress to 1.0 if animation took longer
-        if progress > 1.0 {
-            progress = 1.0;
-        }
-
-        // process animation for 1.0 to set target position
-        render_callback(progress)
-    }
-}

komorebi/src/animation_manager.rs

@@ -1,79 +0,0 @@
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering;
-
-pub static ANIMATIONS_IN_PROGRESS: AtomicUsize = AtomicUsize::new(0);
-
-#[derive(Debug, Clone, Copy)]
-struct AnimationState {
-    pub in_progress: bool,
-    pub is_cancelled: bool,
-}
-
-#[derive(Debug)]
-pub struct AnimationManager {
-    animations: HashMap<isize, AnimationState>,
-}
-
-impl Default for AnimationManager {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AnimationManager {
-    pub fn new() -> Self {
-        Self {
-            animations: HashMap::new(),
-        }
-    }
-
-    pub fn is_cancelled(&self, hwnd: isize) -> bool {
-        if let Some(animation_state) = self.animations.get(&hwnd) {
-            animation_state.is_cancelled
-        } else {
-            false
-        }
-    }
-
-    pub fn in_progress(&self, hwnd: isize) -> bool {
-        if let Some(animation_state) = self.animations.get(&hwnd) {
-            animation_state.in_progress
-        } else {
-            false
-        }
-    }
-
-    pub fn cancel(&mut self, hwnd: isize) {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.is_cancelled = true;
-        }
-    }
-
-    pub fn start(&mut self, hwnd: isize) {
-        if let Entry::Vacant(e) = self.animations.entry(hwnd) {
-            e.insert(AnimationState {
-                in_progress: true,
-                is_cancelled: false,
-            });
-
-            ANIMATIONS_IN_PROGRESS.store(self.animations.len(), Ordering::Release);
-            return;
-        }
-
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.in_progress = true;
-        }
-    }
-
-    pub fn end(&mut self, hwnd: isize) {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.in_progress = false;
-            animation_state.is_cancelled = false;
-
-            self.animations.remove(&hwnd);
-            ANIMATIONS_IN_PROGRESS.store(self.animations.len(), Ordering::Release);
-        }
-    }
-}

komorebi/src/border_manager/border.rs

@@ -1,9 +1,13 @@
-use crate::border_manager::window_kind_colour;
 use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 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;
 use crate::border_manager::Z_ORDER;
 use crate::WindowsApi;
 use crate::WINDOWS_11;
@@ -23,12 +27,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;
@@ -95,19 +99,13 @@ impl Border {
             let hwnd = WindowsApi::create_border_window(PCWSTR(name.as_ptr()), h_module)?;
             hwnd_sender.send(hwnd)?;
 
-            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);
+            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));
                 }
-
-                std::thread::sleep(Duration::from_millis(10))
             }
 
             Ok(())
@@ -122,22 +120,25 @@ impl Border {
         WindowsApi::close_window(self.hwnd())
     }
 
-    pub fn update(&self, rect: &Rect, mut should_invalidate: bool) -> color_eyre::Result<()> {
+    pub fn update(&self, rect: &Rect) -> 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.load()).into()))?;
-            should_invalidate = true;
+            WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((*Z_ORDER.lock()).into()))?;
         }
 
         // Invalidate the rect to trigger the callback to update colours etc.
-        if should_invalidate {
-            self.invalidate();
-        }
+        self.invalidate();
 
         Ok(())
     }
@@ -155,63 +156,63 @@ impl Border {
         unsafe {
             match message {
                 WM_PAINT => {
-                    let mut ps = PAINTSTRUCT::default();
-                    let hdc = BeginPaint(window, &mut ps);
+                    let rects = RECT_STATE.lock();
 
-                    // With the rect that we set in Self::update
-                    match WindowsApi::window_rect(window) {
-                        Ok(rect) => {
-                            // Grab the focus kind for this border
-                            let window_kind = {
-                                FOCUS_STATE
-                                    .lock()
-                                    .get(&window.0)
-                                    .copied()
-                                    .unwrap_or(WindowKind::Unfocused)
-                            };
+                    // 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)
+                        };
 
-                            // Set up the brush to draw the border
-                            let hpen = CreatePen(
-                                PS_SOLID | PS_INSIDEFRAME,
-                                BORDER_WIDTH.load(Ordering::SeqCst),
-                                COLORREF(window_kind_colour(window_kind)),
-                            );
+                        // 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),
+                            }),
+                        );
 
-                            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.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 => {
+                        // 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 {
                                     RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
-                                }
-                                BorderStyle::Square => {
+                                } else {
                                     Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                 }
                             }
-                            DeleteObject(hpen);
-                            DeleteObject(hbrush);
-                        }
-                        Err(error) => {
-                            tracing::error!("could not get border rect: {}", error.to_string())
+                            BorderStyle::Rounded => {
+                                RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                            }
+                            BorderStyle::Square => {
+                                Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                            }
                         }
+                        EndPaint(window, &ps);
+                        ValidateRect(window, None);
                     }
 
-                    EndPaint(window, &ps);
                     LRESULT(0)
                 }
                 WM_DESTROY => {

komorebi/src/border_manager/mod.rs

@@ -4,9 +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::BorderImplementation;
 use komorebi_core::BorderStyle;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
@@ -18,14 +16,15 @@ use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
-use std::sync::atomic::Ordering;
 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;
@@ -37,13 +36,10 @@ pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
 pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
 
 pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(true);
-pub static BORDER_TEMPORARILY_DISABLED: AtomicBool = AtomicBool::new(false);
 
 lazy_static! {
-    pub static ref Z_ORDER: AtomicCell<ZOrder> = AtomicCell::new(ZOrder::Bottom);
-    pub static ref STYLE: AtomicCell<BorderStyle> = AtomicCell::new(BorderStyle::System);
-    pub static ref IMPLEMENTATION: AtomicCell<BorderImplementation> =
-        AtomicCell::new(BorderImplementation::Windows);
+    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 FOCUSED: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
     pub static ref UNFOCUSED: AtomicU32 =
@@ -56,6 +52,7 @@ 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());
 }
 
@@ -64,23 +61,17 @@ 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::bounded(50))
+    CHANNEL.get_or_init(crossbeam_channel::unbounded)
 }
 
-fn event_tx() -> Sender<Notification> {
+pub fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-fn event_rx() -> Receiver<Notification> {
+pub 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!(
@@ -93,6 +84,7 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
     }
 
     borders.clear();
+    RECT_STATE.lock().clear();
     BORDERS_MONITORS.lock().clear();
     FOCUS_STATE.lock().clear();
 
@@ -114,15 +106,6 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
     Ok(())
 }
 
-fn window_kind_colour(focus_kind: WindowKind) -> u32 {
-    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),
-    }
-}
-
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
     std::thread::spawn(move || loop {
         match handle_notifications(wm.clone()) {
@@ -139,289 +122,211 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
 pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
     tracing::info!("listening");
 
-    BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
     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;
+            }
+        }
+
+        instant = Some(Instant::now());
+
+        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();
-        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);
 
-        match IMPLEMENTATION.load() {
-            BorderImplementation::Windows => {
-                '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() {
-                        // Handle the monocle container separately
-                        if let Some(monocle) = ws.monocle_container() {
-                            let window_kind = if monitor_idx != focused_monitor_idx {
+        // If borders are disabled
+        if !BORDER_ENABLED.load_consume()
+           // Or if the wm is paused
+            || state.is_paused
+            // Or if we are handling an alt-tab across workspaces
+            || ALT_TAB_HWND.load().is_some()
+        {
+            // Destroy the borders we know about
+            for (_, border) in borders.iter() {
+                border.destroy()?;
+            }
+
+            borders.clear();
+            continue 'receiver;
+        }
+
+        let focused_monitor_idx = state.focused_monitor_idx();
+
+        'monitors: for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
+            // Only operate on the focused workspace of each monitor
+            if let Some(ws) = m.focused_workspace() {
+                // Workspaces with tiling disabled don't have borders
+                if !ws.tile() {
+                    let mut to_remove = vec![];
+                    for (id, border) in borders.iter() {
+                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
+                            border.destroy()?;
+                            to_remove.push(id.clone());
+                        }
+                    }
+
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
+
+                    continue 'receiver;
+                }
+
+                // Handle the monocle container separately
+                if let Some(monocle) = ws.monocle_container() {
+                    let border = match borders.entry(monocle.id().clone()) {
+                        Entry::Occupied(entry) => entry.into_mut(),
+                        Entry::Vacant(entry) => {
+                            if let Ok(border) = Border::create(monocle.id()) {
+                                entry.insert(border)
+                            } else {
+                                continue 'receiver;
+                            }
+                        }
+                    };
+
+                    borders_monitors.insert(monocle.id().clone(), monitor_idx);
+
+                    {
+                        let mut focus_state = FOCUS_STATE.lock();
+                        focus_state.insert(
+                            border.hwnd,
+                            if monitor_idx != focused_monitor_idx {
                                 WindowKind::Unfocused
                             } else {
                                 WindowKind::Monocle
-                            };
+                            },
+                        );
+                    }
 
-                            monocle
-                                .focused_window()
-                                .copied()
-                                .unwrap_or_default()
-                                .set_accent(window_kind_colour(window_kind))?;
+                    let rect = WindowsApi::window_rect(
+                        monocle.focused_window().copied().unwrap_or_default().hwnd(),
+                    )?;
 
-                            continue 'monitors;
-                        }
+                    border.update(&rect)?;
 
-                        for (idx, c) in ws.containers().iter().enumerate() {
-                            let window_kind = if idx != ws.focused_container_idx()
-                                || monitor_idx != focused_monitor_idx
-                            {
-                                WindowKind::Unfocused
-                            } else if c.windows().len() > 1 {
-                                WindowKind::Stack
-                            } else {
-                                WindowKind::Single
-                            };
-
-                            c.focused_window()
-                                .copied()
-                                .unwrap_or_default()
-                                .set_accent(window_kind_colour(window_kind))?;
+                    let border_hwnd = border.hwnd;
+                    let mut to_remove = vec![];
+                    for (id, b) in borders.iter() {
+                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            && border_hwnd != b.hwnd
+                        {
+                            b.destroy()?;
+                            to_remove.push(id.clone());
                         }
                     }
-                }
-            }
-            BorderImplementation::Komorebi => {
-                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;
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
+                    continue 'monitors;
                 }
 
-                // handle the pause edge case
-                if is_paused && !previous_is_paused {
-                    should_process_notification = true;
+                let is_maximized = WindowsApi::is_zoomed(HWND(
+                    WindowsApi::foreground_window().unwrap_or_default(),
+                ));
+
+                if is_maximized {
+                    let mut to_remove = vec![];
+                    for (id, border) in borders.iter() {
+                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
+                            border.destroy()?;
+                            to_remove.push(id.clone());
+                        }
+                    }
+
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
+
+                    continue 'monitors;
                 }
 
-                // handle the unpause edge case
-                if previous_is_paused && !is_paused {
-                    should_process_notification = true;
-                }
+                // Destroy any borders not associated with the focused workspace
+                let container_ids = ws
+                    .containers()
+                    .iter()
+                    .map(|c| c.id().clone())
+                    .collect::<Vec<_>>();
 
-                // 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();
-
-                // If borders are disabled
-                if !BORDER_ENABLED.load_consume()
-                    // Or if they are temporarily disabled
-                    || BORDER_TEMPORARILY_DISABLED.load(Ordering::SeqCst)
-                    // Or if the wm is paused
-                    || is_paused
-                    // Or if we are handling an alt-tab across workspaces
-                    || ALT_TAB_HWND.load().is_some()
-                {
-                    // Destroy the borders we know about
-                    for (_, border) in borders.iter() {
+                let mut to_remove = vec![];
+                for (id, border) in borders.iter() {
+                    if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                        && !container_ids.contains(id)
+                    {
                         border.destroy()?;
+                        to_remove.push(id.clone());
                     }
-
-                    borders.clear();
-
-                    previous_is_paused = is_paused;
-                    continue 'receiver;
                 }
 
-                '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
-                        if !ws.tile() {
-                            let mut to_remove = vec![];
-                            for (id, border) in borders.iter() {
-                                if borders_monitors.get(id).copied().unwrap_or_default()
-                                    == monitor_idx
-                                {
-                                    border.destroy()?;
-                                    to_remove.push(id.clone());
-                                }
-                            }
+                for id in &to_remove {
+                    borders.remove(id);
+                }
 
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
+                for (idx, c) in ws.containers().iter().enumerate() {
+                    // Update border when moving or resizing with mouse
+                    if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                        let restore_z_order = *Z_ORDER.lock();
+                        *Z_ORDER.lock() = ZOrder::TopMost;
 
-                            continue 'monitors;
-                        }
+                        let mut rect = WindowsApi::window_rect(
+                            c.focused_window().copied().unwrap_or_default().hwnd(),
+                        )?;
 
-                        // Handle the monocle container separately
-                        if let Some(monocle) = ws.monocle_container() {
-                            let border = match borders.entry(monocle.id().clone()) {
-                                Entry::Occupied(entry) => entry.into_mut(),
-                                Entry::Vacant(entry) => {
-                                    if let Ok(border) = Border::create(monocle.id()) {
-                                        entry.insert(border)
-                                    } else {
-                                        continue 'monitors;
-                                    }
-                                }
-                            };
-
-                            borders_monitors.insert(monocle.id().clone(), monitor_idx);
-
-                            {
-                                let mut focus_state = FOCUS_STATE.lock();
-                                focus_state.insert(
-                                    border.hwnd,
-                                    if monitor_idx != focused_monitor_idx {
-                                        WindowKind::Unfocused
-                                    } else {
-                                        WindowKind::Monocle
-                                    },
-                                );
-                            }
-
-                            let rect = WindowsApi::window_rect(
-                                monocle.focused_window().copied().unwrap_or_default().hwnd(),
-                            )?;
-
-                            border.update(&rect, true)?;
-
-                            let border_hwnd = border.hwnd;
-                            let mut to_remove = vec![];
-                            for (id, b) in borders.iter() {
-                                if borders_monitors.get(id).copied().unwrap_or_default()
-                                    == monitor_idx
-                                    && border_hwnd != b.hwnd
-                                {
-                                    b.destroy()?;
-                                    to_remove.push(id.clone());
-                                }
-                            }
-
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
-
-                            continue 'monitors;
-                        }
-
-                        let is_maximized = WindowsApi::is_zoomed(HWND(
-                            WindowsApi::foreground_window().unwrap_or_default(),
-                        ));
-
-                        if is_maximized {
-                            let mut to_remove = vec![];
-                            for (id, border) in borders.iter() {
-                                if borders_monitors.get(id).copied().unwrap_or_default()
-                                    == monitor_idx
-                                {
-                                    border.destroy()?;
-                                    to_remove.push(id.clone());
-                                }
-                            }
-
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
-
-                            continue 'monitors;
-                        }
-
-                        // Destroy any borders not associated with the focused workspace
-                        let container_ids = ws
-                            .containers()
-                            .iter()
-                            .map(|c| c.id().clone())
-                            .collect::<Vec<_>>();
-
-                        let mut to_remove = vec![];
-                        for (id, border) in borders.iter() {
-                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                                && !container_ids.contains(id)
-                            {
-                                border.destroy()?;
-                                to_remove.push(id.clone());
-                            }
-                        }
-
-                        for id in &to_remove {
-                            borders.remove(id);
-                        }
-
-                        for (idx, c) in ws.containers().iter().enumerate() {
-                            // Update border when moving or resizing with mouse
-                            if 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(),
-                                )?;
-
-                                while WindowsApi::lbutton_is_pressed() {
-                                    let border = match borders.entry(c.id().clone()) {
-                                        Entry::Occupied(entry) => entry.into_mut(),
-                                        Entry::Vacant(entry) => {
-                                            if let Ok(border) = Border::create(c.id()) {
-                                                entry.insert(border)
-                                            } else {
-                                                continue 'monitors;
-                                            }
-                                        }
-                                    };
-
-                                    let new_rect = WindowsApi::window_rect(
-                                        c.focused_window().copied().unwrap_or_default().hwnd(),
-                                    )?;
-
-                                    if rect != new_rect {
-                                        rect = new_rect;
-                                        border.update(&rect, true)?;
-                                    }
-                                }
-
-                                Z_ORDER.store(restore_z_order);
-
-                                continue 'monitors;
-                            }
-
-                            // Get the border entry for this container from the map or create one
+                        while WindowsApi::lbutton_is_pressed() {
                             let border = match borders.entry(c.id().clone()) {
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
                                     if let Ok(border) = Border::create(c.id()) {
                                         entry.insert(border)
                                     } else {
-                                        continue 'monitors;
+                                        continue 'receiver;
                                     }
                                 }
                             };
 
-                            borders_monitors.insert(c.id().clone(), monitor_idx);
+                            let new_rect = WindowsApi::window_rect(
+                                c.focused_window().copied().unwrap_or_default().hwnd(),
+                            )?;
 
-                            #[allow(unused_assignments)]
-                            let mut last_focus_state = None;
+                            if rect != new_rect {
+                                rect = new_rect;
+                                border.update(&rect)?;
+                            }
+                        }
 
-                            let new_focus_state = if idx != ws.focused_container_idx()
+                        *Z_ORDER.lock() = restore_z_order;
+
+                        continue 'receiver;
+                    }
+
+                    // Get the border entry for this container from the map or create one
+                    let border = match borders.entry(c.id().clone()) {
+                        Entry::Occupied(entry) => entry.into_mut(),
+                        Entry::Vacant(entry) => {
+                            if let Ok(border) = Border::create(c.id()) {
+                                entry.insert(border)
+                            } else {
+                                continue 'receiver;
+                            }
+                        }
+                    };
+
+                    borders_monitors.insert(c.id().clone(), monitor_idx);
+
+                    // Update the focused state for all containers on this workspace
+                    {
+                        let mut focus_state = FOCUS_STATE.lock();
+                        focus_state.insert(
+                            border.hwnd,
+                            if idx != ws.focused_container_idx()
                                 || monitor_idx != focused_monitor_idx
                             {
                                 WindowKind::Unfocused
@@ -429,33 +334,18 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 WindowKind::Stack
                             } else {
                                 WindowKind::Single
-                            };
-
-                            // Update the focused state for all containers on this workspace
-                            {
-                                let mut focus_state = FOCUS_STATE.lock();
-                                last_focus_state = focus_state.insert(border.hwnd, new_focus_state);
-                            }
-
-                            let rect = WindowsApi::window_rect(
-                                c.focused_window().copied().unwrap_or_default().hwnd(),
-                            )?;
-
-                            let should_invalidate = match last_focus_state {
-                                None => true,
-                                Some(last_focus_state) => last_focus_state != new_focus_state,
-                            };
-
-                            border.update(&rect, should_invalidate)?;
-                        }
+                            },
+                        );
                     }
+
+                    let rect = WindowsApi::window_rect(
+                        c.focused_window().copied().unwrap_or_default().hwnd(),
+                    )?;
+
+                    border.update(&rect)?;
                 }
             }
         }
-
-        previous_snapshot = monitors;
-        previous_pending_move_op = pending_move_op;
-        previous_is_paused = is_paused;
     }
 
     Ok(())

komorebi/src/container.rs

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

komorebi/src/lib.rs

@@ -1,7 +1,3 @@
-#![warn(clippy::all)]
-
-pub mod animation;
-pub mod animation_manager;
 pub mod border_manager;
 pub mod com;
 #[macro_use]
@@ -18,7 +14,6 @@ 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;
@@ -40,12 +35,9 @@ use std::process::Command;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
-use std::sync::atomic::AtomicU64;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
-pub use animation::*;
-pub use animation_manager::*;
 pub use colour::*;
 pub use process_command::*;
 pub use process_event::*;
@@ -60,7 +52,6 @@ use color_eyre::Result;
 use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
-use komorebi_core::AnimationStyle;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
@@ -203,12 +194,6 @@ lazy_static! {
         )
     };
 
-    static ref ANIMATION_STYLE: Arc<Mutex<AnimationStyle >> =
-        Arc::new(Mutex::new(AnimationStyle::Linear));
-
-    static ref ANIMATION_MANAGER: Arc<Mutex<AnimationManager>> =
-        Arc::new(Mutex::new(AnimationManager::new()));
-
     // Use app-specific titlebar removal options where possible
     // eg. Windows Terminal, IntelliJ IDEA, Firefox
     static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
@@ -226,8 +211,6 @@ pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
 
 pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
-pub static ANIMATION_ENABLED: AtomicBool = AtomicBool::new(false);
-pub static ANIMATION_DURATION: AtomicU64 = AtomicU64::new(250);
 
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {

komorebi/src/main.rs

@@ -1,10 +1,9 @@
-#![warn(clippy::all)]
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(
     clippy::missing_errors_doc,
     clippy::redundant_pub_crate,
     clippy::significant_drop_tightening,
-    clippy::significant_drop_in_scrutinee,
-    clippy::doc_markdown
+    clippy::significant_drop_in_scrutinee
 )]
 
 use std::path::PathBuf;
@@ -34,7 +33,6 @@ 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;
@@ -45,8 +43,6 @@ use komorebi::HOME_DIR;
 use komorebi::INITIAL_CONFIGURATION_LOADED;
 use komorebi::SESSION_ID;
 
-shadow_rs::shadow!(build);
-
 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
         std::env::set_var("RUST_LIB_BACKTRACE", "1");
@@ -134,7 +130,7 @@ fn detect_deadlocks() {
 }
 
 #[derive(Parser)]
-#[clap(author, about, version = build::CLAP_LONG_VERSION)]
+#[clap(author, about, version)]
 struct Opts {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
     #[clap(short, long = "ffm")]
@@ -261,7 +257,6 @@ 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());

komorebi/src/monitor.rs

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

komorebi/src/monitor_reconciliator/hidden.rs

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

komorebi/src/monitor_reconciliator/mod.rs

@@ -40,20 +40,14 @@ pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
     CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
 }
 
-fn event_tx() -> Sender<Notification> {
+pub fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-fn event_rx() -> Receiver<Notification> {
+pub 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()))
@@ -63,7 +57,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_all()
+    Ok(win32_display_data::connected_displays()
         .flatten()
         .map(|display| {
             let path = display.device_path;
@@ -166,7 +160,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::send_notification();
+                        border_manager::event_tx().send(border_manager::Notification)?;
                     } else {
                         tracing::debug!(
                             "work areas match, reconciliation not required for {}",
@@ -213,7 +207,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         );
 
                         monitor.update_focused_workspace(offset)?;
-                        border_manager::send_notification();
+                        border_manager::event_tx().send(border_manager::Notification)?;
                     } else {
                         tracing::debug!(
                             "resolutions match, reconciliation not required for {}",
@@ -400,7 +394,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::send_notification();
+                    border_manager::event_tx().send(border_manager::Notification)?;
                 }
             }
         }

komorebi/src/process_command.rs

@@ -27,7 +27,6 @@ use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
-use komorebi_core::BorderImplementation;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
 use komorebi_core::MoveBehaviour;
@@ -40,16 +39,12 @@ use komorebi_core::WindowContainerBehaviour;
 use komorebi_core::WindowKind;
 
 use crate::border_manager;
-use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
 use crate::colour::Rgb;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
-use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
-use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 use crate::static_config::StaticConfig;
-use crate::transparency_manager;
 use crate::window::RuleDebug;
 use crate::window::Window;
 use crate::window_manager;
@@ -58,10 +53,6 @@ use crate::windows_api::WindowsApi;
 use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
-use crate::ANIMATION_DURATION;
-use crate::ANIMATION_ENABLED;
-use crate::ANIMATION_FPS;
-use crate::ANIMATION_STYLE;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
@@ -78,7 +69,6 @@ use crate::SUBSCRIPTION_PIPES;
 use crate::SUBSCRIPTION_SOCKETS;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WINDOWS_11;
 use crate::WORKSPACE_RULES;
 use stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use stackbar_manager::STACKBAR_LABEL;
@@ -90,33 +80,26 @@ use stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        let wm = wm.clone();
+    let listener = wm
+        .lock()
+        .command_listener
+        .try_clone()
+        .expect("could not clone unix listener");
 
-        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;
-                    }
+    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;
                 }
             }
-        })
-        .join();
-
-        tracing::error!("restarting failed thread");
+        }
     });
 }
 
@@ -222,8 +205,6 @@ 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)?;
@@ -235,10 +216,16 @@ impl WindowManager {
                 WindowsApi::left_click();
             }
             SocketMessage::Close => {
-                Window::from(WindowsApi::foreground_window()?).close()?;
+                Window {
+                    hwnd: WindowsApi::foreground_window()?,
+                }
+                .close()?;
             }
             SocketMessage::Minimize => {
-                Window::from(WindowsApi::foreground_window()?).minimize();
+                Window {
+                    hwnd: WindowsApi::foreground_window()?,
+                }
+                .minimize();
             }
             SocketMessage::ToggleFloat => self.toggle_float()?,
             SocketMessage::ToggleMonocle => self.toggle_monocle()?,
@@ -283,40 +270,6 @@ impl WindowManager {
                     self.handle_definitive_workspace_rules(id, monitor_idx, workspace_idx)?;
                 }
             }
-            SocketMessage::ClearWorkspaceRules(monitor_idx, workspace_idx) => {
-                let mut workspace_rules = WORKSPACE_RULES.lock();
-                let mut to_remove = vec![];
-                for (id, (m_idx, w_idx, _)) in workspace_rules.iter() {
-                    if monitor_idx == *m_idx && workspace_idx == *w_idx {
-                        to_remove.push(id.clone());
-                    }
-                }
-
-                for rule in to_remove {
-                    workspace_rules.remove(&rule);
-                }
-            }
-            SocketMessage::ClearNamedWorkspaceRules(ref workspace) => {
-                if let Some((monitor_idx, workspace_idx)) =
-                    self.monitor_workspace_index_by_name(workspace)
-                {
-                    let mut workspace_rules = WORKSPACE_RULES.lock();
-                    let mut to_remove = vec![];
-                    for (id, (m_idx, w_idx, _)) in workspace_rules.iter() {
-                        if monitor_idx == *m_idx && workspace_idx == *w_idx {
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for rule in to_remove {
-                        workspace_rules.remove(&rule);
-                    }
-                }
-            }
-            SocketMessage::ClearAllWorkspaceRules => {
-                let mut workspace_rules = WORKSPACE_RULES.lock();
-                workspace_rules.clear();
-            }
             SocketMessage::ManageRule(identifier, ref id) => {
                 let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
 
@@ -565,7 +518,6 @@ impl WindowManager {
                 self.update_focused_workspace(self.mouse_follows_focus, true)?;
             }
             SocketMessage::Retile => {
-                border_manager::BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
                 border_manager::destroy_all_borders()?;
                 self.retile_all(false)?
             }
@@ -842,22 +794,15 @@ impl WindowManager {
                     }
                 }
 
-                let visible_windows_state = serde_json::to_string_pretty(&monitor_visible_windows)
-                    .unwrap_or_else(|error| error.to_string());
+                let visible_windows_state =
+                    match serde_json::to_string_pretty(&monitor_visible_windows) {
+                        Ok(state) => state,
+                        Err(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(),
@@ -1285,25 +1230,6 @@ impl WindowManager {
             SocketMessage::Border(enable) => {
                 border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst);
             }
-            SocketMessage::BorderImplementation(implementation) => {
-                if !*WINDOWS_11 && matches!(implementation, BorderImplementation::Windows) {
-                    tracing::error!(
-                        "BorderImplementation::Windows is only supported on Windows 11 and above"
-                    );
-                } else {
-                    IMPLEMENTATION.store(implementation);
-                    match IMPLEMENTATION.load() {
-                        BorderImplementation::Komorebi => {
-                            self.remove_all_accents()?;
-                        }
-                        BorderImplementation::Windows => {
-                            border_manager::destroy_all_borders()?;
-                        }
-                    }
-
-                    border_manager::send_notification();
-                }
-            }
             SocketMessage::BorderColour(kind, r, g, b) => match kind {
                 WindowKind::Single => {
                     border_manager::FOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
@@ -1319,7 +1245,8 @@ impl WindowManager {
                 }
             },
             SocketMessage::BorderStyle(style) => {
-                STYLE.store(style);
+                let mut border_style = STYLE.lock();
+                *border_style = style;
             }
             SocketMessage::BorderWidth(width) => {
                 border_manager::BORDER_WIDTH.store(width, Ordering::SeqCst);
@@ -1327,24 +1254,6 @@ impl WindowManager {
             SocketMessage::BorderOffset(offset) => {
                 border_manager::BORDER_OFFSET.store(offset, Ordering::SeqCst);
             }
-            SocketMessage::Animation(enable) => {
-                ANIMATION_ENABLED.store(enable, Ordering::SeqCst);
-            }
-            SocketMessage::AnimationDuration(duration) => {
-                ANIMATION_DURATION.store(duration, Ordering::SeqCst);
-            }
-            SocketMessage::AnimationFps(fps) => {
-                ANIMATION_FPS.store(fps, Ordering::SeqCst);
-            }
-            SocketMessage::AnimationStyle(style) => {
-                *ANIMATION_STYLE.lock() = style;
-            }
-            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);
             }
@@ -1369,13 +1278,6 @@ impl WindowManager {
             SocketMessage::StackbarTabWidth(width) => {
                 STACKBAR_TAB_WIDTH.store(width, Ordering::SeqCst);
             }
-            SocketMessage::StackbarFontSize(size) => {
-                STACKBAR_FONT_SIZE.store(size, Ordering::SeqCst);
-            }
-            #[allow(clippy::assigning_clones)]
-            SocketMessage::StackbarFontFamily(ref font_family) => {
-                *STACKBAR_FONT_FAMILY.lock() = font_family.clone();
-            }
             SocketMessage::ApplicationSpecificConfigurationSchema => {
                 let asc = schema_for!(Vec<ApplicationConfiguration>);
                 let schema = serde_json::to_string_pretty(&asc)?;
@@ -1424,7 +1326,7 @@ impl WindowManager {
                 self.update_focused_workspace(false, false)?;
             }
             SocketMessage::DebugWindow(hwnd) => {
-                let window = Window::from(hwnd);
+                let window = Window { hwnd };
                 let mut rule_debug = RuleDebug::default();
                 let _ = window.should_manage(None, &mut rule_debug);
                 let schema = serde_json::to_string_pretty(&rule_debug)?;
@@ -1442,9 +1344,8 @@ impl WindowManager {
         };
 
         notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::send_notification();
-        transparency_manager::send_notification();
-        stackbar_manager::send_notification();
+        border_manager::event_tx().send(border_manager::Notification)?;
+        stackbar_manager::event_tx().send(stackbar_manager::Notification)?;
 
         tracing::info!("processed");
         Ok(())

komorebi/src/process_event.rs

@@ -6,7 +6,6 @@ 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;
@@ -20,7 +19,6 @@ 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;
@@ -45,8 +43,7 @@ pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
         tracing::info!("listening");
         loop {
             if let Ok(event) = receiver.recv() {
-                let mut guard = wm.lock();
-                match guard.process_event(event) {
+                match wm.lock().process_event(event) {
                     Ok(()) => {}
                     Err(error) => {
                         if cfg!(debug_assertions) {
@@ -77,32 +74,7 @@ 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 {
-            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(());
-            }
+            return Ok(());
         }
 
         if let Some(virtual_desktop_id) = &self.virtual_desktop_id {
@@ -299,7 +271,13 @@ impl WindowManager {
                                 }
                             }
 
-                            workspace_reconciliator::send_notification(i, j);
+                            workspace_reconciliator::event_tx().send(
+                                workspace_reconciliator::Notification {
+                                    monitor_idx: i,
+                                    workspace_idx: j,
+                                },
+                            )?;
+
                             needs_reconciliation = true;
                         }
                     }
@@ -329,8 +307,7 @@ impl WindowManager {
                 }
 
                 if proceed {
-                    let behaviour =
-                        self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
+                    let behaviour = self.window_container_behaviour;
                     let workspace = self.focused_workspace_mut()?;
                     let workspace_contains_window = workspace.contains_window(window.hwnd);
                     let monocle_container = workspace.monocle_container().clone();
@@ -347,8 +324,6 @@ impl WindowManager {
                                     .ok_or_else(|| anyhow!("there is no focused container"))?
                                     .add_window(window);
                                 self.update_focused_workspace(true, false)?;
-
-                                stackbar_manager::send_notification();
                             }
                         }
                     }
@@ -400,12 +375,10 @@ impl WindowManager {
                     .monitor_idx_from_current_pos()
                     .ok_or_else(|| anyhow!("cannot get monitor idx from current position"))?;
 
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx = self.focused_workspace_idx().unwrap_or_default();
-                let window_container_behaviour =
-                    self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
+                let new_window_behaviour = self.window_container_behaviour;
 
                 let workspace = self.focused_workspace_mut()?;
+
                 let focused_container_idx = workspace.focused_container_idx();
                 let new_position = WindowsApi::window_rect(window.hwnd())?;
                 let old_position = *workspace
@@ -522,7 +495,7 @@ impl WindowManager {
                             // Here we handle a simple move on the same monitor which is treated as
                             // a container swap
                         } else {
-                            match window_container_behaviour {
+                            match new_window_behaviour {
                                 WindowContainerBehaviour::Create => {
                                     match workspace.container_idx_from_current_point() {
                                         Some(target_idx) => {
@@ -551,8 +524,6 @@ impl WindowManager {
                                             )?;
                                         }
                                     }
-
-                                    stackbar_manager::send_notification();
                                 }
                             }
                         }
@@ -606,7 +577,7 @@ impl WindowManager {
         };
 
         // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
-        if let WindowManagerEvent::Unmanage(mut window) = event {
+        if let WindowManagerEvent::Unmanage(window) = event {
             window.center(&self.focused_monitor_work_area()?)?;
         }
 
@@ -637,9 +608,8 @@ impl WindowManager {
         };
 
         notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::send_notification();
-        transparency_manager::send_notification();
-        stackbar_manager::send_notification();
+        border_manager::event_tx().send(border_manager::Notification)?;
+        stackbar_manager::event_tx().send(stackbar_manager::Notification)?;
 
         // Too many spammy OBJECT_NAMECHANGE events from JetBrains IDEs
         if !matches!(

komorebi/src/reaper.rs

@@ -51,7 +51,7 @@ pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
                 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();
+                    border_manager::event_tx().send(border_manager::Notification)?;
                     tracing::info!(
                         "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                         reaped_orphans.0,

komorebi/src/ring.rs

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

komorebi/src/stackbar_manager/mod.rs

@@ -15,15 +15,12 @@ use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
-use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use windows::Win32::Foundation::HWND;
 
-pub static STACKBAR_FONT_SIZE: AtomicI32 = AtomicI32::new(0); // 0 will produce the system default
 pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
 pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947); // gray text
 pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
@@ -32,11 +29,8 @@ pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
 pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
 pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::OnStack);
 
-pub static STACKBAR_TEMPORARILY_DISABLED: AtomicBool = AtomicBool::new(false);
-
 lazy_static! {
     pub static ref STACKBAR_STATE: Mutex<HashMap<String, Stackbar>> = Mutex::new(HashMap::new());
-    pub static ref STACKBAR_FONT_FAMILY: Mutex<Option<String>> = Mutex::new(None);
     static ref STACKBARS_MONITORS: Mutex<HashMap<String, usize>> = Mutex::new(HashMap::new());
     static ref STACKBARS_CONTAINERS: Mutex<HashMap<isize, Container>> = Mutex::new(HashMap::new());
 }
@@ -46,23 +40,17 @@ 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::bounded(20))
+    CHANNEL.get_or_init(crossbeam_channel::unbounded)
 }
 
-fn event_tx() -> Sender<Notification> {
+pub fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-fn event_rx() -> Receiver<Notification> {
+pub 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,
@@ -97,9 +85,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
         let mut state = wm.lock();
 
         // If stackbars are disabled
-        if matches!(STACKBAR_MODE.load(), StackbarMode::Never)
-            || STACKBAR_TEMPORARILY_DISABLED.load(Ordering::SeqCst)
-        {
+        if matches!(STACKBAR_MODE.load(), StackbarMode::Never) {
             for (_, stackbar) in stackbars.iter() {
                 stackbar.destroy()?;
             }

komorebi/src/stackbar_manager/stackbar.rs

@@ -4,8 +4,6 @@ use crate::border_manager::STYLE;
 use crate::container::Container;
 use crate::stackbar_manager::STACKBARS_CONTAINERS;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
-use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 use crate::stackbar_manager::STACKBAR_LABEL;
 use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
@@ -18,8 +16,6 @@ use crossbeam_utils::atomic::AtomicConsume;
 use komorebi_core::BorderStyle;
 use komorebi_core::Rect;
 use komorebi_core::StackbarLabel;
-use std::os::windows::ffi::OsStrExt;
-use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::time::Duration;
 use windows::core::PCWSTR;
@@ -31,10 +27,8 @@ 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::GetDeviceCaps;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::ReleaseDC;
 use windows::Win32::Graphics::Gdi::RoundRect;
@@ -48,10 +42,8 @@ use windows::Win32::Graphics::Gdi::DT_VCENTER;
 use windows::Win32::Graphics::Gdi::FONT_QUALITY;
 use windows::Win32::Graphics::Gdi::FW_BOLD;
 use windows::Win32::Graphics::Gdi::LOGFONTW;
-use windows::Win32::Graphics::Gdi::LOGPIXELSY;
 use windows::Win32::Graphics::Gdi::PROOF_QUALITY;
 use windows::Win32::Graphics::Gdi::PS_SOLID;
-use windows::Win32::System::WindowsProgramming::MulDiv;
 use windows::Win32::UI::WindowsAndMessaging::CreateWindowExW;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
@@ -127,17 +119,11 @@ impl Stackbar {
                 SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
                 hwnd_sender.send(hwnd)?;
 
-                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;
-                    };
+                let mut msg = MSG::default();
+                while GetMessageW(&mut msg, hwnd, 0, 0).into() {
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
-
-                    std::thread::sleep(Duration::from_millis(10))
+                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 
@@ -188,29 +174,11 @@ impl Stackbar {
             SelectObject(hdc, hbrush);
             SetBkColor(hdc, COLORREF(background));
 
-            let mut logfont = LOGFONTW {
+            let hfont = CreateFontIndirectW(&LOGFONTW {
                 lfWeight: FW_BOLD.0 as i32,
                 lfQuality: FONT_QUALITY(PROOF_QUALITY.0),
-                lfFaceName: [0; 32],
                 ..Default::default()
-            };
-
-            if let Some(font_name) = &*STACKBAR_FONT_FAMILY.lock() {
-                let font = wide_string(font_name);
-                for (i, &c) in font.iter().enumerate() {
-                    logfont.lfFaceName[i] = c;
-                }
-            }
-
-            let logical_height = -MulDiv(
-                STACKBAR_FONT_SIZE.load(Ordering::SeqCst),
-                72,
-                GetDeviceCaps(hdc, LOGPIXELSY),
-            );
-
-            logfont.lfHeight = logical_height;
-
-            let hfont = CreateFontIndirectW(&logfont);
+            });
 
             SelectObject(hdc, hfont);
 
@@ -229,7 +197,7 @@ impl Stackbar {
                     bottom: height,
                 };
 
-                match STYLE.load() {
+                match *STYLE.lock() {
                     BorderStyle::System => {
                         if *WINDOWS_11 {
                             RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
@@ -267,9 +235,6 @@ impl Stackbar {
             }
 
             ReleaseDC(self.hwnd(), hdc);
-            DeleteObject(hpen);
-            DeleteObject(hbrush);
-            DeleteObject(hfont);
         }
 
         Ok(())
@@ -361,10 +326,3 @@ impl Stackbar {
         }
     }
 }
-
-fn wide_string(s: &str) -> Vec<u16> {
-    std::ffi::OsStr::new(s)
-        .encode_wide()
-        .chain(std::iter::once(0))
-        .collect()
-}

komorebi/src/static_config.rs

@@ -1,6 +1,5 @@
 use crate::border_manager;
 use crate::border_manager::ZOrder;
-use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
 use crate::border_manager::Z_ORDER;
 use crate::colour::Colour;
@@ -9,24 +8,16 @@ use crate::monitor::Monitor;
 use crate::monitor_reconciliator;
 use crate::ring::Ring;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
-use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 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::transparency_manager;
-use crate::window;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
-use crate::ANIMATION_DURATION;
-use crate::ANIMATION_ENABLED;
-use crate::ANIMATION_FPS;
-use crate::ANIMATION_STYLE;
 use crate::DATA_DIR;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
@@ -39,9 +30,7 @@ use crate::MONITOR_INDEX_PREFERENCES;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WINDOWS_11;
 use crate::WORKSPACE_RULES;
-use komorebi_core::BorderImplementation;
 use komorebi_core::StackbarLabel;
 use komorebi_core::StackbarMode;
 
@@ -56,7 +45,6 @@ use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::resolve_home_path;
-use komorebi_core::AnimationStyle;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::BorderStyle;
 use komorebi_core::DefaultLayout;
@@ -123,9 +111,6 @@ pub struct WorkspaceConfig {
     /// Permanent workspace application rules
     #[serde(skip_serializing_if = "Option::is_none")]
     pub workspace_rules: Option<Vec<IdWithIdentifier>>,
-    /// Apply this monitor's window-based work area offset (default: true)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub apply_window_based_work_area_offset: Option<bool>,
 }
 
 impl From<&Workspace> for WorkspaceConfig {
@@ -208,7 +193,6 @@ impl From<&Workspace> for WorkspaceConfig {
             workspace_padding,
             initial_workspace_rules: initial_ws_rules,
             workspace_rules: ws_rules,
-            apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
         }
     }
 }
@@ -245,17 +229,11 @@ impl From<&Monitor> for MonitorConfig {
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.28`
+/// The `komorebi.json` static configuration file reference for `v0.1.26`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
     pub invisible_borders: Option<Rect>,
-    /// DISCOURAGED: Minimum width for a window to be eligible for tiling
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub minimum_window_width: Option<i32>,
-    /// DISCOURAGED: Minimum height for a window to be eligible for tiling
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub minimum_window_height: Option<i32>,
     /// Delta to resize windows by (default 50)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub resize_delta: Option<i32>,
@@ -300,15 +278,6 @@ pub struct StaticConfig {
     /// Active window border z-order (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub border_z_order: Option<ZOrder>,
-    /// Display an active window border (default: false)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub border_implementation: Option<BorderImplementation>,
-    /// 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>,
@@ -318,7 +287,7 @@ pub struct StaticConfig {
     /// Monitor and workspace configurations
     #[serde(skip_serializing_if = "Option::is_none")]
     pub monitors: Option<Vec<MonitorConfig>>,
-    /// Which Windows signal to use when hiding windows (default: Cloak)
+    /// Which Windows signal to use when hiding windows (default: minimize)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_hiding_behaviour: Option<HidingBehaviour>,
     /// Global work area (space used for tiling) offset (default: None)
@@ -351,21 +320,6 @@ pub struct StaticConfig {
     /// Stackbar configuration options
     #[serde(skip_serializing_if = "Option::is_none")]
     pub stackbar: Option<StackbarConfig>,
-    /// Animations configuration options
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub animation: Option<AnimationsConfig>,
-}
-
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct AnimationsConfig {
-    /// Enable or disable animations (default: false)
-    enabled: bool,
-    /// Set the animation duration in ms (default: 250)
-    duration: Option<u64>,
-    /// Set the animation style (default: Linear)
-    style: Option<AnimationStyle>,
-    /// Set the animation FPS (default: 60)
-    fps: Option<u64>,
 }
 
 impl StaticConfig {
@@ -379,7 +333,7 @@ impl StaticConfig {
 
         let mut display = false;
 
-        for aliases in map.values() {
+        for (_, aliases) in &map {
             for a in aliases {
                 if raw.contains(a) {
                     display = true;
@@ -400,25 +354,13 @@ impl StaticConfig {
     }
 
     pub fn deprecated(raw: &str) {
-        let deprecated_options = ["invisible_borders"];
-        let deprecated_variants = vec![
-            ("Hide", "window_hiding_behaviour", "Cloak"),
-            ("Minimize", "window_hiding_behaviour", "Cloak"),
-        ];
+        let deprecated = ["invisible_borders"];
 
-        for option in deprecated_options {
+        for option in deprecated {
             if raw.contains(option) {
                 println!(r#""{option}" is deprecated and can be removed"#);
             }
         }
-
-        for (variant, option, recommended) in deprecated_variants {
-            if raw.contains(option) && raw.contains(variant) {
-                println!(
-                    r#"The "{variant}" option for "{option}" is deprecated and can be removed or replaced with "{recommended}""#
-                );
-            }
-        }
     }
 }
 
@@ -432,12 +374,7 @@ pub struct TabsConfig {
     unfocused_text: Option<Colour>,
     /// Tab background colour
     background: Option<Colour>,
-    /// Font family
-    font_family: Option<String>,
-    /// Font size
-    font_size: Option<i32>,
 }
-
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct StackbarConfig {
     /// Stackbar height
@@ -459,8 +396,6 @@ impl From<&WindowManager> for StaticConfig {
         }
 
         let mut to_remove = vec![];
-        let mut to_add_initial = vec![];
-        let mut to_add_persistent = vec![];
 
         let workspace_rules = WORKSPACE_RULES.lock();
         for (m_idx, m) in monitors.iter().enumerate() {
@@ -477,12 +412,6 @@ impl From<&WindowManager> for StaticConfig {
                     }
                 }
 
-                for (identifier, (monitor_idx, workspace_idx, initial)) in &*workspace_rules {
-                    if *initial && (*monitor_idx == m_idx && *workspace_idx == w_idx) {
-                        to_add_initial.push((m_idx, w_idx, identifier.clone()));
-                    }
-                }
-
                 if let Some(rules) = &w.workspace_rules {
                     for wsr in rules {
                         for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
@@ -494,54 +423,18 @@ impl From<&WindowManager> for StaticConfig {
                         }
                     }
                 }
-
-                for (identifier, (monitor_idx, workspace_idx, initial)) in &*workspace_rules {
-                    if !*initial && (*monitor_idx == m_idx && *workspace_idx == w_idx) {
-                        to_add_persistent.push((m_idx, w_idx, identifier.clone()));
-                    }
-                }
             }
         }
 
         for (m_idx, w_idx, id) in to_remove {
             if let Some(monitor) = monitors.get_mut(m_idx) {
                 if let Some(workspace) = monitor.workspaces.get_mut(w_idx) {
-                    if workspace.workspace_rules.is_none() {
-                        workspace.workspace_rules = Some(vec![]);
-                    }
-
                     if let Some(rules) = &mut workspace.workspace_rules {
                         rules.retain(|r| r.id != id);
-                        for (monitor_idx, workspace_idx, id) in &to_add_persistent {
-                            if m_idx == *monitor_idx && w_idx == *workspace_idx {
-                                rules.push(IdWithIdentifier {
-                                    kind: ApplicationIdentifier::Exe,
-                                    id: id.clone(),
-                                    matching_strategy: None,
-                                })
-                            }
-                        }
-
-                        rules.dedup();
-                    }
-
-                    if workspace.initial_workspace_rules.is_none() {
-                        workspace.workspace_rules = Some(vec![]);
                     }
 
                     if let Some(rules) = &mut workspace.initial_workspace_rules {
                         rules.retain(|r| r.id != id);
-                        for (monitor_idx, workspace_idx, id) in &to_add_initial {
-                            if m_idx == *monitor_idx && w_idx == *workspace_idx {
-                                rules.push(IdWithIdentifier {
-                                    kind: ApplicationIdentifier::Exe,
-                                    id: id.clone(),
-                                    matching_strategy: None,
-                                })
-                            }
-                        }
-
-                        rules.dedup();
                     }
                 }
             }
@@ -568,8 +461,6 @@ impl From<&WindowManager> for StaticConfig {
             unmanaged_window_operation_behaviour: Option::from(
                 value.unmanaged_window_operation_behaviour,
             ),
-            minimum_window_height: Some(window::MINIMUM_HEIGHT.load(Ordering::SeqCst)),
-            minimum_window_width: Some(window::MINIMUM_WIDTH.load(Ordering::SeqCst)),
             focus_follows_mouse: value.focus_follows_mouse,
             mouse_follows_focus: Option::from(value.mouse_follows_focus),
             app_specific_configuration_path: None,
@@ -577,15 +468,8 @@ 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,
-            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()),
-            border_implementation: Option::from(IMPLEMENTATION.load()),
+            border_style: Option::from(*STYLE.lock()),
+            border_z_order: Option::from(*Z_ORDER.lock()),
             default_workspace_padding: Option::from(
                 DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
             ),
@@ -604,7 +488,6 @@ impl From<&WindowManager> for StaticConfig {
             monitor_index_preferences: Option::from(MONITOR_INDEX_PREFERENCES.lock().clone()),
             display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.lock().clone()),
             stackbar: None,
-            animation: None,
         }
     }
 }
@@ -614,12 +497,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.clone_from(monitor_index_preferences);
+            *preferences = monitor_index_preferences.clone();
         }
 
         if let Some(display_index_preferences) = &self.display_index_preferences {
             let mut preferences = DISPLAY_INDEX_PREFERENCES.lock();
-            preferences.clone_from(display_index_preferences);
+            *preferences = display_index_preferences.clone();
         }
 
         if let Some(behaviour) = self.window_hiding_behaviour {
@@ -627,22 +510,6 @@ impl StaticConfig {
             *window_hiding_behaviour = behaviour;
         }
 
-        if let Some(height) = self.minimum_window_height {
-            window::MINIMUM_HEIGHT.store(height, Ordering::SeqCst);
-        }
-
-        if let Some(width) = self.minimum_window_width {
-            window::MINIMUM_WIDTH.store(width, Ordering::SeqCst);
-        }
-
-        if let Some(animations) = &self.animation {
-            ANIMATION_ENABLED.store(animations.enabled, Ordering::SeqCst);
-            ANIMATION_DURATION.store(animations.duration.unwrap_or(250), Ordering::SeqCst);
-            ANIMATION_FPS.store(animations.fps.unwrap_or(60), Ordering::SeqCst);
-            let mut animation_style = ANIMATION_STYLE.lock();
-            *animation_style = animations.style.unwrap_or(AnimationStyle::Linear);
-        }
-
         if let Some(container) = self.default_container_padding {
             DEFAULT_CONTAINER_PADDING.store(container, Ordering::SeqCst);
         }
@@ -676,35 +543,8 @@ impl StaticConfig {
             }
         }
 
-        STYLE.store(self.border_style.unwrap_or_default());
-
-        if !*WINDOWS_11
-            && matches!(
-                self.border_implementation.unwrap_or_default(),
-                BorderImplementation::Windows
-            )
-        {
-            tracing::error!(
-                "BorderImplementation::Windows is only supported on Windows 11 and above"
-            );
-        } else {
-            IMPLEMENTATION.store(self.border_implementation.unwrap_or_default());
-            match IMPLEMENTATION.load() {
-                BorderImplementation::Komorebi => {
-                    border_manager::destroy_all_borders()?;
-                }
-                BorderImplementation::Windows => {
-                    // TODO: figure out how to call wm.remove_all_accents here
-                }
-            }
-
-            border_manager::send_notification();
-        }
-
-        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 border_style = self.border_style.unwrap_or_default();
+        *STYLE.lock() = border_style;
 
         let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
         let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
@@ -754,7 +594,6 @@ impl StaticConfig {
                 STACKBAR_MODE.store(*mode);
             }
 
-            #[allow(clippy::assigning_clones)]
             if let Some(tabs) = &stackbar.tabs {
                 if let Some(background) = &tabs.background {
                     STACKBAR_TAB_BACKGROUND_COLOUR.store((*background).into(), Ordering::SeqCst);
@@ -771,9 +610,6 @@ impl StaticConfig {
                 if let Some(width) = &tabs.width {
                     STACKBAR_TAB_WIDTH.store(*width, Ordering::SeqCst);
                 }
-
-                STACKBAR_FONT_SIZE.store(tabs.font_size.unwrap_or(0), Ordering::SeqCst);
-                *STACKBAR_FONT_FAMILY.lock() = tabs.font_family.clone();
             }
         }
 

komorebi/src/transparency_manager.rs

@@ -1,179 +0,0 @@
-#![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

@@ -1,21 +1,14 @@
-use crate::border_manager;
 use crate::com::SetCloak;
-use crate::stackbar_manager;
-use crate::ANIMATIONS_IN_PROGRESS;
-use crate::ANIMATION_DURATION;
-use crate::ANIMATION_ENABLED;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::fmt::Write as _;
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::Ordering;
 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;
@@ -31,10 +24,8 @@ use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 
-use crate::animation::Animation;
 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;
@@ -47,31 +38,9 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-pub static MINIMUM_WIDTH: AtomicI32 = AtomicI32::new(0);
-pub static MINIMUM_HEIGHT: AtomicI32 = AtomicI32::new(0);
-
-#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
     pub hwnd: isize,
-    animation: Animation,
-}
-
-impl From<isize> for Window {
-    fn from(value: isize) -> Self {
-        Self {
-            hwnd: value,
-            animation: Animation::new(value),
-        }
-    }
-}
-
-impl From<HWND> for Window {
-    fn from(value: HWND) -> Self {
-        Self {
-            hwnd: value.0,
-            animation: Animation::new(value.0),
-        }
-    }
 }
 
 #[allow(clippy::module_name_repetitions)]
@@ -154,7 +123,7 @@ impl Window {
         HWND(self.hwnd)
     }
 
-    pub fn center(&mut self, work_area: &Rect) -> Result<()> {
+    pub fn center(&self, work_area: &Rect) -> Result<()> {
         let half_width = work_area.right / 2;
         let half_weight = work_area.bottom / 2;
 
@@ -169,61 +138,13 @@ impl Window {
         )
     }
 
-    pub fn animate_position(&self, layout: &Rect, top: bool) -> Result<()> {
-        let hwnd = self.hwnd();
-        let curr_rect = WindowsApi::window_rect(hwnd).unwrap();
-
-        let target_rect = *layout;
-        let duration = Duration::from_millis(ANIMATION_DURATION.load(Ordering::SeqCst));
-        let mut animation = self.animation;
-
-        border_manager::BORDER_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
-        border_manager::send_notification();
-
-        stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
-        stackbar_manager::send_notification();
-
-        std::thread::spawn(move || {
-            animation.animate(duration, |progress: f64| {
-                let new_rect = Animation::lerp_rect(&curr_rect, &target_rect, progress);
-
-                if progress == 1.0 {
-                    WindowsApi::position_window(hwnd, &new_rect, top)?;
-
-                    if ANIMATIONS_IN_PROGRESS.load(Ordering::Acquire) == 0 {
-                        border_manager::BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
-                        stackbar_manager::STACKBAR_TEMPORARILY_DISABLED
-                            .store(false, Ordering::SeqCst);
-
-                        border_manager::send_notification();
-                        stackbar_manager::send_notification();
-                        transparency_manager::send_notification();
-                    }
-                } else {
-                    // using MoveWindow because it runs faster than SetWindowPos
-                    // so animation have more fps and feel smoother
-                    WindowsApi::move_window(hwnd, &new_rect, false)?;
-                    // WindowsApi::position_window(hwnd, &new_rect, top)?;
-                    WindowsApi::invalidate_rect(hwnd, None, false);
-                }
-
-                Ok(())
-            })
-        });
-
-        Ok(())
-    }
-
     pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
         if WindowsApi::window_rect(self.hwnd())?.eq(layout) {
             return Ok(());
         }
 
-        if ANIMATION_ENABLED.load(Ordering::SeqCst) {
-            self.animate_position(layout, top)
-        } else {
-            WindowsApi::position_window(self.hwnd(), layout, top)
-        }
+        let rect = *layout;
+        WindowsApi::position_window(self.hwnd(), &rect, top)
     }
 
     pub fn is_maximized(self) -> bool {
@@ -329,10 +250,7 @@ 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(),
-            transparency_manager::TRANSPARENCY_ALPHA.load_consume(),
-        )
+        WindowsApi::set_transparent(self.hwnd())
     }
 
     pub fn opaque(self) -> Result<()> {
@@ -341,14 +259,6 @@ impl Window {
         self.update_ex_style(&ex_style)
     }
 
-    pub fn set_accent(self, colour: u32) -> Result<()> {
-        WindowsApi::set_window_accent(self.hwnd, Some(colour))
-    }
-
-    pub fn remove_accent(self) -> Result<()> {
-        WindowsApi::set_window_accent(self.hwnd, None)
-    }
-
     #[allow(dead_code)]
     pub fn update_style(self, style: &WindowStyle) -> Result<()> {
         WindowsApi::update_style(self.hwnd(), isize::try_from(style.bits())?)
@@ -360,12 +270,12 @@ impl Window {
 
     pub fn style(self) -> Result<WindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd())?)?;
-        Ok(WindowStyle::from_bits_truncate(bits))
+        WindowStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
     }
 
     pub fn ex_style(self) -> Result<ExtendedWindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd())?)?;
-        Ok(ExtendedWindowStyle::from_bits_truncate(bits))
+        ExtendedWindowStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
     }
 
     pub fn title(self) -> Result<String> {
@@ -426,20 +336,6 @@ impl Window {
 
         debug.is_window = true;
 
-        let rect = WindowsApi::window_rect(self.hwnd()).unwrap_or_default();
-
-        if rect.right < MINIMUM_WIDTH.load(Ordering::SeqCst) {
-            return Ok(false);
-        }
-
-        debug.has_minimum_width = true;
-
-        if rect.bottom < MINIMUM_HEIGHT.load(Ordering::SeqCst) {
-            return Ok(false);
-        }
-
-        debug.has_minimum_height = true;
-
         if self.title().is_err() {
             return Ok(false);
         }
@@ -479,7 +375,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(self.hwnd, &title, &exe_name, &class, &path, style, ex_style, event, debug);
+                        let eligible = window_is_eligible(&title, &exe_name, &class, &path, style, ex_style, event, debug);
                         debug.should_manage = eligible;
                         return Ok(eligible);
                     }
@@ -496,12 +392,9 @@ impl Window {
 pub struct RuleDebug {
     pub should_manage: bool,
     pub is_window: bool,
-    pub has_minimum_width: bool,
-    pub has_minimum_height: bool,
     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>,
@@ -518,7 +411,6 @@ pub struct RuleDebug {
 
 #[allow(clippy::too_many_arguments)]
 fn window_is_eligible(
-    hwnd: isize,
     title: &String,
     exe_name: &String,
     class: &String,
@@ -573,7 +465,7 @@ fn window_is_eligible(
     }
 
     let layered_whitelist = LAYERED_WHITELIST.lock();
-    let mut allow_layered = if let Some(rule) = should_act(
+    let allow_layered = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
@@ -587,14 +479,8 @@ fn window_is_eligible(
         false
     };
 
-    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
-    };
+    // TODO: might need this for transparency
+    // let allow_layered = true;
 
     let allow_wsl2_gui = {
         let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();

komorebi/src/window_manager.rs

@@ -55,7 +55,6 @@ 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;
@@ -164,7 +163,7 @@ impl Default for GlobalState {
                     border_manager::UNFOCUSED.load(Ordering::SeqCst),
                 ))),
             },
-            border_style: STYLE.load(),
+            border_style: *STYLE.lock(),
             border_offset: border_manager::BORDER_OFFSET.load(Ordering::SeqCst),
             border_width: border_manager::BORDER_WIDTH.load(Ordering::SeqCst),
             stackbar_mode: STACKBAR_MODE.load(),
@@ -303,24 +302,6 @@ impl WindowManager {
         StaticConfig::reload(pathbuf, self)
     }
 
-    pub fn window_container_behaviour(
-        &self,
-        monitor_idx: usize,
-        workspace_idx: usize,
-    ) -> WindowContainerBehaviour {
-        if let Some(monitor) = self.monitors().get(monitor_idx) {
-            if let Some(workspace) = monitor.workspaces().get(workspace_idx) {
-                return if workspace.containers().is_empty() {
-                    WindowContainerBehaviour::Create
-                } else {
-                    self.window_container_behaviour
-                };
-            }
-        }
-
-        WindowContainerBehaviour::Create
-    }
-
     #[tracing::instrument(skip(self))]
     pub fn watch_configuration(&mut self, enable: bool) -> Result<()> {
         let config_pwsh = HOME_DIR.join("komorebi.ps1");
@@ -538,7 +519,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::from(op.hwnd).hide();
+                Window { hwnd: op.hwnd }.hide();
                 should_update_focused_workspace = true;
             }
 
@@ -568,7 +549,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::from(op.hwnd));
+            target_workspace.new_container_for_window(Window { hwnd: op.hwnd });
         }
 
         // Only re-tile the focused workspace if we need to
@@ -616,14 +597,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::from(hwnd));
+        let event = WindowManagerEvent::Manage(Window { 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::from(hwnd));
+        let event = WindowManagerEvent::Unmanage(Window { hwnd });
         Ok(winevent_listener::event_tx().send(event)?)
     }
 
@@ -632,7 +613,6 @@ 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() {
@@ -641,34 +621,6 @@ 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
@@ -680,13 +632,15 @@ impl WindowManager {
                 return Ok(());
             }
 
-            let event = WindowManagerEvent::Raise(Window::from(hwnd));
+            let event = WindowManagerEvent::Raise(Window { hwnd });
             self.has_pending_raise_op = true;
             winevent_listener::event_tx().send(event)?;
         } else {
             tracing::debug!(
                 "not raising unknown window: {}",
-                Window::from(WindowsApi::window_at_cursor_pos()?)
+                Window {
+                    hwnd: WindowsApi::window_at_cursor_pos()?
+                }
             );
         }
 
@@ -810,7 +764,9 @@ impl WindowManager {
                     window.focus(self.mouse_follows_focus)?;
                 }
             } else {
-                let desktop_window = Window::from(WindowsApi::desktop_window()?);
+                let desktop_window = Window {
+                    hwnd: WindowsApi::desktop_window()?,
+                };
 
                 let rect = self.focused_monitor_size()?;
                 WindowsApi::center_cursor_in_rect(&rect)?;
@@ -951,7 +907,6 @@ 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() {
@@ -961,12 +916,6 @@ impl WindowManager {
                             window.add_title_bar()?;
                         }
 
-                        if known_transparent_hwnds.contains(&window.hwnd) {
-                            window.opaque()?;
-                        }
-
-                        window.remove_accent()?;
-
                         window.restore();
                     }
                 }
@@ -976,29 +925,6 @@ impl WindowManager {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self))]
-    pub fn remove_all_accents(&mut self) -> Result<()> {
-        tracing::info!("removing all window accents");
-
-        for monitor in self.monitors() {
-            for workspace in monitor.workspaces() {
-                if let Some(monocle) = workspace.monocle_container() {
-                    for window in monocle.windows() {
-                        window.remove_accent()?
-                    }
-                }
-
-                for containers in workspace.containers() {
-                    for window in containers.windows() {
-                        window.remove_accent()?;
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
     #[tracing::instrument(skip(self))]
     fn handle_unmanaged_window_behaviour(&self) -> Result<()> {
         if matches!(
@@ -1111,14 +1037,6 @@ 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;
 
@@ -1138,12 +1056,6 @@ 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
@@ -1157,22 +1069,9 @@ 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)?;
         }
@@ -1218,7 +1117,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().saturating_sub(1))?;
+            target_monitor.focus_workspace(target_monitor.workspaces().len() - 1)?;
             target_monitor.load_focused_workspace(mouse_follows_focus)?;
         }
 
@@ -1353,9 +1252,10 @@ impl WindowManager {
                         let origin_workspace =
                             self.focused_workspace_for_monitor_idx_mut(origin_monitor_idx)?;
 
-                        origin_workspace.focus_container(
-                            origin_workspace.focused_container_idx().saturating_sub(1),
-                        );
+                        if origin_workspace.focused_container_idx() != 0 {
+                            origin_workspace
+                                .focus_container(origin_workspace.focused_container_idx() - 1);
+                        }
                     }
                 }
 
@@ -1506,67 +1406,6 @@ 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()?;
@@ -1598,20 +1437,12 @@ impl WindowManager {
                     Layout::Default(DefaultLayout::Grid)
                         | Layout::Default(DefaultLayout::UltrawideVerticalStack)
                 ) {
-                new_idx.saturating_sub(1)
+                new_idx - 1
             } else {
                 new_idx
             };
 
-            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)?;
-                }
-            }
-
+            workspace.move_window_to_container(adjusted_new_index)?;
             self.update_focused_workspace(self.mouse_follows_focus, false)?;
         }
 

komorebi/src/windows_api.rs

@@ -18,13 +18,10 @@ use windows::Win32::Foundation::HMODULE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
-use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::WPARAM;
 use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
 use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
-use windows::Win32::Graphics::Dwm::DWMWA_BORDER_COLOR;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
-use windows::Win32::Graphics::Dwm::DWMWA_COLOR_NONE;
 use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
 use windows::Win32::Graphics::Dwm::DWMWA_WINDOW_CORNER_PREFERENCE;
 use windows::Win32::Graphics::Dwm::DWMWCP_ROUND;
@@ -35,7 +32,6 @@ use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
-use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use windows::Win32::Graphics::Gdi::Rectangle;
@@ -86,7 +82,6 @@ use windows::Win32::UI::WindowsAndMessaging::IsIconic;
 use windows::Win32::UI::WindowsAndMessaging::IsWindow;
 use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
 use windows::Win32::UI::WindowsAndMessaging::IsZoomed;
-use windows::Win32::UI::WindowsAndMessaging::MoveWindow;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
@@ -225,7 +220,7 @@ impl WindowsApi {
     }
 
     pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
-        Ok(win32_display_data::connected_displays_all()
+        Ok(win32_display_data::connected_displays()
             .flatten()
             .map(|d| {
                 let name = d.device_name.trim_start_matches(r"\\.\").to_string();
@@ -237,7 +232,7 @@ impl WindowsApi {
     }
 
     pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
-        'read: for display in win32_display_data::connected_displays_all().flatten() {
+        'read: for display in win32_display_data::connected_displays().flatten() {
             let path = display.device_path.clone();
             let mut split: Vec<_> = path.split('#').collect();
             split.remove(0);
@@ -281,7 +276,8 @@ impl WindowsApi {
             if monitors.elements().is_empty() {
                 monitors.elements_mut().push_back(m);
             } else if let Some(preference) = index_preference {
-                while *preference > monitors.elements().len() {
+                let current_len = monitors.elements().len();
+                while *preference > current_len {
                     monitors.elements_mut().reserve(1);
                 }
 
@@ -432,17 +428,6 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn move_window(hwnd: HWND, layout: &Rect, repaint: bool) -> Result<()> {
-        let shadow_rect = Self::shadow_rect(hwnd).unwrap_or_default();
-        let rect = Rect {
-            left: layout.left + shadow_rect.left,
-            top: layout.top + shadow_rect.top,
-            right: layout.right + shadow_rect.right,
-            bottom: layout.bottom + shadow_rect.bottom,
-        };
-        unsafe { MoveWindow(hwnd, rect.left, rect.top, rect.right, rect.bottom, repaint) }.process()
-    }
-
     pub fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
         // BOOL is returned but does not signify whether or not the operation was succesful
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow
@@ -806,7 +791,7 @@ impl WindowsApi {
     }
 
     pub fn monitor(hmonitor: isize) -> Result<Monitor> {
-        for display in win32_display_data::connected_displays_all().flatten() {
+        for display in win32_display_data::connected_displays().flatten() {
             if display.hmonitor == hmonitor {
                 let path = display.device_path;
                 let mut split: Vec<_> = path.split('#').collect();
@@ -971,19 +956,6 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn set_window_accent(hwnd: isize, color: Option<u32>) -> Result<()> {
-        let col_ref = COLORREF(color.unwrap_or(DWMWA_COLOR_NONE));
-        unsafe {
-            DwmSetWindowAttribute(
-                HWND(hwnd),
-                DWMWA_BORDER_COLOR,
-                std::ptr::addr_of!(col_ref).cast(),
-                4,
-            )
-        }
-        .process()
-    }
-
     pub fn create_border_window(name: PCWSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             let hwnd = CreateWindowExW(
@@ -1008,10 +980,11 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn set_transparent(hwnd: HWND, alpha: u8) -> Result<()> {
+    pub fn set_transparent(hwnd: HWND) -> Result<()> {
         unsafe {
             #[allow(clippy::cast_sign_loss)]
-            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), alpha, LWA_ALPHA)?;
+            // TODO: alpha should be configurable
+            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), 150, LWA_ALPHA)?;
         }
 
         Ok(())
@@ -1037,11 +1010,6 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn invalidate_rect(hwnd: HWND, rect: Option<&Rect>, erase: bool) -> bool {
-        let rect = rect.map(|rect| &rect.rect() as *const RECT);
-        unsafe { InvalidateRect(hwnd, rect, erase) }.as_bool()
-    }
-
     pub fn alt_is_pressed() -> bool {
         let state = unsafe { GetKeyState(i32::from(VK_MENU.0)) };
         #[allow(clippy::cast_sign_loss)]

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::from(hwnd);
+        let window = Window { hwnd: hwnd.0 };
 
         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::from(hwnd);
+        let window = Window { hwnd: hwnd.0 };
 
         if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
             if should_manage {
@@ -74,7 +74,7 @@ pub extern "system" fn win_event_hook(
         return;
     }
 
-    let window = Window::from(hwnd);
+    let window = Window { hwnd: hwnd.0 };
 
     let winevent = match WinEvent::try_from(event) {
         Ok(event) => event,

komorebi/src/winevent_listener.rs

@@ -1,5 +1,4 @@
 use std::sync::OnceLock;
-use std::time::Duration;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
@@ -35,26 +34,23 @@ 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::debug!("windows event processing thread shutdown");
+                        tracing::info!("windows event processing 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::bounded(20))
+    CHANNEL.get_or_init(crossbeam_channel::unbounded)
 }
 
 pub fn event_tx() -> Sender<WindowManagerEvent> {

komorebi/src/workspace.rs

@@ -38,16 +38,7 @@ use crate::REMOVE_TITLEBARS;
 
 #[allow(clippy::struct_field_names)]
 #[derive(
-    Debug,
-    Clone,
-    Serialize,
-    Deserialize,
-    Getters,
-    CopyGetters,
-    MutGetters,
-    Setters,
-    JsonSchema,
-    PartialEq,
+    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema,
 )]
 pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
@@ -81,8 +72,6 @@ pub struct Workspace {
     resize_dimensions: Vec<Option<Rect>>,
     #[getset(get = "pub", set = "pub")]
     tile: bool,
-    #[getset(get_copy = "pub", set = "pub")]
-    apply_window_based_work_area_offset: bool,
 }
 
 impl_ring_elements!(Workspace, Container);
@@ -105,7 +94,6 @@ impl Default for Workspace {
             latest_layout: vec![],
             resize_dimensions: vec![],
             tile: true,
-            apply_window_based_work_area_offset: true,
         }
     }
 }
@@ -158,10 +146,6 @@ impl Workspace {
             self.tile = true;
         }
 
-        self.set_apply_window_based_work_area_offset(
-            config.apply_window_based_work_area_offset.unwrap_or(true),
-        );
-
         Ok(())
     }
 
@@ -267,9 +251,7 @@ impl Workspace {
             },
         );
 
-        if self.containers().len() <= window_based_work_area_offset_limit as usize
-            && self.apply_window_based_work_area_offset
-        {
+        if self.containers().len() <= window_based_work_area_offset_limit as usize {
             adjusted_work_area = window_based_work_area_offset.map_or_else(
                 || adjusted_work_area,
                 |offset| {
@@ -415,28 +397,6 @@ 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() {
@@ -471,14 +431,6 @@ 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()))
     }
 
@@ -757,9 +709,6 @@ impl Workspace {
             self.focus_previous_container();
         } else {
             container.load_focused_window();
-            if let Some(window) = container.focused_window() {
-                window.focus(false)?;
-            }
         }
 
         Ok(())
@@ -814,7 +763,7 @@ impl Workspace {
             self.resize_dimensions_mut().remove(focused_idx);
 
             if focused_idx < target_container_idx {
-                target_container_idx.saturating_sub(1)
+                target_container_idx - 1
             } else {
                 target_container_idx
             }
@@ -936,8 +885,8 @@ impl Workspace {
                 self.containers_mut().remove(focused_idx);
                 self.resize_dimensions_mut().remove(focused_idx);
 
-                if focused_idx == self.containers().len() {
-                    self.focus_container(focused_idx.saturating_sub(1));
+                if focused_idx == self.containers().len() && focused_idx != 0 {
+                    self.focus_container(focused_idx - 1);
                 }
             } else {
                 container.load_focused_window();
@@ -1345,8 +1294,7 @@ impl Workspace {
             .ok_or_else(|| anyhow!("there is no monocle container"))?;
 
         let window = *window;
-        if !self.containers().is_empty() && restore_idx > self.containers().len().saturating_sub(1)
-        {
+        if !self.containers().is_empty() && restore_idx > self.containers().len() - 1 {
             self.containers_mut()
                 .resize(restore_idx, Container::default());
         }
@@ -1435,10 +1383,13 @@ impl Workspace {
 
     pub fn focus_previous_container(&mut self) {
         let focused_idx = self.focused_container_idx();
-        self.focus_container(focused_idx.saturating_sub(1));
+
+        if focused_idx != 0 {
+            self.focus_container(focused_idx - 1);
+        }
     }
 
     fn focus_last_container(&mut self) {
-        self.focus_container(self.containers().len().saturating_sub(1));
+        self.focus_container(self.containers().len() - 1);
     }
 }

komorebi/src/workspace_reconciliator.rs

@@ -30,26 +30,14 @@ pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
     CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
 }
 
-fn event_tx() -> Sender<Notification> {
+pub fn event_tx() -> Sender<Notification> {
     channel().0.clone()
 }
 
-fn event_rx() -> Receiver<Notification> {
+pub 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()) {
@@ -118,7 +106,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::send_notification();
+                    border_manager::event_tx().send(border_manager::Notification)?;
                 }
             }
         }

komorebic-no-console/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.28-dev.0"
+version = "0.1.27-dev.0"
 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.28-dev.0"
+version = "0.1.27-dev.0"
 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,6 +11,7 @@ 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" }
 
@@ -20,6 +21,7 @@ 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"
@@ -32,10 +34,7 @@ sysinfo = { workspace = true }
 thiserror = "1"
 uds_windows = "1"
 which = "6"
-win32-display-data = { workspace = true }
 windows = { workspace = true }
-shadow-rs = { workspace = true }
 
 [build-dependencies]
 reqwest = { version = "0.12", features = ["blocking"] }
-shadow-rs = { workspace = true }

komorebic/build.rs

@@ -5,6 +5,4 @@ fn main() {
     ).unwrap().text().unwrap();
         std::fs::write("applications.yaml", applications_yaml).unwrap();
     }
-
-    shadow_rs::new().unwrap();
 }

komorebic/src/main.rs

@@ -1,7 +1,7 @@
-#![warn(clippy::all)]
-#![allow(clippy::missing_errors_doc, clippy::doc_markdown)]
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc)]
 
-use chrono::Utc;
+use chrono::Local;
 use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
@@ -24,6 +24,7 @@ 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;
@@ -38,6 +39,8 @@ 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;
@@ -99,7 +102,13 @@ lazy_static! {
     };
 }
 
-shadow_rs::shadow!(build);
+trait AhkLibrary {
+    fn generate_ahk_library() -> String;
+}
+
+trait AhkFunction {
+    fn generate_ahk_function() -> String;
+}
 
 #[derive(thiserror::Error, Debug, miette::Diagnostic)]
 #[error("{message}")]
@@ -132,7 +141,7 @@ macro_rules! gen_enum_subcommand_args {
     ( $( $name:ident: $element:ty ),+ $(,)? ) => {
         $(
             paste! {
-                #[derive(clap::Parser)]
+                #[derive(clap::Parser, derive_ahk::AhkFunction)]
                 pub struct $name {
                     #[clap(value_enum)]
                     [<$element:snake>]: $element
@@ -172,7 +181,7 @@ macro_rules! gen_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Target index (zero-indexed)
                 target: usize,
@@ -197,7 +206,7 @@ macro_rules! gen_named_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Target workspace name
                 workspace: String,
@@ -221,7 +230,7 @@ macro_rules! gen_workspace_subcommand_args {
     ( $( $name:ident: $(#[enum] $(@$value_enum:tt)?)? $value:ty ),+ $(,)? ) => (
         paste! {
             $(
-                #[derive(clap::Parser)]
+                #[derive(clap::Parser, derive_ahk::AhkFunction)]
                 pub struct [<Workspace $name>] {
                     /// Monitor index (zero-indexed)
                     monitor: usize,
@@ -253,7 +262,7 @@ macro_rules! gen_named_workspace_subcommand_args {
     ( $( $name:ident: $(#[enum] $(@$value_enum:tt)?)? $value:ty ),+ $(,)? ) => (
         paste! {
             $(
-                #[derive(clap::Parser)]
+                #[derive(clap::Parser, derive_ahk::AhkFunction)]
                 pub struct [<NamedWorkspace $name>] {
                     /// Target workspace name
                     workspace: String,
@@ -275,7 +284,7 @@ gen_named_workspace_subcommand_args! {
     Tiling: #[enum] BooleanState,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct ClearWorkspaceLayoutRules {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -284,7 +293,7 @@ pub struct ClearWorkspaceLayoutRules {
     workspace: usize,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct WorkspaceCustomLayout {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -296,7 +305,7 @@ pub struct WorkspaceCustomLayout {
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct NamedWorkspaceCustomLayout {
     /// Target workspace name
     workspace: String,
@@ -305,7 +314,7 @@ pub struct NamedWorkspaceCustomLayout {
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct WorkspaceLayoutRule {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -320,7 +329,7 @@ pub struct WorkspaceLayoutRule {
     layout: DefaultLayout,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct NamedWorkspaceLayoutRule {
     /// Target workspace name
     workspace: String,
@@ -332,7 +341,7 @@ pub struct NamedWorkspaceLayoutRule {
     layout: DefaultLayout,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct WorkspaceCustomLayoutRule {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -347,7 +356,7 @@ pub struct WorkspaceCustomLayoutRule {
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct NamedWorkspaceCustomLayoutRule {
     /// Target workspace name
     workspace: String,
@@ -359,7 +368,7 @@ pub struct NamedWorkspaceCustomLayoutRule {
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct Resize {
     #[clap(value_enum)]
     edge: OperationDirection,
@@ -367,7 +376,7 @@ struct Resize {
     sizing: Sizing,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct ResizeAxis {
     #[clap(value_enum)]
     axis: Axis,
@@ -375,13 +384,13 @@ struct ResizeAxis {
     sizing: Sizing,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct ResizeDelta {
     /// The delta of pixels by which to increase or decrease window dimensions when resizing
     pixels: i32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct InvisibleBorders {
     /// Size of the left invisible border
     left: i32,
@@ -393,7 +402,7 @@ struct InvisibleBorders {
     bottom: i32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct GlobalWorkAreaOffset {
     /// Size of the left work area offset (set right to left * 2 to maintain right padding)
     left: i32,
@@ -405,7 +414,7 @@ struct GlobalWorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct MonitorWorkAreaOffset {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -419,7 +428,7 @@ struct MonitorWorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct MonitorIndexPreference {
     /// Preferred monitor index (zero-indexed)
     index_preference: usize,
@@ -433,7 +442,7 @@ struct MonitorIndexPreference {
     bottom: i32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct DisplayIndexPreference {
     /// Preferred monitor index (zero-indexed)
     index_preference: usize,
@@ -441,7 +450,7 @@ struct DisplayIndexPreference {
     display: String,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct EnsureWorkspaces {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -449,7 +458,7 @@ struct EnsureWorkspaces {
     workspace_count: usize,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct EnsureNamedWorkspaces {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -457,7 +466,7 @@ struct EnsureNamedWorkspaces {
     names: Vec<String>,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct FocusMonitorWorkspace {
     /// Target monitor index (zero-indexed)
     target_monitor: usize,
@@ -465,7 +474,7 @@ struct FocusMonitorWorkspace {
     target_workspace: usize,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct SendToMonitorWorkspace {
     /// Target monitor index (zero-indexed)
     target_monitor: usize,
@@ -473,7 +482,7 @@ pub struct SendToMonitorWorkspace {
     target_workspace: usize,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 pub struct MoveToMonitorWorkspace {
     /// Target monitor index (zero-indexed)
     target_monitor: usize,
@@ -485,7 +494,7 @@ macro_rules! gen_focused_workspace_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Pixels size to set as an integer
                 size: i32,
@@ -503,7 +512,7 @@ macro_rules! gen_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Monitor index (zero-indexed)
                 monitor: usize,
@@ -525,7 +534,7 @@ macro_rules! gen_named_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Target workspace name
                 workspace: String,
@@ -546,7 +555,7 @@ macro_rules! gen_padding_adjustment_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 #[clap(value_enum)]
                 sizing: Sizing,
@@ -566,7 +575,7 @@ macro_rules! gen_application_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Parser)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 #[clap(value_enum)]
                 identifier: ApplicationIdentifier,
@@ -587,7 +596,7 @@ gen_application_target_subcommand_args! {
     RemoveTitleBar,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct InitialWorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -599,7 +608,7 @@ struct InitialWorkspaceRule {
     workspace: usize,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct InitialNamedWorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -609,7 +618,7 @@ struct InitialNamedWorkspaceRule {
     workspace: String,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct WorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -621,7 +630,7 @@ struct WorkspaceRule {
     workspace: usize,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct NamedWorkspaceRule {
     #[clap(value_enum)]
     identifier: ApplicationIdentifier,
@@ -631,27 +640,13 @@ struct NamedWorkspaceRule {
     workspace: String,
 }
 
-#[derive(Parser)]
-struct ClearWorkspaceRules {
-    /// Monitor index (zero-indexed)
-    monitor: usize,
-    /// Workspace index on the specified monitor (zero-indexed)
-    workspace: usize,
-}
-
-#[derive(Parser)]
-struct ClearNamedWorkspaceRules {
-    /// Name of a workspace
-    workspace: String,
-}
-
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct ToggleFocusFollowsMouse {
     #[clap(value_enum, short, long, default_value = "windows")]
     implementation: FocusFollowsMouseImplementation,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct FocusFollowsMouse {
     #[clap(value_enum, short, long, default_value = "windows")]
     implementation: FocusFollowsMouseImplementation,
@@ -659,25 +654,13 @@ struct FocusFollowsMouse {
     boolean_state: BooleanState,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct Border {
     #[clap(value_enum)]
     boolean_state: BooleanState,
 }
 
-#[derive(Parser)]
-struct Transparency {
-    #[clap(value_enum)]
-    boolean_state: BooleanState,
-}
-
-#[derive(Parser)]
-struct TransparencyAlpha {
-    /// Alpha
-    alpha: u8,
-}
-
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct BorderColour {
     #[clap(value_enum, short, long, default_value = "single")]
     window_kind: WindowKind,
@@ -689,57 +672,19 @@ struct BorderColour {
     b: u32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct BorderWidth {
     /// Desired width of the window border
     width: i32,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct BorderOffset {
     /// Desired offset of the window border
     offset: i32,
 }
-#[derive(Parser)]
-struct BorderStyle {
-    /// Desired border style
-    #[clap(value_enum)]
-    style: komorebi_core::BorderStyle,
-}
 
-#[derive(Parser)]
-struct BorderImplementation {
-    /// Desired border implementation
-    #[clap(value_enum)]
-    style: komorebi_core::BorderImplementation,
-}
-
-#[derive(Parser)]
-struct Animation {
-    #[clap(value_enum)]
-    boolean_state: BooleanState,
-}
-
-#[derive(Parser)]
-struct AnimationDuration {
-    /// Desired animation durations in ms
-    duration: u64,
-}
-
-#[derive(Parser)]
-struct AnimationFps {
-    /// Desired animation frames per second
-    fps: u64,
-}
-
-#[derive(Parser)]
-struct AnimationStyle {
-    /// Desired ease function for animation
-    #[clap(value_enum, short, long, default_value = "linear")]
-    style: komorebi_core::AnimationStyle,
-}
-
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 #[allow(clippy::struct_excessive_bools)]
 struct Start {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
@@ -762,56 +707,56 @@ struct Start {
     ahk: bool,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct Stop {
     /// Stop whkd if it is running as a background process
     #[clap(long)]
     whkd: bool,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct SaveResize {
     /// File to which the resize layout dimensions should be saved
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct LoadResize {
     /// File from which the resize layout dimensions should be loaded
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct LoadCustomLayout {
     /// JSON or YAML file from which the custom layout definition should be loaded
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct SubscribeSocket {
     /// Name of the socket to send event notifications to
     socket: String,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct UnsubscribeSocket {
     /// Name of the socket to stop sending event notifications to
     socket: String,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct SubscribePipe {
     /// Name of the pipe to send event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct UnsubscribePipe {
     /// Name of the pipe to stop sending event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct AhkAppSpecificConfiguration {
     /// YAML file from which the application-specific configurations should be loaded
     path: PathBuf,
@@ -819,7 +764,7 @@ struct AhkAppSpecificConfiguration {
     override_path: Option<PathBuf>,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct PwshAppSpecificConfiguration {
     /// YAML file from which the application-specific configurations should be loaded
     path: PathBuf,
@@ -827,19 +772,19 @@ struct PwshAppSpecificConfiguration {
     override_path: Option<PathBuf>,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct FormatAppSpecificConfiguration {
     /// YAML file from which the application-specific configurations should be loaded
     path: PathBuf,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct AltFocusHack {
     #[clap(value_enum)]
     boolean_state: BooleanState,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkFunction)]
 struct EnableAutostart {
     /// Path to a static configuration JSON file
     #[clap(action, short, long)]
@@ -856,13 +801,13 @@ struct EnableAutostart {
 }
 
 #[derive(Parser)]
-#[clap(author, about, version = build::CLAP_LONG_VERSION)]
+#[clap(author, about, version)]
 struct Opts {
     #[clap(subcommand)]
     subcmd: SubCommand,
 }
 
-#[derive(Parser)]
+#[derive(Parser, AhkLibrary)]
 enum SubCommand {
     #[clap(hide = true)]
     Docgen,
@@ -888,9 +833,6 @@ enum SubCommand {
     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),
@@ -945,10 +887,6 @@ 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")]
@@ -1196,14 +1134,6 @@ enum SubCommand {
     /// Add a rule to associate an application with a named workspace
     #[clap(arg_required_else_help = true)]
     NamedWorkspaceRule(NamedWorkspaceRule),
-    /// Remove all application association rules for a workspace by monitor and workspace index
-    #[clap(arg_required_else_help = true)]
-    ClearWorkspaceRules(ClearWorkspaceRules),
-    /// Remove all application association rules for a named workspace
-    #[clap(arg_required_else_help = true)]
-    ClearNamedWorkspaceRules(ClearNamedWorkspaceRules),
-    /// Remove all application association rules for all workspaces
-    ClearAllWorkspaceRules,
     /// Identify an application that sends EVENT_OBJECT_NAMECHANGE on launch
     #[clap(arg_required_else_help = true)]
     IdentifyObjectNameChangeApplication(IdentifyObjectNameChangeApplication),
@@ -1238,30 +1168,6 @@ enum SubCommand {
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "active-window-border-offset")]
     BorderOffset(BorderOffset),
-    /// Set the border style
-    #[clap(arg_required_else_help = true)]
-    BorderStyle(BorderStyle),
-    /// Set the border implementation
-    #[clap(arg_required_else_help = true)]
-    BorderImplementation(BorderImplementation),
-    /// 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 the window move animation
-    #[clap(arg_required_else_help = true)]
-    Animation(Animation),
-    /// Set the duration for the window move animation in ms
-    #[clap(arg_required_else_help = true)]
-    AnimationDuration(AnimationDuration),
-    /// Set the frames per second for the window move animation
-    #[clap(arg_required_else_help = true)]
-    AnimationFps(AnimationFps),
-    /// Set the ease function for the window move animation
-    #[clap(arg_required_else_help = true)]
-    AnimationStyle(AnimationStyle),
     /// Enable or disable focus follows mouse for the operating system
     #[clap(arg_required_else_help = true)]
     FocusFollowsMouse(FocusFollowsMouse),
@@ -1273,6 +1179,8 @@ 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")]
@@ -1382,25 +1290,21 @@ 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(&*WHKD_CONFIG_DIR)?;
-            std::fs::create_dir_all(&*HOME_DIR)?;
+            std::fs::create_dir_all(&config_dir)?;
             std::fs::create_dir_all(data_dir)?;
 
-            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");
-            }
-
+            let komorebi_json = include_str!("../../docs/komorebi.example.json");
             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(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;
+            std::fs::write(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");
@@ -1560,8 +1464,37 @@ 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 = Utc::now().format("%Y-%m-%d").to_string();
+            let timestamp = Local::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();
@@ -2122,29 +2055,12 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
                     .as_bytes()?,
             )?;
         }
-        SubCommand::ClearWorkspaceRules(arg) => {
-            send_message(
-                &SocketMessage::ClearWorkspaceRules(arg.monitor, arg.workspace).as_bytes()?,
-            )?;
-        }
-        SubCommand::ClearNamedWorkspaceRules(arg) => {
-            send_message(&SocketMessage::ClearNamedWorkspaceRules(arg.workspace).as_bytes()?)?;
-        }
-        SubCommand::ClearAllWorkspaceRules => {
-            send_message(&SocketMessage::ClearAllWorkspaceRules.as_bytes()?)?;
-        }
         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()?)?;
         }
@@ -2242,9 +2158,6 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         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()?);
         }
@@ -2360,31 +2273,6 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         SubCommand::BorderOffset(arg) => {
             send_message(&SocketMessage::BorderOffset(arg.offset).as_bytes()?)?;
         }
-        SubCommand::BorderStyle(arg) => {
-            send_message(&SocketMessage::BorderStyle(arg.style).as_bytes()?)?;
-        }
-        SubCommand::BorderImplementation(arg) => {
-            send_message(&SocketMessage::BorderImplementation(arg.style).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::Animation(arg) => {
-            send_message(&SocketMessage::Animation(arg.boolean_state.into()).as_bytes()?)?;
-        }
-        SubCommand::AnimationDuration(arg) => {
-            send_message(&SocketMessage::AnimationDuration(arg.duration).as_bytes()?)?;
-        }
-        SubCommand::AnimationFps(arg) => {
-            send_message(&SocketMessage::AnimationFps(arg.fps).as_bytes()?)?;
-        }
-        SubCommand::AnimationStyle(arg) => {
-            send_message(&SocketMessage::AnimationStyle(arg.style).as_bytes()?)?;
-        }
-
         SubCommand::ResizeDelta(arg) => {
             send_message(&SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
         }
@@ -2527,11 +2415,6 @@ 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,7 +57,6 @@ 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
@@ -68,7 +67,7 @@ nav:
       - common-workflows/mouse-follows-focus.md
       - common-workflows/custom-layouts.md
       - common-workflows/dynamic-layout-switching.md
-      - common-workflows/set-display-index.md
+      - common-workflows/autohotkey.md
   - Release notes:
       - release/v0-1-22.md
   - Configuration reference: https://komorebi.lgug2z.com/schema
@@ -83,7 +82,6 @@ nav:
       - 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
@@ -102,8 +100,6 @@ 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
@@ -200,12 +196,11 @@ 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.27`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.26`",
   "type": "object",
   "properties": {
     "app_specific_configuration_path": {
@@ -1183,16 +1183,6 @@
         }
       }
     },
-    "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",