feat(borders): add border manager module

This commit removes all border-related code from process_command,
process_event etc. and centralizes it in the new border_manager module.

Instead of trying to figure out where in process_event and
process_command we should make border-related changes, a notification
gets sent to a channel that border_manager listens to whenever an event
or command has finished processing.

The border_manager listener, upon receiving a notification, acquires a
lock on the WindowManager instance and updates borders for the focused
workspace on every monitor; this allows us to centralize all edge case
handling within the border_manager listener's loop.

Borders on workspaces that lose focus are now destroyed and recreated
when those workspaces regain focus, instead of trying to share
individual border instances across workspaces.

A number of common edge cases that have been addressed in this commit
are:

* Paused window manager
* Floating workspaces
* Maximized windows
* Fullscreen videos
* Monocle containers
* Ghost borders on workspace switching
* Incorrect focused window border colours

Global state related to borders has also been moved into the
border_manager module, which also tracks the state of border objects
(BORDER_STATE), their rects (RECT_STATE) and their focus kinds
(FOCUS_STATE).

This allows us to now track multiple borders per-container, enabling
unfocused border windows for the first time.

Additionally, the Z-Order for border windows is now also configurable.

ActiveWindowBorderColours has been expanded to include Unfocused, but in
order to not introduce a breaking configuration change for end users,
all members of this struct have been made Option<Colour>.

.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:
@@ -95,47 +93,23 @@ jobs:
             target/${{ matrix.target }}/release/komorebi.exe
             target/${{ matrix.target }}/release/komorebic.exe
             target/${{ matrix.target }}/release/komorebic-no-console.exe
-            target/${{ matrix.target }}/release/komorebi-bar.exe
-            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/komorebic-no-console.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')
         shell: bash
         run: |
           if ! type kokai >/dev/null; then cargo install --locked kokai --force; fi
-          git tag -d nightly
           kokai release --no-emoji --add-links github:commits,issues --ref "$(git tag --points-at HEAD)" >"CHANGELOG.md"
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v3

.gitignore

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

.goreleaser.yml

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

Cargo.toml

@@ -2,28 +2,24 @@
 
 resolver = "2"
 members = [
+    "derive-ahk",
     "komorebi",
     "komorebi-client",
-    "komorebi-gui",
+    "komorebi-core",
     "komorebic",
     "komorebic-no-console",
-    "komorebi-bar"
 ]
 
 [workspace.dependencies]
-color-eyre = "0.6"
-dirs = "5"
-dunce = "1"
-schemars = "0.8"
-serde = { version = "1", features = ["derive"] }
-serde_json = { package = "serde_json_lenient", version = "0.2" }
-serde_yaml = "0.9"
-sysinfo = "0.30"
-uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "32a45cebf132c3d651ee22c0c40033a6b7edc945" }
-windows-implement = { version = "0.53" }
 windows-interface = { version = "0.53" }
-shadow-rs = "0.34"
+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"
@@ -43,8 +39,5 @@ features = [
     "Win32_UI_Shell",
     "Win32_UI_Shell_Common",
     "Win32_UI_WindowsAndMessaging",
-    "Win32_System_SystemServices",
-    "Win32_System_WindowsProgramming",
-    "Media",
-    "Media_Control"
+    "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` 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
@@ -279,7 +272,7 @@ If the named pipe exists, `komorebi` will start pushing JSON data of successfull
 
 You may then filter on the `type` key to listen to the events that you are interested in. For a full list of possible
 notification types, refer to the enum variants of `WindowManagerEvent` in `komorebi` and `SocketMessage`
-in `komorebi::core`.
+in `komorebi-core`.
 
 Below is an example of how you can subscribe to and filter on events using a named pipe in `nodejs`.
 
@@ -358,7 +351,7 @@ every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust c
 Below is a simple example of how to use `komorebi-client` in a basic Rust application.
 
 ```rust
-// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.28"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.25"}
 
 use anyhow::Result;
 use komorebi_client::Notification;
@@ -414,7 +407,7 @@ A TCP listener can optionally be exposed on a port of your choosing with the `--
 provided to `komorebi` or `komorebic start`, no TCP listener will be created.
 
 Once created, your client may send
-any [SocketMessage](https://github.com/LGUG2Z/komorebi/blob/master/komorebi/src/core/mod.rs#L37) to `komorebi` in the
+any [SocketMessage](https://github.com/LGUG2Z/komorebi/blob/master/komorebi-core/src/lib.rs#L37) to `komorebi` in the
 same way that `komorebic` would.
 
 This can be used if you would like to create your own alternative to `komorebic` which incorporates scripting and

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/active-window-border-colour.md

@@ -0,0 +1,26 @@
+# active-window-border-colour
+
+```
+Set the colour for the active window border
+
+Usage: komorebic.exe active-window-border-colour [OPTIONS] <R> <G> <B>
+
+Arguments:
+  <R>
+          Red
+
+  <G>
+          Green
+
+  <B>
+          Blue
+
+Options:
+  -w, --window-kind <WINDOW_KIND>
+          [default: single]
+          [possible values: single, stack, monocle]
+
+  -h, --help
+          Print help
+
+```

docs/cli/active-window-border-offset.md

@@ -0,0 +1,16 @@
+# active-window-border-offset
+
+```
+Set the offset for the active window border
+
+Usage: komorebic.exe active-window-border-offset <OFFSET>
+
+Arguments:
+  <OFFSET>
+          Desired offset of the active window border
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/active-window-border-width.md

@@ -0,0 +1,16 @@
+# active-window-border-width
+
+```
+Set the width for the active window border
+
+Usage: komorebic.exe active-window-border-width <WIDTH>
+
+Arguments:
+  <WIDTH>
+          Desired width of the active window border
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/active-window-border.md

@@ -1,9 +1,9 @@
-# transparency
+# active-window-border
 
 ```
-Enable or disable transparency for unfocused windows
+Enable or disable the active window border
 
-Usage: komorebic.exe transparency <BOOLEAN_STATE>
+Usage: komorebic.exe active-window-border <BOOLEAN_STATE>
 
 Arguments:
   <BOOLEAN_STATE>

docs/cli/ahk-library.md

@@ -0,0 +1,12 @@
+# ahk-library
+
+```
+Generate a library of AutoHotKey helper functions
+
+Usage: komorebic.exe ahk-library
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/border-colour.md

@@ -1,26 +0,0 @@
-# border-colour
-
-```
-Set the colour for a window border kind
-
-Usage: komorebic.exe border-colour [OPTIONS] <R> <G> <B>
-
-Arguments:
-  <R>
-          Red
-
-  <G>
-          Green
-
-  <B>
-          Blue
-
-Options:
-  -w, --window-kind <WINDOW_KIND>
-          [default: single]
-          [possible values: single, stack, monocle, unfocused]
-
-  -h, --help
-          Print help
-
-```

docs/cli/border-implementation.md

@@ -1,20 +0,0 @@
-# border-implementation
-
-```
-Set the border implementation
-
-Usage: komorebic.exe border-implementation <STYLE>
-
-Arguments:
-  <STYLE>
-          Desired border implementation
-
-          Possible values:
-          - komorebi: Use the adjustable komorebi border implementation
-          - windows:  Use the thin Windows accent border implementation
-
-Options:
-  -h, --help
-          Print help (see a summary with '-h')
-
-```

docs/cli/border-offset.md

@@ -1,16 +0,0 @@
-# border-offset
-
-```
-Set the border offset
-
-Usage: komorebic.exe border-offset <OFFSET>
-
-Arguments:
-  <OFFSET>
-          Desired offset of the window border
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/border-style.md

@@ -1,21 +0,0 @@
-# border-style
-
-```
-Set the border style
-
-Usage: komorebic.exe border-style <STYLE>
-
-Arguments:
-  <STYLE>
-          Desired border style
-
-          Possible values:
-          - system:  Use the system border style
-          - rounded: Use the Windows 11-style rounded borders
-          - square:  Use the Windows 10-style square borders
-
-Options:
-  -h, --help
-          Print help (see a summary with '-h')
-
-```

docs/cli/border-width.md

@@ -1,16 +0,0 @@
-# border-width
-
-```
-Set the border width
-
-Usage: komorebic.exe border-width <WIDTH>
-
-Arguments:
-  <WIDTH>
-          Desired width of the window border
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/border.md

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

docs/cli/clear-all-workspace-rules.md

@@ -1,12 +0,0 @@
-# clear-all-workspace-rules
-
-```
-Remove all application association rules for all workspaces
-
-Usage: komorebic.exe clear-all-workspace-rules
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/clear-named-workspace-rules.md

@@ -1,16 +0,0 @@
-# clear-named-workspace-rules
-
-```
-Remove all application association rules for a named workspace
-
-Usage: komorebic.exe clear-named-workspace-rules <WORKSPACE>
-
-Arguments:
-  <WORKSPACE>
-          Name of a workspace
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/clear-workspace-rules.md

@@ -1,19 +0,0 @@
-# clear-workspace-rules
-
-```
-Remove all application association rules for a workspace by monitor and workspace index
-
-Usage: komorebic.exe clear-workspace-rules <MONITOR> <WORKSPACE>
-
-Arguments:
-  <MONITOR>
-          Monitor index (zero-indexed)
-
-  <WORKSPACE>
-          Workspace index on the specified monitor (zero-indexed)
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/cross-monitor-move-behaviour.md

@@ -10,7 +10,6 @@ Arguments:
           Possible values:
           - swap:   Swap the window container with the window container at the edge of the adjacent monitor
           - insert: Insert the window container into the focused workspace on the adjacent monitor
-          - no-op:  Do nothing if trying to move a window container in the direction of an adjacent monitor
 
 Options:
   -h, --help

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

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

docs/cli/gui.md

@@ -1,12 +0,0 @@
-# gui
-
-```
-Launch the komorebi-gui debugging tool
-
-Usage: komorebic.exe gui
-
-Options:
-  -h, --help
-          Print 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/promote-window.md

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

docs/cli/stack-all.md

@@ -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/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/cli/window-hiding-behaviour.md

@@ -10,7 +10,7 @@ Arguments:
           Possible values:
           - hide:     Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)
           - minimize: Use the SW_MINIMIZE flag to hide windows when switching workspaces (has issues with frequent workspace switching)
-          - cloak:    Use the undocumented SetCloak Win32 function to hide windows when switching workspaces
+          - cloak:    Use the undocumented SetCloak Win32 function to hide windows when switching workspaces (has foregrounding issues)
 
 Options:
   -h, --help

docs/common-workflows/active-window-border.md

@@ -0,0 +1,39 @@
+# Active Window Border
+
+If you would like to add a visual border around the currently focused window,
+ensure the following options are defined in the `komorebi.json` configuration
+file.
+
+```json
+{
+  "active_window_border": true,
+  "active_window_border_style": "Rounded",
+  "active_window_border_colours": {
+    "single": {
+      "r": 66,
+      "g": 165,
+      "b": 245
+    },
+    "stack": {
+      "r": 256,
+      "g": 165,
+      "b": 66
+    },
+    "monocle": {
+      "r": 255,
+      "g": 51,
+      "b": 153
+    }
+  },
+}
+
+```
+
+It is important to note that the active window border will only apply to
+windows managed by `komorebi`.
+
+This feature is not considered stable, and you may encounter visual artifacts
+from time to time.
+
+[![Watch the tutorial
+video](https://img.youtube.com/vi/7_9D22t7KK4/hqdefault.jpg)](https://www.youtube.com/watch?v=7_9D22t7KK4)

docs/common-workflows/animations.md

@@ -1,25 +0,0 @@
-# Animations
-
-If you would like to add window movement animations, ensure the following options are
-defined in the `komorebi.json` configuration file.
-
-```json
-{
-  "animation": {
-    "enabled": true
-  }
-}
-```
-
-Window movement animations only apply to actions taking place within the same monitor
-workspace.
-
-You can optionally set a custom duration in ms with `animation.duration` (default: `250`),
-a custom style with `animation.style` (default: `Linear`), and a custom FPS value with
-`animation.fps` (default: `60`).
-
-It is important to note that higher `fps` and a longer `duration` settings will result
-in increased CPU usage.
-
-This feature is not considered stable, and you may encounter visual artifacts
-from time to time.

docs/common-workflows/autohotkey.md

@@ -1,4 +1,6 @@
-# AutoHotkey
+# AutoHotKey
+
+<!-- TODO: Update this completely -->
 
 If you would like to use Autohotkey, please make sure you have AutoHotKey v2
 installed.
@@ -7,16 +9,19 @@ Generally, users who opt for AHK will have specific needs that can only be
 addressed by the advanced functionality of AHK, and so they are assumed to be
 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.
+If you would like to try out AHK, a simple sample configuration powered by
+`komorebic.lib.ahk` is provided as a starting point. This sample configuration
+does not take into account the use of a static configuration file; if you
+choose to use a static configuration file alongside AHK, you can remove all the
+configuration options from your `komorebi.ahk` and use it solely to handle
+hotkey bindings.
 
-```autohotkey
-{% include "./komorebi.ahk.txt" %}
+
+```powershell
+# save the latest generated komorebic library to ~/komorebic.lib.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.20/komorebic.lib.ahk -OutFile $Env:USERPROFILE\komorebic.lib.ahk
+
+# save the sample komorebi configuration file to ~/komorebi.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.20/komorebi.sample.ahk -OutFile $Env:USERPROFILE\komorebi.ahk
 ```
 
-By default, the `komorebi.ahk` file should be located in the `$Env:USERPROFILE`
-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`.

docs/common-workflows/borders.md

@@ -1,28 +0,0 @@
-# Borders
-
-If you would like to add a visual border around both the currently focused window
-and unfocused windows ensure the following options are defined in the `komorebi.json`
-configuration file.
-
-```json
-{
-  "border": true,
-  "border_width": 8,
-  "border_offset": -1,
-  "border_style": "System",
-  "border_colours": {
-    "single": "#42a5f5",
-    "stack": "#00a542",
-    "monocle": "#ff3399",
-    "unfocused": "#808080"
-  }
-}
-```
-
-It is important to note that borders will only apply to windows managed by `komorebi`.
-
-This feature is not considered stable, and you may encounter visual artifacts
-from time to time.
-
-[![Watch the tutorial
-video](https://img.youtube.com/vi/7_9D22t7KK4/hqdefault.jpg)](https://www.youtube.com/watch?v=7_9D22t7KK4)

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,17 +27,17 @@ 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)
-- [WinGet](#winget)
-- [Building from source](#building-from-source)
-- [Offline](#offline)
+ - [Scoop](#scoop)
+ - [WinGet](#winget)
+ - [Building from source](#building-from-source)
+ - [Offline](#offline)
 
 ## 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,12 +45,6 @@ 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
-
-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
-komorebi.
-
 ## Scoop
 
 Make sure you have installed [`scoop`](https://scoop.sh) and verified that
@@ -114,7 +108,6 @@ Clone the git repository, enter the directory, and build the following binaries:
 cargo +stable install --path komorebi --locked
 cargo +stable install --path komorebic --locked
 cargo +stable install --path komorebic-no-console --locked
-cargo +stable install --path komorebi-gui --locked
 ```
 
 If the binaries have been built and added to your `$PATH` correctly, you should
@@ -128,21 +121,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/komorebi.example.json

@@ -1,22 +1,21 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.28/schema.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.25/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.yaml",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",
   "default_workspace_padding": 20,
   "default_container_padding": 20,
-  "border": true,
   "border_width": 8,
   "border_offset": -1,
-  "border_colours": {
+  "active_window_border": false,
+  "active_window_border_colours": {
     "single": "#42a5f5",
     "stack": "#00a542",
-    "monocle": "#ff3399",
-    "unfocused": "#808080"
+    "monocle": "#ff3399"
   },
   "stackbar": {
     "height": 40,
-    "mode": "OnStack",
+    "mode": "Never",
     "tabs": {
       "width": 300,
       "focused_text": "#00a542",

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
 }
-```
+```

docs/whkdrc.sample

@@ -10,9 +10,6 @@ alt + shift + o         : komorebic reload-configuration
 # alt + f                 : if ($wshell.AppActivate('Firefox') -eq $False) { start firefox }
 # alt + b                 : if ($wshell.AppActivate('Chrome') -eq $False) { start chrome }
 
-alt + q                 : komorebic close
-alt + m                 : komorebic minimize
-
 # Focus windows
 alt + h                 : komorebic focus left
 alt + j                 : komorebic focus down
@@ -59,18 +56,8 @@ alt + y                 : komorebic flip-layout vertical
 alt + 1                 : komorebic focus-workspace 0
 alt + 2                 : komorebic focus-workspace 1
 alt + 3                 : komorebic focus-workspace 2
-alt + 4                 : komorebic focus-workspace 3
-alt + 5                 : komorebic focus-workspace 4
-alt + 6                 : komorebic focus-workspace 5
-alt + 7                 : komorebic focus-workspace 6
-alt + 8                 : komorebic focus-workspace 7
 
 # Move windows across workspaces
 alt + shift + 1         : komorebic move-to-workspace 0
 alt + shift + 2         : komorebic move-to-workspace 1
 alt + shift + 3         : komorebic move-to-workspace 2
-alt + shift + 4         : komorebic move-to-workspace 3
-alt + shift + 5         : komorebic move-to-workspace 4
-alt + shift + 6         : komorebic move-to-workspace 5
-alt + shift + 7         : komorebic move-to-workspace 6
-alt + shift + 8         : komorebic move-to-workspace 7

justfile

@@ -16,12 +16,19 @@ fmt:
 install-target target:
     cargo +stable install --path {{ target }} --locked
 
+prepare:
+    komorebic ahk-asc '~/.config/komorebi/applications.yaml'
+    komorebic pwsh-asc '~/.config/komorebi/applications.yaml'
+    cat '~/.config/komorebi/komorebi.generated.ps1' >komorebi.generated.ps1
+    cat '~/.config/komorebi/komorebi.generated.ahk' >komorebi.generated.ahk
+
 install:
     just install-target komorebic
     just install-target komorebic-no-console
     just install-target komorebi
 
 run:
+    just install-target komorebic
     cargo +stable run --bin komorebi --locked
 
 warn $RUST_LOG="warn":
@@ -37,6 +44,7 @@ trace $RUST_LOG="trace":
     just run
 
 deadlock $RUST_LOG="trace":
+    just install-komorebic
     cargo +stable run --bin komorebi --locked --features deadlock_detection
 
 docgen:

komorebi-bar/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-name = "komorebi-bar"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-komorebi-client = { path = "../komorebi-client" }
-
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "a2c48f45782c5604bf5482d3873021a9fe45ea1a" }
-catppuccin-egui = { version = "5.1", default-features = false, features = ["egui28"] }
-chrono = "0.4"
-clap = { version = "4", features = ["derive", "wrap_help"] }
-color-eyre = "0.6"
-crossbeam-channel = "0.5"
-dirs = { workspace = true }
-eframe = "0.28"
-egui-phosphor = "0.6.0"
-font-loader = "0.11"
-hotwatch = "0.5"
-image = "0.25"
-netdev = "0.30"
-num = "0.4.3"
-num-derive = "0.4.2"
-num-traits = "0.2.19"
-schemars = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-serde_yaml = "0.8"
-starship-battery = "0.10"
-sysinfo = "0.31"
-tracing = "0.1"
-tracing-appender = "0.2"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-windows = { workspace = true }
-windows-icons = "0.1"

komorebi-bar/src/bar.rs

@@ -1,437 +0,0 @@
-use crate::config::Base16Value;
-use crate::config::Catppuccin;
-use crate::config::CatppuccinValue;
-use crate::config::KomobarConfig;
-use crate::config::Theme;
-use crate::komorebi::Komorebi;
-use crate::komorebi::KomorebiNotificationState;
-use crate::widget::BarWidget;
-use crate::widget::WidgetConfig;
-use crossbeam_channel::Receiver;
-use eframe::egui::Align;
-use eframe::egui::CentralPanel;
-use eframe::egui::Color32;
-use eframe::egui::Context;
-use eframe::egui::FontData;
-use eframe::egui::FontDefinitions;
-use eframe::egui::FontFamily;
-use eframe::egui::Frame;
-use eframe::egui::Layout;
-use eframe::egui::Margin;
-use eframe::egui::Style;
-use font_loader::system_fonts;
-use font_loader::system_fonts::FontPropertyBuilder;
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::Arc;
-
-pub struct Komobar {
-    pub config: Arc<KomobarConfig>,
-    pub komorebi_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
-    pub left_widgets: Vec<Box<dyn BarWidget>>,
-    pub right_widgets: Vec<Box<dyn BarWidget>>,
-    pub rx_gui: Receiver<komorebi_client::Notification>,
-    pub rx_config: Receiver<KomobarConfig>,
-    pub bg_color: Color32,
-}
-
-impl Komobar {
-    pub fn apply_config(
-        &mut self,
-        ctx: &Context,
-        config: &KomobarConfig,
-        previous_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
-    ) {
-        if let Some(font_family) = &config.font_family {
-            tracing::info!("attempting to add custom font family: {font_family}");
-            Self::add_custom_font(ctx, font_family);
-        }
-
-        match config.theme {
-            None => {
-                ctx.set_style(Style::default());
-                self.bg_color = Style::default().visuals.panel_fill;
-            }
-            Some(theme) => match theme {
-                Theme::Catppuccin {
-                    name: catppuccin,
-                    accent: catppuccin_value,
-                } => match catppuccin {
-                    Catppuccin::Frappe => {
-                        catppuccin_egui::set_theme(ctx, catppuccin_egui::FRAPPE);
-                        let catppuccin_value = catppuccin_value.unwrap_or_default();
-
-                        let accent = match catppuccin_value {
-                            CatppuccinValue::Rosewater => catppuccin_egui::FRAPPE.rosewater,
-                            CatppuccinValue::Flamingo => catppuccin_egui::FRAPPE.flamingo,
-                            CatppuccinValue::Pink => catppuccin_egui::FRAPPE.pink,
-                            CatppuccinValue::Mauve => catppuccin_egui::FRAPPE.mauve,
-                            CatppuccinValue::Red => catppuccin_egui::FRAPPE.red,
-                            CatppuccinValue::Maroon => catppuccin_egui::FRAPPE.maroon,
-                            CatppuccinValue::Peach => catppuccin_egui::FRAPPE.peach,
-                            CatppuccinValue::Yellow => catppuccin_egui::FRAPPE.yellow,
-                            CatppuccinValue::Green => catppuccin_egui::FRAPPE.green,
-                            CatppuccinValue::Teal => catppuccin_egui::FRAPPE.teal,
-                            CatppuccinValue::Sky => catppuccin_egui::FRAPPE.sky,
-                            CatppuccinValue::Sapphire => catppuccin_egui::FRAPPE.sapphire,
-                            CatppuccinValue::Blue => catppuccin_egui::FRAPPE.blue,
-                            CatppuccinValue::Lavender => catppuccin_egui::FRAPPE.lavender,
-                            CatppuccinValue::Text => catppuccin_egui::FRAPPE.text,
-                            CatppuccinValue::Subtext1 => catppuccin_egui::FRAPPE.subtext1,
-                            CatppuccinValue::Subtext0 => catppuccin_egui::FRAPPE.subtext0,
-                            CatppuccinValue::Overlay2 => catppuccin_egui::FRAPPE.overlay2,
-                            CatppuccinValue::Overlay1 => catppuccin_egui::FRAPPE.overlay1,
-                            CatppuccinValue::Overlay0 => catppuccin_egui::FRAPPE.overlay0,
-                            CatppuccinValue::Surface2 => catppuccin_egui::FRAPPE.surface2,
-                            CatppuccinValue::Surface1 => catppuccin_egui::FRAPPE.surface1,
-                            CatppuccinValue::Surface0 => catppuccin_egui::FRAPPE.surface0,
-                            CatppuccinValue::Base => catppuccin_egui::FRAPPE.base,
-                            CatppuccinValue::Mantle => catppuccin_egui::FRAPPE.mantle,
-                            CatppuccinValue::Crust => catppuccin_egui::FRAPPE.crust,
-                        };
-
-                        ctx.style_mut(|style| {
-                            style.visuals.selection.stroke.color = accent;
-                            style.visuals.widgets.hovered.fg_stroke.color = accent;
-                            style.visuals.widgets.active.fg_stroke.color = accent;
-                            style.visuals.override_text_color = None;
-                        });
-
-                        self.bg_color = catppuccin_egui::FRAPPE.base;
-                    }
-                    Catppuccin::Latte => {
-                        catppuccin_egui::set_theme(ctx, catppuccin_egui::LATTE);
-                        let catppuccin_value = catppuccin_value.unwrap_or_default();
-
-                        let accent = match catppuccin_value {
-                            CatppuccinValue::Rosewater => catppuccin_egui::LATTE.rosewater,
-                            CatppuccinValue::Flamingo => catppuccin_egui::LATTE.flamingo,
-                            CatppuccinValue::Pink => catppuccin_egui::LATTE.pink,
-                            CatppuccinValue::Mauve => catppuccin_egui::LATTE.mauve,
-                            CatppuccinValue::Red => catppuccin_egui::LATTE.red,
-                            CatppuccinValue::Maroon => catppuccin_egui::LATTE.maroon,
-                            CatppuccinValue::Peach => catppuccin_egui::LATTE.peach,
-                            CatppuccinValue::Yellow => catppuccin_egui::LATTE.yellow,
-                            CatppuccinValue::Green => catppuccin_egui::LATTE.green,
-                            CatppuccinValue::Teal => catppuccin_egui::LATTE.teal,
-                            CatppuccinValue::Sky => catppuccin_egui::LATTE.sky,
-                            CatppuccinValue::Sapphire => catppuccin_egui::LATTE.sapphire,
-                            CatppuccinValue::Blue => catppuccin_egui::LATTE.blue,
-                            CatppuccinValue::Lavender => catppuccin_egui::LATTE.lavender,
-                            CatppuccinValue::Text => catppuccin_egui::LATTE.text,
-                            CatppuccinValue::Subtext1 => catppuccin_egui::LATTE.subtext1,
-                            CatppuccinValue::Subtext0 => catppuccin_egui::LATTE.subtext0,
-                            CatppuccinValue::Overlay2 => catppuccin_egui::LATTE.overlay2,
-                            CatppuccinValue::Overlay1 => catppuccin_egui::LATTE.overlay1,
-                            CatppuccinValue::Overlay0 => catppuccin_egui::LATTE.overlay0,
-                            CatppuccinValue::Surface2 => catppuccin_egui::LATTE.surface2,
-                            CatppuccinValue::Surface1 => catppuccin_egui::LATTE.surface1,
-                            CatppuccinValue::Surface0 => catppuccin_egui::LATTE.surface0,
-                            CatppuccinValue::Base => catppuccin_egui::LATTE.base,
-                            CatppuccinValue::Mantle => catppuccin_egui::LATTE.mantle,
-                            CatppuccinValue::Crust => catppuccin_egui::LATTE.crust,
-                        };
-
-                        ctx.style_mut(|style| {
-                            style.visuals.selection.stroke.color = accent;
-                            style.visuals.widgets.hovered.fg_stroke.color = accent;
-                            style.visuals.widgets.active.fg_stroke.color = accent;
-                            style.visuals.override_text_color = None;
-                        });
-
-                        self.bg_color = catppuccin_egui::LATTE.base;
-                    }
-                    Catppuccin::Macchiato => {
-                        catppuccin_egui::set_theme(ctx, catppuccin_egui::MACCHIATO);
-                        let catppuccin_value = catppuccin_value.unwrap_or_default();
-
-                        let accent = match catppuccin_value {
-                            CatppuccinValue::Rosewater => catppuccin_egui::MACCHIATO.rosewater,
-                            CatppuccinValue::Flamingo => catppuccin_egui::MACCHIATO.flamingo,
-                            CatppuccinValue::Pink => catppuccin_egui::MACCHIATO.pink,
-                            CatppuccinValue::Mauve => catppuccin_egui::MACCHIATO.mauve,
-                            CatppuccinValue::Red => catppuccin_egui::MACCHIATO.red,
-                            CatppuccinValue::Maroon => catppuccin_egui::MACCHIATO.maroon,
-                            CatppuccinValue::Peach => catppuccin_egui::MACCHIATO.peach,
-                            CatppuccinValue::Yellow => catppuccin_egui::MACCHIATO.yellow,
-                            CatppuccinValue::Green => catppuccin_egui::MACCHIATO.green,
-                            CatppuccinValue::Teal => catppuccin_egui::MACCHIATO.teal,
-                            CatppuccinValue::Sky => catppuccin_egui::MACCHIATO.sky,
-                            CatppuccinValue::Sapphire => catppuccin_egui::MACCHIATO.sapphire,
-                            CatppuccinValue::Blue => catppuccin_egui::MACCHIATO.blue,
-                            CatppuccinValue::Lavender => catppuccin_egui::MACCHIATO.lavender,
-                            CatppuccinValue::Text => catppuccin_egui::MACCHIATO.text,
-                            CatppuccinValue::Subtext1 => catppuccin_egui::MACCHIATO.subtext1,
-                            CatppuccinValue::Subtext0 => catppuccin_egui::MACCHIATO.subtext0,
-                            CatppuccinValue::Overlay2 => catppuccin_egui::MACCHIATO.overlay2,
-                            CatppuccinValue::Overlay1 => catppuccin_egui::MACCHIATO.overlay1,
-                            CatppuccinValue::Overlay0 => catppuccin_egui::MACCHIATO.overlay0,
-                            CatppuccinValue::Surface2 => catppuccin_egui::MACCHIATO.surface2,
-                            CatppuccinValue::Surface1 => catppuccin_egui::MACCHIATO.surface1,
-                            CatppuccinValue::Surface0 => catppuccin_egui::MACCHIATO.surface0,
-                            CatppuccinValue::Base => catppuccin_egui::MACCHIATO.base,
-                            CatppuccinValue::Mantle => catppuccin_egui::MACCHIATO.mantle,
-                            CatppuccinValue::Crust => catppuccin_egui::MACCHIATO.crust,
-                        };
-
-                        ctx.style_mut(|style| {
-                            style.visuals.selection.stroke.color = accent;
-                            style.visuals.widgets.hovered.fg_stroke.color = accent;
-                            style.visuals.widgets.active.fg_stroke.color = accent;
-                            style.visuals.override_text_color = None;
-                        });
-
-                        self.bg_color = catppuccin_egui::MACCHIATO.base;
-                    }
-                    Catppuccin::Mocha => {
-                        catppuccin_egui::set_theme(ctx, catppuccin_egui::MOCHA);
-                        let catppuccin_value = catppuccin_value.unwrap_or_default();
-
-                        let accent = match catppuccin_value {
-                            CatppuccinValue::Rosewater => catppuccin_egui::MOCHA.rosewater,
-                            CatppuccinValue::Flamingo => catppuccin_egui::MOCHA.flamingo,
-                            CatppuccinValue::Pink => catppuccin_egui::MOCHA.pink,
-                            CatppuccinValue::Mauve => catppuccin_egui::MOCHA.mauve,
-                            CatppuccinValue::Red => catppuccin_egui::MOCHA.red,
-                            CatppuccinValue::Maroon => catppuccin_egui::MOCHA.maroon,
-                            CatppuccinValue::Peach => catppuccin_egui::MOCHA.peach,
-                            CatppuccinValue::Yellow => catppuccin_egui::MOCHA.yellow,
-                            CatppuccinValue::Green => catppuccin_egui::MOCHA.green,
-                            CatppuccinValue::Teal => catppuccin_egui::MOCHA.teal,
-                            CatppuccinValue::Sky => catppuccin_egui::MOCHA.sky,
-                            CatppuccinValue::Sapphire => catppuccin_egui::MOCHA.sapphire,
-                            CatppuccinValue::Blue => catppuccin_egui::MOCHA.blue,
-                            CatppuccinValue::Lavender => catppuccin_egui::MOCHA.lavender,
-                            CatppuccinValue::Text => catppuccin_egui::MOCHA.text,
-                            CatppuccinValue::Subtext1 => catppuccin_egui::MOCHA.subtext1,
-                            CatppuccinValue::Subtext0 => catppuccin_egui::MOCHA.subtext0,
-                            CatppuccinValue::Overlay2 => catppuccin_egui::MOCHA.overlay2,
-                            CatppuccinValue::Overlay1 => catppuccin_egui::MOCHA.overlay1,
-                            CatppuccinValue::Overlay0 => catppuccin_egui::MOCHA.overlay0,
-                            CatppuccinValue::Surface2 => catppuccin_egui::MOCHA.surface2,
-                            CatppuccinValue::Surface1 => catppuccin_egui::MOCHA.surface1,
-                            CatppuccinValue::Surface0 => catppuccin_egui::MOCHA.surface0,
-                            CatppuccinValue::Base => catppuccin_egui::MOCHA.base,
-                            CatppuccinValue::Mantle => catppuccin_egui::MOCHA.mantle,
-                            CatppuccinValue::Crust => catppuccin_egui::MOCHA.crust,
-                        };
-
-                        ctx.style_mut(|style| {
-                            style.visuals.selection.stroke.color = accent;
-                            style.visuals.widgets.hovered.fg_stroke.color = accent;
-                            style.visuals.widgets.active.fg_stroke.color = accent;
-                            style.visuals.override_text_color = None;
-                        });
-
-                        self.bg_color = catppuccin_egui::MOCHA.base;
-                    }
-                },
-                Theme::Base16 {
-                    name: base16,
-                    accent: base16_value,
-                } => {
-                    ctx.set_style(base16.style());
-                    let base16_value = base16_value.unwrap_or_default();
-
-                    let accent = match base16_value {
-                        Base16Value::Base00 => base16.base00(),
-                        Base16Value::Base01 => base16.base01(),
-                        Base16Value::Base02 => base16.base02(),
-                        Base16Value::Base03 => base16.base03(),
-                        Base16Value::Base04 => base16.base04(),
-                        Base16Value::Base05 => base16.base05(),
-                        Base16Value::Base06 => base16.base06(),
-                        Base16Value::Base07 => base16.base07(),
-                        Base16Value::Base08 => base16.base08(),
-                        Base16Value::Base09 => base16.base09(),
-                        Base16Value::Base0A => base16.base0a(),
-                        Base16Value::Base0B => base16.base0b(),
-                        Base16Value::Base0C => base16.base0c(),
-                        Base16Value::Base0D => base16.base0d(),
-                        Base16Value::Base0E => base16.base0e(),
-                        Base16Value::Base0F => base16.base0f(),
-                    };
-
-                    ctx.style_mut(|style| {
-                        style.visuals.selection.stroke.color = accent;
-                        style.visuals.widgets.hovered.fg_stroke.color = accent;
-                        style.visuals.widgets.active.fg_stroke.color = accent;
-                    });
-
-                    self.bg_color = base16.background();
-                }
-            },
-        }
-
-        let mut komorebi_widget = None;
-        let mut komorebi_widget_idx = None;
-        let mut komorebi_notification_state = previous_notification_state;
-        let mut side = None;
-
-        for (idx, widget_config) in config.left_widgets.iter().enumerate() {
-            if let WidgetConfig::Komorebi(config) = widget_config {
-                komorebi_widget = Some(Komorebi::from(*config));
-                komorebi_widget_idx = Some(idx);
-                side = Some(Side::Left);
-            }
-        }
-
-        for (idx, widget_config) in config.right_widgets.iter().enumerate() {
-            if let WidgetConfig::Komorebi(config) = widget_config {
-                komorebi_widget = Some(Komorebi::from(*config));
-                komorebi_widget_idx = Some(idx);
-                side = Some(Side::Right);
-            }
-        }
-
-        let mut left_widgets = config
-            .left_widgets
-            .iter()
-            .map(|config| config.as_boxed_bar_widget())
-            .collect::<Vec<Box<dyn BarWidget>>>();
-
-        let mut right_widgets = config
-            .right_widgets
-            .iter()
-            .map(|config| config.as_boxed_bar_widget())
-            .collect::<Vec<Box<dyn BarWidget>>>();
-
-        if let (Some(idx), Some(mut widget), Some(side)) =
-            (komorebi_widget_idx, komorebi_widget, side)
-        {
-            match komorebi_notification_state {
-                None => {
-                    komorebi_notification_state = Some(widget.komorebi_notification_state.clone());
-                }
-                Some(ref previous) => {
-                    previous
-                        .borrow_mut()
-                        .update_from_config(&widget.komorebi_notification_state.borrow());
-
-                    widget.komorebi_notification_state = previous.clone();
-                }
-            }
-
-            let boxed: Box<dyn BarWidget> = Box::new(widget);
-            match side {
-                Side::Left => left_widgets[idx] = boxed,
-                Side::Right => right_widgets[idx] = boxed,
-            }
-        }
-
-        right_widgets.reverse();
-
-        self.left_widgets = left_widgets;
-        self.right_widgets = right_widgets;
-
-        tracing::info!("widget configuration options applied");
-
-        self.komorebi_notification_state = komorebi_notification_state;
-    }
-    pub fn new(
-        cc: &eframe::CreationContext<'_>,
-        rx_gui: Receiver<komorebi_client::Notification>,
-        rx_config: Receiver<KomobarConfig>,
-        config: Arc<KomobarConfig>,
-    ) -> Self {
-        let mut komobar = Self {
-            config: config.clone(),
-            komorebi_notification_state: None,
-            left_widgets: vec![],
-            right_widgets: vec![],
-            rx_gui,
-            rx_config,
-            bg_color: Style::default().visuals.panel_fill,
-        };
-
-        komobar.apply_config(&cc.egui_ctx, &config, None);
-
-        komobar
-    }
-
-    fn add_custom_font(ctx: &Context, name: &str) {
-        let mut fonts = FontDefinitions::default();
-        egui_phosphor::add_to_fonts(&mut fonts, egui_phosphor::Variant::Regular);
-
-        let property = FontPropertyBuilder::new().family(name).build();
-
-        if let Some((font, _)) = system_fonts::get(&property) {
-            fonts
-                .font_data
-                .insert(name.to_owned(), FontData::from_owned(font));
-
-            fonts
-                .families
-                .entry(FontFamily::Proportional)
-                .or_default()
-                .insert(0, name.to_owned());
-
-            fonts
-                .families
-                .entry(FontFamily::Monospace)
-                .or_default()
-                .push(name.to_owned());
-
-            // Tell egui to use these fonts:
-            ctx.set_fonts(fonts);
-        }
-    }
-}
-impl eframe::App for Komobar {
-    // TODO: I think this is needed for transparency??
-    // fn clear_color(&self, _visuals: &Visuals) -> [f32; 4] {
-    // egui::Rgba::TRANSPARENT.to_array()
-    // let mut background = Color32::from_gray(18).to_normalized_gamma_f32();
-    // background[3] = 0.9;
-    // background
-    // }
-
-    fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
-        if let Ok(updated_config) = self.rx_config.try_recv() {
-            self.apply_config(
-                ctx,
-                &updated_config,
-                self.komorebi_notification_state.clone(),
-            );
-        }
-
-        if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
-            komorebi_notification_state
-                .borrow_mut()
-                .handle_notification(self.config.monitor.index, self.rx_gui.clone());
-        }
-
-        let frame = if let Some(frame) = &self.config.frame {
-            Frame::none()
-                .inner_margin(Margin::symmetric(
-                    frame.inner_margin.x,
-                    frame.inner_margin.y,
-                ))
-                .fill(self.bg_color)
-        } else {
-            Frame::none().fill(self.bg_color)
-        };
-
-        CentralPanel::default().frame(frame).show(ctx, |ui| {
-            ui.horizontal_centered(|ui| {
-                ui.with_layout(Layout::left_to_right(Align::Center), |ui| {
-                    for w in &mut self.left_widgets {
-                        w.render(ctx, ui);
-                    }
-                });
-
-                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
-                    for w in &mut self.right_widgets {
-                        w.render(ctx, ui);
-                    }
-                })
-            })
-        });
-    }
-}
-
-#[derive(Copy, Clone)]
-enum Side {
-    Left,
-    Right,
-}

komorebi-bar/src/battery.rs

@@ -1,141 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use starship_battery::units::ratio::percent;
-use starship_battery::Manager;
-use starship_battery::State;
-use std::time::Duration;
-use std::time::Instant;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct BatteryConfig {
-    /// Enable the Battery widget
-    pub enable: bool,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<BatteryConfig> for Battery {
-    fn from(value: BatteryConfig) -> Self {
-        let manager = Manager::new().unwrap();
-        let mut last_state = String::new();
-        let mut state = None;
-
-        if let Ok(mut batteries) = manager.batteries() {
-            if let Some(Ok(first)) = batteries.nth(0) {
-                let percentage = first.state_of_charge().get::<percent>();
-                match first.state() {
-                    State::Charging => state = Some(BatteryState::Charging),
-                    State::Discharging => state = Some(BatteryState::Discharging),
-                    _ => {}
-                }
-
-                last_state = format!("{percentage}%");
-            }
-        }
-
-        Self {
-            enable: value.enable,
-            manager,
-            last_state,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            state: state.unwrap_or(BatteryState::Discharging),
-            last_updated: Instant::now(),
-        }
-    }
-}
-
-pub enum BatteryState {
-    Charging,
-    Discharging,
-}
-
-pub struct Battery {
-    pub enable: bool,
-    manager: Manager,
-    pub state: BatteryState,
-    data_refresh_interval: u64,
-    last_state: String,
-    last_updated: Instant,
-}
-
-impl Battery {
-    fn output(&mut self) -> String {
-        let mut output = self.last_state.clone();
-
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            output.clear();
-
-            if let Ok(mut batteries) = self.manager.batteries() {
-                if let Some(Ok(first)) = batteries.nth(0) {
-                    let percentage = first.state_of_charge().get::<percent>();
-                    match first.state() {
-                        State::Charging => self.state = BatteryState::Charging,
-                        State::Discharging => self.state = BatteryState::Discharging,
-                        _ => {}
-                    }
-
-                    output = format!("{percentage}%");
-                }
-            }
-
-            self.last_state.clone_from(&output);
-            self.last_updated = now;
-        }
-
-        output
-    }
-}
-
-impl BarWidget for Battery {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let emoji = match self.state {
-                    BatteryState::Charging => egui_phosphor::regular::BATTERY_CHARGING,
-                    BatteryState::Discharging => egui_phosphor::regular::BATTERY_FULL,
-                };
-
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    emoji.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                ui.add(
-                    Label::new(layout_job)
-                        .selectable(false)
-                        .sense(Sense::click()),
-                );
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/config.rs

@@ -1,170 +0,0 @@
-use crate::widget::WidgetConfig;
-use base16_egui_themes::Base16;
-use eframe::egui::Pos2;
-use eframe::egui::TextBuffer;
-use eframe::egui::Vec2;
-use komorebi_client::Rect;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::path::PathBuf;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomobarConfig {
-    /// Viewport options (see: https://docs.rs/egui/latest/egui/viewport/struct.ViewportBuilder.html)
-    pub viewport: Option<ViewportConfig>,
-    /// Frame options (see: https://docs.rs/egui/latest/egui/containers/struct.Frame.html)
-    pub frame: Option<FrameConfig>,
-    /// Monitor options
-    pub monitor: MonitorConfig,
-    /// Font family
-    pub font_family: Option<String>,
-    /// Theme
-    pub theme: Option<Theme>,
-    /// Left side widgets (ordered left-to-right)
-    pub left_widgets: Vec<WidgetConfig>,
-    /// Right side widgets (ordered left-to-right)
-    pub right_widgets: Vec<WidgetConfig>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct ViewportConfig {
-    /// The desired starting position of the bar (0,0 = top left of the screen)
-    pub position: Option<Position>,
-    /// The desired size of the bar from the starting position (usually monitor width x desired height)
-    pub inner_size: Option<Position>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct FrameConfig {
-    /// Margin inside the painted frame
-    pub inner_margin: Position,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct MonitorConfig {
-    /// Komorebi monitor index of the monitor on which to render the bar
-    pub index: usize,
-    /// Automatically apply a work area offset for this monitor to accommodate the bar
-    pub work_area_offset: Option<Rect>,
-}
-
-impl KomobarConfig {
-    pub fn read(path: &PathBuf) -> color_eyre::Result<Self> {
-        let content = std::fs::read_to_string(path)?;
-        let mut value: Self = match path.extension().unwrap().to_string_lossy().as_str() {
-            "yaml" => serde_yaml::from_str(&content)?,
-            "json" => serde_json::from_str(&content)?,
-            _ => panic!("unsupported format"),
-        };
-
-        if value.frame.is_none() {
-            value.frame = Some(FrameConfig {
-                inner_margin: Position { x: 10.0, y: 10.0 },
-            });
-        }
-
-        Ok(value)
-    }
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct Position {
-    /// X coordinate
-    pub x: f32,
-    /// Y coordinate
-    pub y: f32,
-}
-
-impl From<Position> for Vec2 {
-    fn from(value: Position) -> Self {
-        Self {
-            x: value.x,
-            y: value.y,
-        }
-    }
-}
-
-impl From<Position> for Pos2 {
-    fn from(value: Position) -> Self {
-        Self {
-            x: value.x,
-            y: value.y,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(tag = "type")]
-pub enum Theme {
-    /// A theme from catppuccin-egui
-    Catppuccin {
-        name: Catppuccin,
-        accent: Option<CatppuccinValue>,
-    },
-    /// A theme from base16-egui-themes
-    Base16 {
-        name: Base16,
-        accent: Option<Base16Value>,
-    },
-}
-
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
-pub enum Base16Value {
-    Base00,
-    Base01,
-    Base02,
-    Base03,
-    Base04,
-    Base05,
-    #[default]
-    Base06,
-    Base07,
-    Base08,
-    Base09,
-    Base0A,
-    Base0B,
-    Base0C,
-    Base0D,
-    Base0E,
-    Base0F,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum Catppuccin {
-    Frappe,
-    Latte,
-    Macchiato,
-    Mocha,
-}
-
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
-pub enum CatppuccinValue {
-    Rosewater,
-    Flamingo,
-    Pink,
-    Mauve,
-    Red,
-    Maroon,
-    Peach,
-    Yellow,
-    Green,
-    Teal,
-    Sky,
-    Sapphire,
-    Blue,
-    Lavender,
-    #[default]
-    Text,
-    Subtext1,
-    Subtext0,
-    Overlay2,
-    Overlay1,
-    Overlay0,
-    Surface2,
-    Surface1,
-    Surface0,
-    Base,
-    Mantle,
-    Crust,
-}

komorebi-bar/src/date.rs

@@ -1,124 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use eframe::egui::WidgetText;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct DateConfig {
-    /// Enable the Date widget
-    pub enable: bool,
-    /// Set the Date format
-    pub format: DateFormat,
-}
-
-impl From<DateConfig> for Date {
-    fn from(value: DateConfig) -> Self {
-        Self {
-            enable: value.enable,
-            format: value.format,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum DateFormat {
-    /// Month/Date/Year format (09/08/24)
-    MonthDateYear,
-    /// Year-Month-Date format (2024-09-08)
-    YearMonthDate,
-    /// Date-Month-Year format (8-Sep-2024)
-    DateMonthYear,
-    /// Day Date Month Year format (8 September 2024)
-    DayDateMonthYear,
-    /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
-    Custom(String),
-}
-
-impl DateFormat {
-    pub fn next(&mut self) {
-        match self {
-            DateFormat::MonthDateYear => *self = Self::YearMonthDate,
-            DateFormat::YearMonthDate => *self = Self::DateMonthYear,
-            DateFormat::DateMonthYear => *self = Self::DayDateMonthYear,
-            DateFormat::DayDateMonthYear => *self = Self::MonthDateYear,
-            _ => {}
-        };
-    }
-
-    fn fmt_string(&self) -> String {
-        match self {
-            DateFormat::MonthDateYear => String::from("%D"),
-            DateFormat::YearMonthDate => String::from("%F"),
-            DateFormat::DateMonthYear => String::from("%v"),
-            DateFormat::DayDateMonthYear => String::from("%A %e %B %Y"),
-            DateFormat::Custom(custom) => custom.to_string(),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Date {
-    pub enable: bool,
-    pub format: DateFormat,
-}
-
-impl Date {
-    fn output(&mut self) -> String {
-        chrono::Local::now()
-            .format(&self.format.fmt_string())
-            .to_string()
-    }
-}
-
-impl BarWidget for Date {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::CALENDAR_DOTS.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(WidgetText::LayoutJob(layout_job.clone()))
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    self.format.next()
-                }
-            }
-
-            // TODO: make spacing configurable
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/komorebi.rs

@@ -1,245 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use crossbeam_channel::Receiver;
-use eframe::egui::ColorImage;
-use eframe::egui::Context;
-use eframe::egui::Image;
-use eframe::egui::Label;
-use eframe::egui::SelectableLabel;
-use eframe::egui::Sense;
-use eframe::egui::TextureHandle;
-use eframe::egui::TextureOptions;
-use eframe::egui::Ui;
-use image::RgbaImage;
-use komorebi_client::CycleDirection;
-use komorebi_client::SocketMessage;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::cell::RefCell;
-use std::rc::Rc;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiConfig {
-    /// Configure the Workspaces widget
-    pub workspaces: KomorebiWorkspacesConfig,
-    /// Configure the Layout widget
-    pub layout: KomorebiLayoutConfig,
-    /// Configure the Focused Window widget
-    pub focused_window: KomorebiFocusedWindowConfig,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiWorkspacesConfig {
-    /// Enable the Komorebi Workspaces widget
-    pub enable: bool,
-    /// Hide workspaces without any windows
-    pub hide_empty_workspaces: bool,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiLayoutConfig {
-    /// Enable the Komorebi Layout widget
-    pub enable: bool,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiFocusedWindowConfig {
-    /// Enable the Komorebi Focused Window widget
-    pub enable: bool,
-    /// Show the icon of the currently focused window
-    pub show_icon: bool,
-}
-
-impl From<KomorebiConfig> for Komorebi {
-    fn from(value: KomorebiConfig) -> Self {
-        Self {
-            komorebi_notification_state: Rc::new(RefCell::new(KomorebiNotificationState {
-                selected_workspace: String::new(),
-                focused_window_title: String::new(),
-                focused_window_pid: None,
-                focused_window_icon: None,
-                layout: String::new(),
-                workspaces: vec![],
-                hide_empty_workspaces: value.workspaces.hide_empty_workspaces,
-            })),
-            workspaces: value.workspaces,
-            layout: value.layout,
-            focused_window: value.focused_window,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Komorebi {
-    pub komorebi_notification_state: Rc<RefCell<KomorebiNotificationState>>,
-    pub workspaces: KomorebiWorkspacesConfig,
-    pub layout: KomorebiLayoutConfig,
-    pub focused_window: KomorebiFocusedWindowConfig,
-}
-
-impl BarWidget for Komorebi {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        let mut komorebi_notification_state = self.komorebi_notification_state.borrow_mut();
-
-        if self.workspaces.enable {
-            let mut update = None;
-
-            for (i, ws) in komorebi_notification_state.workspaces.iter().enumerate() {
-                if ui
-                    .add(SelectableLabel::new(
-                        komorebi_notification_state.selected_workspace.eq(ws),
-                        ws.to_string(),
-                    ))
-                    .clicked()
-                {
-                    update = Some(ws.to_string());
-                    komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(false))
-                        .unwrap();
-                    komorebi_client::send_message(&SocketMessage::FocusWorkspaceNumber(i)).unwrap();
-                    // TODO: store MFF value from state and restore that here instead of "true"
-                    komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(true)).unwrap();
-                    komorebi_client::send_message(&SocketMessage::Retile).unwrap();
-                }
-            }
-
-            if let Some(update) = update {
-                komorebi_notification_state.selected_workspace = update;
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if self.layout.enable {
-            if ui
-                .add(
-                    Label::new(&komorebi_notification_state.layout)
-                        .selectable(false)
-                        .sense(Sense::click()),
-                )
-                .clicked()
-            {
-                komorebi_client::send_message(&SocketMessage::CycleLayout(CycleDirection::Next))
-                    .unwrap();
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if self.focused_window.enable {
-            if self.focused_window.show_icon {
-                if let Some(img) = &komorebi_notification_state.focused_window_icon {
-                    ui.add(
-                        Image::from(&img_to_texture(ctx, img))
-                            .maintain_aspect_ratio(true)
-                            .max_height(15.0),
-                    );
-                }
-            }
-
-            ui.add(Label::new(&komorebi_notification_state.focused_window_title).selectable(false));
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}
-
-fn img_to_texture(ctx: &Context, rgba_image: &RgbaImage) -> TextureHandle {
-    let size = [rgba_image.width() as usize, rgba_image.height() as usize];
-    let pixels = rgba_image.as_flat_samples();
-    let color_image = ColorImage::from_rgba_unmultiplied(size, pixels.as_slice());
-    ctx.load_texture("icon", color_image, TextureOptions::default())
-}
-
-#[derive(Clone, Debug)]
-pub struct KomorebiNotificationState {
-    pub workspaces: Vec<String>,
-    pub selected_workspace: String,
-    pub focused_window_title: String,
-    pub focused_window_pid: Option<u32>,
-    pub focused_window_icon: Option<RgbaImage>,
-    pub layout: String,
-    pub hide_empty_workspaces: bool,
-}
-
-impl KomorebiNotificationState {
-    pub fn update_from_config(&mut self, config: &Self) {
-        self.hide_empty_workspaces = config.hide_empty_workspaces;
-    }
-
-    pub fn handle_notification(
-        &mut self,
-        monitor_index: usize,
-        rx_gui: Receiver<komorebi_client::Notification>,
-    ) {
-        if let Ok(notification) = rx_gui.try_recv() {
-            let monitor = &notification.state.monitors.elements()[monitor_index];
-            let focused_workspace_idx = monitor.focused_workspace_idx();
-
-            let mut workspaces = vec![];
-            self.selected_workspace = monitor.workspaces()[focused_workspace_idx]
-                .name()
-                .to_owned()
-                .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));
-
-            for (i, ws) in monitor.workspaces().iter().enumerate() {
-                let should_add = if self.hide_empty_workspaces {
-                    focused_workspace_idx == i || !ws.containers().is_empty()
-                } else {
-                    true
-                };
-
-                if should_add {
-                    workspaces.push(ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)));
-                }
-            }
-
-            self.workspaces = workspaces;
-            self.layout = match monitor.workspaces()[focused_workspace_idx].layout() {
-                komorebi_client::Layout::Default(layout) => layout.to_string(),
-                komorebi_client::Layout::Custom(_) => String::from("Custom"),
-            };
-
-            if let Some(container) = monitor.workspaces()[focused_workspace_idx].monocle_container()
-            {
-                if let Some(window) = container.focused_window() {
-                    if let Ok(title) = window.title() {
-                        self.focused_window_title.clone_from(&title);
-                        self.focused_window_pid = Some(window.process_id());
-                        let img = windows_icons::get_icon_by_process_id(window.process_id());
-                        self.focused_window_icon = Some(img);
-                    }
-                }
-            } else if let Some(container) =
-                monitor.workspaces()[focused_workspace_idx].focused_container()
-            {
-                if let Some(window) = container.focused_window() {
-                    if let Ok(title) = window.title() {
-                        self.focused_window_title.clone_from(&title);
-                        self.focused_window_pid = Some(window.process_id());
-                        let img = windows_icons::get_icon_by_process_id(window.process_id());
-                        self.focused_window_icon = Some(img);
-                    }
-                }
-            } else {
-                self.focused_window_title.clear();
-                self.focused_window_icon = None;
-            }
-
-            if let Some(container) = monitor.workspaces()[focused_workspace_idx].monocle_container()
-            {
-                if let Some(window) = container.focused_window() {
-                    if let Ok(title) = window.title() {
-                        self.focused_window_title.clone_from(&title);
-                    }
-                }
-            }
-
-            if let Some(window) = monitor.workspaces()[focused_workspace_idx].maximized_window() {
-                if let Ok(title) = window.title() {
-                    self.focused_window_title.clone_from(&title);
-                }
-            }
-        }
-    }
-}

komorebi-bar/src/main.rs

@@ -1,280 +0,0 @@
-mod bar;
-mod battery;
-mod config;
-mod date;
-mod komorebi;
-mod media;
-mod memory;
-mod network;
-mod storage;
-mod time;
-mod widget;
-
-use crate::bar::Komobar;
-use crate::config::KomobarConfig;
-use crate::config::Position;
-use clap::Parser;
-use eframe::egui::ViewportBuilder;
-use font_loader::system_fonts;
-use hotwatch::EventKind;
-use hotwatch::Hotwatch;
-use komorebi_client::SocketMessage;
-use schemars::gen::SchemaSettings;
-use std::io::BufReader;
-use std::io::Read;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-use tracing_subscriber::EnvFilter;
-
-pub static WIDGET_SPACING: f32 = 10.0;
-
-#[derive(Parser)]
-#[clap(author, about, version)]
-struct Opts {
-    /// Print the JSON schema of the configuration file and exit
-    #[clap(long)]
-    schema: bool,
-    /// Print a list of fonts available on this system and exit
-    #[clap(long)]
-    fonts: bool,
-    /// Path to a JSON or YAML configuration file
-    #[clap(short, long)]
-    config: Option<PathBuf>,
-}
-
-fn main() -> color_eyre::Result<()> {
-    let opts: Opts = Opts::parse();
-
-    if opts.schema {
-        let settings = SchemaSettings::default().with(|s| {
-            s.option_nullable = false;
-            s.option_add_null_type = false;
-            s.inline_subschemas = true;
-        });
-
-        let gen = settings.into_generator();
-        let socket_message = gen.into_root_schema_for::<KomobarConfig>();
-        let schema = serde_json::to_string_pretty(&socket_message)?;
-
-        println!("{schema}");
-        std::process::exit(0);
-    }
-
-    if opts.fonts {
-        for font in system_fonts::query_all() {
-            println!("{font}");
-        }
-
-        std::process::exit(0);
-    }
-
-    if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        std::env::set_var("RUST_LIB_BACKTRACE", "1");
-    }
-
-    color_eyre::install()?;
-
-    if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
-    }
-
-    tracing::subscriber::set_global_default(
-        tracing_subscriber::fmt::Subscriber::builder()
-            .with_env_filter(EnvFilter::from_default_env())
-            .finish(),
-    )?;
-
-    let home_dir: PathBuf = std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(
-        |_| dirs::home_dir().expect("there is no home directory"),
-        |home_path| {
-            let home = PathBuf::from(&home_path);
-
-            if home.as_path().is_dir() {
-                home
-            } else {
-                panic!("$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory");
-            }
-        },
-    );
-
-    let config_path = opts.config.map_or_else(
-        || {
-            let mut config = home_dir.join("komorebi.bar.json");
-            if !config.is_file() {
-                config.pop();
-                config.push("komorebi.bar.yaml");
-            }
-
-            if !config.is_file() {
-                None
-            } else {
-                Some(config)
-            }
-        },
-        Option::from,
-    );
-
-    let config = match config_path {
-        None => panic!(
-            "no komorebi.bar.json or komorebi.bar.yaml found in {}",
-            home_dir.as_path().to_string_lossy()
-        ),
-        Some(ref config) => {
-            tracing::info!(
-                "found configuration file: {}",
-                config.as_path().to_string_lossy()
-            );
-
-            KomobarConfig::read(config)?
-        }
-    };
-
-    let config_path = config_path.unwrap();
-
-    let mut viewport_builder = ViewportBuilder::default()
-        .with_decorations(false)
-        // .with_transparent(config.transparent)
-        .with_taskbar(false)
-        .with_position(Position { x: 0.0, y: 0.0 })
-        .with_inner_size({
-            let state = serde_json::from_str::<komorebi_client::State>(
-                &komorebi_client::send_query(&SocketMessage::State).unwrap(),
-            )?;
-
-            Position {
-                x: state.monitors.elements()[config.monitor.index].size().right as f32,
-                y: 20.0,
-            }
-        });
-
-    if let Some(viewport) = &config.viewport {
-        if let Some(position) = &viewport.position {
-            let b = viewport_builder.clone();
-            viewport_builder = b.with_position(*position);
-        }
-
-        if let Some(inner_size) = &viewport.inner_size {
-            let b = viewport_builder.clone();
-            viewport_builder = b.with_inner_size(*inner_size);
-        }
-    }
-
-    let native_options = eframe::NativeOptions {
-        viewport: viewport_builder,
-        ..Default::default()
-    };
-
-    if let Some(rect) = &config.monitor.work_area_offset {
-        komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(
-            config.monitor.index,
-            *rect,
-        ))?;
-        tracing::info!(
-            "work area offset applied to monitor: {}",
-            config.monitor.index
-        );
-    }
-
-    let (tx_gui, rx_gui) = crossbeam_channel::unbounded();
-    let (tx_config, rx_config) = crossbeam_channel::unbounded();
-
-    let mut hotwatch = Hotwatch::new()?;
-    let config_path_cl = config_path.clone();
-
-    hotwatch.watch(config_path, move |event| match event.kind {
-        EventKind::Modify(_) | EventKind::Remove(_) => match KomobarConfig::read(&config_path_cl) {
-            Ok(updated) => {
-                tx_config.send(updated).unwrap();
-
-                tracing::info!(
-                    "configuration file updated: {}",
-                    config_path_cl.as_path().to_string_lossy()
-                );
-            }
-            Err(error) => {
-                tracing::error!("{error}");
-            }
-        },
-        _ => {}
-    })?;
-
-    tracing::info!("watching configuration file for changes");
-
-    let config_arc = Arc::new(config);
-    eframe::run_native(
-        "komorebi-bar",
-        native_options,
-        Box::new(|cc| {
-            let config_cl = config_arc.clone();
-
-            let ctx_repainter = cc.egui_ctx.clone();
-            std::thread::spawn(move || loop {
-                std::thread::sleep(Duration::from_secs(1));
-                ctx_repainter.request_repaint();
-            });
-
-            let ctx_komorebi = cc.egui_ctx.clone();
-            std::thread::spawn(move || {
-                let listener = komorebi_client::subscribe("komorebi-bar").unwrap();
-                tracing::info!("subscribed to komorebi notifications: \"komorebi-bar\"");
-
-                for client in listener.incoming() {
-                    match client {
-                        Ok(subscription) => {
-                            let mut buffer = Vec::new();
-                            let mut reader = BufReader::new(subscription);
-
-                            // this is when we know a shutdown has been sent
-                            if matches!(reader.read_to_end(&mut buffer), Ok(0)) {
-                                tracing::info!("disconnected from komorebi");
-
-                                // keep trying to reconnect to komorebi
-                                while komorebi_client::send_message(
-                                    &SocketMessage::AddSubscriberSocket(String::from(
-                                        "komorebi-bar",
-                                    )),
-                                )
-                                .is_err()
-                                {
-                                    std::thread::sleep(Duration::from_secs(1));
-                                }
-
-                                tracing::info!("reconnected to komorebi");
-
-                                if let Some(rect) = &config_cl.monitor.work_area_offset {
-                                    while komorebi_client::send_message(
-                                        &SocketMessage::MonitorWorkAreaOffset(
-                                            config_cl.monitor.index,
-                                            *rect,
-                                        ),
-                                    )
-                                    .is_err()
-                                    {
-                                        std::thread::sleep(Duration::from_secs(1));
-                                    }
-                                }
-                            }
-
-                            if let Ok(notification) =
-                                serde_json::from_str::<komorebi_client::Notification>(
-                                    &String::from_utf8(buffer).unwrap(),
-                                )
-                            {
-                                tracing::debug!("received notification from komorebi");
-                                tx_gui.send(notification).unwrap();
-                                ctx_komorebi.request_repaint();
-                            }
-                        }
-                        Err(error) => {
-                            tracing::error!("{error}");
-                        }
-                    }
-                }
-            });
-
-            Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config_arc)))
-        }),
-    )
-    .map_err(|error| color_eyre::eyre::Error::msg(error.to_string()))
-}

komorebi-bar/src/media.rs

@@ -1,116 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct MediaConfig {
-    /// Enable the Media widget
-    pub enable: bool,
-}
-
-impl From<MediaConfig> for Media {
-    fn from(value: MediaConfig) -> Self {
-        Self::new(value.enable)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Media {
-    pub enable: bool,
-    pub session_manager: GlobalSystemMediaTransportControlsSessionManager,
-}
-
-impl Media {
-    pub fn new(enable: bool) -> Self {
-        Self {
-            enable,
-            session_manager: GlobalSystemMediaTransportControlsSessionManager::RequestAsync()
-                .unwrap()
-                .get()
-                .unwrap(),
-        }
-    }
-
-    pub fn toggle(&self) {
-        if let Ok(session) = self.session_manager.GetCurrentSession() {
-            if let Ok(op) = session.TryTogglePlayPauseAsync() {
-                op.get().unwrap_or_default();
-            }
-        }
-    }
-
-    fn output(&mut self) -> String {
-        if let Ok(session) = self.session_manager.GetCurrentSession() {
-            if let Ok(operation) = session.TryGetMediaPropertiesAsync() {
-                if let Ok(properties) = operation.get() {
-                    if let (Ok(artist), Ok(title)) = (properties.Artist(), properties.Title()) {
-                        if artist.is_empty() {
-                            return format!("{title}");
-                        }
-
-                        if title.is_empty() {
-                            return format!("{artist}");
-                        }
-
-                        return format!("{artist} - {title}");
-                    }
-                }
-            }
-        }
-
-        String::new()
-    }
-}
-
-impl BarWidget for Media {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::HEADPHONES.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    self.toggle();
-                }
-
-                ui.add_space(WIDGET_SPACING);
-            }
-        }
-    }
-}

komorebi-bar/src/memory.rs

@@ -1,108 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::process::Command;
-use std::time::Duration;
-use std::time::Instant;
-use sysinfo::RefreshKind;
-use sysinfo::System;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct MemoryConfig {
-    /// Enable the Memory widget
-    pub enable: bool,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<MemoryConfig> for Memory {
-    fn from(value: MemoryConfig) -> Self {
-        let mut system =
-            System::new_with_specifics(RefreshKind::default().without_cpu().without_processes());
-
-        system.refresh_memory();
-
-        Self {
-            enable: value.enable,
-            system,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            last_updated: Instant::now(),
-        }
-    }
-}
-
-pub struct Memory {
-    pub enable: bool,
-    system: System,
-    data_refresh_interval: u64,
-    last_updated: Instant,
-}
-
-impl Memory {
-    fn output(&mut self) -> String {
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            self.system.refresh_memory();
-            self.last_updated = now;
-        }
-
-        let used = self.system.used_memory();
-        let total = self.system.total_memory();
-        format!("RAM: {}%", (used * 100) / total)
-    }
-}
-
-impl BarWidget for Memory {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::MEMORY.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    if let Err(error) = Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
-                    {
-                        eprintln!("{}", error)
-                    }
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/network.rs

@@ -1,297 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use num_derive::FromPrimitive;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::fmt;
-use std::process::Command;
-use std::time::Duration;
-use std::time::Instant;
-use sysinfo::Networks;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct NetworkConfig {
-    /// Enable the Network widget
-    pub enable: bool,
-    /// Show total data transmitted
-    pub show_total_data_transmitted: bool,
-    /// Show network activity
-    pub show_network_activity: bool,
-    /// Characters to reserve for network activity data
-    pub network_activity_fill_characters: Option<usize>,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<NetworkConfig> for Network {
-    fn from(value: NetworkConfig) -> Self {
-        let mut last_state_data = vec![];
-        let mut last_state_transmitted = vec![];
-
-        let mut networks_total_data_transmitted = Networks::new_with_refreshed_list();
-        let mut networks_network_activity = Networks::new_with_refreshed_list();
-
-        let mut default_interface = String::new();
-
-        if let Ok(interface) = netdev::get_default_interface() {
-            if let Some(friendly_name) = interface.friendly_name {
-                default_interface.clone_from(&friendly_name);
-
-                if value.show_total_data_transmitted {
-                    networks_total_data_transmitted.refresh();
-                    for (interface_name, data) in &networks_total_data_transmitted {
-                        if friendly_name.eq(interface_name) {
-                            last_state_data.push(format!(
-                                "{} {} / {} {}",
-                                egui_phosphor::regular::ARROW_FAT_DOWN,
-                                to_pretty_bytes(data.total_received(), 1),
-                                egui_phosphor::regular::ARROW_FAT_UP,
-                                to_pretty_bytes(data.total_transmitted(), 1),
-                            ))
-                        }
-                    }
-                }
-
-                if value.show_network_activity {
-                    networks_network_activity.refresh();
-                    for (interface_name, data) in &networks_network_activity {
-                        if friendly_name.eq(interface_name) {
-                            last_state_transmitted.push(format!(
-                                "{} {: >width$}/s {} {: >width$}/s",
-                                egui_phosphor::regular::ARROW_FAT_DOWN,
-                                to_pretty_bytes(data.received(), 1),
-                                egui_phosphor::regular::ARROW_FAT_UP,
-                                to_pretty_bytes(data.transmitted(), 1),
-                                width = value.network_activity_fill_characters.unwrap_or_default(),
-                            ))
-                        }
-                    }
-                }
-            }
-        }
-
-        Self {
-            enable: value.enable,
-            networks_total_data_transmitted,
-            networks_network_activity,
-            default_interface,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            show_total_data_transmitted: value.show_total_data_transmitted,
-            show_network_activity: value.show_network_activity,
-            network_activity_fill_characters: value
-                .network_activity_fill_characters
-                .unwrap_or_default(),
-            last_state_total_data_transmitted: last_state_data,
-            last_state_network_activity: last_state_transmitted,
-            last_updated_total_data_transmitted: Instant::now(),
-            last_updated_network_activity: Instant::now(),
-        }
-    }
-}
-
-pub struct Network {
-    pub enable: bool,
-    pub show_total_data_transmitted: bool,
-    pub show_network_activity: bool,
-    networks_total_data_transmitted: Networks,
-    networks_network_activity: Networks,
-    data_refresh_interval: u64,
-    default_interface: String,
-    last_state_total_data_transmitted: Vec<String>,
-    last_state_network_activity: Vec<String>,
-    last_updated_total_data_transmitted: Instant,
-    last_updated_network_activity: Instant,
-    network_activity_fill_characters: usize,
-}
-
-impl Network {
-    fn default_interface(&mut self) {
-        if let Ok(interface) = netdev::get_default_interface() {
-            if let Some(friendly_name) = &interface.friendly_name {
-                self.default_interface.clone_from(friendly_name);
-            }
-        }
-    }
-
-    fn network_activity(&mut self) -> Vec<String> {
-        let mut outputs = self.last_state_network_activity.clone();
-        let now = Instant::now();
-
-        if self.show_network_activity
-            && now.duration_since(self.last_updated_network_activity)
-                > Duration::from_secs(self.data_refresh_interval)
-        {
-            outputs.clear();
-
-            if let Ok(interface) = netdev::get_default_interface() {
-                if let Some(friendly_name) = &interface.friendly_name {
-                    if self.show_network_activity {
-                        self.networks_network_activity.refresh();
-                        for (interface_name, data) in &self.networks_network_activity {
-                            if friendly_name.eq(interface_name) {
-                                outputs.push(format!(
-                                    "{} {: >width$}/s {} {: >width$}/s",
-                                    egui_phosphor::regular::ARROW_FAT_DOWN,
-                                    to_pretty_bytes(data.received(), self.data_refresh_interval),
-                                    egui_phosphor::regular::ARROW_FAT_UP,
-                                    to_pretty_bytes(data.transmitted(), self.data_refresh_interval),
-                                    width = self.network_activity_fill_characters,
-                                ))
-                            }
-                        }
-                    }
-                }
-            }
-
-            self.last_state_network_activity.clone_from(&outputs);
-            self.last_updated_network_activity = now;
-        }
-
-        outputs
-    }
-
-    fn total_data_transmitted(&mut self) -> Vec<String> {
-        let mut outputs = self.last_state_total_data_transmitted.clone();
-        let now = Instant::now();
-
-        if self.show_total_data_transmitted
-            && now.duration_since(self.last_updated_total_data_transmitted)
-                > Duration::from_secs(self.data_refresh_interval)
-        {
-            outputs.clear();
-
-            if let Ok(interface) = netdev::get_default_interface() {
-                if let Some(friendly_name) = &interface.friendly_name {
-                    if self.show_total_data_transmitted {
-                        self.networks_total_data_transmitted.refresh();
-
-                        for (interface_name, data) in &self.networks_total_data_transmitted {
-                            if friendly_name.eq(interface_name) {
-                                outputs.push(format!(
-                                    "{} {} / {} {}",
-                                    egui_phosphor::regular::ARROW_FAT_DOWN,
-                                    to_pretty_bytes(data.total_received(), 1),
-                                    egui_phosphor::regular::ARROW_FAT_UP,
-                                    to_pretty_bytes(data.total_transmitted(), 1),
-                                ))
-                            }
-                        }
-                    }
-                }
-            }
-
-            self.last_state_total_data_transmitted.clone_from(&outputs);
-            self.last_updated_total_data_transmitted = now;
-        }
-
-        outputs
-    }
-}
-
-impl BarWidget for Network {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.show_total_data_transmitted {
-            for output in self.total_data_transmitted() {
-                ui.add(Label::new(output).selectable(false));
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if self.show_network_activity {
-            for output in self.network_activity() {
-                ui.add(Label::new(output).selectable(false));
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if self.enable {
-            self.default_interface();
-
-            if !self.default_interface.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::WIFI_HIGH.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &self.default_interface,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    if let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn() {
-                        eprintln!("{}", error)
-                    }
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}
-
-#[derive(Debug, FromPrimitive)]
-enum DataUnit {
-    B = 0,
-    K = 1,
-    M = 2,
-    G = 3,
-    T = 4,
-    P = 5,
-    E = 6,
-    Z = 7,
-    Y = 8,
-}
-
-impl fmt::Display for DataUnit {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-fn to_pretty_bytes(input_in_bytes: u64, timespan_in_s: u64) -> String {
-    let input = input_in_bytes as f32 / timespan_in_s as f32;
-    let mut magnitude = input.log(1024f32) as u32;
-
-    // let the base unit be KiB
-    if magnitude < 1 {
-        magnitude = 1;
-    }
-
-    let base: Option<DataUnit> = num::FromPrimitive::from_u32(magnitude);
-    let result = input / ((1u64) << (magnitude * 10)) as f32;
-
-    match base {
-        Some(DataUnit::B) => format!("{result:.1} B"),
-        Some(unit) => format!("{result:.1} {unit}iB"),
-        None => String::from("Unknown data unit"),
-    }
-}

komorebi-bar/src/storage.rs

@@ -1,123 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::process::Command;
-use std::time::Duration;
-use std::time::Instant;
-use sysinfo::Disks;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct StorageConfig {
-    /// Enable the Storage widget
-    pub enable: bool,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<StorageConfig> for Storage {
-    fn from(value: StorageConfig) -> Self {
-        Self {
-            enable: value.enable,
-            disks: Disks::new_with_refreshed_list(),
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            last_updated: Instant::now(),
-        }
-    }
-}
-
-pub struct Storage {
-    pub enable: bool,
-    disks: Disks,
-    data_refresh_interval: u64,
-    last_updated: Instant,
-}
-
-impl Storage {
-    fn output(&mut self) -> Vec<String> {
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            self.disks.refresh();
-            self.last_updated = now;
-        }
-
-        let mut disks = vec![];
-
-        for disk in &self.disks {
-            let mount = disk.mount_point();
-            let total = disk.total_space();
-            let available = disk.available_space();
-            let used = total - available;
-
-            disks.push(format!(
-                "{} {}%",
-                mount.to_string_lossy(),
-                (used * 100) / total
-            ))
-        }
-
-        disks.sort();
-        disks.reverse();
-
-        disks
-    }
-}
-
-impl BarWidget for Storage {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let font_id = ctx
-                .style()
-                .text_styles
-                .get(&TextStyle::Body)
-                .cloned()
-                .unwrap_or_else(FontId::default);
-
-            for output in self.output() {
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::HARD_DRIVES.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id.clone(), ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    if let Err(error) = Command::new("cmd.exe")
-                        .args([
-                            "/C",
-                            "explorer.exe",
-                            output.split(' ').collect::<Vec<&str>>()[0],
-                        ])
-                        .spawn()
-                    {
-                        eprintln!("{}", error)
-                    }
-                }
-
-                ui.add_space(WIDGET_SPACING);
-            }
-        }
-    }
-}

komorebi-bar/src/time.rs

@@ -1,115 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct TimeConfig {
-    /// Enable the Time widget
-    pub enable: bool,
-    /// Set the Time format
-    pub format: TimeFormat,
-}
-
-impl From<TimeConfig> for Time {
-    fn from(value: TimeConfig) -> Self {
-        Self {
-            enable: value.enable,
-            format: value.format,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum TimeFormat {
-    /// Twelve-hour format (with seconds)
-    TwelveHour,
-    /// Twenty-four-hour format (with seconds)
-    TwentyFourHour,
-    /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
-    Custom(String),
-}
-
-impl TimeFormat {
-    pub fn toggle(&mut self) {
-        match self {
-            TimeFormat::TwelveHour => *self = TimeFormat::TwentyFourHour,
-            TimeFormat::TwentyFourHour => *self = TimeFormat::TwelveHour,
-            _ => {}
-        };
-    }
-
-    fn fmt_string(&self) -> String {
-        match self {
-            TimeFormat::TwelveHour => String::from("%l:%M:%S %p"),
-            TimeFormat::TwentyFourHour => String::from("%T"),
-            TimeFormat::Custom(format) => format.to_string(),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Time {
-    pub enable: bool,
-    pub format: TimeFormat,
-}
-
-impl Time {
-    fn output(&mut self) -> String {
-        chrono::Local::now()
-            .format(&self.format.fmt_string())
-            .to_string()
-    }
-}
-
-impl BarWidget for Time {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::CLOCK.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    self.format.toggle()
-                }
-            }
-
-            // TODO: make spacing configurable
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/widget.rs

@@ -1,52 +0,0 @@
-use crate::battery::Battery;
-use crate::battery::BatteryConfig;
-use crate::date::Date;
-use crate::date::DateConfig;
-use crate::komorebi::Komorebi;
-use crate::komorebi::KomorebiConfig;
-use crate::media::Media;
-use crate::media::MediaConfig;
-use crate::memory::Memory;
-use crate::memory::MemoryConfig;
-use crate::network::Network;
-use crate::network::NetworkConfig;
-use crate::storage::Storage;
-use crate::storage::StorageConfig;
-use crate::time::Time;
-use crate::time::TimeConfig;
-use eframe::egui::Context;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-pub trait BarWidget {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui);
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum WidgetConfig {
-    Battery(BatteryConfig),
-    Date(DateConfig),
-    Komorebi(KomorebiConfig),
-    Media(MediaConfig),
-    Memory(MemoryConfig),
-    Network(NetworkConfig),
-    Storage(StorageConfig),
-    Time(TimeConfig),
-}
-
-impl WidgetConfig {
-    pub fn as_boxed_bar_widget(&self) -> Box<dyn BarWidget> {
-        match self {
-            WidgetConfig::Battery(config) => Box::new(Battery::from(*config)),
-            WidgetConfig::Date(config) => Box::new(Date::from(config.clone())),
-            WidgetConfig::Komorebi(config) => Box::new(Komorebi::from(*config)),
-            WidgetConfig::Media(config) => Box::new(Media::from(*config)),
-            WidgetConfig::Memory(config) => Box::new(Memory::from(*config)),
-            WidgetConfig::Network(config) => Box::new(Network::from(*config)),
-            WidgetConfig::Storage(config) => Box::new(Storage::from(*config)),
-            WidgetConfig::Time(config) => Box::new(Time::from(config.clone())),
-        }
-    }
-}

komorebi-client/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "komorebi-client"
-version = "0.1.29"
+version = "0.1.26-dev.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 komorebi = { path = "../komorebi" }
+komorebi-core = { path = "../komorebi-core" }
 uds_windows = "1"
 serde_json = { workspace = true }

komorebi-client/src/lib.rs

@@ -1,40 +1,15 @@
-#![warn(clippy::all)]
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(clippy::missing_errors_doc)]
 
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;
 pub use komorebi::container::Container;
-pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
-pub use komorebi::core::resolve_home_path;
-pub use komorebi::core::AnimationStyle;
-pub use komorebi::core::ApplicationIdentifier;
-pub use komorebi::core::Arrangement;
-pub use komorebi::core::Axis;
-pub use komorebi::core::BorderImplementation;
-pub use komorebi::core::BorderStyle;
-pub use komorebi::core::CustomLayout;
-pub use komorebi::core::CycleDirection;
-pub use komorebi::core::DefaultLayout;
-pub use komorebi::core::Direction;
-pub use komorebi::core::FocusFollowsMouseImplementation;
-pub use komorebi::core::HidingBehaviour;
-pub use komorebi::core::Layout;
-pub use komorebi::core::MoveBehaviour;
-pub use komorebi::core::OperationBehaviour;
-pub use komorebi::core::OperationDirection;
-pub use komorebi::core::Rect;
-pub use komorebi::core::Sizing;
-pub use komorebi::core::SocketMessage;
-pub use komorebi::core::StackbarLabel;
-pub use komorebi::core::StackbarMode;
-pub use komorebi::core::StateQuery;
-pub use komorebi::core::WindowKind;
 pub use komorebi::monitor::Monitor;
 pub use komorebi::ring::Ring;
 pub use komorebi::window::Window;
 pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
-pub use komorebi::BorderColours;
+pub use komorebi::ActiveWindowBorderColours;
 pub use komorebi::GlobalState;
 pub use komorebi::Notification;
 pub use komorebi::NotificationEvent;
@@ -43,6 +18,19 @@ pub use komorebi::StackbarConfig;
 pub use komorebi::State;
 pub use komorebi::StaticConfig;
 pub use komorebi::TabsConfig;
+pub use komorebi_core::ActiveWindowBorderStyle;
+pub use komorebi_core::Arrangement;
+pub use komorebi_core::Axis;
+pub use komorebi_core::CustomLayout;
+pub use komorebi_core::CycleDirection;
+pub use komorebi_core::DefaultLayout;
+pub use komorebi_core::Direction;
+pub use komorebi_core::Layout;
+pub use komorebi_core::OperationDirection;
+pub use komorebi_core::Rect;
+pub use komorebi_core::SocketMessage;
+pub use komorebi_core::StackbarMode;
+pub use komorebi_core::WindowKind;
 
 use komorebi::DATA_DIR;
 
@@ -57,10 +45,16 @@ const KOMOREBI: &str = "komorebi.sock";
 
 pub fn send_message(message: &SocketMessage) -> std::io::Result<()> {
     let socket = DATA_DIR.join(KOMOREBI);
-    let mut stream = UnixStream::connect(socket)?;
-    stream.write_all(serde_json::to_string(message)?.as_bytes())
-}
+    let mut connected = false;
+    while !connected {
+        if let Ok(mut stream) = UnixStream::connect(&socket) {
+            connected = true;
+            stream.write_all(serde_json::to_string(message)?.as_bytes())?;
+        }
+    }
 
+    Ok(())
+}
 pub fn send_query(message: &SocketMessage) -> std::io::Result<String> {
     let socket = DATA_DIR.join(KOMOREBI);
 

komorebi-core/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "komorebi-core"
+version = "0.1.26-dev.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "4", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = { workspace = true }
+serde_yaml = "0.9"
+strum = { version = "0.26", features = ["derive"] }
+schemars = "0.8"
+color-eyre = { workspace = true }
+windows = { workspace = true }
+dunce = { workspace = true }
+dirs = { workspace = true }

komorebi-core/src/arrangement.rs

@@ -7,12 +7,12 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::custom_layout::Column;
-use super::custom_layout::ColumnSplit;
-use super::custom_layout::ColumnSplitWithCapacity;
-use super::CustomLayout;
-use super::DefaultLayout;
-use super::Rect;
+use crate::custom_layout::Column;
+use crate::custom_layout::ColumnSplit;
+use crate::custom_layout::ColumnSplitWithCapacity;
+use crate::CustomLayout;
+use crate::DefaultLayout;
+use crate::Rect;
 
 pub trait Arrangement {
     fn calculate(
@@ -26,7 +26,7 @@ pub trait Arrangement {
 }
 
 impl Arrangement for DefaultLayout {
-    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
+    #[allow(clippy::too_many_lines)]
     fn calculate(
         &self,
         area: &Rect,
@@ -58,13 +58,12 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        columns_reverse(&mut layouts);
-                    }
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => columns_reverse(&mut layouts),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -83,13 +82,12 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        rows_reverse(&mut layouts);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        2.. => rows_reverse(&mut layouts),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -137,28 +135,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];
 
-                        for rect in rest.iter_mut() {
-                            rect.left = primary.left;
+                            for rect in rest.iter_mut() {
+                                rect.left = primary.left;
+                            }
+                            primary.left = rest[0].left + rest[0].right;
                         }
-                        primary.left = rest[0].left + rest[0].right;
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        rows_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        3.. => rows_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -209,28 +207,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];
 
-                        primary.left = rest[0].left;
-                        for rect in rest.iter_mut() {
-                            rect.left = primary.left + primary.right;
+                            primary.left = rest[0].left;
+                            for rect in rest.iter_mut() {
+                                rect.left = primary.left + primary.right;
+                            }
                         }
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        rows_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        3.. => rows_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -278,28 +276,28 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];
 
-                        for rect in rest.iter_mut() {
-                            rect.top = primary.top;
+                            for rect in rest.iter_mut() {
+                                rect.top = primary.top;
+                            }
+                            primary.top = rest[0].top + rest[0].bottom;
                         }
-                        primary.top = rest[0].top + rest[0].bottom;
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        columns_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        3.. => columns_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
@@ -376,11 +374,8 @@ impl Arrangement for DefaultLayout {
                         layout.right += adjustment.right;
                     });
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    match len {
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
                         2 => {
                             let (primary, secondary) = layouts.split_at_mut(1);
                             let primary = &mut primary[0];
@@ -402,20 +397,20 @@ impl Arrangement for DefaultLayout {
                             secondary.left = primary.left + primary.right;
                         }
                         _ => {}
-                    }
+                    },
+                    _ => {}
                 }
 
-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 4.. = len {
-                        rows_reverse(&mut layouts[2..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        4.. => rows_reverse(&mut layouts[2..]),
+                        _ => {}
+                    },
+                    _ => {}
                 }
 
                 layouts
-            }
+            },
             #[allow(
                 clippy::cast_precision_loss,
                 clippy::cast_possible_truncation,
@@ -604,16 +599,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/config_generation.rs

@@ -6,7 +6,7 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::ApplicationIdentifier;
+use crate::ApplicationIdentifier;
 
 #[derive(
     Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,

komorebi-core/src/custom_layout.rs

@@ -12,9 +12,9 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::Rect;
+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/default_layout.rs

@@ -5,9 +5,9 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::OperationDirection;
-use super::Rect;
-use super::Sizing;
+use crate::OperationDirection;
+use crate::Rect;
+use crate::Sizing;
 
 #[derive(
     Clone,
@@ -164,14 +164,14 @@ impl DefaultLayout {
     #[must_use]
     pub const fn cycle_previous(self) -> Self {
         match self {
-            Self::RightMainVerticalStack => Self::Grid,
-            Self::Grid => Self::UltrawideVerticalStack,
+            Self::BSP => Self::UltrawideVerticalStack,
             Self::UltrawideVerticalStack => Self::HorizontalStack,
             Self::HorizontalStack => Self::VerticalStack,
             Self::VerticalStack => Self::Rows,
             Self::Rows => Self::Columns,
-            Self::Columns => Self::BSP,
-            Self::BSP => Self::RightMainVerticalStack,
+            Self::Columns => Self::Grid,
+            Self::Grid => Self::RightMainVerticalStack,
+            Self::RightMainVerticalStack => Self::BSP,
         }
     }
 }

komorebi-core/src/direction.rs

@@ -1,9 +1,9 @@
-use super::custom_layout::Column;
-use super::custom_layout::ColumnSplit;
-use super::custom_layout::ColumnSplitWithCapacity;
-use super::custom_layout::CustomLayout;
-use super::DefaultLayout;
-use super::OperationDirection;
+use crate::custom_layout::Column;
+use crate::custom_layout::ColumnSplit;
+use crate::custom_layout::ColumnSplitWithCapacity;
+use crate::custom_layout::CustomLayout;
+use crate::DefaultLayout;
+use crate::OperationDirection;
 
 pub trait Direction {
     fn index_in_direction(
@@ -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

@@ -2,12 +2,12 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-use super::Arrangement;
-use super::CustomLayout;
-use super::DefaultLayout;
-use super::Direction;
+use crate::Arrangement;
+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,13 +43,10 @@ pub enum SocketMessage {
     CycleFocusWindow(CycleDirection),
     CycleMoveWindow(CycleDirection),
     StackWindow(OperationDirection),
-    UnstackWindow,
-    CycleStack(CycleDirection),
-    FocusStackWindow(usize),
-    StackAll,
-    UnstackAll,
     ResizeWindowEdge(OperationDirection, Sizing),
     ResizeWindowAxis(Axis, Sizing),
+    UnstackWindow,
+    CycleStack(CycleDirection),
     MoveContainerToMonitorNumber(usize),
     CycleMoveContainerToMonitor(CycleDirection),
     MoveContainerToWorkspaceNumber(usize),
@@ -64,7 +59,6 @@ pub enum SocketMessage {
     SendContainerToMonitorWorkspaceNumber(usize, usize),
     MoveContainerToMonitorWorkspaceNumber(usize, usize),
     SendContainerToNamedWorkspace(String),
-    CycleMoveWorkspaceToMonitor(CycleDirection),
     MoveWorkspaceToMonitorNumber(usize),
     SwapWorkspacesToMonitorNumber(usize),
     ForceFocus,
@@ -72,7 +66,6 @@ pub enum SocketMessage {
     Minimize,
     Promote,
     PromoteFocus,
-    PromoteWindow(OperationDirection),
     ToggleFloat,
     ToggleMonocle,
     ToggleMaximize,
@@ -137,32 +130,18 @@ pub enum SocketMessage {
     WatchConfiguration(bool),
     CompleteConfiguration,
     AltFocusHack(bool),
-    Animation(bool),
-    AnimationDuration(u64),
-    AnimationFps(u64),
-    AnimationStyle(AnimationStyle),
-    #[serde(alias = "ActiveWindowBorder")]
-    Border(bool),
-    #[serde(alias = "ActiveWindowBorderColour")]
-    BorderColour(WindowKind, u32, u32, u32),
-    #[serde(alias = "ActiveWindowBorderStyle")]
-    BorderStyle(BorderStyle),
+    ActiveWindowBorder(bool),
+    ActiveWindowBorderColour(WindowKind, u32, u32, u32),
+    ActiveWindowBorderStyle(ActiveWindowBorderStyle),
     BorderWidth(i32),
     BorderOffset(i32),
-    BorderImplementation(BorderImplementation),
-    Transparency(bool),
-    ToggleTransparency,
-    TransparencyAlpha(u8),
     InvisibleBorders(Rect),
     StackbarMode(StackbarMode),
-    StackbarLabel(StackbarLabel),
     StackbarFocusedTextColour(u32, u32, u32),
     StackbarUnfocusedTextColour(u32, u32, u32),
     StackbarBackgroundColour(u32, u32, u32),
     StackbarHeight(i32),
     StackbarTabWidth(i32),
-    StackbarFontSize(i32),
-    StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
     ResizeDelta(i32),
@@ -170,9 +149,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),
@@ -182,7 +158,6 @@ pub enum SocketMessage {
     State,
     GlobalState,
     VisibleWindows,
-    MonitorInformation,
     Query(StateQuery),
     FocusFollowsMouse(FocusFollowsMouseImplementation, bool),
     ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
@@ -224,28 +199,9 @@ pub enum StackbarMode {
 }
 
 #[derive(
-    Debug, Copy, Default, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
+    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
 )]
-pub enum StackbarLabel {
-    #[default]
-    Process,
-    Title,
-}
-
-#[derive(
-    Default,
-    Copy,
-    Clone,
-    Debug,
-    Eq,
-    PartialEq,
-    Display,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    ValueEnum,
-)]
-pub enum BorderStyle {
+pub enum ActiveWindowBorderStyle {
     #[default]
     /// Use the system border style
     System,
@@ -256,37 +212,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,
@@ -357,18 +283,6 @@ pub enum MoveBehaviour {
     Swap,
     /// Insert the window container into the focused workspace on the adjacent monitor
     Insert,
-    /// Do nothing if trying to move a window container in the direction of an adjacent monitor
-    NoOp,
-}
-
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
-pub enum CrossBoundaryBehaviour {
-    /// Attempt to perform actions across a workspace boundary
-    Workspace,
-    /// Attempt to perform actions across a monitor boundary
-    Monitor,
 }
 
 #[derive(
@@ -379,7 +293,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/operation_direction.rs

@@ -7,8 +7,8 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::direction::Direction;
-use super::Axis;
+use crate::direction::Direction;
+use crate::Axis;
 
 #[derive(
     Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,

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,14 +0,0 @@
-[package]
-name = "komorebi-gui"
-version = "0.1.29"
-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"
-komorebi-client = { path = "../komorebi-client" }
-serde_json = "1"
-random_word = { version = "0.4.3", features = ["en"] }
-windows = { workspace = true }

komorebi-gui/src/main.rs

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

komorebi.sample.ahk

@@ -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.29"
+version = "0.1.26-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -11,14 +11,15 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+komorebi-core = { path = "../komorebi-core" }
+
 bitflags = { version = "2", features = ["serde"] }
 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 }
-dunce = { workspace = true }
 getset = "0.1"
 hex_color = { version = "3", features = ["serde"] }
 hotwatch = "0.5"
@@ -27,13 +28,12 @@ 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 = { workspace = true }
+schemars = "0.8"
 serde = { version = "1", features = ["derive"] }
 serde_json = { workspace = true }
-serde_yaml = { workspace = true }
 strum = { version = "0.26", features = ["derive"] }
 sysinfo = { workspace = true }
 tracing = "0.1"
@@ -42,16 +42,11 @@ 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 }
 
 [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,517 +0,0 @@
-use crate::core::AnimationStyle;
-use crate::core::Rect;
-use color_eyre::Result;
-
-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 }
-    }
-
-    /// Returns true if the animation needs to continue
-    pub fn cancel(&mut self) -> bool {
-        if !ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
-            return true;
-        }
-
-        // should be more than 0
-        let cancel_idx = ANIMATION_MANAGER.lock().init_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,
-            ));
-        }
-
-        let latest_cancel_idx = ANIMATION_MANAGER.lock().latest_cancel_idx(self.hwnd);
-
-        ANIMATION_MANAGER.lock().end_cancel(self.hwnd);
-
-        latest_cancel_idx == cancel_idx
-    }
-
-    #[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) {
-            let should_animate = self.cancel();
-
-            if !should_animate {
-                return Ok(());
-            }
-        }
-
-        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
-                ANIMATION_MANAGER.lock().cancel(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
-            let frame_time_elapsed = frame_start.elapsed();
-
-            if frame_time_elapsed < target_frame_time {
-                std::thread::sleep(target_frame_time - frame_time_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,108 +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 cancel_idx_counter: usize,
-    pub pending_cancel_count: usize,
-}
-
-#[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.pending_cancel_count > 0
-        } 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 init_cancel(&mut self, hwnd: isize) -> usize {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.pending_cancel_count += 1;
-            animation_state.cancel_idx_counter += 1;
-
-            // return cancel idx
-            animation_state.cancel_idx_counter
-        } else {
-            0
-        }
-    }
-
-    pub fn latest_cancel_idx(&mut self, hwnd: isize) -> usize {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.cancel_idx_counter
-        } else {
-            0
-        }
-    }
-
-    pub fn end_cancel(&mut self, hwnd: isize) {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.pending_cancel_count -= 1;
-        }
-    }
-
-    pub fn cancel(&mut self, hwnd: isize) {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.in_progress = false;
-        }
-    }
-
-    pub fn start(&mut self, hwnd: isize) {
-        if let Entry::Vacant(e) = self.animations.entry(hwnd) {
-            e.insert(AnimationState {
-                in_progress: true,
-                cancel_idx_counter: 0,
-                pending_cancel_count: 0,
-            });
-
-            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;
-
-            if animation_state.pending_cancel_count == 0 {
-                self.animations.remove(&hwnd);
-                ANIMATIONS_IN_PROGRESS.store(self.animations.len(), Ordering::Release);
-            }
-        }
-    }
-}

komorebi/src/border_manager/border.rs

@@ -1,21 +1,24 @@
-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;
 
-use crate::core::BorderStyle;
-use crate::core::Rect;
+use komorebi_core::ActiveWindowBorderStyle;
+use komorebi_core::Rect;
 
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::time::Duration;
 use windows::core::PCWSTR;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -23,12 +26,12 @@ use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::WPARAM;
 use windows::Win32::Graphics::Gdi::BeginPaint;
 use windows::Win32::Graphics::Gdi::CreatePen;
-use windows::Win32::Graphics::Gdi::DeleteObject;
 use windows::Win32::Graphics::Gdi::EndPaint;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::RoundRect;
 use windows::Win32::Graphics::Gdi::SelectObject;
+use windows::Win32::Graphics::Gdi::ValidateRect;
 use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
 use windows::Win32::Graphics::Gdi::PS_INSIDEFRAME;
 use windows::Win32::Graphics::Gdi::PS_SOLID;
@@ -44,29 +47,10 @@ use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 
-pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
-
-    if let Ok(class) = WindowsApi::real_window_class_w(hwnd) {
-        if class.starts_with("komoborder") {
-            hwnds.push(hwnd.0);
-        }
-    }
-
-    true.into()
-}
-
-#[derive(Debug)]
 pub struct Border {
     pub hwnd: isize,
 }
 
-impl From<isize> for Border {
-    fn from(value: isize) -> Self {
-        Self { hwnd: value }
-    }
-}
-
 impl Border {
     pub const fn hwnd(&self) -> HWND {
         HWND(self.hwnd)
@@ -95,19 +79,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(())
@@ -119,25 +97,26 @@ impl Border {
     }
 
     pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd())
+        WindowsApi::destroy_window(self.hwnd())
     }
 
-    pub fn update(&self, rect: &Rect, 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));
 
-        // 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;
+        // 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
+        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 +134,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() {
+                            ActiveWindowBorderStyle::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())
+                            ActiveWindowBorderStyle::Rounded => {
+                                RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                            }
+                            ActiveWindowBorderStyle::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

@@ -1,49 +1,39 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
 mod border;
 
-use crate::core::BorderImplementation;
-use crate::core::BorderStyle;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
 use crossbeam_utils::atomic::AtomicConsume;
+use komorebi_core::ActiveWindowBorderStyle;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use windows::Win32::Foundation::HWND;
 
-use crate::core::WindowKind;
-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;
-use border::border_hwnds;
 use border::Border;
+use komorebi_core::WindowKind;
 
 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::Komorebi);
+    pub static ref Z_ORDER: Arc<Mutex<ZOrder>> = Arc::new(Mutex::new(ZOrder::Bottom));
+    pub static ref STYLE: Arc<Mutex<ActiveWindowBorderStyle>> =
+        Arc::new(Mutex::new(ActiveWindowBorderStyle::System));
     pub static ref FOCUSED: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
     pub static ref UNFOCUSED: AtomicU32 =
@@ -56,6 +46,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,299 +55,51 @@ 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!(
-        "purging known borders: {:?}",
-        borders.iter().map(|b| b.1.hwnd).collect::<Vec<_>>()
-    );
-
-    for (_, border) in borders.iter() {
-        border.destroy()?;
-    }
-
-    borders.clear();
-    BORDERS_MONITORS.lock().clear();
-    FOCUS_STATE.lock().clear();
-
-    let mut remaining_hwnds = vec![];
-
-    WindowsApi::enum_windows(
-        Some(border_hwnds),
-        &mut remaining_hwnds as *mut Vec<isize> as isize,
-    )?;
-
-    if !remaining_hwnds.is_empty() {
-        tracing::info!("purging unknown borders: {:?}", remaining_hwnds);
-
-        for hwnd in remaining_hwnds {
-            Border::from(hwnd).destroy()?;
-        }
-    }
-
-    Ok(())
-}
-
-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()) {
-            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");
-
-    BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
     let receiver = event_rx();
-    event_tx().send(Notification)?;
 
-    let mut previous_snapshot = Ring::default();
-    let mut previous_pending_move_op = None;
-    let mut previous_is_paused = false;
+    std::thread::spawn(move || -> color_eyre::Result<()> {
+        'receiver: for _ in receiver {
+            let mut borders = BORDER_STATE.lock();
+            let mut borders_monitors = BORDERS_MONITORS.lock();
 
-    'receiver: for _ in receiver {
-        // Check the wm state every time we receive a notification
-        let state = wm.lock();
-        let is_paused = state.is_paused;
-        let focused_monitor_idx = state.focused_monitor_idx();
-        let monitors = state.monitors.clone();
-        let pending_move_op = state.pending_move_op;
-        drop(state);
+            // Check the wm state every time we receive a notification
+            let state = wm.lock();
 
-        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 {
-                                WindowKind::Unfocused
-                            } else {
-                                WindowKind::Monocle
-                            };
-
-                            monocle
-                                .focused_window()
-                                .copied()
-                                .unwrap_or_default()
-                                .set_accent(window_kind_colour(window_kind))?;
-
-                            continue 'monitors;
-                        }
-
-                        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))?;
-                        }
-                    }
-                }
-            }
-            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;
-                }
-
-                // handle the pause edge case
-                if is_paused && !previous_is_paused {
-                    should_process_notification = true;
-                }
-
-                // handle the unpause edge case
-                if previous_is_paused && !is_paused {
-                    should_process_notification = true;
-                }
-
-                // handle the retile edge case
-                if !should_process_notification && BORDER_STATE.lock().is_empty() {
-                    should_process_notification = true;
-                }
-
-                if !should_process_notification {
-                    tracing::trace!("monitor state matches latest snapshot, skipping notification");
-                    continue 'receiver;
-                }
-
-                let mut borders = BORDER_STATE.lock();
-                let mut borders_monitors = BORDERS_MONITORS.lock();
-
-                // 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
+            if !BORDER_ENABLED.load_consume() || state.is_paused {
+                if !borders.is_empty() {
                     for (_, border) in borders.iter() {
                         border.destroy()?;
                     }
 
                     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());
-                                }
-                            }
+                continue 'receiver;
+            }
 
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
-
-                            continue 'monitors;
-                        }
-
-                        // 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 focused_monitor_idx = state.focused_monitor_idx();
 
+            for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
+                // Only operate on the focused workspace of each monitor
+                if let Some(ws) = m.focused_workspace() {
+                    // Workspaces with tiling disabled don't have borders
+                    if !ws.tile() {
                         let mut to_remove = vec![];
                         for (id, border) in borders.iter() {
                             if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                                && !container_ids.contains(id)
                             {
                                 border.destroy()?;
                                 to_remove.push(id.clone());
@@ -367,98 +110,162 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             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);
+                        continue 'receiver;
+                    }
 
-                                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
-                            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;
-                                    }
-                                }
-                            };
-
-                            borders_monitors.insert(c.id().clone(), monitor_idx);
-
-                            #[allow(unused_assignments)]
-                            let mut last_focus_state = None;
-
-                            let new_focus_state = if idx != ws.focused_container_idx()
-                                || monitor_idx != focused_monitor_idx
+                    // Handle the monocle container separately
+                    if let Some(monocle) = ws.monocle_container() {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
                             {
-                                WindowKind::Unfocused
-                            } else if c.windows().len() > 1 {
-                                WindowKind::Stack
-                            } else {
-                                WindowKind::Single
-                            };
-
-                            // Update the focused state for all containers on this workspace
-                            {
-                                let mut focus_state = FOCUS_STATE.lock();
-                                last_focus_state = focus_state.insert(border.hwnd, new_focus_state);
+                                border.destroy()?;
+                                to_remove.push(id.clone());
                             }
+                        }
 
-                            let rect = WindowsApi::window_rect(
-                                c.focused_window().copied().unwrap_or_default().hwnd(),
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
+
+                        let border = borders.entry(monocle.id().clone()).or_insert_with(|| {
+                            Border::create(monocle.id()).expect("border creation failed")
+                        });
+
+                        borders_monitors.insert(monocle.id().clone(), monitor_idx);
+
+                        {
+                            let mut focus_state = FOCUS_STATE.lock();
+                            focus_state.insert(border.hwnd, WindowKind::Monocle);
+                        }
+
+                        let rect = WindowsApi::window_rect(
+                            monocle
+                                .focused_window()
+                                .expect("monocle container has no focused window")
+                                .hwnd(),
+                        )?;
+
+                        border.update(&rect)?;
+                        continue 'receiver;
+                    }
+
+                    let is_maximized = WindowsApi::is_zoomed(HWND(
+                        WindowsApi::foreground_window().unwrap_or_default(),
+                    ));
+
+                    if is_maximized {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
+
+                        continue 'receiver;
+                    }
+
+                    // Destroy any borders not associated with the focused workspace
+                    let container_ids = ws
+                        .containers()
+                        .iter()
+                        .map(|c| c.id().clone())
+                        .collect::<Vec<_>>();
+
+                    let mut to_remove = vec![];
+                    for (id, border) in borders.iter() {
+                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
+                            if !container_ids.contains(id) {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+                    }
+
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
+
+                    for (idx, c) in ws.containers().iter().enumerate() {
+                        // Update border when moving or resizing with mouse
+                        if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                            let restore_z_order = *Z_ORDER.lock();
+                            *Z_ORDER.lock() = ZOrder::TopMost;
+
+                            let mut rect = WindowsApi::window_rect(
+                                c.focused_window()
+                                    .expect("container has no focused window")
+                                    .hwnd(),
                             )?;
 
-                            let should_invalidate = match last_focus_state {
-                                None => true,
-                                Some(last_focus_state) => last_focus_state != new_focus_state,
-                            };
+                            while WindowsApi::lbutton_is_pressed() {
+                                let border = borders.entry(c.id().clone()).or_insert_with(|| {
+                                    Border::create(c.id()).expect("border creation failed")
+                                });
 
-                            border.update(&rect, should_invalidate)?;
+                                let new_rect = WindowsApi::window_rect(
+                                    c.focused_window()
+                                        .expect("container has no focused window")
+                                        .hwnd(),
+                                )?;
+
+                                if rect != new_rect {
+                                    rect = new_rect;
+                                    border.update(&rect)?;
+                                }
+                            }
+
+                            *Z_ORDER.lock() = restore_z_order;
+
+                            continue 'receiver;
                         }
+
+                        // Get the border entry for this container from the map or create one
+                        let border = borders.entry(c.id().clone()).or_insert_with(|| {
+                            Border::create(c.id()).expect("border creation failed")
+                        });
+
+                        borders_monitors.insert(c.id().clone(), monitor_idx);
+
+                        // Update the focused state for all containers on this workspace
+                        {
+                            let mut focus_state = FOCUS_STATE.lock();
+                            focus_state.insert(
+                                border.hwnd,
+                                if idx != ws.focused_container_idx()
+                                    || monitor_idx != focused_monitor_idx
+                                {
+                                    WindowKind::Unfocused
+                                } else {
+                                    if c.windows().len() > 1 {
+                                        WindowKind::Stack
+                                    } else {
+                                        WindowKind::Single
+                                    }
+                                },
+                            );
+                        }
+
+                        let rect = WindowsApi::window_rect(
+                            c.focused_window()
+                                .expect("container has no focused window")
+                                .hwnd(),
+                        )?;
+
+                        border.update(&rect)?;
                     }
                 }
             }
         }
 
-        previous_snapshot = monitors;
-        previous_pending_move_op = pending_move_op;
-        previous_is_paused = is_paused;
-    }
-
-    Ok(())
+        Ok(())
+    });
 }
 
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
@@ -469,9 +276,9 @@ pub enum ZOrder {
     TopMost,
 }
 
-impl From<ZOrder> for isize {
-    fn from(val: ZOrder) -> Self {
-        match val {
+impl Into<isize> for ZOrder {
+    fn into(self) -> isize {
+        match self {
             ZOrder::Top => 0,
             ZOrder::NoTopMost => -2,
             ZOrder::Bottom => 1,

komorebi/src/colour.rs

@@ -39,7 +39,6 @@ impl JsonSchema for Hex {
     fn json_schema(_: &mut SchemaGenerator) -> Schema {
         SchemaObject {
             instance_type: Some(InstanceType::String.into()),
-            format: Some("color-hex".to_string()),
             ..Default::default()
         }
         .into()

komorebi/src/container.rs

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

komorebi/src/core/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/src/focus_manager.rs

@@ -1,70 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use parking_lot::Mutex;
-use std::ops::Deref;
-use std::sync::Arc;
-use std::sync::OnceLock;
-
-use crate::Window;
-use crate::WindowManager;
-
-pub struct Notification(isize);
-
-impl Deref for Notification {
-    type Target = isize;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-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))
-}
-
-fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-// Currently this should only be used for async focus updates, such as
-// when an animation finishes and we need to focus to set the cursor
-// position if the user has mouse follows focus enabled
-pub fn send_notification(hwnd: isize) {
-    if event_tx().try_send(Notification(hwnd)).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();
-
-    for notification in receiver {
-        let mouse_follows_focus = wm.lock().mouse_follows_focus;
-        let _ = Window::from(*notification).focus(mouse_follows_focus);
-    }
-
-    Ok(())
-}

komorebi/src/hidden.rs

@@ -0,0 +1,75 @@
+use std::sync::atomic::Ordering;
+
+use color_eyre::Result;
+use windows::core::PCWSTR;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
+use windows::Win32::UI::WindowsAndMessaging::FindWindowW;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
+
+use crate::windows_callbacks;
+use crate::WindowsApi;
+use crate::HIDDEN_HWND;
+
+#[derive(Debug, Clone, Copy)]
+pub struct Hidden {
+    pub(crate) hwnd: isize,
+}
+
+impl From<isize> for Hidden {
+    fn from(hwnd: isize) -> Self {
+        Self { hwnd }
+    }
+}
+
+impl Hidden {
+    pub const fn hwnd(self) -> HWND {
+        HWND(self.hwnd)
+    }
+
+    pub fn create(name: &str) -> Result<()> {
+        let name: Vec<u16> = format!("{name}\0").encode_utf16().collect();
+        let instance = WindowsApi::module_handle_w()?;
+        let class_name = PCWSTR(name.as_ptr());
+        let brush = WindowsApi::create_solid_brush(0);
+        let window_class = WNDCLASSW {
+            hInstance: instance.into(),
+            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
+            lpfnWndProc: Some(windows_callbacks::hidden_window),
+            hbrBackground: brush,
+            ..Default::default()
+        };
+
+        let _atom = WindowsApi::register_class_w(&window_class)?;
+
+        let name_cl = name.clone();
+        std::thread::spawn(move || -> Result<()> {
+            let hwnd = WindowsApi::create_hidden_window(PCWSTR(name_cl.as_ptr()), instance)?;
+            let hidden = Self::from(hwnd);
+
+            let mut message = MSG::default();
+
+            unsafe {
+                while GetMessageW(&mut message, hidden.hwnd(), 0, 0).into() {
+                    DispatchMessageW(&message);
+                }
+            }
+
+            Ok(())
+        });
+
+        let mut hwnd = HWND(0);
+        while hwnd == HWND(0) {
+            hwnd = unsafe { FindWindowW(PCWSTR(name.as_ptr()), PCWSTR::null()) };
+        }
+
+        HIDDEN_HWND.store(hwnd.0, Ordering::SeqCst);
+
+        Ok(())
+    }
+}

komorebi/src/lib.rs

@@ -1,26 +1,18 @@
-#![warn(clippy::all)]
-
-pub mod animation;
-pub mod animation_manager;
 pub mod border_manager;
 pub mod com;
 #[macro_use]
 pub mod ring;
 pub mod colour;
 pub mod container;
-pub mod core;
-pub mod focus_manager;
+pub mod hidden;
 pub mod monitor;
-pub mod monitor_reconciliator;
 pub mod process_command;
 pub mod process_event;
 pub mod process_movement;
-pub mod reaper;
 pub mod set_window_position;
-pub mod stackbar_manager;
+pub mod stackbar;
 pub mod static_config;
 pub mod styles;
-pub mod transparency_manager;
 pub mod window;
 pub mod window_manager;
 pub mod window_manager_event;
@@ -29,7 +21,6 @@ pub mod windows_callbacks;
 pub mod winevent;
 pub mod winevent_listener;
 pub mod workspace;
-pub mod workspace_reconciliator;
 
 use lazy_static::lazy_static;
 use std::collections::HashMap;
@@ -41,17 +32,16 @@ use std::path::PathBuf;
 use std::process::Command;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
+use std::sync::atomic::AtomicIsize;
 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 core::*;
+pub use hidden::*;
 pub use process_command::*;
 pub use process_event::*;
+pub use stackbar::*;
 pub use static_config::*;
 pub use window::*;
 pub use window_manager::*;
@@ -59,10 +49,15 @@ pub use window_manager_event::*;
 pub use windows_api::WindowsApi;
 pub use windows_api::*;
 
-use crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
 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::ApplicationIdentifier;
+use komorebi_core::HidingBehaviour;
+use komorebi_core::Rect;
+use komorebi_core::SocketMessage;
+use komorebi_core::StackbarMode;
 use os_info::Version;
 use parking_lot::Mutex;
 use regex::Regex;
@@ -151,13 +146,9 @@ lazy_static! {
             kind: ApplicationIdentifier::Class,
             id: String::from("IHWindowClass"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
-        MatchingRule::Simple(IdWithIdentifier {
-            kind: ApplicationIdentifier::Exe,
-            id: String::from("komorebi-bar.exe"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
         })
     ]));
+
     static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "Chrome_RenderWidgetHostHWND".to_string(),
     ]));
@@ -167,7 +158,7 @@ lazy_static! {
     ]));
     static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
         Arc::new(Mutex::new(HashMap::new()));
-    pub static ref SUBSCRIPTION_SOCKETS: Arc<Mutex<HashMap<String, PathBuf>>> =
+    static ref SUBSCRIPTION_SOCKETS: Arc<Mutex<HashMap<String, PathBuf>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
         Arc::new(Mutex::new(HashMap::new()));
@@ -205,16 +196,11 @@ 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![]));
 
+    static ref STACKBAR_MODE: Arc<Mutex<StackbarMode >> = Arc::new(Mutex::new(StackbarMode::Never));
     static ref WINDOWS_BY_BAR_HWNDS: Arc<Mutex<HashMap<isize, VecDeque<isize>>>> =
         Arc::new(Mutex::new(HashMap::new()));
 
@@ -228,8 +214,14 @@ 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);
+
+pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);
+
+pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
+pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947); // gray text
+pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
+pub static STACKBAR_TAB_HEIGHT: AtomicI32 = AtomicI32::new(40);
+pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
 
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {

komorebi/src/main.rs

@@ -1,13 +1,11 @@
-#![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::net::Shutdown;
 use std::path::PathBuf;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
@@ -24,32 +22,24 @@ use sysinfo::Process;
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
-use uds_windows::UnixStream;
 
 use komorebi::border_manager;
-use komorebi::focus_manager;
+use komorebi::hidden::Hidden;
 use komorebi::load_configuration;
-use komorebi::monitor_reconciliator;
 use komorebi::process_command::listen_for_commands;
 use komorebi::process_command::listen_for_commands_tcp;
 use komorebi::process_event::listen_for_events;
 use komorebi::process_movement::listen_for_movements;
-use komorebi::reaper;
-use komorebi::stackbar_manager;
 use komorebi::static_config::StaticConfig;
-use komorebi::transparency_manager;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
-use komorebi::workspace_reconciliator;
 use komorebi::CUSTOM_FFM;
 use komorebi::DATA_DIR;
 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");
@@ -61,8 +51,8 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
         std::env::set_var("RUST_LOG", "info");
     }
 
-    let appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi_plaintext.log");
-    let color_appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi.log");
+    let appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi_plaintext.log");
+    let color_appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi.log");
     let (non_blocking, guard) = tracing_appender::non_blocking(appender);
     let (color_non_blocking, color_guard) = tracing_appender::non_blocking(color_appender);
 
@@ -137,7 +127,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")]
@@ -197,6 +187,8 @@ fn main() -> Result<()> {
     #[cfg(feature = "deadlock_detection")]
     detect_deadlocks();
 
+    Hidden::create("komorebi-hidden")?;
+
     let static_config = opts.config.map_or_else(
         || {
             let komorebi_json = HOME_DIR.join("komorebi.json");
@@ -263,12 +255,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());
-    focus_manager::listen_for_notifications(wm.clone());
 
     let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
     ctrlc::set_handler(move || {
@@ -289,15 +275,5 @@ fn main() -> Result<()> {
         WindowsApi::disable_focus_follows_mouse()?;
     }
 
-    let sockets = komorebi::SUBSCRIPTION_SOCKETS.lock();
-    for path in (*sockets).values() {
-        if let Ok(stream) = UnixStream::connect(path) {
-            stream.shutdown(Shutdown::Both)?;
-        }
-    }
-
-    let socket = DATA_DIR.join("komorebi.sock");
-    let _ = std::fs::remove_file(socket);
-
     std::process::exit(130);
 }

komorebi/src/monitor.rs

@@ -12,24 +12,14 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::core::Rect;
+use komorebi_core::Rect;
 
 use crate::container::Container;
 use crate::ring::Ring;
 use crate::workspace::Workspace;
-use crate::OperationDirection;
 
 #[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")]
@@ -37,19 +27,15 @@ pub struct Monitor {
     #[getset(get = "pub", set = "pub")]
     name: String,
     #[getset(get = "pub", set = "pub")]
-    device: String,
+    device: Option<String>,
     #[getset(get = "pub", set = "pub")]
-    device_id: String,
+    device_id: Option<String>,
     #[getset(get = "pub", set = "pub")]
     size: Rect,
     #[getset(get = "pub", set = "pub")]
     work_area_size: Rect,
     #[getset(get_copy = "pub", set = "pub")]
     work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset_limit: isize,
     workspaces: Ring<Workspace>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
@@ -60,27 +46,18 @@ pub struct Monitor {
 
 impl_ring_elements!(Monitor, Workspace);
 
-pub fn new(
-    id: isize,
-    size: Rect,
-    work_area_size: Rect,
-    name: String,
-    device: String,
-    device_id: String,
-) -> Monitor {
+pub fn new(id: isize, size: Rect, work_area_size: Rect, name: String) -> Monitor {
     let mut workspaces = Ring::default();
     workspaces.elements_mut().push_back(Workspace::default());
 
     Monitor {
         id,
         name,
-        device,
-        device_id,
+        device: None,
+        device_id: None,
         size,
         work_area_size,
         work_area_offset: None,
-        window_based_work_area_offset: None,
-        window_based_work_area_offset_limit: 1,
         workspaces,
         last_focused_workspace: None,
         workspace_names: HashMap::default(),
@@ -88,22 +65,6 @@ pub fn new(
 }
 
 impl Monitor {
-    pub fn placeholder() -> Self {
-        Self {
-            id: 0,
-            name: "PLACEHOLDER".to_string(),
-            device: "".to_string(),
-            device_id: "".to_string(),
-            size: Default::default(),
-            work_area_size: Default::default(),
-            work_area_offset: None,
-            window_based_work_area_offset: None,
-            window_based_work_area_offset_limit: 0,
-            workspaces: Default::default(),
-            last_focused_workspace: None,
-            workspace_names: Default::default(),
-        }
-    }
     pub fn load_focused_workspace(&mut self, mouse_follows_focus: bool) -> Result<()> {
         let focused_idx = self.focused_workspace_idx();
         for (i, workspace) in self.workspaces_mut().iter_mut().enumerate() {
@@ -131,7 +92,7 @@ impl Monitor {
                 .ok_or_else(|| anyhow!("there is no workspace"))?
         };
 
-        workspace.add_container_to_back(container);
+        workspace.add_container(container);
 
         Ok(())
     }
@@ -144,7 +105,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
@@ -166,7 +127,6 @@ impl Monitor {
         &mut self,
         target_workspace_idx: usize,
         follow: bool,
-        direction: Option<OperationDirection>,
     ) -> Result<()> {
         let workspace = self
             .focused_workspace_mut()
@@ -191,11 +151,7 @@ impl Monitor {
             Some(workspace) => workspace,
         };
 
-        if matches!(direction, Some(OperationDirection::Right)) {
-            target_workspace.add_container_to_front(container);
-        } else {
-            target_workspace.add_container_to_back(container);
-        }
+        target_workspace.add_container(container);
 
         if follow {
             self.focus_workspace(target_workspace_idx)?;
@@ -238,11 +194,6 @@ impl Monitor {
 
     pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> Result<()> {
         let work_area = *self.work_area_size();
-        let window_based_work_area_offset = (
-            self.window_based_work_area_offset_limit(),
-            self.window_based_work_area_offset(),
-        );
-
         let offset = if self.work_area_offset().is_some() {
             self.work_area_offset()
         } else {
@@ -251,7 +202,7 @@ impl Monitor {
 
         self.focused_workspace_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?
-            .update(&work_area, offset, window_based_work_area_offset)?;
+            .update(&work_area, offset)?;
 
         Ok(())
     }

komorebi/src/monitor_reconciliator/hidden.rs

@@ -1,203 +0,0 @@
-use std::sync::mpsc;
-use std::time::Duration;
-
-use windows::core::PCWSTR;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::Foundation::LPARAM;
-use windows::Win32::Foundation::LRESULT;
-use windows::Win32::Foundation::WPARAM;
-use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
-use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
-use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMEAUTOMATIC;
-use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMESUSPEND;
-use windows::Win32::UI::WindowsAndMessaging::PBT_APMSUSPEND;
-use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
-use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_POWERBROADCAST;
-use windows::Win32::UI::WindowsAndMessaging::WM_SETTINGCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_WTSSESSION_CHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-use windows::Win32::UI::WindowsAndMessaging::WTS_SESSION_LOCK;
-use windows::Win32::UI::WindowsAndMessaging::WTS_SESSION_UNLOCK;
-
-use crate::monitor_reconciliator;
-use crate::WindowsApi;
-
-// This is a hidden window specifically spawned to listen to system-wide events related to monitors
-#[derive(Debug, Clone, Copy)]
-pub struct Hidden {
-    pub hwnd: isize,
-}
-
-impl From<isize> for Hidden {
-    fn from(hwnd: isize) -> Self {
-        Self { hwnd }
-    }
-}
-
-impl Hidden {
-    pub const fn hwnd(self) -> HWND {
-        HWND(self.hwnd)
-    }
-
-    pub fn create(name: &str) -> color_eyre::Result<Self> {
-        let name: Vec<u16> = format!("{name}\0").encode_utf16().collect();
-        let class_name = PCWSTR(name.as_ptr());
-
-        let h_module = WindowsApi::module_handle_w()?;
-        let window_class = WNDCLASSW {
-            hInstance: h_module.into(),
-            lpszClassName: class_name,
-            style: CS_HREDRAW | CS_VREDRAW,
-            lpfnWndProc: Some(Self::callback),
-            hbrBackground: WindowsApi::create_solid_brush(0),
-            ..Default::default()
-        };
-
-        let _ = WindowsApi::register_class_w(&window_class)?;
-
-        let (hwnd_sender, hwnd_receiver) = mpsc::channel();
-
-        std::thread::spawn(move || -> color_eyre::Result<()> {
-            let hwnd = WindowsApi::create_hidden_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!("hidden window event processing thread shutdown");
-                        break;
-                    };
-                    TranslateMessage(&msg);
-                    DispatchMessageW(&msg);
-                }
-
-                std::thread::sleep(Duration::from_millis(10))
-            }
-
-            Ok(())
-        });
-
-        let hwnd = hwnd_receiver.recv()?;
-
-        WindowsApi::wts_register_session_notification(hwnd)?;
-
-        Ok(Self { hwnd })
-    }
-
-    pub extern "system" fn callback(
-        window: HWND,
-        message: u32,
-        wparam: WPARAM,
-        lparam: LPARAM,
-    ) -> LRESULT {
-        unsafe {
-            match message {
-                WM_POWERBROADCAST => {
-                    match wparam.0 as u32 {
-                        // Automatic: System resumed itself from sleep or hibernation
-                        // Suspend: User resumed system from sleep or hibernation
-                        PBT_APMRESUMEAUTOMATIC | PBT_APMRESUMESUSPEND => {
-                            tracing::debug!(
-                                "WM_POWERBROADCAST event received - resume from suspend"
-                            );
-                            monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::ResumingFromSuspendedState,
-                            );
-                            LRESULT(0)
-                        }
-                        // Computer is entering a suspended state
-                        PBT_APMSUSPEND => {
-                            tracing::debug!(
-                                "WM_POWERBROADCAST event received - entering suspended state"
-                            );
-                            monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::EnteringSuspendedState,
-                            );
-                            LRESULT(0)
-                        }
-                        _ => LRESULT(0),
-                    }
-                }
-                WM_WTSSESSION_CHANGE => {
-                    match wparam.0 as u32 {
-                        WTS_SESSION_LOCK => {
-                            tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_LOCK - screen locked");
-
-                            monitor_reconciliator::send_notification(
-                                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,
-                            );
-                        }
-                        _ => {}
-                    }
-
-                    LRESULT(0)
-                }
-                // This event gets sent when:
-                // - The scaling factor on a display changes
-                // - The resolution on a display changes
-                // - A monitor is added
-                // - A monitor is removed
-                // Since WM_DEVICECHANGE also notifies on monitor changes, we only handle scaling
-                // and resolution changes here
-                WM_DISPLAYCHANGE => {
-                    tracing::debug!(
-                        "WM_DISPLAYCHANGE event received with wparam: {}- work area or display resolution changed", wparam.0
-                    );
-
-                    monitor_reconciliator::send_notification(
-                        monitor_reconciliator::Notification::ResolutionScalingChanged,
-                    );
-                    LRESULT(0)
-                }
-                // Unfortunately this is the event sent with ButteryTaskbar which I use a lot
-                // Original idea from https://stackoverflow.com/a/33762334
-                WM_SETTINGCHANGE => {
-                    #[allow(clippy::cast_possible_truncation)]
-                    if wparam.0 as u32 == SPI_SETWORKAREA.0 {
-                        tracing::debug!(
-                                "WM_SETTINGCHANGE event received with SPI_SETWORKAREA - work area changed (probably butterytaskbar or something similar)"
-                            );
-
-                        monitor_reconciliator::send_notification(
-                            monitor_reconciliator::Notification::WorkAreaChanged,
-                        );
-                    }
-                    LRESULT(0)
-                }
-                // This event + wparam combo is sent 4 times when a monitor is added based on my testing on win11
-                // Original idea from https://stackoverflow.com/a/33762334
-                WM_DEVICECHANGE => {
-                    #[allow(clippy::cast_possible_truncation)]
-                    if wparam.0 as u32 == DBT_DEVNODES_CHANGED {
-                        tracing::debug!(
-                                "WM_DEVICECHANGE event received with DBT_DEVNODES_CHANGED - display added or removed"
-                            );
-                        monitor_reconciliator::send_notification(
-                            monitor_reconciliator::Notification::DisplayConnectionChange,
-                        );
-                    }
-
-                    LRESULT(0)
-                }
-                _ => DefWindowProcW(window, message, wparam, lparam),
-            }
-        }
-    }
-}

komorebi/src/monitor_reconciliator/mod.rs

@@ -1,416 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crate::border_manager;
-use crate::core::Rect;
-use crate::monitor;
-use crate::monitor::Monitor;
-use crate::monitor_reconciliator::hidden::Hidden;
-use crate::MonitorConfig;
-use crate::WindowManager;
-use crate::WindowsApi;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicConsume;
-use parking_lot::Mutex;
-use std::collections::HashMap;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-use std::sync::OnceLock;
-
-pub mod hidden;
-
-pub enum Notification {
-    ResolutionScalingChanged,
-    WorkAreaChanged,
-    DisplayConnectionChange,
-    EnteringSuspendedState,
-    ResumingFromSuspendedState,
-    SessionLocked,
-    SessionUnlocked,
-}
-
-static ACTIVE: AtomicBool = AtomicBool::new(true);
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, MonitorConfig>>> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
-}
-
-fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-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()))
-        .lock();
-
-    monitor_cache.insert(device_id.to_string(), config);
-}
-
-pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
-    Ok(win32_display_data::connected_displays_all()
-        .flatten()
-        .map(|display| {
-            let path = display.device_path;
-
-            let (device, device_id) = if path.is_empty() {
-                (String::from("UNKNOWN"), String::from("UNKNOWN"))
-            } else {
-                let mut split: Vec<_> = path.split('#').collect();
-                split.remove(0);
-                split.remove(split.len() - 1);
-                let device = split[0].to_string();
-                let device_id = split.join("-");
-                (device, device_id)
-            };
-
-            let name = display.device_name.trim_start_matches(r"\\.\").to_string();
-            let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
-
-            monitor::new(
-                display.hmonitor,
-                display.size.into(),
-                display.work_area_size.into(),
-                name,
-                device,
-                device_id,
-            )
-        })
-        .collect::<Vec<_>>())
-}
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    #[allow(clippy::expect_used)]
-    Hidden::create("komorebi-hidden")?;
-
-    tracing::info!("created hidden window to listen for monitor-related events");
-
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                if cfg!(debug_assertions) {
-                    tracing::error!("restarting failed thread: {:?}", error)
-                } else {
-                    tracing::error!("restarting failed thread: {}", error)
-                }
-            }
-        }
-    });
-
-    Ok(())
-}
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-
-    'receiver: for notification in receiver {
-        if !ACTIVE.load_consume() {
-            if matches!(
-                notification,
-                Notification::ResumingFromSuspendedState | Notification::SessionUnlocked
-            ) {
-                tracing::debug!(
-                    "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
-                );
-
-                ACTIVE.store(true, Ordering::SeqCst);
-            }
-
-            continue 'receiver;
-        }
-
-        let mut wm = wm.lock();
-
-        match notification {
-            Notification::EnteringSuspendedState | Notification::SessionLocked => {
-                tracing::debug!(
-                    "deactivating reconciliator until system resumes from suspended state or session is unlocked"
-                );
-                ACTIVE.store(false, Ordering::SeqCst);
-            }
-            Notification::ResumingFromSuspendedState | Notification::SessionUnlocked => {
-                // this is only handled above if the reconciliator is paused
-            }
-            Notification::WorkAreaChanged => {
-                tracing::debug!("handling work area changed notification");
-                let offset = wm.work_area_offset;
-                for monitor in wm.monitors_mut() {
-                    let mut should_update = false;
-
-                    // Update work areas as necessary
-                    if let Ok(reference) = WindowsApi::monitor(monitor.id()) {
-                        if reference.work_area_size() != monitor.work_area_size() {
-                            monitor.set_work_area_size(Rect {
-                                left: reference.work_area_size().left,
-                                top: reference.work_area_size().top,
-                                right: reference.work_area_size().right,
-                                bottom: reference.work_area_size().bottom,
-                            });
-
-                            should_update = true;
-                        }
-                    }
-
-                    if should_update {
-                        tracing::info!("updated work area for {}", monitor.device_id());
-                        monitor.update_focused_workspace(offset)?;
-                        border_manager::send_notification();
-                    } else {
-                        tracing::debug!(
-                            "work areas match, reconciliation not required for {}",
-                            monitor.device_id()
-                        );
-                    }
-                }
-            }
-            Notification::ResolutionScalingChanged => {
-                tracing::debug!("handling resolution/scaling changed notification");
-                let offset = wm.work_area_offset;
-                for monitor in wm.monitors_mut() {
-                    let mut should_update = false;
-
-                    // Update sizes and work areas as necessary
-                    if let Ok(reference) = WindowsApi::monitor(monitor.id()) {
-                        if reference.work_area_size() != monitor.work_area_size() {
-                            monitor.set_work_area_size(Rect {
-                                left: reference.work_area_size().left,
-                                top: reference.work_area_size().top,
-                                right: reference.work_area_size().right,
-                                bottom: reference.work_area_size().bottom,
-                            });
-
-                            should_update = true;
-                        }
-
-                        if reference.size() != monitor.size() {
-                            monitor.set_size(Rect {
-                                left: reference.size().left,
-                                top: reference.size().top,
-                                right: reference.size().right,
-                                bottom: reference.size().bottom,
-                            });
-
-                            should_update = true;
-                        }
-                    }
-
-                    if should_update {
-                        tracing::info!(
-                            "updated monitor resolution/scaling for {}",
-                            monitor.device_id()
-                        );
-
-                        monitor.update_focused_workspace(offset)?;
-                        border_manager::send_notification();
-                    } else {
-                        tracing::debug!(
-                            "resolutions match, reconciliation not required for {}",
-                            monitor.device_id()
-                        );
-                    }
-                }
-            }
-            Notification::DisplayConnectionChange => {
-                tracing::debug!("handling display connection change notification");
-                let mut monitor_cache = MONITOR_CACHE
-                    .get_or_init(|| Mutex::new(HashMap::new()))
-                    .lock();
-
-                let initial_monitor_count = wm.monitors().len();
-
-                // Get the currently attached display devices
-                let attached_devices = attached_display_devices()?;
-
-                // Make sure that in our state any attached displays have the latest Win32 data
-                for monitor in wm.monitors_mut() {
-                    for attached in &attached_devices {
-                        if attached.device_id().eq(monitor.device_id()) {
-                            monitor.set_id(attached.id());
-                            monitor.set_name(attached.name().clone());
-                            monitor.set_size(*attached.size());
-                            monitor.set_work_area_size(*attached.work_area_size());
-                        }
-                    }
-                }
-
-                if initial_monitor_count == attached_devices.len() {
-                    tracing::debug!("monitor counts match, reconciliation not required");
-                    continue 'receiver;
-                }
-
-                if attached_devices.is_empty() {
-                    tracing::debug!(
-                        "no devices found, skipping reconciliation to avoid breaking state"
-                    );
-                    continue 'receiver;
-                }
-
-                if initial_monitor_count > attached_devices.len() {
-                    tracing::info!(
-                        "monitor count mismatch ({initial_monitor_count} vs {}), removing disconnected monitors",
-                        attached_devices.len()
-                    );
-
-                    // Gather all the containers that will be orphaned from disconnected and invalid displays
-                    let mut orphaned_containers = vec![];
-
-                    // Collect the ids in our state which aren't in the current attached display ids
-                    // These are monitors that have been removed
-                    let mut newly_removed_displays = vec![];
-
-                    for m in wm.monitors().iter() {
-                        if !attached_devices
-                            .iter()
-                            .any(|attached| attached.device_id().eq(m.device_id()))
-                        {
-                            newly_removed_displays.push(m.device_id().clone());
-                            for workspace in m.workspaces() {
-                                for container in workspace.containers() {
-                                    // Save the orphaned containers from the removed monitor
-                                    orphaned_containers.push(container.clone());
-                                }
-                            }
-
-                            // Let's add their state to the cache for later
-                            monitor_cache.insert(m.device_id().clone(), m.into());
-                        }
-                    }
-
-                    if !orphaned_containers.is_empty() {
-                        tracing::info!(
-                            "removed orphaned containers from: {newly_removed_displays:?}"
-                        );
-                    }
-
-                    if !newly_removed_displays.is_empty() {
-                        // After we have cached them, remove them from our state
-                        wm.monitors_mut()
-                            .retain(|m| !newly_removed_displays.contains(m.device_id()));
-                    }
-
-                    let post_removal_monitor_count = wm.monitors().len();
-                    let focused_monitor_idx = wm.focused_monitor_idx();
-                    if focused_monitor_idx >= post_removal_monitor_count {
-                        wm.focus_monitor(0)?;
-                    }
-
-                    if !orphaned_containers.is_empty() {
-                        if let Some(primary) = wm.monitors_mut().front_mut() {
-                            if let Some(focused_ws) = primary.focused_workspace_mut() {
-                                let focused_container_idx = focused_ws.focused_container_idx();
-
-                                // Put the orphaned containers somewhere visible
-                                for container in orphaned_containers {
-                                    focused_ws.add_container_to_back(container);
-                                }
-
-                                // Gotta reset the focus or the movement will feel "off"
-                                if initial_monitor_count != post_removal_monitor_count {
-                                    focused_ws.focus_container(focused_container_idx);
-                                }
-                            }
-                        }
-                    }
-
-                    let offset = wm.work_area_offset;
-
-                    for monitor in wm.monitors_mut() {
-                        // If we have lost a monitor, update everything to filter out any jank
-                        if initial_monitor_count != post_removal_monitor_count {
-                            monitor.update_focused_workspace(offset)?;
-                        }
-                    }
-                }
-
-                let post_removal_monitor_count = wm.monitors().len();
-
-                // This is the list of device ids after we have removed detached displays
-                let post_removal_device_ids = wm
-                    .monitors()
-                    .iter()
-                    .map(Monitor::device_id)
-                    .cloned()
-                    .collect::<Vec<_>>();
-
-                // Check for and add any new monitors that may have been plugged in
-                // Monitor and display index preferences get applied in this function
-                WindowsApi::load_monitor_information(&mut wm.monitors)?;
-
-                let post_addition_monitor_count = wm.monitors().len();
-
-                if post_addition_monitor_count > post_removal_monitor_count {
-                    tracing::info!(
-                        "monitor count mismatch ({post_removal_monitor_count} vs {post_addition_monitor_count}), adding connected monitors",
-                    );
-
-                    // Look in the updated state for new monitors
-                    for m in wm.monitors_mut() {
-                        let device_id = m.device_id().clone();
-                        // We identify a new monitor when we encounter a new device id
-                        if !post_removal_device_ids.contains(&device_id) {
-                            let mut cache_hit = false;
-                            // Check if that device id exists in the cache for this session
-                            if let Some(cached) = monitor_cache.get(&device_id) {
-                                cache_hit = true;
-
-                                tracing::info!("found monitor and workspace configuration for {device_id} in the monitor cache, applying");
-
-                                // If it does, load all the monitor settings from the cache entry
-                                m.ensure_workspace_count(cached.workspaces.len());
-                                m.set_work_area_offset(cached.work_area_offset);
-                                m.set_window_based_work_area_offset(
-                                    cached.window_based_work_area_offset,
-                                );
-                                m.set_window_based_work_area_offset_limit(
-                                    cached.window_based_work_area_offset_limit.unwrap_or(1),
-                                );
-
-                                for (w_idx, workspace) in m.workspaces_mut().iter_mut().enumerate()
-                                {
-                                    if let Some(cached_workspace) = cached.workspaces.get(w_idx) {
-                                        workspace.load_static_config(cached_workspace)?;
-                                    }
-                                }
-                            }
-
-                            // Entries in the cache should only be used once; remove the entry there was a cache hit
-                            if cache_hit {
-                                monitor_cache.remove(&device_id);
-                            }
-                        }
-                    }
-                }
-
-                let final_count = wm.monitors().len();
-
-                if post_removal_monitor_count != final_count {
-                    wm.retile_all(true)?;
-                    // Second retile to fix DPI/resolution related jank
-                    wm.retile_all(true)?;
-                    // Border updates to fix DPI/resolution related jank
-                    border_manager::send_notification();
-                }
-            }
-        }
-    }
-
-    Ok(())
-}

komorebi/src/process_command.rs

@@ -4,7 +4,6 @@ use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Read;
-use std::net::Shutdown;
 use std::net::TcpListener;
 use std::net::TcpStream;
 use std::num::NonZeroUsize;
@@ -22,35 +21,29 @@ use schemars::gen::SchemaSettings;
 use schemars::schema_for;
 use uds_windows::UnixStream;
 
-use crate::core::config_generation::ApplicationConfiguration;
-use crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
-use crate::core::ApplicationIdentifier;
-use crate::core::Axis;
-use crate::core::BorderImplementation;
-use crate::core::FocusFollowsMouseImplementation;
-use crate::core::Layout;
-use crate::core::MoveBehaviour;
-use crate::core::OperationDirection;
-use crate::core::Rect;
-use crate::core::Sizing;
-use crate::core::SocketMessage;
-use crate::core::StateQuery;
-use crate::core::WindowContainerBehaviour;
-use crate::core::WindowKind;
+use komorebi_core::config_generation::ApplicationConfiguration;
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::config_generation::MatchingRule;
+use komorebi_core::config_generation::MatchingStrategy;
+use komorebi_core::ApplicationIdentifier;
+use komorebi_core::Axis;
+use komorebi_core::FocusFollowsMouseImplementation;
+use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
+use komorebi_core::OperationDirection;
+use komorebi_core::Rect;
+use komorebi_core::Sizing;
+use komorebi_core::SocketMessage;
+use komorebi_core::StateQuery;
+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;
@@ -59,10 +52,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;
@@ -75,49 +64,40 @@ use crate::MONITOR_INDEX_PREFERENCES;
 use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REMOVE_TITLEBARS;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_MODE;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::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;
-use stackbar_manager::STACKBAR_MODE;
-use stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
-use stackbar_manager::STACKBAR_TAB_HEIGHT;
-use stackbar_manager::STACKBAR_TAB_WIDTH;
-use stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    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");
+        }
     });
 }
 
@@ -205,10 +185,6 @@ impl WindowManager {
         match message {
             SocketMessage::Promote => self.promote_container_to_front()?,
             SocketMessage::PromoteFocus => self.promote_focus_to_front()?,
-            SocketMessage::PromoteWindow(direction) => {
-                self.focus_container_in_direction(direction)?;
-                self.promote_container_to_front()?
-            }
             SocketMessage::FocusWindow(direction) => {
                 self.focus_container_in_direction(direction)?;
             }
@@ -223,28 +199,18 @@ 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)?;
             }
-            SocketMessage::FocusStackWindow(idx) => {
-                self.focus_container_window(idx)?;
-                self.focused_window()?.focus(self.mouse_follows_focus)?;
-            }
             SocketMessage::ForceFocus => {
                 let focused_window = self.focused_window()?;
                 let focused_window_rect = WindowsApi::window_rect(focused_window.hwnd())?;
                 WindowsApi::center_cursor_in_rect(&focused_window_rect)?;
                 WindowsApi::left_click();
             }
-            SocketMessage::Close => {
-                Window::from(WindowsApi::foreground_window()?).close()?;
-            }
-            SocketMessage::Minimize => {
-                Window::from(WindowsApi::foreground_window()?).minimize();
-            }
+            SocketMessage::Close => self.focused_window()?.close()?,
+            SocketMessage::Minimize => self.focused_window()?.minimize(),
             SocketMessage::ToggleFloat => self.toggle_float()?,
             SocketMessage::ToggleMonocle => self.toggle_monocle()?,
             SocketMessage::ToggleMaximize => self.toggle_maximize()?,
@@ -288,40 +254,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();
 
@@ -441,7 +373,7 @@ impl WindowManager {
                 self.adjust_workspace_padding(sizing, adjustment)?;
             }
             SocketMessage::MoveContainerToWorkspaceNumber(workspace_idx) => {
-                self.move_container_to_workspace(workspace_idx, true, None)?;
+                self.move_container_to_workspace(workspace_idx, true)?;
             }
             SocketMessage::CycleMoveContainerToWorkspace(direction) => {
                 let focused_monitor = self
@@ -457,7 +389,7 @@ impl WindowManager {
                         .ok_or_else(|| anyhow!("there must be at least one workspace"))?,
                 );
 
-                self.move_container_to_workspace(workspace_idx, true, None)?;
+                self.move_container_to_workspace(workspace_idx, true)?;
             }
             SocketMessage::MoveContainerToMonitorNumber(monitor_idx) => {
                 self.move_container_to_monitor(monitor_idx, None, true)?;
@@ -475,7 +407,7 @@ impl WindowManager {
                 self.move_container_to_monitor(monitor_idx, None, true)?;
             }
             SocketMessage::SendContainerToWorkspaceNumber(workspace_idx) => {
-                self.move_container_to_workspace(workspace_idx, false, None)?;
+                self.move_container_to_workspace(workspace_idx, false)?;
             }
             SocketMessage::CycleSendContainerToWorkspace(direction) => {
                 let focused_monitor = self
@@ -491,7 +423,7 @@ impl WindowManager {
                         .ok_or_else(|| anyhow!("there must be at least one workspace"))?,
                 );
 
-                self.move_container_to_workspace(workspace_idx, false, None)?;
+                self.move_container_to_workspace(workspace_idx, false)?;
             }
             SocketMessage::SendContainerToMonitorNumber(monitor_idx) => {
                 self.move_container_to_monitor(monitor_idx, None, false)?;
@@ -533,15 +465,6 @@ impl WindowManager {
             SocketMessage::MoveWorkspaceToMonitorNumber(monitor_idx) => {
                 self.move_workspace_to_monitor(monitor_idx)?;
             }
-            SocketMessage::CycleMoveWorkspaceToMonitor(direction) => {
-                let monitor_idx = direction.next_idx(
-                    self.focused_monitor_idx(),
-                    NonZeroUsize::new(self.monitors().len())
-                        .ok_or_else(|| anyhow!("there must be at least one monitor"))?,
-                );
-
-                self.move_workspace_to_monitor(monitor_idx)?;
-            }
             SocketMessage::TogglePause => {
                 if self.is_paused {
                     tracing::info!("resuming");
@@ -569,11 +492,7 @@ impl WindowManager {
                 self.focus_monitor(monitor_idx)?;
                 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)?
-            }
+            SocketMessage::Retile => self.retile_all(false)?,
             SocketMessage::FlipLayout(layout_flip) => self.flip_layout(layout_flip)?,
             SocketMessage::ChangeLayout(layout) => self.change_workspace_layout_default(layout)?,
             SocketMessage::CycleLayout(direction) => self.cycle_layout(direction)?,
@@ -728,9 +647,7 @@ impl WindowManager {
                     self.focus_monitor(monitor_idx)?;
                 }
 
-                if self.focused_workspace_idx().unwrap_or_default() != workspace_idx {
-                    self.focus_workspace(workspace_idx)?;
-                }
+                self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::FocusWorkspaceNumbers(workspace_idx) => {
                 // This is to ensure that even on an empty workspace on a secondary monitor, the
@@ -752,15 +669,8 @@ impl WindowManager {
                 self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx = self.focused_workspace_idx().unwrap_or_default();
-
-                let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                if focused_pair != (monitor_idx, workspace_idx) {
-                    self.focus_monitor(monitor_idx)?;
-                    self.focus_workspace(workspace_idx)?;
-                }
+                self.focus_monitor(monitor_idx)?;
+                self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::FocusNamedWorkspace(ref name) => {
                 if let Some((monitor_idx, workspace_idx)) =
@@ -780,16 +690,6 @@ impl WindowManager {
                     WindowsApi::disable_focus_follows_mouse()?;
                 }
 
-                let sockets = SUBSCRIPTION_SOCKETS.lock();
-                for path in (*sockets).values() {
-                    if let Ok(stream) = UnixStream::connect(path) {
-                        stream.shutdown(Shutdown::Both)?;
-                    }
-                }
-
-                let socket = DATA_DIR.join("komorebi.sock");
-                let _ = std::fs::remove_file(socket);
-
                 std::process::exit(0)
             }
             SocketMessage::MonitorIndexPreference(index_preference, left, top, right, bottom) => {
@@ -848,31 +748,27 @@ impl WindowManager {
             SocketMessage::VisibleWindows => {
                 let mut monitor_visible_windows = HashMap::new();
 
-                for monitor in self.monitors() {
+                for (index, monitor) in self.monitors().iter().enumerate() {
                     if let Some(ws) = monitor.focused_workspace() {
                         monitor_visible_windows.insert(
-                            monitor.device_id().clone(),
+                            monitor
+                                .device_id()
+                                .clone()
+                                .unwrap_or_else(|| format!("{index}")),
                             ws.visible_window_details().clone(),
                         );
                     }
                 }
 
-                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(),
@@ -1288,7 +1184,6 @@ impl WindowManager {
                     MoveBehaviour::Insert => {
                         self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
                     }
-                    _ => {}
                 }
             }
             SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {
@@ -1297,29 +1192,10 @@ impl WindowManager {
             SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
                 self.unmanaged_window_operation_behaviour = behaviour;
             }
-            SocketMessage::Border(enable) => {
+            SocketMessage::ActiveWindowBorder(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 {
+            SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => match kind {
                 WindowKind::Single => {
                     border_manager::FOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
@@ -1333,8 +1209,9 @@ impl WindowManager {
                     border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
             },
-            SocketMessage::BorderStyle(style) => {
-                STYLE.store(style);
+            SocketMessage::ActiveWindowBorderStyle(style) => {
+                let mut active_window_border_style = STYLE.lock();
+                *active_window_border_style = style;
             }
             SocketMessage::BorderWidth(width) => {
                 border_manager::BORDER_WIDTH.store(width, Ordering::SeqCst);
@@ -1342,33 +1219,17 @@ 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::ToggleTransparency => {
-                let current = transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst);
-                transparency_manager::TRANSPARENCY_ENABLED.store(!current, Ordering::SeqCst);
-            }
-            SocketMessage::Transparency(enable) => {
-                transparency_manager::TRANSPARENCY_ENABLED.store(enable, Ordering::SeqCst);
-            }
-            SocketMessage::TransparencyAlpha(alpha) => {
-                transparency_manager::TRANSPARENCY_ALPHA.store(alpha, Ordering::SeqCst);
-            }
             SocketMessage::StackbarMode(mode) => {
-                STACKBAR_MODE.store(mode);
-            }
-            SocketMessage::StackbarLabel(label) => {
-                STACKBAR_LABEL.store(label);
+                let mut stackbar_mode = STACKBAR_MODE.lock();
+                *stackbar_mode = mode;
+
+                for m in self.monitors_mut() {
+                    for w in m.workspaces_mut() {
+                        for c in w.containers_mut() {
+                            c.set_stackbar_mode(mode);
+                        }
+                    }
+                }
             }
             SocketMessage::StackbarFocusedTextColour(r, g, b) => {
                 let rgb = Rgb::new(r, g, b);
@@ -1388,13 +1249,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)?;
@@ -1443,7 +1297,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)?;
@@ -1461,9 +1315,7 @@ 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)?;
 
         tracing::info!("processed");
         Ok(())

komorebi/src/process_event.rs

@@ -1,35 +1,27 @@
 use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::time::Duration;
-use std::time::Instant;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
-use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
 
-use crate::core::OperationDirection;
-use crate::core::Rect;
-use crate::core::Sizing;
-use crate::core::WindowContainerBehaviour;
+use komorebi_core::OperationDirection;
+use komorebi_core::Rect;
+use komorebi_core::Sizing;
+use komorebi_core::WindowContainerBehaviour;
 
 use crate::border_manager;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
-use crate::stackbar_manager;
-use crate::transparency_manager;
 use crate::window::should_act;
 use crate::window::RuleDebug;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
-use crate::workspace_reconciliator;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::DATA_DIR;
@@ -45,8 +37,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) {
@@ -63,7 +54,7 @@ pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
 
 impl WindowManager {
     #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
-    #[tracing::instrument(skip(self, event), fields(event = event.title(), winevent = event.winevent(), hwnd = event.hwnd()))]
+    #[tracing::instrument(skip(self))]
     pub fn process_event(&mut self, event: WindowManagerEvent) -> Result<()> {
         if self.is_paused {
             tracing::trace!("ignoring while paused");
@@ -76,33 +67,8 @@ 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(());
-            }
+        if !should_manage && !matches!(event, WindowManagerEvent::DisplayChange(_)) {
+            return Ok(());
         }
 
         if let Some(virtual_desktop_id) = &self.virtual_desktop_id {
@@ -121,39 +87,62 @@ impl WindowManager {
         match event {
             WindowManagerEvent::FocusChange(_, window)
             | WindowManagerEvent::Show(_, window)
+            | WindowManagerEvent::DisplayChange(window)
             | WindowManagerEvent::MoveResizeEnd(_, window) => {
-                if let Some(monitor_idx) = self.monitor_idx_from_window(window) {
-                    // This is a hidden window apparently associated with COM support mechanisms (based
-                    // on a post from http://www.databaseteam.org/1-ms-sql-server/a5bb344836fb889c.htm)
-                    //
-                    // The hidden window, OLEChannelWnd, associated with this class (spawned by
-                    // explorer.exe), after some debugging, is observed to always be tied to the primary
-                    // display monitor, or (usually) monitor 0 in the WindowManager state.
-                    //
-                    // Due to this, at least one user in the Discord has witnessed behaviour where, when
-                    // a MonitorPoll event is triggered by OLEChannelWnd, the focused monitor index gets
-                    // set repeatedly to 0, regardless of where the current foreground window is actually
-                    // located.
-                    //
-                    // This check ensures that we only update the focused monitor when the window
-                    // triggering monitor reconciliation is known to not be tied to a specific monitor.
-                    if let Ok(class) = window.class() {
-                        if class != "OleMainThreadWndClass"
-                            && self.focused_monitor_idx() != monitor_idx
-                        {
-                            self.focus_monitor(monitor_idx)?;
-                        }
-                    }
+                self.reconcile_monitors()?;
+
+                let monitor_idx = self.monitor_idx_from_window(window)
+                    .ok_or_else(|| anyhow!("there is no monitor associated with this window, it may have already been destroyed"))?;
+
+                // This is a hidden window apparently associated with COM support mechanisms (based
+                // on a post from http://www.databaseteam.org/1-ms-sql-server/a5bb344836fb889c.htm)
+                //
+                // The hidden window, OLEChannelWnd, associated with this class (spawned by
+                // explorer.exe), after some debugging, is observed to always be tied to the primary
+                // display monitor, or (usually) monitor 0 in the WindowManager state.
+                //
+                // Due to this, at least one user in the Discord has witnessed behaviour where, when
+                // a MonitorPoll event is triggered by OLEChannelWnd, the focused monitor index gets
+                // set repeatedly to 0, regardless of where the current foreground window is actually
+                // located.
+                //
+                // This check ensures that we only update the focused monitor when the window
+                // triggering monitor reconciliation is known to not be tied to a specific monitor.
+                if window.class()? != "OleMainThreadWndClass"
+                    && self.focused_monitor_idx() != monitor_idx
+                {
+                    self.focus_monitor(monitor_idx)?;
                 }
             }
             _ => {}
         }
 
-        for monitor in self.monitors_mut() {
-            for workspace in monitor.workspaces_mut() {
+        let offset = self.work_area_offset;
+
+        for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
+            let work_area = *monitor.work_area_size();
+            let offset = if monitor.work_area_offset().is_some() {
+                monitor.work_area_offset()
+            } else {
+                offset
+            };
+
+            for (j, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
                 if let WindowManagerEvent::FocusChange(_, window) = event {
                     let _ = workspace.focus_changed(window.hwnd);
                 }
+
+                let reaped_orphans = workspace.reap_orphans()?;
+                if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
+                    workspace.update(&work_area, offset)?;
+                    tracing::info!(
+                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
+                        reaped_orphans.0,
+                        reaped_orphans.1,
+                        i,
+                        j
+                    );
+                }
             }
         }
 
@@ -270,101 +259,75 @@ impl WindowManager {
             WindowManagerEvent::Show(_, window)
             | WindowManagerEvent::Manage(window)
             | WindowManagerEvent::Uncloak(_, window) => {
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx =
-                    self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
-
-                let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                let mut needs_reconciliation = false;
-
+                let mut switch_to = None;
                 for (i, monitors) in self.monitors().iter().enumerate() {
                     for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                        if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
-                            // At this point we know we are going to send a notification to the workspace reconciliator
-                            // So we get the topmost window returned by EnumWindows, which is almost always the window
-                            // that has been selected by alt-tab
-                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                if let Some(first) =
-                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                {
-                                    // If our record of this HWND hasn't been updated in over a minute
-                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                        // Update our record with the HWND we just found
-                                        ALT_TAB_HWND.store(Some(first.hwnd));
-                                        // Update the timestamp of our record
-                                        *instant = Instant::now();
-                                    }
-                                }
-                            }
-
-                            workspace_reconciliator::send_notification(i, j);
-                            needs_reconciliation = true;
+                        if workspace.contains_window(window.hwnd) {
+                            switch_to = Some((i, j));
                         }
                     }
                 }
 
-                // There are some applications such as Firefox where, if they are focused when a
-                // workspace switch takes place, it will fire an additional Show event, which will
-                // result in them being associated with both the original workspace and the workspace
-                // being switched to. This loop is to try to ensure that we don't end up with
-                // duplicates across multiple workspaces, as it results in ghost layout tiles.
-                let mut proceed = true;
+                match switch_to {
+                    Some((known_monitor_idx, known_workspace_idx)) => {
+                        if !matches!(event, WindowManagerEvent::Uncloak(_, _)) {
+                            if self.focused_monitor_idx() != known_monitor_idx
+                                || self
+                                    .focused_monitor()
+                                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                                    .focused_workspace_idx()
+                                    != known_workspace_idx
+                            {
+                                self.focus_monitor(known_monitor_idx)?;
+                                self.focus_workspace(known_workspace_idx)?;
+                            }
+                        }
+                    }
+                    None => {
+                        // There are some applications such as Firefox where, if they are focused when a
+                        // workspace switch takes place, it will fire an additional Show event, which will
+                        // result in them being associated with both the original workspace and the workspace
+                        // being switched to. This loop is to try to ensure that we don't end up with
+                        // duplicates across multiple workspaces, as it results in ghost layout tiles.
+                        let mut proceed = true;
 
-                for (i, monitor) in self.monitors().iter().enumerate() {
-                    for (j, workspace) in monitor.workspaces().iter().enumerate() {
-                        if workspace.container_for_window(window.hwnd).is_some()
-                            && i != self.focused_monitor_idx()
-                            && j != monitor.focused_workspace_idx()
-                        {
-                            tracing::debug!(
+                        for (i, monitor) in self.monitors().iter().enumerate() {
+                            for (j, workspace) in monitor.workspaces().iter().enumerate() {
+                                if workspace.container_for_window(window.hwnd).is_some()
+                                    && i != self.focused_monitor_idx()
+                                    && j != monitor.focused_workspace_idx()
+                                {
+                                    tracing::debug!(
                                 "ignoring show event for window already associated with another workspace"
                             );
 
-                            window.hide();
-                            proceed = false;
-                        }
-                    }
-                }
-
-                if proceed {
-                    let behaviour =
-                        self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
-                    let workspace = self.focused_workspace_mut()?;
-                    let workspace_contains_window = workspace.contains_window(window.hwnd);
-                    let monocle_container = workspace.monocle_container().clone();
-
-                    if !workspace_contains_window && !needs_reconciliation {
-                        match behaviour {
-                            WindowContainerBehaviour::Create => {
-                                workspace.new_container_for_window(window);
-                                self.update_focused_workspace(false, false)?;
-                            }
-                            WindowContainerBehaviour::Append => {
-                                workspace
-                                    .focused_container_mut()
-                                    .ok_or_else(|| anyhow!("there is no focused container"))?
-                                    .add_window(window);
-                                self.update_focused_workspace(true, false)?;
-
-                                stackbar_manager::send_notification();
-                            }
-                        }
-                    }
-
-                    if workspace_contains_window {
-                        let mut monocle_window_event = false;
-                        if let Some(ref monocle) = monocle_container {
-                            if let Some(monocle_window) = monocle.focused_window() {
-                                if monocle_window.hwnd == window.hwnd {
-                                    monocle_window_event = true;
+                                    window.hide();
+                                    proceed = false;
                                 }
                             }
                         }
 
-                        if !monocle_window_event && monocle_container.is_some() {
-                            window.hide();
+                        if proceed {
+                            let behaviour = self.window_container_behaviour;
+                            let workspace = self.focused_workspace_mut()?;
+
+                            if !workspace.contains_window(window.hwnd) && switch_to.is_none() {
+                                match behaviour {
+                                    WindowContainerBehaviour::Create => {
+                                        workspace.new_container_for_window(window);
+                                        self.update_focused_workspace(false, false)?;
+                                    }
+                                    WindowContainerBehaviour::Append => {
+                                        workspace
+                                            .focused_container_mut()
+                                            .ok_or_else(|| {
+                                                anyhow!("there is no focused container")
+                                            })?
+                                            .add_window(window);
+                                        self.update_focused_workspace(true, false)?;
+                                    }
+                                }
+                            }
                         }
                     }
                 }
@@ -400,12 +363,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
@@ -461,7 +422,10 @@ impl WindowManager {
 
                     // If we have moved across the monitors, use that override, otherwise determine
                     // if a move has taken place by ruling out a resize
-                    let right_bottom_constant = 0;
+                    let right_bottom_constant = ((BORDER_WIDTH.load(Ordering::SeqCst)
+                        + BORDER_OFFSET.load(Ordering::SeqCst))
+                        * 2)
+                    .abs();
 
                     let is_move = moved_across_monitors
                         || resize.right.abs() == right_bottom_constant
@@ -522,7 +486,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 +515,6 @@ impl WindowManager {
                                             )?;
                                         }
                                     }
-
-                                    stackbar_manager::send_notification();
                                 }
                             }
                         }
@@ -581,19 +543,14 @@ impl WindowManager {
                             ops.push(resize_op!(resize.top, >, OperationDirection::Up));
                         }
 
-                        // TODO: Determine if this is still needed
                         let top_left_constant = BORDER_WIDTH.load(Ordering::SeqCst)
                             + BORDER_OFFSET.load(Ordering::SeqCst);
 
-                        if resize.right != 0
-                            && (resize.left == top_left_constant || resize.left == 0)
-                        {
+                        if resize.right != 0 && resize.left == top_left_constant {
                             ops.push(resize_op!(resize.right, <, OperationDirection::Right));
                         }
 
-                        if resize.bottom != 0
-                            && (resize.top == top_left_constant || resize.top == 0)
-                        {
+                        if resize.bottom != 0 && resize.top == top_left_constant {
                             ops.push(resize_op!(resize.bottom, <, OperationDirection::Down));
                         }
 
@@ -605,13 +562,16 @@ impl WindowManager {
                     }
                 }
             }
-            WindowManagerEvent::MouseCapture(..)
-            | WindowManagerEvent::Cloak(..)
-            | WindowManagerEvent::TitleUpdate(..) => {}
+            WindowManagerEvent::ForceUpdate(_) => {
+                self.update_focused_workspace(false, true)?;
+            }
+            WindowManagerEvent::DisplayChange(..)
+            | WindowManagerEvent::MouseCapture(..)
+            | WindowManagerEvent::Cloak(..) => {}
         };
 
         // 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()?)?;
         }
 
@@ -641,21 +601,17 @@ impl WindowManager {
             state: self.as_ref().into(),
         };
 
-        notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::send_notification();
-        transparency_manager::send_notification();
-        stackbar_manager::send_notification();
-
-        // Too many spammy OBJECT_NAMECHANGE events from JetBrains IDEs
+        // Avoid unnecessary updates, this fires every single time you interact
+        // with something on JetBrains IDEs
         if !matches!(
             event,
             WindowManagerEvent::Show(WinEvent::ObjectNameChange, _)
         ) {
-            tracing::info!("processed: {}", event.window().to_string());
-        } else {
-            tracing::trace!("processed: {}", event.window().to_string());
+            notify_subscribers(&serde_json::to_string(&notification)?)?;
+            border_manager::event_tx().send(border_manager::Notification)?;
         }
 
+        tracing::info!("processed: {}", event.window().to_string());
         Ok(())
     }
 }

komorebi/src/process_movement.rs

@@ -5,7 +5,7 @@ use winput::message_loop;
 use winput::message_loop::Event;
 use winput::Action;
 
-use crate::core::FocusFollowsMouseImplementation;
+use komorebi_core::FocusFollowsMouseImplementation;
 
 use crate::window_manager::WindowManager;
 

komorebi/src/reaper.rs

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

komorebi/src/ring.rs

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

komorebi/src/stackbar.rs

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

komorebi/src/stackbar_manager/mod.rs

@@ -1,224 +0,0 @@
-mod stackbar;
-
-use crate::container::Container;
-use crate::core::StackbarLabel;
-use crate::core::StackbarMode;
-use crate::stackbar_manager::stackbar::Stackbar;
-use crate::WindowManager;
-use crate::WindowsApi;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
-use crossbeam_utils::atomic::AtomicConsume;
-use 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
-pub static STACKBAR_TAB_HEIGHT: AtomicI32 = AtomicI32::new(40);
-pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
-pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
-pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::OnStack);
-
-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());
-}
-
-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))
-}
-
-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 should_have_stackbar(window_count: usize) -> bool {
-    match STACKBAR_MODE.load() {
-        StackbarMode::Always => true,
-        StackbarMode::OnStack => window_count > 1,
-        StackbarMode::Never => false,
-    }
-}
-
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                tracing::warn!("restarting failed thread: {}", error);
-            }
-        }
-    });
-}
-
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-
-    'receiver: for _ in receiver {
-        let mut stackbars = STACKBAR_STATE.lock();
-        let mut stackbars_monitors = STACKBARS_MONITORS.lock();
-
-        // Check the wm state every time we receive a notification
-        let mut state = wm.lock();
-
-        // If stackbars are disabled
-        if matches!(STACKBAR_MODE.load(), StackbarMode::Never)
-            || STACKBAR_TEMPORARILY_DISABLED.load(Ordering::SeqCst)
-        {
-            for (_, stackbar) in stackbars.iter() {
-                stackbar.destroy()?;
-            }
-
-            stackbars.clear();
-            continue 'receiver;
-        }
-
-        for (monitor_idx, m) in state.monitors_mut().iter_mut().enumerate() {
-            // Only operate on the focused workspace of each monitor
-            if let Some(ws) = m.focused_workspace_mut() {
-                // Workspaces with tiling disabled don't have stackbars
-                if !ws.tile() {
-                    let mut to_remove = vec![];
-                    for (id, border) in stackbars.iter() {
-                        if stackbars_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        stackbars.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                let is_maximized = WindowsApi::is_zoomed(HWND(
-                    WindowsApi::foreground_window().unwrap_or_default(),
-                ));
-
-                // Handle the monocle container separately
-                if ws.monocle_container().is_some() || is_maximized {
-                    // Destroy any stackbars associated with the focused workspace
-                    let mut to_remove = vec![];
-                    for (id, stackbar) in stackbars.iter() {
-                        if stackbars_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            stackbar.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        stackbars.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                // Destroy any stackbars not associated with the focused workspace
-                let container_ids = ws
-                    .containers()
-                    .iter()
-                    .map(|c| c.id().clone())
-                    .collect::<Vec<_>>();
-
-                let mut to_remove = vec![];
-                for (id, stackbar) in stackbars.iter() {
-                    if stackbars_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                        && !container_ids.contains(id)
-                    {
-                        stackbar.destroy()?;
-                        to_remove.push(id.clone());
-                    }
-                }
-
-                for id in &to_remove {
-                    stackbars.remove(id);
-                }
-
-                let container_padding = ws
-                    .container_padding()
-                    .unwrap_or_else(|| DEFAULT_CONTAINER_PADDING.load_consume());
-
-                'containers: for container in ws.containers_mut() {
-                    let should_add_stackbar = match STACKBAR_MODE.load() {
-                        StackbarMode::Always => true,
-                        StackbarMode::OnStack => container.windows().len() > 1,
-                        StackbarMode::Never => false,
-                    };
-
-                    if !should_add_stackbar {
-                        if let Some(stackbar) = stackbars.get(container.id()) {
-                            stackbar.destroy()?
-                        }
-
-                        stackbars.remove(container.id());
-                        stackbars_monitors.remove(container.id());
-                        continue 'containers;
-                    }
-
-                    // Get the stackbar entry for this container from the map or create one
-                    let stackbar = match stackbars.entry(container.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(stackbar) = Stackbar::create(container.id()) {
-                                entry.insert(stackbar)
-                            } else {
-                                continue 'receiver;
-                            }
-                        }
-                    };
-
-                    stackbars_monitors.insert(container.id().clone(), monitor_idx);
-
-                    let rect = WindowsApi::window_rect(
-                        container
-                            .focused_window()
-                            .copied()
-                            .unwrap_or_default()
-                            .hwnd(),
-                    )?;
-
-                    stackbar.update(container_padding, container, &rect)?;
-                }
-            }
-        }
-    }
-
-    Ok(())
-}

komorebi/src/stackbar_manager/stackbar.rs

@@ -1,370 +0,0 @@
-use crate::border_manager::BORDER_OFFSET;
-use crate::border_manager::BORDER_WIDTH;
-use crate::border_manager::STYLE;
-use crate::container::Container;
-use crate::core::BorderStyle;
-use crate::core::Rect;
-use crate::core::StackbarLabel;
-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;
-use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
-use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::WindowsApi;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::WINDOWS_11;
-use crossbeam_utils::atomic::AtomicConsume;
-use std::os::windows::ffi::OsStrExt;
-use std::sync::atomic::Ordering;
-use std::sync::mpsc;
-use std::time::Duration;
-use windows::core::PCWSTR;
-use windows::Win32::Foundation::COLORREF;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::Foundation::LPARAM;
-use windows::Win32::Foundation::LRESULT;
-use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Gdi::CreateFontIndirectW;
-use windows::Win32::Graphics::Gdi::CreatePen;
-use windows::Win32::Graphics::Gdi::CreateSolidBrush;
-use windows::Win32::Graphics::Gdi::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;
-use windows::Win32::Graphics::Gdi::SelectObject;
-use windows::Win32::Graphics::Gdi::SetBkColor;
-use windows::Win32::Graphics::Gdi::SetTextColor;
-use windows::Win32::Graphics::Gdi::DT_CENTER;
-use windows::Win32::Graphics::Gdi::DT_END_ELLIPSIS;
-use windows::Win32::Graphics::Gdi::DT_SINGLELINE;
-use windows::Win32::Graphics::Gdi::DT_VCENTER;
-use windows::Win32::Graphics::Gdi::FONT_QUALITY;
-use windows::Win32::Graphics::Gdi::FW_BOLD;
-use windows::Win32::Graphics::Gdi::LOGFONTW;
-use windows::Win32::Graphics::Gdi::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;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
-use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
-use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
-use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
-use windows::Win32::UI::WindowsAndMessaging::WM_LBUTTONDOWN;
-use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
-use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
-use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
-use windows::Win32::UI::WindowsAndMessaging::WS_VISIBLE;
-
-#[derive(Debug)]
-pub struct Stackbar {
-    pub hwnd: isize,
-}
-
-impl From<isize> for Stackbar {
-    fn from(value: isize) -> Self {
-        Self { hwnd: value }
-    }
-}
-
-impl Stackbar {
-    pub const fn hwnd(&self) -> HWND {
-        HWND(self.hwnd)
-    }
-
-    pub fn create(id: &str) -> color_eyre::Result<Self> {
-        let name: Vec<u16> = format!("komostackbar-{id}\0").encode_utf16().collect();
-        let class_name = PCWSTR(name.as_ptr());
-
-        let h_module = WindowsApi::module_handle_w()?;
-
-        let window_class = WNDCLASSW {
-            style: CS_HREDRAW | CS_VREDRAW,
-            lpfnWndProc: Some(Self::callback),
-            hInstance: h_module.into(),
-            lpszClassName: class_name,
-            hbrBackground: WindowsApi::create_solid_brush(0),
-            ..Default::default()
-        };
-
-        let _ = WindowsApi::register_class_w(&window_class);
-
-        let (hwnd_sender, hwnd_receiver) = mpsc::channel();
-
-        let name_cl = name.clone();
-        std::thread::spawn(move || -> color_eyre::Result<()> {
-            unsafe {
-                let hwnd = CreateWindowExW(
-                    WS_EX_TOOLWINDOW | WS_EX_LAYERED,
-                    PCWSTR(name_cl.as_ptr()),
-                    PCWSTR(name_cl.as_ptr()),
-                    WS_POPUP | WS_VISIBLE,
-                    0,
-                    0,
-                    0,
-                    0,
-                    None,
-                    None,
-                    h_module,
-                    None,
-                );
-
-                SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
-                hwnd_sender.send(hwnd)?;
-
-                let mut msg: MSG = MSG::default();
-
-                loop {
-                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
-                        tracing::debug!("stackbar window event processing thread shutdown");
-                        break;
-                    };
-                    TranslateMessage(&msg);
-                    DispatchMessageW(&msg);
-
-                    std::thread::sleep(Duration::from_millis(10))
-                }
-            }
-
-            Ok(())
-        });
-
-        Ok(Self {
-            hwnd: hwnd_receiver.recv()?.0,
-        })
-    }
-
-    pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd())
-    }
-
-    pub fn update(
-        &self,
-        container_padding: i32,
-        container: &mut Container,
-        layout: &Rect,
-    ) -> color_eyre::Result<()> {
-        let width = STACKBAR_TAB_WIDTH.load_consume();
-        let height = STACKBAR_TAB_HEIGHT.load_consume();
-        let gap = DEFAULT_CONTAINER_PADDING.load_consume();
-        let background = STACKBAR_TAB_BACKGROUND_COLOUR.load_consume();
-        let focused_text_colour = STACKBAR_FOCUSED_TEXT_COLOUR.load_consume();
-        let unfocused_text_colour = STACKBAR_UNFOCUSED_TEXT_COLOUR.load_consume();
-
-        let mut stackbars_containers = STACKBARS_CONTAINERS.lock();
-        stackbars_containers.insert(self.hwnd, container.clone());
-
-        let mut layout = *layout;
-        let workspace_specific_offset =
-            BORDER_WIDTH.load_consume() + BORDER_OFFSET.load_consume() + container_padding;
-
-        layout.top -= workspace_specific_offset + STACKBAR_TAB_HEIGHT.load_consume();
-        layout.left -= workspace_specific_offset;
-
-        WindowsApi::position_window(self.hwnd(), &layout, false)?;
-
-        unsafe {
-            let hdc = GetDC(self.hwnd());
-
-            let hpen = CreatePen(PS_SOLID, 0, COLORREF(background));
-            let hbrush = CreateSolidBrush(COLORREF(background));
-
-            SelectObject(hdc, hpen);
-            SelectObject(hdc, hbrush);
-            SetBkColor(hdc, COLORREF(background));
-
-            let mut logfont = 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);
-
-            for (i, window) in container.windows().iter().enumerate() {
-                if window.hwnd == container.focused_window().copied().unwrap_or_default().hwnd {
-                    SetTextColor(hdc, COLORREF(focused_text_colour));
-                } else {
-                    SetTextColor(hdc, COLORREF(unfocused_text_colour));
-                }
-
-                let left = gap + (i as i32 * (width + gap));
-                let mut rect = Rect {
-                    top: 0,
-                    left,
-                    right: left + width,
-                    bottom: height,
-                };
-
-                match STYLE.load() {
-                    BorderStyle::System => {
-                        if *WINDOWS_11 {
-                            RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
-                        } else {
-                            Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
-                        }
-                    }
-                    BorderStyle::Rounded => {
-                        RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
-                    }
-                    BorderStyle::Square => {
-                        Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
-                    }
-                }
-
-                let label = match STACKBAR_LABEL.load() {
-                    StackbarLabel::Process => {
-                        let exe = window.exe()?;
-                        exe.trim_end_matches(".exe").to_string()
-                    }
-                    StackbarLabel::Title => window.title()?,
-                };
-
-                let mut tab_title: Vec<u16> = label.encode_utf16().collect();
-
-                rect.left_padding(10);
-                rect.right_padding(10);
-
-                DrawTextW(
-                    hdc,
-                    &mut tab_title,
-                    &mut rect.into(),
-                    DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_END_ELLIPSIS,
-                );
-            }
-
-            ReleaseDC(self.hwnd(), hdc);
-            DeleteObject(hpen);
-            DeleteObject(hbrush);
-            DeleteObject(hfont);
-        }
-
-        Ok(())
-    }
-
-    pub fn get_position_from_container_layout(&self, layout: &Rect) -> Rect {
-        Rect {
-            bottom: STACKBAR_TAB_HEIGHT.load_consume(),
-            ..*layout
-        }
-    }
-
-    unsafe extern "system" fn callback(
-        hwnd: HWND,
-        msg: u32,
-        w_param: WPARAM,
-        l_param: LPARAM,
-    ) -> LRESULT {
-        unsafe {
-            match msg {
-                WM_LBUTTONDOWN => {
-                    let stackbars_containers = STACKBARS_CONTAINERS.lock();
-                    if let Some(container) = stackbars_containers.get(&hwnd.0) {
-                        let x = l_param.0 as i32 & 0xFFFF;
-                        let y = (l_param.0 as i32 >> 16) & 0xFFFF;
-
-                        let width = STACKBAR_TAB_WIDTH.load_consume();
-                        let height = STACKBAR_TAB_HEIGHT.load_consume();
-                        let gap = DEFAULT_CONTAINER_PADDING.load_consume();
-
-                        let focused_window_idx = container.focused_window_idx();
-                        let focused_window_rect = WindowsApi::window_rect(
-                            container
-                                .focused_window()
-                                .cloned()
-                                .unwrap_or_default()
-                                .hwnd(),
-                        )
-                        .unwrap_or_default();
-
-                        for (index, window) in container.windows().iter().enumerate() {
-                            let left = gap + (index as i32 * (width + gap));
-                            let right = left + width;
-                            let top = 0;
-                            let bottom = height;
-
-                            if x >= left && x <= right && y >= top && y <= bottom {
-                                // If we are focusing a window that isn't currently focused in the
-                                // stackbar, make sure we update its location so that it doesn't render
-                                // on top of other tiles before eventually ending up in the correct
-                                // tile
-                                if index != focused_window_idx {
-                                    if let Err(err) =
-                                        window.set_position(&focused_window_rect, false)
-                                    {
-                                        tracing::error!(
-                                        "stackbar WM_LBUTTONDOWN repositioning error: hwnd {} ({})",
-                                        *window,
-                                        err
-                                    );
-                                    }
-                                }
-
-                                // Restore the window corresponding to the tab we have clicked
-                                window.restore();
-                                if let Err(err) = window.focus(false) {
-                                    tracing::error!(
-                                        "stackbar WMLBUTTONDOWN focus error: hwnd {} ({})",
-                                        *window,
-                                        err
-                                    );
-                                }
-                            } else {
-                                // Hide any windows in the stack that don't correspond to the window
-                                // we have clicked
-                                window.hide();
-                            }
-                        }
-                    }
-
-                    LRESULT(0)
-                }
-                WM_DESTROY => {
-                    PostQuitMessage(0);
-                    LRESULT(0)
-                }
-                _ => DefWindowProcW(hwnd, msg, w_param, l_param),
-            }
-        }
-    }
-}
-
-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,36 +1,15 @@
 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;
-use crate::core::BorderImplementation;
-use crate::core::StackbarLabel;
-use crate::core::StackbarMode;
 use crate::current_virtual_desktop;
 use crate::monitor::Monitor;
-use crate::monitor_reconciliator;
 use crate::ring::Ring;
-use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_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::CrossBoundaryBehaviour;
-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;
@@ -42,33 +21,38 @@ use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
+use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::STACKBAR_MODE;
+use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
+use crate::STACKBAR_TAB_HEIGHT;
+use crate::STACKBAR_TAB_WIDTH;
+use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WINDOWS_11;
 use crate::WORKSPACE_RULES;
+use komorebi_core::StackbarMode;
 
-use crate::core::config_generation::ApplicationConfiguration;
-use crate::core::config_generation::ApplicationConfigurationGenerator;
-use crate::core::config_generation::ApplicationOptions;
-use crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
-use crate::core::resolve_home_path;
-use crate::core::AnimationStyle;
-use crate::core::ApplicationIdentifier;
-use crate::core::BorderStyle;
-use crate::core::DefaultLayout;
-use crate::core::FocusFollowsMouseImplementation;
-use crate::core::HidingBehaviour;
-use crate::core::Layout;
-use crate::core::MoveBehaviour;
-use crate::core::OperationBehaviour;
-use crate::core::Rect;
-use crate::core::SocketMessage;
-use crate::core::WindowContainerBehaviour;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
+use komorebi_core::config_generation::ApplicationConfiguration;
+use komorebi_core::config_generation::ApplicationConfigurationGenerator;
+use komorebi_core::config_generation::ApplicationOptions;
+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::ActiveWindowBorderStyle;
+use komorebi_core::ApplicationIdentifier;
+use komorebi_core::DefaultLayout;
+use komorebi_core::FocusFollowsMouseImplementation;
+use komorebi_core::HidingBehaviour;
+use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
+use komorebi_core::OperationBehaviour;
+use komorebi_core::Rect;
+use komorebi_core::SocketMessage;
+use komorebi_core::WindowContainerBehaviour;
 use parking_lot::Mutex;
 use regex::Regex;
 use schemars::JsonSchema;
@@ -85,7 +69,7 @@ use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct BorderColours {
+pub struct ActiveWindowBorderColours {
     /// Border colour when the container contains a single window
     pub single: Option<Colour>,
     /// Border colour when the container contains multiple windows
@@ -96,7 +80,7 @@ pub struct BorderColours {
     pub unfocused: Option<Colour>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct WorkspaceConfig {
     /// Name
     pub name: String,
@@ -124,9 +108,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 {
@@ -209,24 +190,17 @@ 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()),
         }
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct MonitorConfig {
     /// Workspace configurations
     pub workspaces: Vec<WorkspaceConfig>,
     /// Monitor-specific work area offset (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub work_area_offset: Option<Rect>,
-    /// Window based work area offset (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_based_work_area_offset: Option<Rect>,
-    /// Open window limit after which the window based work area offset will no longer be applied (default: 1)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_based_work_area_offset_limit: Option<isize>,
 }
 
 impl From<&Monitor> for MonitorConfig {
@@ -239,24 +213,16 @@ impl From<&Monitor> for MonitorConfig {
         Self {
             workspaces,
             work_area_offset: value.work_area_offset(),
-            window_based_work_area_offset: value.window_based_work_area_offset(),
-            window_based_work_area_offset_limit: Some(value.window_based_work_area_offset_limit()),
         }
     }
 }
 
 #[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.25`
 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>,
@@ -266,9 +232,6 @@ pub struct StaticConfig {
     /// Determine what happens when a window is moved across a monitor boundary (default: Swap)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub cross_monitor_move_behaviour: Option<MoveBehaviour>,
-    /// Determine what happens when an action is called on a window at a monitor boundary (default: Monitor)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cross_boundary_behaviour: Option<CrossBoundaryBehaviour>,
     /// Determine what happens when commands are sent while an unmanaged window is in the foreground (default: Op)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub unmanaged_window_operation_behaviour: Option<OperationBehaviour>,
@@ -291,28 +254,16 @@ pub struct StaticConfig {
     pub border_offset: Option<i32>,
     /// Display an active window border (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border")]
-    pub border: Option<bool>,
+    pub active_window_border: Option<bool>,
     /// Active window border colours for different container types
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border_colours")]
-    pub border_colours: Option<BorderColours>,
+    pub active_window_border_colours: Option<ActiveWindowBorderColours>,
     /// Active window border style (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border_style")]
-    pub border_style: Option<BorderStyle>,
+    pub active_window_border_style: Option<ActiveWindowBorderStyle>,
     /// Active window border z-order (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub border_z_order: Option<ZOrder>,
-    /// Active window border implementation (default: Komorebi)
-    #[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>,
+    pub active_window_border_z_order: Option<ZOrder>,
     /// Global default workspace padding (default: 10)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub default_workspace_padding: Option<i32>,
@@ -322,7 +273,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)
@@ -355,75 +306,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 {
-    pub fn aliases(raw: &str) {
-        let mut map = HashMap::new();
-        map.insert("border", ["active_window_border"]);
-        map.insert("border_width", ["active_window_border_width"]);
-        map.insert("border_offset", ["active_window_border_offset"]);
-        map.insert("border_colours", ["active_window_border_colours"]);
-        map.insert("border_style", ["active_window_border_style"]);
-
-        let mut display = false;
-
-        for aliases in map.values() {
-            for a in aliases {
-                if raw.contains(a) {
-                    display = true;
-                }
-            }
-        }
-
-        if display {
-            println!("\nYour configuration file contains some options that have been renamed or deprecated:\n");
-            for (canonical, aliases) in map {
-                for alias in aliases {
-                    if raw.contains(alias) {
-                        println!(r#""{alias}" is now "{canonical}""#);
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn deprecated(raw: &str) {
-        let deprecated_options = ["invisible_borders"];
-        let deprecated_variants = vec![
-            ("Hide", "window_hiding_behaviour", "Cloak"),
-            ("Minimize", "window_hiding_behaviour", "Cloak"),
-        ];
-
-        for option in deprecated_options {
-            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}""#
-                );
-            }
-        }
-    }
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -436,18 +318,12 @@ 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
     pub height: Option<i32>,
-    /// Stackbar height
-    pub label: Option<StackbarLabel>,
     /// Stackbar mode
     pub mode: Option<StackbarMode>,
     /// Stackbar tab configuration options
@@ -463,8 +339,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() {
@@ -481,12 +355,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 {
@@ -498,54 +366,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();
                     }
                 }
             }
@@ -554,7 +386,7 @@ impl From<&WindowManager> for StaticConfig {
         let border_colours = if border_manager::FOCUSED.load(Ordering::SeqCst) == 0 {
             None
         } else {
-            Option::from(BorderColours {
+            Option::from(ActiveWindowBorderColours {
                 single: Option::from(Colour::from(border_manager::FOCUSED.load(Ordering::SeqCst))),
                 stack: Option::from(Colour::from(border_manager::STACK.load(Ordering::SeqCst))),
                 monocle: Option::from(Colour::from(border_manager::MONOCLE.load(Ordering::SeqCst))),
@@ -569,28 +401,20 @@ impl From<&WindowManager> for StaticConfig {
             resize_delta: Option::from(value.resize_delta),
             window_container_behaviour: Option::from(value.window_container_behaviour),
             cross_monitor_move_behaviour: Option::from(value.cross_monitor_move_behaviour),
-            cross_boundary_behaviour: Option::from(value.cross_boundary_behaviour),
             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,
             border_width: Option::from(border_manager::BORDER_WIDTH.load(Ordering::SeqCst)),
             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),
+            active_window_border: Option::from(
+                border_manager::BORDER_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()),
+            active_window_border_colours: border_colours,
+            active_window_border_style: Option::from(*STYLE.lock()),
+            active_window_border_z_order: Option::from(*Z_ORDER.lock()),
             default_workspace_padding: Option::from(
                 DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
             ),
@@ -609,7 +433,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,
         }
     }
 }
@@ -619,12 +442,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 {
@@ -632,22 +455,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);
         }
@@ -659,11 +466,11 @@ impl StaticConfig {
         border_manager::BORDER_WIDTH.store(self.border_width.unwrap_or(8), Ordering::SeqCst);
         border_manager::BORDER_OFFSET.store(self.border_offset.unwrap_or(-1), Ordering::SeqCst);
 
-        if let Some(enabled) = &self.border {
+        if let Some(enabled) = &self.active_window_border {
             border_manager::BORDER_ENABLED.store(*enabled, Ordering::SeqCst);
         }
 
-        if let Some(colours) = &self.border_colours {
+        if let Some(colours) = &self.active_window_border_colours {
             if let Some(single) = colours.single {
                 border_manager::FOCUSED.store(u32::from(single), Ordering::SeqCst);
             }
@@ -681,35 +488,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 active_window_border_style = self.active_window_border_style.unwrap_or_default();
+        *STYLE.lock() = active_window_border_style;
 
         let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
         let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
@@ -751,15 +531,11 @@ impl StaticConfig {
                 STACKBAR_TAB_HEIGHT.store(*height, Ordering::SeqCst);
             }
 
-            if let Some(label) = &stackbar.label {
-                STACKBAR_LABEL.store(*label);
-            }
-
             if let Some(mode) = &stackbar.mode {
-                STACKBAR_MODE.store(*mode);
+                let mut stackbar_mode = STACKBAR_MODE.lock();
+                *stackbar_mode = *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);
@@ -776,9 +552,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();
             }
         }
 
@@ -860,6 +633,7 @@ impl StaticConfig {
 
         let mut wm = WindowManager {
             monitors: Ring::default(),
+            monitor_cache: HashMap::new(),
             incoming_events: incoming,
             command_listener: listener,
             is_paused: false,
@@ -871,9 +645,6 @@ impl StaticConfig {
             cross_monitor_move_behaviour: value
                 .cross_monitor_move_behaviour
                 .unwrap_or(MoveBehaviour::Swap),
-            cross_boundary_behaviour: value
-                .cross_boundary_behaviour
-                .unwrap_or(CrossBoundaryBehaviour::Monitor),
             unmanaged_window_operation_behaviour: value
                 .unmanaged_window_operation_behaviour
                 .unwrap_or(OperationBehaviour::Op),
@@ -920,20 +691,9 @@ impl StaticConfig {
 
         if let Some(monitors) = value.monitors {
             for (i, monitor) in monitors.iter().enumerate() {
-                {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                    if let Some(device_id) = display_index_preferences.get(&i) {
-                        monitor_reconciliator::insert_in_monitor_cache(device_id, monitor.clone());
-                    }
-                }
-
                 if let Some(m) = wm.monitors_mut().get_mut(i) {
                     m.ensure_workspace_count(monitor.workspaces.len());
                     m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );
 
                     for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
                         ws.load_static_config(
@@ -961,7 +721,7 @@ impl StaticConfig {
             }
         }
 
-        if value.border == Some(true) {
+        if value.active_window_border == Some(true) {
             border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
         }
 
@@ -974,15 +734,21 @@ impl StaticConfig {
 
         value.apply_globals()?;
 
+        let stackbar_mode = *STACKBAR_MODE.lock();
+
+        for m in wm.monitors_mut() {
+            for w in m.workspaces_mut() {
+                for c in w.containers_mut() {
+                    c.set_stackbar_mode(stackbar_mode);
+                }
+            }
+        }
+
         if let Some(monitors) = value.monitors {
             for (i, monitor) in monitors.iter().enumerate() {
                 if let Some(m) = wm.monitors_mut().get_mut(i) {
                     m.ensure_workspace_count(monitor.workspaces.len());
                     m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );
 
                     for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
                         ws.load_static_config(
@@ -1010,7 +776,7 @@ impl StaticConfig {
             }
         }
 
-        if let Some(enabled) = value.border {
+        if let Some(enabled) = value.active_window_border {
             border_manager::BORDER_ENABLED.store(enabled, Ordering::SeqCst);
         }
 

komorebi/src/transparency_manager.rs

@@ -1,188 +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 monitor_idx == focused_monitor_idx {
-                            if let Err(error) = window.opaque() {
-                                let hwnd = window.hwnd;
-                                tracing::error!(
-                                    "failed to make monocle window {hwnd} opaque: {error}"
-                                )
-                            }
-                        } else if let Err(error) = window.transparent() {
-                            let hwnd = window.hwnd;
-                            tracing::error!(
-                                "failed to make monocle window {hwnd} transparent: {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,25 +1,17 @@
-use crate::border_manager;
 use crate::com::SetCloak;
-use crate::focus_manager;
-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 crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
 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;
 use regex::Regex;
 use schemars::JsonSchema;
 use serde::ser::SerializeStruct;
@@ -28,14 +20,12 @@ use serde::Serialize;
 use serde::Serializer;
 use windows::Win32::Foundation::HWND;
 
-use crate::core::ApplicationIdentifier;
-use crate::core::HidingBehaviour;
-use crate::core::Rect;
+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;
@@ -48,32 +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, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
     pub hwnd: isize,
-    #[serde(skip)]
-    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)]
@@ -156,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;
 
@@ -171,64 +138,9 @@ impl Window {
         )
     }
 
-    pub fn animate_position(&self, start_rect: &Rect, target_rect: &Rect, top: bool) -> Result<()> {
-        let hwnd = self.hwnd();
-        let start_rect = *start_rect;
-        let target_rect = *target_rect;
-        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(&start_rect, &target_rect, progress);
-
-                if progress == 1.0 {
-                    WindowsApi::position_window(hwnd, &new_rect, top)?;
-                    if WindowsApi::foreground_window().unwrap_or_default() == hwnd.0 {
-                        focus_manager::send_notification(hwnd.0)
-                    }
-
-                    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::invalidate_rect(hwnd, None, false);
-                }
-
-                Ok(())
-            })
-        });
-
-        Ok(())
-    }
-
     pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
-        let window_rect = WindowsApi::window_rect(self.hwnd())?;
-
-        if window_rect.eq(layout) {
-            return Ok(());
-        }
-
-        if ANIMATION_ENABLED.load(Ordering::SeqCst) {
-            self.animate_position(&window_rect, 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 {
@@ -311,11 +223,6 @@ impl Window {
         // If the target window is already focused, do nothing.
         if let Ok(ihwnd) = WindowsApi::foreground_window() {
             if HWND(ihwnd) == self.hwnd() {
-                // Center cursor in Window
-                if mouse_follows_focus {
-                    WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd())?)?;
-                }
-
                 return Ok(());
             }
         }
@@ -334,10 +241,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<()> {
@@ -346,14 +250,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())?)
@@ -365,12 +261,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> {
@@ -393,11 +289,6 @@ impl Window {
         exe
     }
 
-    pub fn process_id(self) -> u32 {
-        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd());
-        process_id
-    }
-
     pub fn class(self) -> Result<String> {
         WindowsApi::real_window_class_w(self.hwnd())
     }
@@ -436,20 +327,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);
         }
@@ -489,7 +366,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);
                     }
@@ -506,12 +383,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>,
@@ -528,7 +402,6 @@ pub struct RuleDebug {
 
 #[allow(clippy::too_many_arguments)]
 fn window_is_eligible(
-    hwnd: isize,
     title: &String,
     exe_name: &String,
     class: &String,
@@ -583,7 +456,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,
@@ -597,14 +470,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();