wip

.github/workflows/feature-check.yaml

@@ -12,7 +12,7 @@ jobs:
 
     steps:
       - name: Check and close feature issues
-        uses: actions/github-script@v8
+        uses: actions/github-script@v7
         with:
           script: |
             const issue = context.payload.issue;

.github/workflows/windows.yaml

@@ -21,7 +21,7 @@ jobs:
   cargo-deny:
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - uses: EmbarkStudios/cargo-deny-action@v2
@@ -43,11 +43,10 @@ jobs:
       RUSTFLAGS: -Ctarget-feature=+crt-static -Dwarnings
       GH_TOKEN: ${{ github.token }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - run: rustup toolchain install stable --profile minimal
-      - run: rustup component add --toolchain stable-x86_64-pc-windows-msvc clippy
       - run: rustup toolchain install nightly --allow-downgrade -c rustfmt
       - uses: Swatinem/rust-cache@v2
         with:
@@ -82,12 +81,12 @@ jobs:
     env:
       GH_TOKEN: ${{ github.token }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - shell: bash
         run: echo "VERSION=nightly" >> $GITHUB_ENV
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
       - run: |
           Compress-Archive -Force ./komorebi-x86_64-pc-windows-msvc-${{ github.sha }}/x86_64-pc-windows-msvc/release/*.exe komorebi-$Env:VERSION-x86_64-pc-windows-msvc.zip
           Copy-Item ./komorebi-x86_64-pc-windows-msvc-${{ github.sha }}/wix/*x86_64.msi -Destination ./komorebi-$Env:VERSION-x86_64.msi
@@ -129,14 +128,14 @@ jobs:
     env:
       GH_TOKEN: ${{ github.token }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - shell: bash
         run: |
           TAG=${{ github.event.release.tag_name }}
           echo "VERSION=${TAG#v}" >> $GITHUB_ENV
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
       - run: |
           Compress-Archive -Force ./komorebi-x86_64-pc-windows-msvc-${{ github.sha }}/x86_64-pc-windows-msvc/release/*.exe komorebi-$Env:VERSION-x86_64-pc-windows-msvc.zip
           Copy-Item ./komorebi-x86_64-pc-windows-msvc-${{ github.sha }}/wix/*x86_64.msi -Destination ./komorebi-$Env:VERSION-x86_64.msi
@@ -171,14 +170,14 @@ jobs:
     env:
       GH_TOKEN: ${{ github.token }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - shell: bash
         run: |
           TAG=${{ github.ref_name }}
           echo "VERSION=${TAG#v}" >> $GITHUB_ENV
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
       - run: |
           Compress-Archive -Force ./komorebi-x86_64-pc-windows-msvc-${{ github.sha }}/x86_64-pc-windows-msvc/release/*.exe komorebi-$Env:VERSION-x86_64-pc-windows-msvc.zip
           Copy-Item ./komorebi-x86_64-pc-windows-msvc-${{ github.sha }}/wix/*x86_64.msi -Destination ./komorebi-$Env:VERSION-x86_64.msi

Cargo.toml

@@ -9,7 +9,7 @@ members = [
     "komorebic-no-console",
     "komorebi-bar",
     "komorebi-themes",
-    "komorebi-shortcuts",
+    "komorebi-shortcuts"
 ]
 
 [workspace.dependencies]
@@ -19,8 +19,8 @@ chrono = "0.4"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 color-eyre = "0.6"
-eframe = "0.32"
-egui_extras = "0.32"
+eframe = "0.31"
+egui_extras = "0.31"
 dirs = "6"
 dunce = "1"
 hotwatch = "0.5"
@@ -33,20 +33,19 @@ strum = { version = "0.27", features = ["derive"] }
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-parking_lot = "0.12"
 paste = "1"
-sysinfo = "0.37"
+sysinfo = "0.34"
 uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "8c42d8db257d30fe95bc98c2e5cd8f75da861021" }
-windows-numerics = { version = "0.3" }
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "a28c6559a9de2f92c142a714947a9b081776caca" }
+windows-numerics = { version = "0.2" }
 windows-implement = { version = "0.60" }
 windows-interface = { version = "0.59" }
-windows-core = { version = "0.62" }
+windows-core = { version = "0.61" }
 shadow-rs = "1"
-which = "8"
+which = "7"
 
 [workspace.dependencies.windows]
-version = "0.62"
+version = "0.61"
 features = [
     "Foundation_Numerics",
     "Win32_Devices",
@@ -73,12 +72,5 @@ features = [
     "Win32_System_SystemServices",
     "Win32_System_WindowsProgramming",
     "Media",
-    "Media_Control",
+    "Media_Control"
 ]
-
-[profile.release-opt]
-inherits = "release"
-lto = true
-panic = "abort"
-codegen-units = 1
-strip = true

README.md

@@ -394,7 +394,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.38"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.36"}
 
 use anyhow::Result;
 use komorebi_client::Notification;

deny.toml

@@ -14,8 +14,7 @@ feature-depth = 1
 ignore = [
     { id = "RUSTSEC-2020-0016", reason = "local tcp connectivity is an opt-in feature, and there is no upgrade path for TcpStreamExt" },
     { id = "RUSTSEC-2024-0436", reason = "paste being unmaintained is not an issue in our use" },
-    { id = "RUSTSEC-2024-0320", reason = "not using any yaml features from this library" },
-    { id = "RUSTSEC-2025-0056", reason = "only used for colour palette generation" }
+    { id = "RUSTSEC-2024-0320", reason = "not using any yaml features from this library" }
 ]
 
 [licenses]
@@ -107,10 +106,10 @@ unknown-git = "deny"
 allow-registry = ["https://github.com/rust-lang/crates.io-index"]
 allow-git = [
     "https://github.com/LGUG2Z/base16-egui-themes",
+    "https://github.com/LGUG2Z/catppuccin-egui",
     "https://github.com/LGUG2Z/windows-icons",
     "https://github.com/LGUG2Z/win32-display-data",
     "https://github.com/LGUG2Z/flavours",
     "https://github.com/LGUG2Z/base16_color_scheme",
     "https://github.com/LGUG2Z/whkd",
-    #    "https://github.com/LGUG2Z/catppuccin-egui",
 ]

docs/cli/change-layout.md

@@ -7,7 +7,7 @@ Usage: komorebic.exe change-layout <DEFAULT_LAYOUT>
 
 Arguments:
   <DEFAULT_LAYOUT>
-          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack, scrolling]
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
 
 Options:
   -h, --help

docs/cli/named-workspace-layout-rule.md

@@ -13,7 +13,7 @@ Arguments:
           The number of window containers on-screen required to trigger this layout rule
 
   <LAYOUT>
-          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack, scrolling]
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
 
 Options:
   -h, --help

docs/cli/named-workspace-layout.md

@@ -10,7 +10,7 @@ Arguments:
           Target workspace name
 
   <VALUE>
-          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack, scrolling]
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
 
 Options:
   -h, --help

docs/cli/query.md

@@ -7,7 +7,7 @@ Usage: komorebic.exe query <STATE_QUERY>
 
 Arguments:
   <STATE_QUERY>
-          [possible values: focused-monitor-index, focused-workspace-index, focused-container-index, focused-window-index, focused-workspace-name, focused-workspace-layout, focused-container-kind, version]
+          [possible values: focused-monitor-index, focused-workspace-index, focused-container-index, focused-window-index, focused-workspace-name, focused-workspace-layout, version]
 
 Options:
   -h, --help

docs/cli/scrolling-layout-columns.md

@@ -1,16 +0,0 @@
-# scrolling-layout-columns
-
-```
-Set the number of visible columns for the Scrolling layout on the focused workspace
-
-Usage: komorebic.exe scrolling-layout-columns <COUNT>
-
-Arguments:
-  <COUNT>
-          Desired number of visible columns
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/toggle-pause.md

@@ -1,7 +1,7 @@
 # toggle-pause
 
 ```
-Toggle the paused state for all window tiling
+Toggle window tiling on the focused workspace
 
 Usage: komorebic.exe toggle-pause
 

docs/cli/toggle-shortcuts.md

@@ -1,12 +0,0 @@
-# toggle-shortcuts
-
-```
-Toggle the komorebi-shortcuts helper
-
-Usage: komorebic.exe toggle-shortcuts
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/window-hiding-behaviour.md

@@ -8,7 +8,7 @@ Usage: komorebic.exe window-hiding-behaviour <HIDING_BEHAVIOUR>
 Arguments:
   <HIDING_BEHAVIOUR>
           Possible values:
-          - hide:     END OF LIFE FEATURE: Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)
+          - 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
 

docs/cli/workspace-layout-rule.md

@@ -16,7 +16,7 @@ Arguments:
           The number of window containers on-screen required to trigger this layout rule
 
   <LAYOUT>
-          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack, scrolling]
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
 
 Options:
   -h, --help

docs/cli/workspace-layout.md

@@ -13,7 +13,7 @@ Arguments:
           Workspace index on the specified monitor (zero-indexed)
 
   <VALUE>
-          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack, scrolling]
+          [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack, grid, right-main-vertical-stack]
 
 Options:
   -h, --help

docs/cli/workspace-work-area-offset.md

@@ -1,31 +0,0 @@
-# workspace-work-area-offset
-
-```
-Set offsets for a workspace to exclude parts of the work area from tiling
-
-Usage: komorebic.exe workspace-work-area-offset <MONITOR> <WORKSPACE> <LEFT> <TOP> <RIGHT> <BOTTOM>
-
-Arguments:
-  <MONITOR>
-          Monitor index (zero-indexed)
-
-  <WORKSPACE>
-          Workspace index (zero-indexed)
-
-  <LEFT>
-          Size of the left work area offset (set right to left * 2 to maintain right padding)
-
-  <TOP>
-          Size of the top work area offset (set bottom to the same value to maintain bottom padding)
-
-  <RIGHT>
-          Size of the right work area offset
-
-  <BOTTOM>
-          Size of the bottom work area offset
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/common-workflows/animations.md

@@ -6,10 +6,7 @@ defined in the `komorebi.json` configuration file.
 ```json
 {
   "animation": {
-    "enabled": true,
-    "duration": 250,
-    "fps": 60,
-    "style": "EaseOutSine"
+    "enabled": true
   }
 }
 ```

docs/common-workflows/multi-monitor-setup.md

@@ -301,7 +301,7 @@ how to map the indices and would use default behaviour which would result in a m
 }
 ```
 
-# Multiple monitors on different machines
+# Multiple Monitors on different machines
 
 You can use the same `komorebi.json` to configure two different setups and then synchronize your config across machines.
 However, if you do this it is important to be aware of a few things.
@@ -393,13 +393,6 @@ This is because komorebi will apply the appropriate config to the loaded monitor
 index (the index defined in the user config) to the actual monitor index, and the bar will use that map to know if it
 should be enabled, and where it should be drawn.
 
-# Windows Display Settings
-
-In `Settings > System > Display > Multiple Displays`:
-
-- Disable "Remember windows locations on monitor connection"
-- Enable "Minimize windows when a monitor is disconnected"
-
 ### Things to keep in mind
 
 * If you are using a laptop connected to one monitor at work and a different one at home, the work monitor and the home

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

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

docs/example-configurations.md

@@ -186,9 +186,6 @@ limitations on hotkey bindings that include the `win` key. However, you will sti
 to [modify the registry](https://superuser.com/questions/1059511/how-to-disable-winl-in-windows-10) to prevent
 `win + l` from locking the operating system.
 
-You can toggle an overlay of the current `whkdrc` shortcuts related to `komorebi` at any time when using the example
-configuration with `alt + i`.
-
 ```
 {% include "./whkdrc.sample" %}
 ```

docs/installation.md

@@ -120,7 +120,6 @@ cargo +stable install --path komorebic --locked
 cargo +stable install --path komorebic-no-console --locked
 cargo +stable install --path komorebi-gui --locked
 cargo +stable install --path komorebi-bar --locked
-cargo +stable install --path komorebi-shortcuts --locked
 ```
 
 If the binaries have been built and added to your `$PATH` correctly, you should

docs/komorebi.bar.example.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.39/schema.bar.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.36/schema.bar.json",
   "monitor": 0,
   "font_family": "JetBrains Mono",
   "theme": {

docs/komorebi.example.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.39/schema.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.36/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.json",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",

docs/troubleshooting.md

@@ -138,14 +138,13 @@ running `komorebic stop` and `komorebic start`.
 Users with Nvidia GPUs may have issues with transparency on the Komorebi Bar.
 
 To solve this the user can do the following:
-
-- Open the Nvidia Control Panel
-- On the left menu tree, under "3D Settings", select "Manage 3D Settings"
-- Select the "Program Settings" tab
-- Press the "Add" button and select "komorebi-bar"
-- Under "3. Specify the settings for this program:", find the feature labelled, "OpenGL GDI compatibility"
-- Change the setting to "Prefer compatibility"
-- At the bottom of the window select "Apply"
-- Restart the Komorebi Bar with "komorebic stop --bar; komorebic start --bar"
+1. Open the Nvidia Control Panel
+2. On the left menu tree, under "3D Settings", select "Manage 3D Settings"
+3. Select the "Program Settings" tab
+4. Press the "Add" button and select "komorebi-bar"
+5. Under "3. Specify the settings for this program:", find the feature labelled, "OpenGL GDI compatibility"
+6. Change the setting to "Prefer compatibility"
+7. At the bottom of the window select "Apply"
+8. Restart the Komorebi Bar with "komorebic stop --bar; komorebic start --bar"
 
 This should resolve the issue and your Komorebi Bar should render with the proper transparency.

justfile

@@ -28,7 +28,7 @@ install-target-with-jsonschema target:
     cargo +stable install --path {{ target }} --locked
 
 install:
-    just install-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui komorebi-shortcuts
+    just install-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
 install-with-jsonschema:
     just install-targets-with-jsonschema komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui komorebi-shortcuts
@@ -52,7 +52,7 @@ wpm target:
     just build-target {{ target }} && wpmctl stop {{ target }}; just copy-target {{ target }} && wpmctl start {{ target }}
 
 copy:
-    just copy-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui komorebi-shortcuts
+    just copy-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
 run target:
     cargo +stable run --bin {{ target }} --locked --no-default-features

komorebi-bar/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.37"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-komorebi-client = { path = "../komorebi-client", default-features = false }
-komorebi-themes = { path = "../komorebi-themes", default-features = false }
+komorebi-client = { path = "../komorebi-client" }
+komorebi-themes = { path = "../komorebi-themes" }
 
 chrono-tz = { workspace = true }
 chrono = { workspace = true }
@@ -17,16 +17,15 @@ crossbeam-channel = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 eframe = { workspace = true }
-egui-phosphor = "0.10"
+egui-phosphor = "0.9"
 font-loader = "0.11"
 hotwatch = { workspace = true }
 image = "0.25"
 lazy_static = { workspace = true }
-netdev = "0.36"
+netdev = "0.34"
 num = "0.4"
 num-derive = "0.4"
 num-traits = "0.2"
-parking_lot = { workspace = true }
 random_word = { version = "0.5", features = ["en"] }
 reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true, optional = true }
@@ -44,4 +43,4 @@ windows-icons-fallback = { package = "windows-icons", git = "https://github.com/
 
 [features]
 default = ["schemars"]
-schemars = ["dep:schemars", "komorebi-client/default", "komorebi-themes/default"]
+schemars = ["dep:schemars", "komorebi-client/schemars", "komorebi-themes/schemars"]

komorebi-bar/src/bar.rs

@@ -1,28 +1,27 @@
-use crate::AUTO_SELECT_FILL_COLOUR;
-use crate::AUTO_SELECT_TEXT_COLOUR;
-use crate::BAR_HEIGHT;
-use crate::DEFAULT_PADDING;
-use crate::KomorebiEvent;
-use crate::MAX_LABEL_WIDTH;
-use crate::MONITOR_LEFT;
-use crate::MONITOR_RIGHT;
-use crate::MONITOR_TOP;
+use crate::config::get_individual_spacing;
 use crate::config::KomobarConfig;
 use crate::config::KomobarTheme;
 use crate::config::MonitorConfigOrIndex;
 use crate::config::Position;
 use crate::config::PositionConfig;
-use crate::config::get_individual_spacing;
 use crate::process_hwnd;
 use crate::render::Color32Ext;
 use crate::render::Grouping;
 use crate::render::RenderConfig;
 use crate::render::RenderExt;
 use crate::widgets::komorebi::Komorebi;
-use crate::widgets::komorebi::MonitorInfo;
+use crate::widgets::komorebi::KomorebiNotificationState;
 use crate::widgets::widget::BarWidget;
 use crate::widgets::widget::WidgetConfig;
-use color_eyre::eyre;
+use crate::KomorebiEvent;
+use crate::AUTO_SELECT_FILL_COLOUR;
+use crate::AUTO_SELECT_TEXT_COLOUR;
+use crate::BAR_HEIGHT;
+use crate::DEFAULT_PADDING;
+use crate::MAX_LABEL_WIDTH;
+use crate::MONITOR_LEFT;
+use crate::MONITOR_RIGHT;
+use crate::MONITOR_TOP;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::TryRecvError;
 use eframe::egui::Align;
@@ -39,7 +38,6 @@ use eframe::egui::Frame;
 use eframe::egui::Id;
 use eframe::egui::Layout;
 use eframe::egui::Margin;
-use eframe::egui::PointerButton;
 use eframe::egui::Rgba;
 use eframe::egui::Style;
 use eframe::egui::TextStyle;
@@ -48,98 +46,23 @@ use eframe::egui::Visuals;
 use font_loader::system_fonts;
 use font_loader::system_fonts::FontPropertyBuilder;
 use komorebi_client::Colour;
+use komorebi_client::KomorebiTheme;
 use komorebi_client::MonitorNotification;
 use komorebi_client::NotificationEvent;
 use komorebi_client::PathExt;
 use komorebi_client::SocketMessage;
 use komorebi_client::VirtualDesktopNotification;
+use komorebi_themes::catppuccin_egui;
+use komorebi_themes::Base16Value;
 use komorebi_themes::Base16Wrapper;
 use komorebi_themes::Catppuccin;
-use komorebi_themes::catppuccin_egui;
-use lazy_static::lazy_static;
-use parking_lot::Mutex;
+use komorebi_themes::CatppuccinValue;
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::io::Error;
-use std::io::ErrorKind;
-use std::io::Write;
-use std::os::windows::process::CommandExt;
 use std::path::PathBuf;
-use std::process::ChildStdin;
-use std::process::Command;
-use std::process::Stdio;
 use std::rc::Rc;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
-
-const CREATE_NO_WINDOW: u32 = 0x0800_0000;
-
-lazy_static! {
-    static ref SESSION_STDIN: Mutex<Option<ChildStdin>> = Mutex::new(None);
-}
-
-fn start_powershell() -> eyre::Result<()> {
-    // found running session, do nothing
-    if SESSION_STDIN.lock().as_mut().is_some() {
-        tracing::debug!("PowerShell session already started");
-        return Ok(());
-    }
-
-    tracing::debug!("Starting PowerShell session");
-
-    let mut child = Command::new("powershell.exe")
-        .args(["-NoLogo", "-NoProfile", "-Command", "-"])
-        .stdin(Stdio::piped())
-        .creation_flags(CREATE_NO_WINDOW)
-        .spawn()?;
-
-    let stdin = child.stdin.take().expect("stdin piped");
-
-    // Store stdin for later commands
-    let mut session_stdin = SESSION_STDIN.lock();
-    *session_stdin = Option::from(stdin);
-
-    Ok(())
-}
-
-fn stop_powershell() -> eyre::Result<()> {
-    tracing::debug!("Stopping PowerShell session");
-
-    if let Some(mut session_stdin) = SESSION_STDIN.lock().take() {
-        if let Err(e) = session_stdin.write_all(b"exit\n") {
-            tracing::error!(error = %e, "failed to write exit command to PowerShell stdin");
-            return Err(e.into());
-        }
-        if let Err(e) = session_stdin.flush() {
-            tracing::error!(error = %e, "failed to flush PowerShell stdin");
-            return Err(e.into());
-        }
-
-        tracing::debug!("PowerShell session stopped");
-    } else {
-        tracing::debug!("PowerShell session already stopped");
-    }
-
-    Ok(())
-}
-
-pub fn exec_powershell(cmd: &str) -> eyre::Result<()> {
-    if let Some(session_stdin) = SESSION_STDIN.lock().as_mut() {
-        if let Err(e) = writeln!(session_stdin, "{cmd}") {
-            tracing::error!(error = %e, cmd = cmd, "failed to write command to PowerShell stdin");
-            return Err(e.into());
-        }
-
-        if let Err(e) = session_stdin.flush() {
-            tracing::error!(error = %e, "failed to flush PowerShell stdin");
-            return Err(e.into());
-        }
-
-        return Ok(());
-    }
-
-    Err(Error::new(ErrorKind::NotFound, "PowerShell session not started").into())
-}
+use std::sync::Arc;
 
 pub struct Komobar {
     pub hwnd: Option<isize>,
@@ -147,7 +70,7 @@ pub struct Komobar {
     pub disabled: bool,
     pub config: KomobarConfig,
     pub render_config: Rc<RefCell<RenderConfig>>,
-    pub monitor_info: Option<Rc<RefCell<MonitorInfo>>>,
+    pub komorebi_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     pub left_widgets: Vec<Box<dyn BarWidget>>,
     pub center_widgets: Vec<Box<dyn BarWidget>>,
     pub right_widgets: Vec<Box<dyn BarWidget>>,
@@ -159,18 +82,6 @@ pub struct Komobar {
     pub size_rect: komorebi_client::Rect,
     pub work_area_offset: komorebi_client::Rect,
     applied_theme_on_first_frame: bool,
-    mouse_follows_focus: bool,
-    input_config: InputConfig,
-}
-
-struct InputConfig {
-    accumulated_scroll_delta: Vec2,
-    act_on_vertical_scroll: bool,
-    act_on_horizontal_scroll: bool,
-    vertical_scroll_threshold: f32,
-    horizontal_scroll_threshold: f32,
-    vertical_scroll_max_threshold: f32,
-    horizontal_scroll_max_threshold: f32,
 }
 
 pub fn apply_theme(
@@ -319,15 +230,16 @@ pub fn apply_theme(
     // apply rounding to the widgets
     if let Some(Grouping::Bar(config) | Grouping::Alignment(config) | Grouping::Widget(config)) =
         &grouping
-        && let Some(rounding) = config.rounding
     {
-        ctx.style_mut(|style| {
-            style.visuals.widgets.noninteractive.corner_radius = rounding.into();
-            style.visuals.widgets.inactive.corner_radius = rounding.into();
-            style.visuals.widgets.hovered.corner_radius = rounding.into();
-            style.visuals.widgets.active.corner_radius = rounding.into();
-            style.visuals.widgets.open.corner_radius = rounding.into();
-        });
+        if let Some(rounding) = config.rounding {
+            ctx.style_mut(|style| {
+                style.visuals.widgets.noninteractive.corner_radius = rounding.into();
+                style.visuals.widgets.inactive.corner_radius = rounding.into();
+                style.visuals.widgets.hovered.corner_radius = rounding.into();
+                style.visuals.widgets.active.corner_radius = rounding.into();
+                style.visuals.widgets.open.corner_radius = rounding.into();
+            });
+        }
     }
 
     // Update RenderConfig's background_color so that widgets will have the new color
@@ -338,7 +250,7 @@ impl Komobar {
     pub fn apply_config(
         &mut self,
         ctx: &Context,
-        previous_monitor_info: Option<Rc<RefCell<MonitorInfo>>>,
+        previous_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     ) {
         MAX_LABEL_WIDTH.store(
             self.config.max_label_width.unwrap_or(400.0) as i32,
@@ -367,7 +279,7 @@ impl Komobar {
             self.config.icon_scale,
         ));
 
-        let mut monitor_info = previous_monitor_info;
+        let mut komorebi_notification_state = previous_notification_state;
         let mut komorebi_widgets = Vec::new();
 
         for (idx, widget_config) in self.config.left_widgets.iter().enumerate() {
@@ -419,18 +331,19 @@ impl Komobar {
             komorebi_widgets
                 .into_iter()
                 .for_each(|(mut widget, idx, side)| {
-                    match monitor_info {
+                    match komorebi_notification_state {
                         None => {
-                            monitor_info = Some(widget.monitor_info.clone());
+                            komorebi_notification_state =
+                                Some(widget.komorebi_notification_state.clone());
                         }
                         Some(ref previous) => {
-                            if widget.workspaces.is_some() {
-                                previous
-                                    .borrow_mut()
-                                    .update_from_self(&widget.monitor_info.borrow());
+                            if widget.workspaces.is_some_and(|w| w.enable) {
+                                previous.borrow_mut().update_from_config(
+                                    &widget.komorebi_notification_state.borrow(),
+                                );
                             }
 
-                            widget.monitor_info = previous.clone();
+                            widget.komorebi_notification_state = previous.clone();
                         }
                     }
 
@@ -455,19 +368,15 @@ impl Komobar {
             }
             MonitorConfigOrIndex::Index(idx) => (*idx, None),
         };
-
-        let mapped_info = self.monitor_info.as_ref().map(|info| {
-            let monitor = info.borrow();
-            (
-                monitor.monitor_usr_idx_map.get(&usr_monitor_index).copied(),
-                monitor.mouse_follows_focus,
-            )
+        let monitor_index = self.komorebi_notification_state.as_ref().and_then(|state| {
+            state
+                .borrow()
+                .monitor_usr_idx_map
+                .get(&usr_monitor_index)
+                .copied()
         });
 
-        if let Some(info) = mapped_info {
-            self.monitor_index = info.0;
-            self.mouse_follows_focus = info.1;
-        }
+        self.monitor_index = monitor_index;
 
         if let Some(monitor_index) = self.monitor_index {
             if let (prev_rect, Some(new_rect)) = (&self.work_area_offset, &config_work_area_offset)
@@ -518,51 +427,17 @@ impl Komobar {
                     }
                 }
             }
-        } else if self.monitor_info.is_some() && !self.disabled {
-            tracing::warn!(
-                "couldn't find the monitor index of this bar! Disabling the bar until the monitor connects..."
-            );
+        } else if self.komorebi_notification_state.is_some() && !self.disabled {
+            tracing::warn!("couldn't find the monitor index of this bar! Disabling the bar until the monitor connects...");
             self.disabled = true;
         } else {
-            tracing::warn!(
-                "couldn't find the monitor index of this bar, if the bar is starting up this is normal until it receives the first state from komorebi."
-            );
+            tracing::warn!("couldn't find the monitor index of this bar, if the bar is starting up this is normal until it receives the first state from komorebi.");
             self.disabled = true;
         }
 
-        if let Some(mouse) = &self.config.mouse {
-            self.input_config.act_on_vertical_scroll =
-                mouse.on_scroll_up.is_some() || mouse.on_scroll_down.is_some();
-            self.input_config.act_on_horizontal_scroll =
-                mouse.on_scroll_left.is_some() || mouse.on_scroll_right.is_some();
-            self.input_config.vertical_scroll_threshold = mouse
-                .vertical_scroll_threshold
-                .unwrap_or(30.0)
-                .clamp(10.0, 300.0);
-            self.input_config.horizontal_scroll_threshold = mouse
-                .horizontal_scroll_threshold
-                .unwrap_or(30.0)
-                .clamp(10.0, 300.0);
-            // limit how many "ticks" can be accumulated
-            self.input_config.vertical_scroll_max_threshold =
-                self.input_config.vertical_scroll_threshold * 3.0;
-            self.input_config.horizontal_scroll_max_threshold =
-                self.input_config.horizontal_scroll_threshold * 3.0;
-
-            if mouse.has_command() {
-                start_powershell().unwrap_or_else(|_| {
-                    tracing::error!("failed to start powershell session");
-                });
-            } else {
-                stop_powershell().unwrap_or_else(|_| {
-                    tracing::error!("failed to stop powershell session");
-                });
-            }
-        }
-
         tracing::info!("widget configuration options applied");
 
-        self.monitor_info = monitor_info;
+        self.komorebi_notification_state = komorebi_notification_state;
     }
 
     /// Updates the `size_rect` field. Returns a bool indicating if the field was changed or not
@@ -599,9 +474,7 @@ impl Komobar {
         end.x -= margin.left + margin.right;
 
         if end.y == 0.0 {
-            tracing::warn!(
-                "position.end.y is set to 0.0 which will make your bar invisible on a config reload - this is usually set to 50.0 by default"
-            )
+            tracing::warn!("position.end.y is set to 0.0 which will make your bar invisible on a config reload - this is usually set to 50.0 by default")
         }
 
         self.size_rect = komorebi_client::Rect {
@@ -633,7 +506,8 @@ impl Komobar {
 
                         assert!(
                             home.is_dir(),
-                            "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                            "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                            home_path
                         );
 
                         home
@@ -647,6 +521,26 @@ impl Komobar {
                 match komorebi_client::StaticConfig::read(&config) {
                     Ok(config) => {
                         if let Some(theme) = config.theme {
+                            let stack_accent = match theme {
+                                KomorebiTheme::Catppuccin {
+                                    name, stack_border, ..
+                                } => stack_border
+                                    .unwrap_or(CatppuccinValue::Green)
+                                    .color32(name.as_theme()),
+                                KomorebiTheme::Base16 {
+                                    name, stack_border, ..
+                                } => stack_border
+                                    .unwrap_or(Base16Value::Base0B)
+                                    .color32(Base16Wrapper::Base16(name)),
+                                KomorebiTheme::Custom {
+                                    ref colours,
+                                    stack_border,
+                                    ..
+                                } => stack_border
+                                    .unwrap_or(Base16Value::Base0B)
+                                    .color32(Base16Wrapper::Custom(colours.clone())),
+                            };
+
                             apply_theme(
                                 ctx,
                                 KomobarTheme::from(theme),
@@ -656,6 +550,10 @@ impl Komobar {
                                 bar_grouping,
                                 self.render_config.clone(),
                             );
+
+                            if let Some(state) = &self.komorebi_notification_state {
+                                state.borrow_mut().stack_accent = Some(stack_accent);
+                            }
                         }
                     }
                     Err(_) => {
@@ -668,16 +566,17 @@ impl Komobar {
                             | Grouping::Alignment(config)
                             | Grouping::Widget(config),
                         ) = &bar_grouping
-                            && let Some(rounding) = config.rounding
                         {
-                            ctx.style_mut(|style| {
-                                style.visuals.widgets.noninteractive.corner_radius =
-                                    rounding.into();
-                                style.visuals.widgets.inactive.corner_radius = rounding.into();
-                                style.visuals.widgets.hovered.corner_radius = rounding.into();
-                                style.visuals.widgets.active.corner_radius = rounding.into();
-                                style.visuals.widgets.open.corner_radius = rounding.into();
-                            });
+                            if let Some(rounding) = config.rounding {
+                                ctx.style_mut(|style| {
+                                    style.visuals.widgets.noninteractive.corner_radius =
+                                        rounding.into();
+                                    style.visuals.widgets.inactive.corner_radius = rounding.into();
+                                    style.visuals.widgets.hovered.corner_radius = rounding.into();
+                                    style.visuals.widgets.active.corner_radius = rounding.into();
+                                    style.visuals.widgets.open.corner_radius = rounding.into();
+                                });
+                            }
                         }
                     }
                 }
@@ -697,7 +596,7 @@ impl Komobar {
             disabled: false,
             config,
             render_config: Rc::new(RefCell::new(RenderConfig::new())),
-            monitor_info: None,
+            komorebi_notification_state: None,
             left_widgets: vec![],
             center_widgets: vec![],
             right_widgets: vec![],
@@ -709,16 +608,6 @@ impl Komobar {
             size_rect: komorebi_client::Rect::default(),
             work_area_offset: komorebi_client::Rect::default(),
             applied_theme_on_first_frame: false,
-            mouse_follows_focus: false,
-            input_config: InputConfig {
-                accumulated_scroll_delta: Vec2::new(0.0, 0.0),
-                act_on_vertical_scroll: false,
-                act_on_horizontal_scroll: false,
-                vertical_scroll_threshold: 0.0,
-                horizontal_scroll_threshold: 0.0,
-                vertical_scroll_max_threshold: 0.0,
-                horizontal_scroll_max_threshold: 0.0,
-            },
         };
 
         komobar.apply_config(&cc.egui_ctx, None);
@@ -843,12 +732,12 @@ impl eframe::App for Komobar {
 
         if self.scale_factor != ctx.native_pixels_per_point().unwrap_or(1.0) {
             self.scale_factor = ctx.native_pixels_per_point().unwrap_or(1.0);
-            self.apply_config(ctx, self.monitor_info.clone());
+            self.apply_config(ctx, self.komorebi_notification_state.clone());
         }
 
         if let Ok(updated_config) = self.rx_config.try_recv() {
             self.config = updated_config;
-            self.apply_config(ctx, self.monitor_info.clone());
+            self.apply_config(ctx, self.komorebi_notification_state.clone());
         }
 
         match self.rx_gui.try_recv() {
@@ -938,9 +827,9 @@ impl eframe::App for Komobar {
                 ) {
                     let monitor_index = self.monitor_index.expect("should have a monitor index");
 
-                    let monitor_size = state.monitors.elements()[monitor_index].size;
+                    let monitor_size = state.monitors.elements()[monitor_index].size();
 
-                    self.update_monitor_coordinates(&monitor_size);
+                    self.update_monitor_coordinates(monitor_size);
 
                     should_apply_config = true;
                 }
@@ -951,7 +840,7 @@ impl eframe::App for Komobar {
 
                 // Check if monitor coordinates/size has changed
                 if let Some(monitor_index) = self.monitor_index {
-                    let monitor_size = state.monitors.elements()[monitor_index].size;
+                    let monitor_size = state.monitors.elements()[monitor_index].size();
                     let top = MONITOR_TOP.load(Ordering::SeqCst);
                     let left = MONITOR_LEFT.load(Ordering::SeqCst);
                     let right = MONITOR_RIGHT.load(Ordering::SeqCst);
@@ -961,38 +850,36 @@ impl eframe::App for Komobar {
                         bottom: monitor_size.bottom,
                         right,
                     };
-                    if monitor_size != rect {
+                    if *monitor_size != rect {
                         tracing::info!(
                             "Monitor coordinates/size has changed, storing new coordinates: {:#?}",
                             monitor_size
                         );
 
-                        self.update_monitor_coordinates(&monitor_size);
+                        self.update_monitor_coordinates(monitor_size);
 
                         should_apply_config = true;
                     }
                 }
 
-                if let Some(monitor_info) = &self.monitor_info {
-                    monitor_info.borrow_mut().update(
-                        self.monitor_index,
-                        notification.state,
-                        self.render_config.borrow().show_all_icons,
-                    );
-                    handle_notification(
-                        ctx,
-                        notification.event,
-                        self.bg_color.clone(),
-                        self.bg_color_with_alpha.clone(),
-                        self.config.transparency_alpha,
-                        self.config.grouping,
-                        self.config.theme.clone(),
-                        self.render_config.clone(),
-                    );
+                if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
+                    komorebi_notification_state
+                        .borrow_mut()
+                        .handle_notification(
+                            ctx,
+                            self.monitor_index,
+                            notification,
+                            self.bg_color.clone(),
+                            self.bg_color_with_alpha.clone(),
+                            self.config.transparency_alpha,
+                            self.config.grouping,
+                            self.config.theme.clone(),
+                            self.render_config.clone(),
+                        );
                 }
 
                 if should_apply_config {
-                    self.apply_config(ctx, self.monitor_info.clone());
+                    self.apply_config(ctx, self.komorebi_notification_state.clone());
 
                     // Reposition the Bar
                     self.position_bar();
@@ -1074,111 +961,6 @@ impl eframe::App for Komobar {
         let frame = render_config.change_frame_on_bar(frame, &ctx.style());
 
         CentralPanel::default().frame(frame).show(ctx, |ui| {
-            if let Some(mouse_config) = &self.config.mouse {
-                let command = if ui
-                    .input(|i| i.pointer.button_double_clicked(PointerButton::Primary))
-                {
-                    tracing::debug!("Input: primary button double clicked");
-                    &mouse_config.on_primary_double_click
-                } else if ui.input(|i| i.pointer.button_clicked(PointerButton::Secondary)) {
-                    tracing::debug!("Input: secondary button clicked");
-                    &mouse_config.on_secondary_click
-                } else if ui.input(|i| i.pointer.button_clicked(PointerButton::Middle)) {
-                    tracing::debug!("Input: middle button clicked");
-                    &mouse_config.on_middle_click
-                } else if ui.input(|i| i.pointer.button_clicked(PointerButton::Extra1)) {
-                    tracing::debug!("Input: extra1 button clicked");
-                    &mouse_config.on_extra1_click
-                } else if ui.input(|i| i.pointer.button_clicked(PointerButton::Extra2)) {
-                    tracing::debug!("Input: extra2 button clicked");
-                    &mouse_config.on_extra2_click
-                } else if self.input_config.act_on_vertical_scroll
-                    || self.input_config.act_on_horizontal_scroll
-                {
-                    let scroll_delta = ui.input(|input| input.smooth_scroll_delta);
-
-                    self.input_config.accumulated_scroll_delta += scroll_delta;
-
-                    if scroll_delta.y != 0.0 && self.input_config.act_on_vertical_scroll {
-                        // Do not store more than the max threshold
-                        self.input_config.accumulated_scroll_delta.y =
-                            self.input_config.accumulated_scroll_delta.y.clamp(
-                                -self.input_config.vertical_scroll_max_threshold,
-                                self.input_config.vertical_scroll_max_threshold,
-                            );
-
-                        // When the accumulated scroll passes the threshold, trigger a tick.
-                        if self.input_config.accumulated_scroll_delta.y.abs()
-                            >= self.input_config.vertical_scroll_threshold
-                        {
-                            let direction_command =
-                                if self.input_config.accumulated_scroll_delta.y > 0.0 {
-                                    &mouse_config.on_scroll_up
-                                } else {
-                                    &mouse_config.on_scroll_down
-                                };
-
-                            // Remove one tick's worth of scroll from the accumulator, preserving any excess.
-                            self.input_config.accumulated_scroll_delta.y -=
-                                self.input_config.vertical_scroll_threshold
-                                    * self.input_config.accumulated_scroll_delta.y.signum();
-
-                            tracing::debug!(
-                                "Input: vertical scroll ticked. excess: {} | threshold: {}",
-                                self.input_config.accumulated_scroll_delta.y,
-                                self.input_config.vertical_scroll_threshold
-                            );
-
-                            direction_command
-                        } else {
-                            &None
-                        }
-                    } else if scroll_delta.x != 0.0 && self.input_config.act_on_horizontal_scroll {
-                        // Do not store more than the max threshold
-                        self.input_config.accumulated_scroll_delta.x =
-                            self.input_config.accumulated_scroll_delta.x.clamp(
-                                -self.input_config.horizontal_scroll_max_threshold,
-                                self.input_config.horizontal_scroll_max_threshold,
-                            );
-
-                        // When the accumulated scroll passes the threshold, trigger a tick.
-                        if self.input_config.accumulated_scroll_delta.x.abs()
-                            >= self.input_config.horizontal_scroll_threshold
-                        {
-                            let direction_command =
-                                if self.input_config.accumulated_scroll_delta.x > 0.0 {
-                                    &mouse_config.on_scroll_left
-                                } else {
-                                    &mouse_config.on_scroll_right
-                                };
-
-                            // Remove one tick's worth of scroll from the accumulator, preserving any excess.
-                            self.input_config.accumulated_scroll_delta.x -=
-                                self.input_config.horizontal_scroll_threshold
-                                    * self.input_config.accumulated_scroll_delta.x.signum();
-
-                            tracing::debug!(
-                                "Input: horizontal scroll ticked. excess: {} | threshold: {}",
-                                self.input_config.accumulated_scroll_delta.x,
-                                self.input_config.horizontal_scroll_threshold
-                            );
-
-                            direction_command
-                        } else {
-                            &None
-                        }
-                    } else {
-                        &None
-                    }
-                } else {
-                    &None
-                };
-
-                if let Some(command) = command {
-                    command.execute(self.mouse_follows_focus);
-                }
-            }
-
             // Apply grouping logic for the bar as a whole
             let area_frame = if let Some(frame) = &self.config.frame {
                 Frame::NONE
@@ -1318,66 +1100,3 @@ pub enum Alignment {
     Center,
     Right,
 }
-
-#[allow(clippy::too_many_arguments)]
-fn handle_notification(
-    ctx: &Context,
-    event: komorebi_client::NotificationEvent,
-    bg_color: Rc<RefCell<Color32>>,
-    bg_color_with_alpha: Rc<RefCell<Color32>>,
-    transparency_alpha: Option<u8>,
-    grouping: Option<Grouping>,
-    default_theme: Option<KomobarTheme>,
-    render_config: Rc<RefCell<RenderConfig>>,
-) {
-    if let NotificationEvent::Socket(message) = event {
-        match message {
-            SocketMessage::ReloadStaticConfiguration(path) => {
-                if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
-                    if let Some(theme) = config.theme {
-                        apply_theme(
-                            ctx,
-                            KomobarTheme::from(theme),
-                            bg_color.clone(),
-                            bg_color_with_alpha.clone(),
-                            transparency_alpha,
-                            grouping,
-                            render_config,
-                        );
-                        tracing::info!("applied theme from updated komorebi.json");
-                    } else if let Some(default_theme) = default_theme {
-                        apply_theme(
-                            ctx,
-                            default_theme,
-                            bg_color.clone(),
-                            bg_color_with_alpha.clone(),
-                            transparency_alpha,
-                            grouping,
-                            render_config,
-                        );
-                        tracing::info!(
-                            "removed theme from updated komorebi.json and applied default theme"
-                        );
-                    } else {
-                        tracing::warn!(
-                            "theme was removed from updated komorebi.json but there was no default theme to apply"
-                        );
-                    }
-                }
-            }
-            SocketMessage::Theme(theme) => {
-                apply_theme(
-                    ctx,
-                    KomobarTheme::from(*theme),
-                    bg_color,
-                    bg_color_with_alpha.clone(),
-                    transparency_alpha,
-                    grouping,
-                    render_config,
-                );
-                tracing::info!("applied theme from komorebi socket message");
-            }
-            _ => {}
-        }
-    }
-}

komorebi-bar/src/config.rs

@@ -1,14 +1,11 @@
-use crate::DEFAULT_PADDING;
-use crate::bar::exec_powershell;
 use crate::render::Grouping;
 use crate::widgets::widget::WidgetConfig;
+use crate::DEFAULT_PADDING;
 use eframe::egui::Pos2;
 use eframe::egui::TextBuffer;
 use eframe::egui::Vec2;
 use komorebi_client::KomorebiTheme;
-use komorebi_client::PathExt;
 use komorebi_client::Rect;
-use komorebi_client::SocketMessage;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
@@ -16,7 +13,7 @@ use std::path::PathBuf;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.39`
+/// The `komorebi.bar.json` configuration file reference for `v0.1.37`
 pub struct KomobarConfig {
     /// Bar height (default: 50)
     pub height: Option<f32>,
@@ -93,8 +90,6 @@ pub struct KomobarConfig {
     pub widget_spacing: Option<f32>,
     /// Visual grouping for widgets
     pub grouping: Option<Grouping>,
-    /// Options for mouse interaction on the bar
-    pub mouse: Option<MouseConfig>,
     /// Left side widgets (ordered left-to-right)
     pub left_widgets: Vec<WidgetConfig>,
     /// Center widgets (ordered left-to-right)
@@ -120,9 +115,7 @@ impl KomobarConfig {
         }
 
         if display {
-            println!(
-                "\nYour bar configuration file contains some options that have been renamed or deprecated:\n"
-            );
+            println!("\nYour bar 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) {
@@ -332,146 +325,6 @@ pub fn get_individual_spacing(
         })
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-#[serde(untagged)]
-pub enum MouseMessage {
-    /// Send a message to the komorebi client.
-    /// By default, a batch of messages are sent in the following order:
-    /// FocusMonitorAtCursor =>
-    /// MouseFollowsFocus(false) =>
-    /// {message} =>
-    /// MouseFollowsFocus({original.value})
-    ///
-    /// Example:
-    /// ```json
-    /// "on_extra2_click": {
-    ///   "message": {
-    ///     "type": "NewWorkspace"
-    ///   }
-    /// },
-    /// ```
-    /// or:
-    /// ```json
-    /// "on_middle_click": {
-    ///   "focus_monitor_at_cursor": false,
-    ///   "ignore_mouse_follows_focus": false,
-    ///   "message": {
-    ///     "type": "TogglePause"
-    ///   }
-    /// }
-    /// ```
-    /// or:
-    /// ```json
-    /// "on_scroll_up": {
-    ///   "message": {
-    ///     "type": "CycleFocusWorkspace",
-    ///     "content": "Previous"
-    ///   }
-    /// }
-    /// ```
-    Komorebi(KomorebiMouseMessage),
-    /// Execute a custom command.
-    /// CMD (%variable%), Bash ($variable) and PowerShell ($Env:variable) variables will be resolved.
-    /// Example: `komorebic toggle-pause`
-    Command(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub struct KomorebiMouseMessage {
-    /// Send the FocusMonitorAtCursor message (default:true)
-    pub focus_monitor_at_cursor: Option<bool>,
-    /// Wrap the {message} with a MouseFollowsFocus(false) and MouseFollowsFocus({original.value}) message (default:true)
-    pub ignore_mouse_follows_focus: Option<bool>,
-    /// The message to send to the komorebi client
-    pub message: komorebi_client::SocketMessage,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub struct MouseConfig {
-    /// Command to send on primary/left double button click
-    pub on_primary_double_click: Option<MouseMessage>,
-    /// Command to send on secondary/right button click
-    pub on_secondary_click: Option<MouseMessage>,
-    /// Command to send on middle button click
-    pub on_middle_click: Option<MouseMessage>,
-    /// Command to send on extra1/back button click
-    pub on_extra1_click: Option<MouseMessage>,
-    /// Command to send on extra2/forward button click
-    pub on_extra2_click: Option<MouseMessage>,
-
-    /// Defines how many points a user needs to scroll vertically to make a "tick" on a mouse/touchpad/touchscreen (default: 30)
-    pub vertical_scroll_threshold: Option<f32>,
-    /// Command to send on scrolling up (every tick)
-    pub on_scroll_up: Option<MouseMessage>,
-    /// Command to send on scrolling down (every tick)
-    pub on_scroll_down: Option<MouseMessage>,
-
-    /// Defines how many points a user needs to scroll horizontally to make a "tick" on a mouse/touchpad/touchscreen (default: 30)
-    pub horizontal_scroll_threshold: Option<f32>,
-    /// Command to send on scrolling left (every tick)
-    pub on_scroll_left: Option<MouseMessage>,
-    /// Command to send on scrolling right (every tick)
-    pub on_scroll_right: Option<MouseMessage>,
-}
-
-impl MouseConfig {
-    pub fn has_command(&self) -> bool {
-        [
-            &self.on_primary_double_click,
-            &self.on_secondary_click,
-            &self.on_middle_click,
-            &self.on_extra1_click,
-            &self.on_extra2_click,
-            &self.on_scroll_up,
-            &self.on_scroll_down,
-            &self.on_scroll_left,
-            &self.on_scroll_right,
-        ]
-        .iter()
-        .any(|opt| matches!(opt, Some(MouseMessage::Command(_))))
-    }
-}
-
-impl MouseMessage {
-    pub fn execute(&self, mouse_follows_focus: bool) {
-        match self {
-            MouseMessage::Komorebi(config) => {
-                let mut messages = Vec::new();
-
-                if config.focus_monitor_at_cursor.unwrap_or(true) {
-                    messages.push(SocketMessage::FocusMonitorAtCursor);
-                }
-
-                if config.ignore_mouse_follows_focus.unwrap_or(true) {
-                    messages.push(SocketMessage::MouseFollowsFocus(false));
-                    messages.push(config.message.clone());
-                    messages.push(SocketMessage::MouseFollowsFocus(mouse_follows_focus));
-                } else {
-                    messages.push(config.message.clone());
-                }
-
-                tracing::debug!("Sending messages: {messages:?}");
-
-                if komorebi_client::send_batch(messages).is_err() {
-                    tracing::error!("could not send commands");
-                }
-            }
-            MouseMessage::Command(cmd) => {
-                tracing::debug!("Executing command: {}", cmd);
-
-                let cmd_no_env = cmd.replace_env();
-
-                if exec_powershell(cmd_no_env.to_str().expect("Invalid command")).is_err() {
-                    tracing::error!("Failed to execute '{}'", cmd);
-                }
-            }
-        };
-    }
-}
-
 impl KomobarConfig {
     pub fn read(path: &PathBuf) -> color_eyre::Result<Self> {
         let content = std::fs::read_to_string(path)?;

komorebi-bar/src/main.rs

@@ -15,10 +15,12 @@ use eframe::egui::ViewportBuilder;
 use font_loader::system_fonts;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
+use image::RgbaImage;
+use komorebi_client::replace_env_in_path;
 use komorebi_client::PathExt;
 use komorebi_client::SocketMessage;
 use komorebi_client::SubscribeOptions;
-use komorebi_client::replace_env_in_path;
+use std::collections::HashMap;
 use std::io::BufReader;
 use std::io::Read;
 use std::path::PathBuf;
@@ -26,14 +28,16 @@ use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
+use std::sync::LazyLock;
+use std::sync::Mutex;
 use std::time::Duration;
 use tracing_subscriber::EnvFilter;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::System::Threading::GetCurrentProcessId;
 use windows::Win32::System::Threading::GetCurrentThreadId;
-use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 use windows_core::BOOL;
@@ -49,6 +53,9 @@ pub static DEFAULT_PADDING: f32 = 10.0;
 pub static AUTO_SELECT_FILL_COLOUR: AtomicU32 = AtomicU32::new(0);
 pub static AUTO_SELECT_TEXT_COLOUR: AtomicU32 = AtomicU32::new(0);
 
+pub static ICON_CACHE: LazyLock<Mutex<HashMap<isize, RgbaImage>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
+
 #[derive(Parser)]
 #[clap(author, about, version)]
 struct Opts {
@@ -114,14 +121,14 @@ fn main() -> color_eyre::Result<()> {
 
     #[cfg(feature = "schemars")]
     if opts.schema {
-        let settings = schemars::r#gen::SchemaSettings::default().with(|s| {
+        let settings = schemars::gen::SchemaSettings::default().with(|s| {
             s.option_nullable = false;
             s.option_add_null_type = false;
             s.inline_subschemas = true;
         });
 
-        let generator = settings.into_generator();
-        let socket_message = generator.into_root_schema_for::<KomobarConfig>();
+        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}");
@@ -137,17 +144,13 @@ fn main() -> color_eyre::Result<()> {
     }
 
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        unsafe {
-            std::env::set_var("RUST_LIB_BACKTRACE", "1");
-        }
+        std::env::set_var("RUST_LIB_BACKTRACE", "1");
     }
 
     color_eyre::install()?;
 
     if std::env::var("RUST_LOG").is_err() {
-        unsafe {
-            std::env::set_var("RUST_LOG", "info");
-        }
+        std::env::set_var("RUST_LOG", "info");
     }
 
     tracing::subscriber::set_global_default(
@@ -163,7 +166,8 @@ fn main() -> color_eyre::Result<()> {
 
             assert!(
                 home.is_dir(),
-                "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                home_path
             );
 
             home
@@ -234,17 +238,17 @@ fn main() -> color_eyre::Result<()> {
         .map_or(usr_monitor_index, |i| *i);
 
     MONITOR_RIGHT.store(
-        state.monitors.elements()[monitor_index].size.right,
+        state.monitors.elements()[monitor_index].size().right,
         Ordering::SeqCst,
     );
 
     MONITOR_TOP.store(
-        state.monitors.elements()[monitor_index].size.top,
+        state.monitors.elements()[monitor_index].size().top,
         Ordering::SeqCst,
     );
 
     MONITOR_LEFT.store(
-        state.monitors.elements()[monitor_index].size.left,
+        state.monitors.elements()[monitor_index].size().left,
         Ordering::SeqCst,
     );
 
@@ -254,11 +258,11 @@ fn main() -> color_eyre::Result<()> {
         None => {
             config.position = Some(PositionConfig {
                 start: Some(Position {
-                    x: state.monitors.elements()[monitor_index].size.left as f32,
-                    y: state.monitors.elements()[monitor_index].size.top as f32,
+                    x: state.monitors.elements()[monitor_index].size().left as f32,
+                    y: state.monitors.elements()[monitor_index].size().top as f32,
                 }),
                 end: Some(Position {
-                    x: state.monitors.elements()[monitor_index].size.right as f32,
+                    x: state.monitors.elements()[monitor_index].size().right as f32,
                     y: 50.0,
                 }),
             })
@@ -266,14 +270,14 @@ fn main() -> color_eyre::Result<()> {
         Some(ref mut position) => {
             if position.start.is_none() {
                 position.start = Some(Position {
-                    x: state.monitors.elements()[monitor_index].size.left as f32,
-                    y: state.monitors.elements()[monitor_index].size.top as f32,
+                    x: state.monitors.elements()[monitor_index].size().left as f32,
+                    y: state.monitors.elements()[monitor_index].size().top as f32,
                 });
             }
 
             if position.end.is_none() {
                 position.end = Some(Position {
-                    x: state.monitors.elements()[monitor_index].size.right as f32,
+                    x: state.monitors.elements()[monitor_index].size().right as f32,
                     y: 50.0,
                 })
             }
@@ -358,7 +362,7 @@ fn main() -> color_eyre::Result<()> {
                                 while komorebi_client::send_message(
                                     &SocketMessage::AddSubscriberSocket(subscriber_name.clone()),
                                 )
-                                    .is_err()
+                                .is_err()
                                 {
                                     std::thread::sleep(Duration::from_secs(1));
                                 }
@@ -409,5 +413,5 @@ fn main() -> color_eyre::Result<()> {
             Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config)))
         }),
     )
-        .map_err(|error| color_eyre::eyre::Error::msg(error.to_string()))
+    .map_err(|error| color_eyre::eyre::Error::msg(error.to_string()))
 }

komorebi-bar/src/render.rs

@@ -1,8 +1,8 @@
-use crate::AUTO_SELECT_FILL_COLOUR;
-use crate::AUTO_SELECT_TEXT_COLOUR;
 use crate::bar::Alignment;
 use crate::config::KomobarConfig;
 use crate::config::MonitorConfigOrIndex;
+use crate::AUTO_SELECT_FILL_COLOUR;
+use crate::AUTO_SELECT_TEXT_COLOUR;
 use eframe::egui::Color32;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
@@ -18,9 +18,9 @@ use komorebi_client::Rgb;
 use serde::Deserialize;
 use serde::Serialize;
 use std::num::NonZeroU32;
-use std::sync::Arc;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 static SHOW_KOMOREBI_LAYOUT_OPTIONS: AtomicUsize = AtomicUsize::new(0);
 

komorebi-bar/src/widgets/applications.rs

@@ -1,7 +1,8 @@
-use super::ImageIcon;
+use super::komorebi::img_to_texture;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::vec2;
 use eframe::egui::Color32;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
@@ -16,14 +17,14 @@ use eframe::egui::Stroke;
 use eframe::egui::StrokeKind;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
-use eframe::egui::vec2;
+use image::DynamicImage;
+use image::RgbaImage;
 use komorebi_client::PathExt;
 use serde::Deserialize;
 use serde::Serialize;
-use std::borrow::Cow;
 use std::path::Path;
+use std::path::PathBuf;
 use std::process::Command;
-use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 use tracing;
@@ -118,32 +119,42 @@ impl BarWidget for Applications {
 
 impl From<&ApplicationsConfig> for Applications {
     fn from(applications_config: &ApplicationsConfig) -> Self {
+        // Allow immediate launch by initializing last_launch in the past.
+        let last_launch = Instant::now() - 2 * MIN_LAUNCH_INTERVAL;
+        let mut applications_config = applications_config.clone();
         let items = applications_config
             .items
-            .iter()
+            .iter_mut()
             .enumerate()
-            .map(|(index, config)| {
-                let command = UserCommand::new(&config.command);
+            .map(|(index, app_config)| {
+                app_config.command = app_config
+                    .command
+                    .replace_env()
+                    .to_string_lossy()
+                    .to_string();
+
+                if let Some(icon) = &mut app_config.icon {
+                    *icon = icon.replace_env().to_string_lossy().to_string();
+                }
 
                 App {
-                    enable: config.enable.unwrap_or(applications_config.enable),
-                    #[allow(clippy::obfuscated_if_else)]
-                    name: config
+                    enable: app_config.enable.unwrap_or(applications_config.enable),
+                    name: app_config
                         .name
                         .is_empty()
                         .then(|| format!("App {}", index + 1))
-                        .unwrap_or_else(|| config.name.clone()),
-                    icon: Icon::try_from_path(config.icon.as_deref())
-                        .or_else(|| Icon::try_from_command(&command)),
-                    command,
-                    display: config
+                        .unwrap_or_else(|| app_config.name.clone()),
+                    icon: Icon::try_from(app_config),
+                    command: app_config.command.clone(),
+                    display: app_config
                         .display
                         .or(applications_config.display)
                         .unwrap_or_default(),
-                    show_command_on_hover: config
+                    show_command_on_hover: app_config
                         .show_command_on_hover
                         .or(applications_config.show_command_on_hover)
                         .unwrap_or(false),
+                    last_launch,
                 }
             })
             .collect();
@@ -166,11 +177,13 @@ pub struct App {
     /// Icon to display for this application, if available.
     pub icon: Option<Icon>,
     /// Command to execute when the application is launched.
-    pub command: UserCommand,
+    pub command: String,
     /// Display format (icon, text, or both).
     pub display: DisplayFormat,
     /// Whether to show the launch command on hover.
     pub show_command_on_hover: bool,
+    /// Last time this application was launched (used for cooldown control).
+    pub last_launch: Instant,
 }
 
 impl App {
@@ -192,15 +205,17 @@ impl App {
                     }
 
                     // Add hover text with command information
-                    let response = ui.response();
                     if self.show_command_on_hover {
-                        response.on_hover_text(format!("Launch: {}", self.command.as_ref()));
+                        ui.response()
+                            .on_hover_text(format!("Launch: {}", self.command));
+                    } else {
+                        ui.response();
                     }
                 })
                 .clicked()
         {
             // Launch the application when clicked
-            self.command.launch_if_ready();
+            self.launch_if_ready();
         }
     }
 
@@ -220,75 +235,84 @@ impl App {
     fn draw_name(&self, ui: &mut Ui) {
         ui.add(Label::new(&self.name).selectable(false));
     }
+
+    /// Attempts to launch the specified command in a separate thread if enough time has passed
+    /// since the last launch. This prevents repeated launches from rapid consecutive clicks.
+    ///
+    /// Errors during launch are logged using the `tracing` crate.
+    pub fn launch_if_ready(&mut self) {
+        let now = Instant::now();
+        if now.duration_since(self.last_launch) < MIN_LAUNCH_INTERVAL {
+            return;
+        }
+
+        self.last_launch = now;
+        let command_string = self.command.clone();
+        // Launch the application in a separate thread to avoid blocking the UI
+        std::thread::spawn(move || {
+            if let Err(e) = Command::new("cmd").args(["/C", &command_string]).spawn() {
+                tracing::error!("Failed to launch command '{}': {}", command_string, e);
+            }
+        });
+    }
 }
 
-/// Holds image/text data to be used as an icon in the UI.
-/// This represents source icon data before rendering.
+/// Holds decoded image data to be used as an icon in the UI.
 #[derive(Clone, Debug)]
 pub enum Icon {
     /// RGBA image used for rendering the icon.
-    Image(ImageIcon),
+    Image(RgbaImage),
     /// Text-based icon, e.g. from a font like Nerd Fonts.
     Text(String),
 }
 
 impl Icon {
-    /// Attempts to create an [`Icon`] from a string path or text glyph/glyphs.
-    ///
-    /// - Environment variables in the path are resolved using [`PathExt::replace_env`].
-    /// - Uses [`ImageIcon::try_load`] to load and cache the icon image based on the resolved path.
-    /// - If the path is invalid but the string is non-empty, it is interpreted as a text-based icon and
-    ///   returned as [`Icon::Text`].
-    /// - Returns `None` if the input is empty, `None`, or image loading fails.
+    /// Attempts to create an `Icon` from the given `AppConfig`.
+    /// Loads the image from a specified icon path or extracts it from the application's
+    /// executable if the command points to a valid executable file.
     #[inline]
-    pub fn try_from_path(icon: Option<&str>) -> Option<Self> {
-        let icon = icon.map(str::trim)?;
-        if icon.is_empty() {
-            return None;
-        }
-
-        let path = icon.replace_env();
-        if !path.is_file() {
-            return Some(Icon::Text(icon.to_owned()));
-        }
-
-        let image_icon = ImageIcon::try_load(path.as_ref(), || match image::open(&path) {
-            Ok(img) => Some(img),
-            Err(err) => {
-                tracing::error!("Failed to load icon from {:?}, error: {}", path, err);
-                None
+    pub fn try_from(config: &AppConfig) -> Option<Self> {
+        if let Some(icon) = config.icon.as_deref().map(str::trim) {
+            if !icon.is_empty() {
+                let path = Path::new(&icon);
+                if path.is_file() {
+                    match image::open(path).as_ref().map(DynamicImage::to_rgba8) {
+                        Ok(image) => return Some(Icon::Image(image)),
+                        Err(err) => {
+                            tracing::error!("Failed to load icon from {}, error: {}", icon, err)
+                        }
+                    }
+                } else {
+                    return Some(Icon::Text(icon.to_owned()));
+                }
             }
-        })?;
+        }
 
-        Some(Icon::Image(image_icon))
+        let binary = PathBuf::from(config.command.split(".exe").next()?);
+        let path = if binary.is_file() {
+            Some(binary)
+        } else {
+            which(binary).ok()
+        };
+
+        match path {
+            Some(path) => windows_icons::get_icon_by_path(&path.to_string_lossy())
+                .or_else(|| windows_icons_fallback::get_icon_by_path(&path.to_string_lossy()))
+                .map(Icon::Image),
+            None => None,
+        }
     }
 
-    /// Attempts to create an [`Icon`] by extracting an image from the executable path of a [`UserCommand`].
-    ///
-    /// - Uses [`ImageIcon::try_load`] to load and cache the icon image based on the resolved executable path.
-    /// - Returns [`Icon::Image`] if an icon is successfully extracted.
-    /// - Returns `None` if the executable path is unavailable or icon extraction fails.
-    #[inline]
-    pub fn try_from_command(command: &UserCommand) -> Option<Self> {
-        let path = command.get_executable()?;
-        let image_icon = ImageIcon::try_load(path.as_ref(), || {
-            let path_str = path.to_str()?;
-            windows_icons::get_icon_by_path(path_str)
-                .or_else(|| windows_icons_fallback::get_icon_by_path(path_str))
-        })?;
-        Some(Icon::Image(image_icon))
-    }
-
-    /// Renders the icon in the given [`Ui`] using the provided [`IconConfig`].
+    /// Renders the icon in the given `Ui` context with the specified size.
     #[inline]
     pub fn draw(&self, ctx: &Context, ui: &mut Ui, icon_config: &IconConfig) {
         match self {
-            Icon::Image(image_icon) => {
+            Icon::Image(image) => {
                 Frame::NONE
                     .inner_margin(Margin::same(ui.style().spacing.button_padding.y as i8))
                     .show(ui, |ui| {
                         ui.add(
-                            Image::from_texture(&image_icon.texture(ctx))
+                            Image::from(&img_to_texture(ctx, image))
                                 .maintain_aspect_ratio(true)
                                 .fit_to_exact_size(Vec2::splat(icon_config.size)),
                         );
@@ -330,77 +354,3 @@ pub struct IconConfig {
     /// Color of the icon used for text-based icons
     pub color: Color32,
 }
-
-/// A structure to manage command execution with cooldown prevention.
-#[derive(Clone, Debug)]
-pub struct UserCommand {
-    /// The command string to execute
-    pub command: Arc<str>,
-    /// Last time this command was executed (used for cooldown control)
-    pub last_launch: Instant,
-}
-
-impl AsRef<str> for UserCommand {
-    #[inline]
-    fn as_ref(&self) -> &str {
-        &self.command
-    }
-}
-
-impl UserCommand {
-    /// Creates a new [`UserCommand`] with environment variables in the command path
-    /// resolved using [`PathExt::replace_env`].
-    #[inline]
-    pub fn new(command: &str) -> Self {
-        // Allow immediate launch by initializing last_launch in the past
-        let last_launch = Instant::now() - 2 * MIN_LAUNCH_INTERVAL;
-
-        Self {
-            command: Arc::from(command.replace_env().to_str().unwrap_or_default()),
-            last_launch,
-        }
-    }
-
-    /// Attempts to resolve the executable path from the command string.
-    ///
-    /// Resolution logic:
-    /// - Splits the command by ".exe" and checks if the first part is an existing file.
-    /// - If not, attempts to locate the binary using [`which`] on this name.
-    /// - If still unresolved, takes the first word (separated by whitespace) and attempts
-    ///   to find it in the system `PATH` using [`which`].
-    ///
-    /// Returns `None` if no executable path can be determined.
-    #[inline]
-    pub fn get_executable(&self) -> Option<Cow<'_, Path>> {
-        if let Some(binary) = self.command.split(".exe").next().map(Path::new) {
-            if binary.is_file() {
-                return Some(Cow::Borrowed(binary));
-            } else if let Ok(binary) = which(binary) {
-                return Some(Cow::Owned(binary));
-            }
-        }
-
-        which(self.command.split(' ').next()?).ok().map(Cow::Owned)
-    }
-
-    /// Attempts to launch the specified command in a separate thread if enough time has passed
-    /// since the last launch. This prevents repeated launches from rapid consecutive clicks.
-    ///
-    /// Errors during launch are logged using the `tracing` crate.
-    pub fn launch_if_ready(&mut self) {
-        let now = Instant::now();
-        // Check if enough time has passed since the last launch
-        if now.duration_since(self.last_launch) < MIN_LAUNCH_INTERVAL {
-            return;
-        }
-
-        self.last_launch = now;
-        let command_string = self.command.clone();
-        // Launch the application in a separate thread to avoid blocking the UI
-        std::thread::spawn(move || {
-            if let Err(e) = Command::new("cmd").args(["/C", &command_string]).spawn() {
-                tracing::error!("Failed to launch command '{}': {}", command_string, e);
-            }
-        });
-    }
-}

komorebi-bar/src/widgets/battery.rs

@@ -2,17 +2,17 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
+use starship_battery::units::ratio::percent;
 use starship_battery::Manager;
 use starship_battery::State;
-use starship_battery::units::ratio::percent;
 use std::process::Command;
 use std::time::Duration;
 use std::time::Instant;
@@ -87,41 +87,41 @@ impl Battery {
         if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
             output = None;
 
-            if let Ok(mut batteries) = self.manager.batteries()
-                && let Some(Ok(first)) = batteries.nth(0)
-            {
-                let percentage = first.state_of_charge().get::<percent>().round() as u8;
+            if let Ok(mut batteries) = self.manager.batteries() {
+                if let Some(Ok(first)) = batteries.nth(0) {
+                    let percentage = first.state_of_charge().get::<percent>().round() as u8;
 
-                if percentage == 100 && self.hide_on_full_charge {
-                    output = None
-                } else {
-                    match first.state() {
-                        State::Charging => self.state = BatteryState::Charging,
-                        State::Discharging => {
-                            self.state = match percentage {
-                                p if p > 75 => BatteryState::Discharging,
-                                p if p > 50 => BatteryState::High,
-                                p if p > 25 => BatteryState::Medium,
-                                p if p > 10 => BatteryState::Low,
-                                _ => BatteryState::Warning,
+                    if percentage == 100 && self.hide_on_full_charge {
+                        output = None
+                    } else {
+                        match first.state() {
+                            State::Charging => self.state = BatteryState::Charging,
+                            State::Discharging => {
+                                self.state = match percentage {
+                                    p if p > 75 => BatteryState::Discharging,
+                                    p if p > 50 => BatteryState::High,
+                                    p if p > 25 => BatteryState::Medium,
+                                    p if p > 10 => BatteryState::Low,
+                                    _ => BatteryState::Warning,
+                                }
                             }
+                            _ => {}
                         }
-                        _ => {}
+
+                        let selected = self.auto_select_under.is_some_and(|u| percentage <= u);
+
+                        output = Some(BatteryOutput {
+                            label: match self.label_prefix {
+                                LabelPrefix::Text | LabelPrefix::IconAndText => {
+                                    format!("BAT: {percentage}%")
+                                }
+                                LabelPrefix::None | LabelPrefix::Icon => {
+                                    format!("{percentage}%")
+                                }
+                            },
+                            selected,
+                        })
                     }
-
-                    let selected = self.auto_select_under.is_some_and(|u| percentage <= u);
-
-                    output = Some(BatteryOutput {
-                        label: match self.label_prefix {
-                            LabelPrefix::Text | LabelPrefix::IconAndText => {
-                                format!("BAT: {percentage}%")
-                            }
-                            LabelPrefix::None | LabelPrefix::Icon => {
-                                format!("{percentage}%")
-                            }
-                        },
-                        selected,
-                    })
                 }
             }
 
@@ -176,11 +176,13 @@ impl BarWidget for Battery {
                     if SelectableFrame::new_auto(output.selected, auto_focus_fill)
                         .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
-                        && let Err(error) = Command::new("cmd.exe")
+                    {
+                        if let Err(error) = Command::new("cmd.exe")
                             .args(["/C", "start", "ms-settings:batterysaver"])
                             .spawn()
-                    {
-                        eprintln!("{error}")
+                        {
+                            eprintln!("{}", error)
+                        }
                     }
                 });
             }

komorebi-bar/src/widgets/cpu.rs

@@ -2,12 +2,12 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -76,8 +76,8 @@ impl Cpu {
 
         CpuOutput {
             label: match self.label_prefix {
-                LabelPrefix::Text | LabelPrefix::IconAndText => format!("CPU: {used}%"),
-                LabelPrefix::None | LabelPrefix::Icon => format!("{used}%"),
+                LabelPrefix::Text | LabelPrefix::IconAndText => format!("CPU: {}%", used),
+                LabelPrefix::None | LabelPrefix::Icon => format!("{}%", used),
             },
             selected,
         }
@@ -120,10 +120,12 @@ impl BarWidget for Cpu {
                     if SelectableFrame::new_auto(output.selected, auto_focus_fill)
                         .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
-                        && let Err(error) =
-                            Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
                     {
-                        eprintln!("{error}")
+                        if let Err(error) =
+                            Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
+                        {
+                            eprintln!("{}", error)
+                        }
                     }
                 });
             }

komorebi-bar/src/widgets/date.rs

@@ -4,16 +4,15 @@ use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
 use chrono::Local;
 use chrono_tz::Tz;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
 use eframe::egui::WidgetText;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
-use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 
@@ -167,7 +166,7 @@ impl Date {
                         .to_string()
                         .trim()
                         .to_string(),
-                    Err(_) => format!("Invalid timezone: {timezone}"),
+                    Err(_) => format!("Invalid timezone: {}", timezone),
                 },
                 None => Local::now()
                     .format(&self.format.fmt_string())
@@ -226,7 +225,7 @@ impl BarWidget for Date {
                     if SelectableFrame::new(false)
                         .show(ui, |ui| {
                             ui.add(
-                                Label::new(WidgetText::LayoutJob(Arc::from(layout_job.clone())))
+                                Label::new(WidgetText::LayoutJob(layout_job.clone()))
                                     .selectable(false),
                             )
                         })

komorebi-bar/src/widgets/keyboard.rs

@@ -1,17 +1,15 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::widgets::widget::BarWidget;
-use color_eyre::eyre;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
 use eframe::egui::WidgetText;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
-use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 use windows::Win32::Globalization::LCIDToLocaleName;
@@ -82,7 +80,7 @@ pub struct Keyboard {
 /// - `Ok(String)`: The name of the active keyboard layout as a valid UTF-8 string.
 /// - `Err(())`: Indicates that the function failed to retrieve the locale name or encountered
 ///   invalid UTF-16 characters during conversion.
-fn get_active_keyboard_layout() -> eyre::Result<String, ()> {
+fn get_active_keyboard_layout() -> Result<String, ()> {
     let foreground_window_tid = unsafe { GetWindowThreadProcessId(GetForegroundWindow(), None) };
     let lcid = unsafe { GetKeyboardLayout(foreground_window_tid) };
 
@@ -171,10 +169,7 @@ impl BarWidget for Keyboard {
                 );
 
                 config.apply_on_widget(true, ui, |ui| {
-                    ui.add(
-                        Label::new(WidgetText::LayoutJob(Arc::from(layout_job.clone())))
-                            .selectable(false),
-                    )
+                    ui.add(Label::new(WidgetText::LayoutJob(layout_job.clone())).selectable(false))
                 });
             }
         }

komorebi-bar/src/widgets/komorebi_layout.rs

@@ -2,7 +2,7 @@ use crate::config::DisplayFormat;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::komorebi::KomorebiLayoutConfig;
-use color_eyre::eyre;
+use eframe::egui::vec2;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
 use eframe::egui::FontId;
@@ -13,12 +13,11 @@ use eframe::egui::Stroke;
 use eframe::egui::StrokeKind;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
-use eframe::egui::vec2;
 use komorebi_client::SocketMessage;
+use serde::de::Error;
 use serde::Deserialize;
 use serde::Deserializer;
 use serde::Serialize;
-use serde::de::Error;
 use serde_json::from_str;
 use std::fmt::Display;
 use std::fmt::Formatter;
@@ -35,14 +34,15 @@ pub enum KomorebiLayout {
 }
 
 impl<'de> Deserialize<'de> for KomorebiLayout {
-    fn deserialize<D>(deserializer: D) -> eyre::Result<Self, D::Error>
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         let s: String = String::deserialize(deserializer)?;
 
         // Attempt to deserialize the string as a DefaultLayout
-        if let Ok(default_layout) = from_str::<komorebi_client::DefaultLayout>(&format!("\"{s}\""))
+        if let Ok(default_layout) =
+            from_str::<komorebi_client::DefaultLayout>(&format!("\"{}\"", s))
         {
             return Ok(KomorebiLayout::Default(default_layout));
         }
@@ -53,7 +53,7 @@ impl<'de> Deserialize<'de> for KomorebiLayout {
             "Floating" => Ok(KomorebiLayout::Floating),
             "Paused" => Ok(KomorebiLayout::Paused),
             "Custom" => Ok(KomorebiLayout::Custom),
-            _ => Err(Error::custom(format!("Invalid layout: {s}"))),
+            _ => Err(Error::custom(format!("Invalid layout: {}", s))),
         }
     }
 }
@@ -92,15 +92,16 @@ impl KomorebiLayout {
     fn on_click_option(&mut self, monitor_idx: usize, workspace_idx: Option<usize>) {
         match self {
             KomorebiLayout::Default(option) => {
-                if let Some(ws_idx) = workspace_idx
-                    && komorebi_client::send_message(&SocketMessage::WorkspaceLayout(
+                if let Some(ws_idx) = workspace_idx {
+                    if komorebi_client::send_message(&SocketMessage::WorkspaceLayout(
                         monitor_idx,
                         ws_idx,
                         *option,
                     ))
                     .is_err()
-                {
-                    tracing::error!("could not send message to komorebi: WorkspaceLayout");
+                    {
+                        tracing::error!("could not send message to komorebi: WorkspaceLayout");
+                    }
                 }
             }
             KomorebiLayout::Monocle => {
@@ -187,12 +188,6 @@ impl KomorebiLayout {
                     painter.line_segment([c - vec2(r, 0.0), c + vec2(r, 0.0)], stroke);
                     painter.line_segment([c - vec2(0.0, r), c + vec2(0.0, r)], stroke);
                 }
-                // TODO: @CtByte can you think of a nice icon to draw here?
-                komorebi_client::DefaultLayout::Scrolling => {
-                    painter.line_segment([c - vec2(r / 2.0, r), c + vec2(-r / 2.0, r)], stroke);
-                    painter.line_segment([c - vec2(0.0, r), c + vec2(0.0, r)], stroke);
-                    painter.line_segment([c - vec2(-r / 2.0, r), c + vec2(r / 2.0, r)], stroke);
-                }
             },
             KomorebiLayout::Monocle => {}
             KomorebiLayout::Floating => {
@@ -269,53 +264,57 @@ impl KomorebiLayout {
                 show_options = self.on_click(&show_options, monitor_idx, workspace_idx);
             }
 
-            if show_options && let Some(workspace_idx) = workspace_idx {
-                Frame::NONE.show(ui, |ui| {
-                    ui.add(
-                        Label::new(egui_phosphor::regular::ARROW_FAT_LINES_RIGHT.to_string())
-                            .selectable(false),
-                    );
+            if show_options {
+                if let Some(workspace_idx) = workspace_idx {
+                    Frame::NONE.show(ui, |ui| {
+                        ui.add(
+                            Label::new(egui_phosphor::regular::ARROW_FAT_LINES_RIGHT.to_string())
+                                .selectable(false),
+                        );
 
-                    let mut layout_options = layout_config.options.clone().unwrap_or(vec![
-                        KomorebiLayout::Default(komorebi_client::DefaultLayout::BSP),
-                        KomorebiLayout::Default(komorebi_client::DefaultLayout::Columns),
-                        KomorebiLayout::Default(komorebi_client::DefaultLayout::Rows),
-                        KomorebiLayout::Default(komorebi_client::DefaultLayout::VerticalStack),
-                        KomorebiLayout::Default(
-                            komorebi_client::DefaultLayout::RightMainVerticalStack,
-                        ),
-                        KomorebiLayout::Default(komorebi_client::DefaultLayout::HorizontalStack),
-                        KomorebiLayout::Default(
-                            komorebi_client::DefaultLayout::UltrawideVerticalStack,
-                        ),
-                        KomorebiLayout::Default(komorebi_client::DefaultLayout::Grid),
-                        //KomorebiLayout::Custom,
-                        KomorebiLayout::Monocle,
-                        KomorebiLayout::Floating,
-                        KomorebiLayout::Paused,
-                    ]);
+                        let mut layout_options = layout_config.options.clone().unwrap_or(vec![
+                            KomorebiLayout::Default(komorebi_client::DefaultLayout::BSP),
+                            KomorebiLayout::Default(komorebi_client::DefaultLayout::Columns),
+                            KomorebiLayout::Default(komorebi_client::DefaultLayout::Rows),
+                            KomorebiLayout::Default(komorebi_client::DefaultLayout::VerticalStack),
+                            KomorebiLayout::Default(
+                                komorebi_client::DefaultLayout::RightMainVerticalStack,
+                            ),
+                            KomorebiLayout::Default(
+                                komorebi_client::DefaultLayout::HorizontalStack,
+                            ),
+                            KomorebiLayout::Default(
+                                komorebi_client::DefaultLayout::UltrawideVerticalStack,
+                            ),
+                            KomorebiLayout::Default(komorebi_client::DefaultLayout::Grid),
+                            //KomorebiLayout::Custom,
+                            KomorebiLayout::Monocle,
+                            KomorebiLayout::Floating,
+                            KomorebiLayout::Paused,
+                        ]);
 
-                    for layout_option in &mut layout_options {
-                        let is_selected = self == layout_option;
+                        for layout_option in &mut layout_options {
+                            let is_selected = self == layout_option;
 
-                        if SelectableFrame::new(is_selected)
-                            .show(ui, |ui| {
-                                layout_option.show_icon(is_selected, font_id.clone(), ctx, ui)
-                            })
-                            .on_hover_text(match layout_option {
-                                KomorebiLayout::Default(layout) => layout.to_string(),
-                                KomorebiLayout::Monocle => "Toggle monocle".to_string(),
-                                KomorebiLayout::Floating => "Toggle tiling".to_string(),
-                                KomorebiLayout::Paused => "Toggle pause".to_string(),
-                                KomorebiLayout::Custom => "Custom".to_string(),
-                            })
-                            .clicked()
-                        {
-                            layout_option.on_click_option(monitor_idx, Some(workspace_idx));
-                            show_options = false;
-                        };
-                    }
-                });
+                            if SelectableFrame::new(is_selected)
+                                .show(ui, |ui| {
+                                    layout_option.show_icon(is_selected, font_id.clone(), ctx, ui)
+                                })
+                                .on_hover_text(match layout_option {
+                                    KomorebiLayout::Default(layout) => layout.to_string(),
+                                    KomorebiLayout::Monocle => "Toggle monocle".to_string(),
+                                    KomorebiLayout::Floating => "Toggle tiling".to_string(),
+                                    KomorebiLayout::Paused => "Toggle pause".to_string(),
+                                    KomorebiLayout::Custom => "Custom".to_string(),
+                                })
+                                .clicked()
+                            {
+                                layout_option.on_click_option(monitor_idx, Some(workspace_idx));
+                                show_options = false;
+                            };
+                        }
+                    });
+                }
             }
         });
 

komorebi-bar/src/widgets/media.rs

@@ -1,15 +1,15 @@
-use crate::MAX_LABEL_WIDTH;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
 use crate::widgets::widget::BarWidget;
+use crate::MAX_LABEL_WIDTH;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
 use std::sync::atomic::Ordering;
@@ -40,34 +40,36 @@ impl Media {
             enable,
             session_manager: GlobalSystemMediaTransportControlsSessionManager::RequestAsync()
                 .unwrap()
-                .join()
+                .get()
                 .unwrap(),
         }
     }
 
     pub fn toggle(&self) {
-        if let Ok(session) = self.session_manager.GetCurrentSession()
-            && let Ok(op) = session.TryTogglePlayPauseAsync()
-        {
-            op.join().unwrap_or_default();
+        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()
-            && let Ok(operation) = session.TryGetMediaPropertiesAsync()
-            && let Ok(properties) = operation.join()
-            && let (Ok(artist), Ok(title)) = (properties.Artist(), properties.Title())
-        {
-            if artist.is_empty() {
-                return format!("{title}");
-            }
+        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}");
-            }
+                        if title.is_empty() {
+                            return format!("{artist}");
+                        }
 
-            return format!("{artist} - {title}");
+                        return format!("{artist} - {title}");
+                    }
+                }
+            }
         }
 
         String::new()

komorebi-bar/src/widgets/memory.rs

@@ -2,12 +2,12 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -79,9 +79,9 @@ impl Memory {
         MemoryOutput {
             label: match self.label_prefix {
                 LabelPrefix::Text | LabelPrefix::IconAndText => {
-                    format!("RAM: {usage}%")
+                    format!("RAM: {}%", usage)
                 }
-                LabelPrefix::None | LabelPrefix::Icon => format!("{usage}%"),
+                LabelPrefix::None | LabelPrefix::Icon => format!("{}%", usage),
             },
             selected,
         }
@@ -124,10 +124,12 @@ impl BarWidget for Memory {
                     if SelectableFrame::new_auto(output.selected, auto_focus_fill)
                         .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
-                        && let Err(error) =
-                            Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
                     {
-                        eprintln!("{error}")
+                        if let Err(error) =
+                            Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
+                        {
+                            eprintln!("{}", error)
+                        }
                     }
                 });
             }

komorebi-bar/src/widgets/mod.rs

@@ -1,14 +1,3 @@
-use eframe::egui::ColorImage;
-use eframe::egui::Context;
-use eframe::egui::TextureHandle;
-use eframe::egui::TextureOptions;
-use image::RgbaImage;
-use std::collections::HashMap;
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::LazyLock;
-use std::sync::RwLock;
-
 pub mod applications;
 pub mod battery;
 pub mod cpu;
@@ -23,151 +12,3 @@ pub mod storage;
 pub mod time;
 pub mod update;
 pub mod widget;
-
-/// Global cache for icon images and their associated GPU textures.
-pub static ICONS_CACHE: IconsCache = IconsCache::new();
-
-/// In-memory cache for icon images and their associated GPU textures.
-///
-/// Stores raw [`ColorImage`]s and [`TextureHandle`]s keyed by [`ImageIconId`].
-/// Texture entries are context-dependent and automatically invalidated when the [`Context`] changes.
-#[allow(clippy::type_complexity)]
-pub struct IconsCache {
-    textures: LazyLock<RwLock<(Option<Context>, HashMap<ImageIconId, TextureHandle>)>>,
-    images: LazyLock<RwLock<HashMap<ImageIconId, Arc<ColorImage>>>>,
-}
-
-impl IconsCache {
-    /// Creates a new empty IconsCache instance.
-    #[inline]
-    pub const fn new() -> Self {
-        Self {
-            textures: LazyLock::new(|| RwLock::new((None, HashMap::new()))),
-            images: LazyLock::new(|| RwLock::new(HashMap::new())),
-        }
-    }
-
-    /// Retrieves or creates a texture handle for the given icon ID and image.
-    ///
-    /// If a texture for the given ID already exists for the current [`Context`], it is reused.
-    /// Otherwise, a new texture is created, inserted into the cache, and returned.
-    /// The cache is reset if the [`Context`] has changed.
-    #[inline]
-    pub fn texture(&self, ctx: &Context, id: &ImageIconId, img: &Arc<ColorImage>) -> TextureHandle {
-        if let Some(texture) = self.get_texture(ctx, id) {
-            return texture;
-        }
-        let texture_handle = ctx.load_texture("icon", img.clone(), TextureOptions::default());
-        self.insert_texture(ctx, id.clone(), texture_handle.clone());
-        texture_handle
-    }
-
-    /// Returns the cached texture for the given icon ID if it exists and matches the current [`Context`].
-    pub fn get_texture(&self, ctx: &Context, id: &ImageIconId) -> Option<TextureHandle> {
-        let textures_lock = self.textures.read().unwrap();
-        if textures_lock.0.as_ref() == Some(ctx) {
-            return textures_lock.1.get(id).cloned();
-        }
-        None
-    }
-
-    /// Inserts a texture handle, resetting the cache if the [`Context`] has changed.
-    pub fn insert_texture(&self, ctx: &Context, id: ImageIconId, texture: TextureHandle) {
-        let mut textures_lock = self.textures.write().unwrap();
-
-        if textures_lock.0.as_ref() != Some(ctx) {
-            textures_lock.0 = Some(ctx.clone());
-            textures_lock.1.clear();
-        }
-
-        textures_lock.1.insert(id, texture);
-    }
-
-    /// Returns the cached image for the given icon ID, if available.
-    pub fn get_image(&self, id: &ImageIconId) -> Option<Arc<ColorImage>> {
-        self.images.read().unwrap().get(id).cloned()
-    }
-
-    /// Caches a raw [`ColorImage`] associated with the given icon ID.
-    pub fn insert_image(&self, id: ImageIconId, image: Arc<ColorImage>) {
-        self.images.write().unwrap().insert(id, image);
-    }
-}
-
-#[inline]
-fn rgba_to_color_image(rgba_image: &RgbaImage) -> ColorImage {
-    let size = [rgba_image.width() as usize, rgba_image.height() as usize];
-    let pixels = rgba_image.as_flat_samples();
-    ColorImage::from_rgba_unmultiplied(size, pixels.as_slice())
-}
-
-/// Represents an image-based icon with a unique ID and pixel data.
-#[derive(Clone, Debug)]
-pub struct ImageIcon {
-    /// Unique identifier for the image icon, used for texture caching.
-    pub id: ImageIconId,
-    /// Shared pixel data of the icon in `ColorImage` format.
-    pub image: Arc<ColorImage>,
-}
-
-impl ImageIcon {
-    /// Creates a new [`ImageIcon`] from the given ID and image data.
-    #[inline]
-    pub fn new(id: ImageIconId, image: Arc<ColorImage>) -> Self {
-        Self { id, image }
-    }
-
-    /// Loads an [`ImageIcon`] from [`ICONS_CACHE`] or calls `loader` if not cached.
-    /// The loaded image is converted to a [`ColorImage`], cached, and returned.
-    #[inline]
-    pub fn try_load<F, I>(id: impl Into<ImageIconId>, loader: F) -> Option<Self>
-    where
-        F: FnOnce() -> Option<I>,
-        I: Into<RgbaImage>,
-    {
-        let id = id.into();
-        let image = ICONS_CACHE.get_image(&id).or_else(|| {
-            let img = loader()?;
-            let img = Arc::new(rgba_to_color_image(&img.into()));
-            ICONS_CACHE.insert_image(id.clone(), img.clone());
-            Some(img)
-        })?;
-
-        Some(ImageIcon::new(id, image))
-    }
-
-    /// Returns a texture handle for the icon, using the given [`Context`].
-    ///
-    /// If the texture is already cached in [`ICONS_CACHE`], it is reused.
-    /// Otherwise, a new texture is created from the [`ColorImage`] and cached.
-    #[inline]
-    pub fn texture(&self, ctx: &Context) -> TextureHandle {
-        ICONS_CACHE.texture(ctx, &self.id, &self.image)
-    }
-}
-
-/// Unique identifier for an image-based icon.
-///
-/// Used to distinguish cached images and textures by either a file path
-/// or a Windows window handle.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub enum ImageIconId {
-    /// Identifier based on a file system path.
-    Path(Arc<Path>),
-    /// Windows HWND handle.
-    Hwnd(isize),
-}
-
-impl From<&Path> for ImageIconId {
-    #[inline]
-    fn from(value: &Path) -> Self {
-        Self::Path(value.into())
-    }
-}
-
-impl From<isize> for ImageIconId {
-    #[inline]
-    fn from(value: isize) -> Self {
-        Self::Hwnd(value)
-    }
-}

komorebi-bar/src/widgets/network.rs

@@ -3,13 +3,13 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Color32;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
-use eframe::egui::text::LayoutJob;
 use num_derive::FromPrimitive;
 use serde::Deserialize;
 use serde::Serialize;
@@ -58,7 +58,6 @@ pub struct NetworkSelectConfig {
 
 impl From<NetworkConfig> for Network {
     fn from(value: NetworkConfig) -> Self {
-        let default_refresh_interval = 10;
         let data_refresh_interval = value.data_refresh_interval.unwrap_or(10);
 
         Self {
@@ -68,14 +67,10 @@ impl From<NetworkConfig> for Network {
             show_default_interface: value.show_default_interface.unwrap_or(true),
             networks_network_activity: Networks::new_with_refreshed_list(),
             default_interface: String::new(),
-            default_refresh_interval,
             data_refresh_interval,
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
             auto_select: value.auto_select,
             activity_left_padding: value.activity_left_padding.unwrap_or_default(),
-            last_updated_default_interface: Instant::now()
-                .checked_sub(Duration::from_secs(default_refresh_interval))
-                .unwrap(),
             last_state_total_activity: vec![],
             last_state_activity: vec![],
             last_updated_network_activity: Instant::now()
@@ -91,12 +86,10 @@ pub struct Network {
     pub show_activity: bool,
     pub show_default_interface: bool,
     networks_network_activity: Networks,
-    default_refresh_interval: u64,
     data_refresh_interval: u64,
     label_prefix: LabelPrefix,
     auto_select: Option<NetworkSelectConfig>,
     default_interface: String,
-    last_updated_default_interface: Instant,
     last_state_total_activity: Vec<NetworkReading>,
     last_state_activity: Vec<NetworkReading>,
     last_updated_network_activity: Instant,
@@ -105,18 +98,10 @@ pub struct Network {
 
 impl Network {
     fn default_interface(&mut self) {
-        let now = Instant::now();
-
-        if now.duration_since(self.last_updated_default_interface)
-            > Duration::from_secs(self.default_refresh_interval)
-        {
-            if let Ok(interface) = netdev::get_default_interface()
-                && let Some(friendly_name) = &interface.friendly_name
-            {
+        if let Ok(interface) = netdev::get_default_interface() {
+            if let Some(friendly_name) = &interface.friendly_name {
                 self.default_interface.clone_from(friendly_name);
             }
-
-            self.last_updated_default_interface = now;
         }
     }
 
@@ -131,40 +116,43 @@ impl Network {
             activity.clear();
             total_activity.clear();
 
-            if let Ok(interface) = netdev::get_default_interface()
-                && let Some(friendly_name) = &interface.friendly_name
-            {
-                self.default_interface.clone_from(friendly_name);
+            if let Ok(interface) = netdev::get_default_interface() {
+                if let Some(friendly_name) = &interface.friendly_name {
+                    self.default_interface.clone_from(friendly_name);
 
-                self.networks_network_activity.refresh(true);
+                    self.networks_network_activity.refresh(true);
 
-                for (interface_name, data) in &self.networks_network_activity {
-                    if friendly_name.eq(interface_name) {
-                        if self.show_activity {
-                            let received =
-                                Self::to_pretty_bytes(data.received(), self.data_refresh_interval);
-                            let transmitted = Self::to_pretty_bytes(
-                                data.transmitted(),
-                                self.data_refresh_interval,
-                            );
+                    for (interface_name, data) in &self.networks_network_activity {
+                        if friendly_name.eq(interface_name) {
+                            if self.show_activity {
+                                let received = Self::to_pretty_bytes(
+                                    data.received(),
+                                    self.data_refresh_interval,
+                                );
+                                let transmitted = Self::to_pretty_bytes(
+                                    data.transmitted(),
+                                    self.data_refresh_interval,
+                                );
 
-                            activity.push(NetworkReading::new(
-                                NetworkReadingFormat::Speed,
-                                ReadingValue::from(received),
-                                ReadingValue::from(transmitted),
-                            ));
-                        }
+                                activity.push(NetworkReading::new(
+                                    NetworkReadingFormat::Speed,
+                                    ReadingValue::from(received),
+                                    ReadingValue::from(transmitted),
+                                ));
+                            }
 
-                        if self.show_total_activity {
-                            let total_received = Self::to_pretty_bytes(data.total_received(), 1);
-                            let total_transmitted =
-                                Self::to_pretty_bytes(data.total_transmitted(), 1);
+                            if self.show_total_activity {
+                                let total_received =
+                                    Self::to_pretty_bytes(data.total_received(), 1);
+                                let total_transmitted =
+                                    Self::to_pretty_bytes(data.total_transmitted(), 1);
 
-                            total_activity.push(NetworkReading::new(
-                                NetworkReadingFormat::Total,
-                                ReadingValue::from(total_received),
-                                ReadingValue::from(total_transmitted),
-                            ))
+                                total_activity.push(NetworkReading::new(
+                                    NetworkReadingFormat::Total,
+                                    ReadingValue::from(total_received),
+                                    ReadingValue::from(total_transmitted),
+                                ))
+                            }
                         }
                     }
                 }
@@ -324,9 +312,10 @@ impl Network {
         if SelectableFrame::new_auto(selected, auto_focus_fill)
             .show(ui, add_contents)
             .clicked()
-            && let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn()
         {
-            eprintln!("{error}");
+            if let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn() {
+                eprintln!("{}", error);
+            }
         }
     }
 }
@@ -546,6 +535,6 @@ enum DataUnit {
 
 impl fmt::Display for DataUnit {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{self:?}")
+        write!(f, "{:?}", self)
     }
 }

komorebi-bar/src/widgets/storage.rs

@@ -3,12 +3,12 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -25,10 +25,6 @@ pub struct StorageConfig {
     pub data_refresh_interval: Option<u64>,
     /// Display label prefix
     pub label_prefix: Option<LabelPrefix>,
-    /// Show disks that are read only. (default: false)
-    pub show_read_only_disks: Option<bool>,
-    /// Show removable disks. (default: true)
-    pub show_removable_disks: Option<bool>,
     /// Select when the current percentage is over this value [[1-100]]
     pub auto_select_over: Option<u8>,
     /// Hide when the current percentage is under this value [[1-100]]
@@ -42,8 +38,6 @@ impl From<StorageConfig> for Storage {
             disks: Disks::new_with_refreshed_list(),
             data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
-            show_read_only_disks: value.show_read_only_disks.unwrap_or(false),
-            show_removable_disks: value.show_removable_disks.unwrap_or(true),
             auto_select_over: value.auto_select_over.map(|o| o.clamp(1, 100)),
             auto_hide_under: value.auto_hide_under.map(|o| o.clamp(1, 100)),
             last_updated: Instant::now(),
@@ -61,8 +55,6 @@ pub struct Storage {
     disks: Disks,
     data_refresh_interval: u64,
     label_prefix: LabelPrefix,
-    show_read_only_disks: bool,
-    show_removable_disks: bool,
     auto_select_over: Option<u8>,
     auto_hide_under: Option<u8>,
     last_updated: Instant,
@@ -79,12 +71,6 @@ impl Storage {
         let mut disks = vec![];
 
         for disk in &self.disks {
-            if disk.is_read_only() && !self.show_read_only_disks {
-                continue;
-            }
-            if disk.is_removable() && !self.show_removable_disks {
-                continue;
-            }
             let mount = disk.mount_point();
             let total = disk.total_space();
             let available = disk.available_space();
@@ -101,7 +87,7 @@ impl Storage {
                         LabelPrefix::Text | LabelPrefix::IconAndText => {
                             format!("{} {}%", mount.to_string_lossy(), percentage)
                         }
-                        LabelPrefix::None | LabelPrefix::Icon => format!("{percentage}%"),
+                        LabelPrefix::None | LabelPrefix::Icon => format!("{}%", percentage),
                     },
                     selected,
                 })
@@ -156,15 +142,17 @@ impl BarWidget for Storage {
                     if SelectableFrame::new_auto(output.selected, auto_focus_fill)
                         .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
-                        && let Err(error) = Command::new("cmd.exe")
+                    {
+                        if let Err(error) = Command::new("cmd.exe")
                             .args([
                                 "/C",
                                 "explorer.exe",
                                 output.label.split(' ').collect::<Vec<&str>>()[0],
                             ])
                             .spawn()
-                    {
-                        eprintln!("{error}")
+                        {
+                            eprintln!("{}", error)
+                        }
                     }
                 });
             }

komorebi-bar/src/widgets/time.rs

@@ -6,6 +6,7 @@ use crate::widgets::widget::BarWidget;
 use chrono::Local;
 use chrono::NaiveTime;
 use chrono_tz::Tz;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
@@ -15,7 +16,6 @@ use eframe::egui::Stroke;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
-use eframe::egui::text::LayoutJob;
 use eframe::epaint::StrokeKind;
 use lazy_static::lazy_static;
 use serde::Deserialize;
@@ -209,7 +209,7 @@ impl Time {
                             Some(dt.time()),
                         )
                     }
-                    Err(_) => (format!("Invalid timezone: {timezone:?}"), None),
+                    Err(_) => (format!("Invalid timezone: {:?}", timezone), None),
                 },
                 None => {
                     let dt = Local::now();

komorebi-bar/src/widgets/update.rs

@@ -2,12 +2,12 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widgets::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
-use eframe::egui::text::LayoutJob;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -140,14 +140,16 @@ impl BarWidget for Update {
                     if SelectableFrame::new(false)
                         .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
-                        && let Err(error) = Command::new("explorer.exe")
+                    {
+                        if let Err(error) = Command::new("explorer.exe")
                             .args([format!(
                                 "https://github.com/LGUG2Z/komorebi/releases/v{}",
                                 self.latest_version
                             )])
                             .spawn()
-                    {
-                        eprintln!("{error}")
+                        {
+                            eprintln!("{}", error)
+                        }
                     }
                 });
             }

komorebi-client/Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "komorebi-client"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.37"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-komorebi = { path = "../komorebi", default-features = false }
+komorebi = { path = "../komorebi" }
 
 uds_windows = { workspace = true }
 serde_json = { workspace = true }
 
 [features]
 default = ["schemars"]
-schemars = ["komorebi/default"]
+schemars = ["komorebi/schemars"]

komorebi-client/src/lib.rs

@@ -1,31 +1,8 @@
 #![warn(clippy::all)]
 #![allow(clippy::missing_errors_doc)]
 
-pub use komorebi::AnimationsConfig;
-pub use komorebi::AppSpecificConfigurationPath;
-pub use komorebi::AspectRatio;
-pub use komorebi::BorderColours;
-pub use komorebi::Colour;
-pub use komorebi::CrossBoundaryBehaviour;
-pub use komorebi::GlobalState;
-pub use komorebi::KomorebiTheme;
-pub use komorebi::MonitorConfig;
-pub use komorebi::Notification;
-pub use komorebi::NotificationEvent;
-pub use komorebi::PredefinedAspectRatio;
-pub use komorebi::Rgb;
-pub use komorebi::RuleDebug;
-pub use komorebi::StackbarConfig;
-pub use komorebi::State;
-pub use komorebi::StaticConfig;
-pub use komorebi::SubscribeOptions;
-pub use komorebi::TabsConfig;
-pub use komorebi::VirtualDesktopNotification;
-pub use komorebi::WindowContainerBehaviour;
-pub use komorebi::WindowsApi;
-pub use komorebi::WorkspaceConfig;
-pub use komorebi::animation::PerAnimationPrefixConfig;
 pub use komorebi::animation::prefix::AnimationPrefix;
+pub use komorebi::animation::PerAnimationPrefixConfig;
 pub use komorebi::asc::ApplicationSpecificConfiguration;
 pub use komorebi::border_manager::BorderInfo;
 pub use komorebi::config_generation::ApplicationConfiguration;
@@ -34,6 +11,8 @@ pub use komorebi::config_generation::IdWithIdentifierAndComment;
 pub use komorebi::config_generation::MatchingRule;
 pub use komorebi::config_generation::MatchingStrategy;
 pub use komorebi::container::Container;
+pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
+pub use komorebi::core::replace_env_in_path;
 pub use komorebi::core::AnimationStyle;
 pub use komorebi::core::ApplicationIdentifier;
 pub use komorebi::core::Arrangement;
@@ -63,8 +42,6 @@ pub use komorebi::core::StackbarLabel;
 pub use komorebi::core::StackbarMode;
 pub use komorebi::core::StateQuery;
 pub use komorebi::core::WindowKind;
-pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
-pub use komorebi::core::replace_env_in_path;
 pub use komorebi::monitor::Monitor;
 pub use komorebi::monitor_reconciliator::MonitorNotification;
 pub use komorebi::ring::Ring;
@@ -74,10 +51,32 @@ pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
 pub use komorebi::workspace::WorkspaceGlobals;
 pub use komorebi::workspace::WorkspaceLayer;
+pub use komorebi::AnimationsConfig;
+pub use komorebi::AppSpecificConfigurationPath;
+pub use komorebi::AspectRatio;
+pub use komorebi::BorderColours;
+pub use komorebi::Colour;
+pub use komorebi::CrossBoundaryBehaviour;
+pub use komorebi::GlobalState;
+pub use komorebi::KomorebiTheme;
+pub use komorebi::MonitorConfig;
+pub use komorebi::Notification;
+pub use komorebi::NotificationEvent;
+pub use komorebi::PredefinedAspectRatio;
+pub use komorebi::Rgb;
+pub use komorebi::RuleDebug;
+pub use komorebi::StackbarConfig;
+pub use komorebi::State;
+pub use komorebi::StaticConfig;
+pub use komorebi::SubscribeOptions;
+pub use komorebi::TabsConfig;
+pub use komorebi::VirtualDesktopNotification;
+pub use komorebi::WindowContainerBehaviour;
+pub use komorebi::WindowsApi;
+pub use komorebi::WorkspaceConfig;
 
 use komorebi::DATA_DIR;
 
-use std::borrow::Borrow;
 use std::io::BufReader;
 use std::io::Read;
 use std::io::Write;
@@ -95,15 +94,12 @@ pub fn send_message(message: &SocketMessage) -> std::io::Result<()> {
     stream.write_all(serde_json::to_string(message)?.as_bytes())
 }
 
-pub fn send_batch<Q>(messages: impl IntoIterator<Item = Q>) -> std::io::Result<()>
-where
-    Q: Borrow<SocketMessage>,
-{
+pub fn send_batch(messages: impl IntoIterator<Item = SocketMessage>) -> std::io::Result<()> {
     let socket = DATA_DIR.join(KOMOREBI);
     let mut stream = UnixStream::connect(socket)?;
     stream.set_write_timeout(Some(Duration::from_secs(1)))?;
     let msgs = messages.into_iter().fold(String::new(), |mut s, m| {
-        if let Ok(m_str) = serde_json::to_string(m.borrow()) {
+        if let Ok(m_str) = serde_json::to_string(&m) {
             s.push_str(&m_str);
             s.push('\n');
         }

komorebi-gui/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.37"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-komorebi-client = { path = "../komorebi-client", default-features = false }
+komorebi-client = { path = "../komorebi-client" }
 
 eframe = { workspace = true }
 egui_extras = { workspace = true }

komorebi-gui/src/main.rs

@@ -1,9 +1,9 @@
 #![warn(clippy::all)]
 
 use eframe::egui;
+use eframe::egui::color_picker::Alpha;
 use eframe::egui::Color32;
 use eframe::egui::ViewportBuilder;
-use eframe::egui::color_picker::Alpha;
 use komorebi_client::BorderStyle;
 use komorebi_client::Colour;
 use komorebi_client::DefaultLayout;
@@ -78,8 +78,8 @@ impl From<&komorebi_client::Monitor> for MonitorConfig {
         }
 
         Self {
-            size: value.size,
-            work_area_offset: value.work_area_offset.unwrap_or_default(),
+            size: *value.size(),
+            work_area_offset: value.work_area_offset().unwrap_or_default(),
             workspaces,
         }
     }
@@ -95,22 +95,22 @@ struct WorkspaceConfig {
 
 impl From<&komorebi_client::Workspace> for WorkspaceConfig {
     fn from(value: &komorebi_client::Workspace) -> Self {
-        let layout = match value.layout {
-            Layout::Default(layout) => layout,
+        let layout = match value.layout() {
+            Layout::Default(layout) => *layout,
             Layout::Custom(_) => DefaultLayout::BSP,
         };
 
         let name = value
-            .name
+            .name()
             .to_owned()
             .unwrap_or_else(|| random_word::get(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),
+            tile: *value.tile(),
+            workspace_padding: value.workspace_padding().unwrap_or(20),
+            container_padding: value.container_padding().unwrap_or(20),
         }
     }
 }
@@ -437,7 +437,7 @@ impl eframe::App for KomorebiGui {
                             BorderStyle::Square,
                         ] {
                             if ui
-                                .add(egui::Button::selectable(
+                                .add(egui::SelectableLabel::new(
                                     self.border_config.border_style == option,
                                     option.to_string(),
                                 ))
@@ -494,7 +494,7 @@ impl eframe::App for KomorebiGui {
                         StackbarMode::Always,
                     ] {
                         if ui
-                            .add(egui::Button::selectable(
+                            .add(egui::SelectableLabel::new(
                                 self.stackbar_config.mode == option,
                                 option.to_string(),
                             ))
@@ -513,7 +513,7 @@ impl eframe::App for KomorebiGui {
                     ui.collapsing("Label", |ui| {
                         for option in [StackbarLabel::Process, StackbarLabel::Title] {
                             if ui
-                                .add(egui::Button::selectable(
+                                .add(egui::SelectableLabel::new(
                                     self.stackbar_config.label == option,
                                     option.to_string(),
                                 ))
@@ -772,7 +772,7 @@ impl eframe::App for KomorebiGui {
                                                     DefaultLayout::Grid,
                                                 ] {
                                                     if ui
-                                                        .add(egui::Button::selectable(
+                                                        .add(egui::SelectableLabel::new(
                                                             workspace.layout == option,
                                                             option.to_string(),
                                                         ))

komorebi-shortcuts/Cargo.toml

@@ -4,8 +4,8 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-whkd-parser = { git = "https://github.com/LGUG2Z/whkd", rev = "v0.2.9" }
-whkd-core = { git = "https://github.com/LGUG2Z/whkd", rev = "v0.2.9" }
+whkd-parser = { git = "https://github.com/LGUG2Z/whkd", rev = "29df24ff2dd715655b0366bd2a598837c699a8e9" }
+whkd-core = { git = "https://github.com/LGUG2Z/whkd", rev = "29df24ff2dd715655b0366bd2a598837c699a8e9" }
 
 eframe = { workspace = true }
 dirs = { workspace = true }

komorebi-shortcuts/src/main.rs

@@ -1,5 +1,6 @@
 use eframe::egui::ViewportBuilder;
 use std::path::PathBuf;
+use whkd_core::HotkeyBinding;
 use whkd_core::Whkdrc;
 
 #[derive(Default)]
@@ -57,18 +58,21 @@ impl eframe::App for Quicklook {
                             ui.label("Filter");
                             ui.add(
                                 eframe::egui::text_edit::TextEdit::singleline(&mut self.filter)
-                                    .hint_text("Filter by command...")
                                     .background_color(ctx.style().visuals.faint_bg_color),
                             );
                             ui.end_row();
+                            ui.end_row();
 
                             for binding in &whkdrc.bindings {
-                                let keys = binding.keys.join(" + ");
-                                if self.filter.is_empty() || binding.command.contains(&self.filter)
-                                {
-                                    ui.label(keys);
-                                    ui.label(&binding.command);
-                                    ui.end_row();
+                                if is_komorebic_binding(binding) {
+                                    let keys = binding.keys.join(" + ");
+                                    if self.filter.is_empty()
+                                        || binding.command.contains(&self.filter)
+                                    {
+                                        ui.label(keys);
+                                        ui.label(&binding.command);
+                                        ui.end_row();
+                                    }
                                 }
                             }
                         }
@@ -96,3 +100,7 @@ fn main() {
     )
     .unwrap();
 }
+
+fn is_komorebic_binding(binding: &HotkeyBinding) -> bool {
+    binding.command.starts_with("komorebic")
+}

komorebi-themes/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "komorebi-themes"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.37"
+edition = "2021"
 
 [dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "c9008bd5cfa288c926e9ea3aa18c92073f9281bd" }
-catppuccin-egui = { version = "5", default-features = false, features = ["egui32"] }
+base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "96f26c88d83781f234d42222293ec73d23a39ad8" }
+catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "bdaff30959512c4f7ee7304117076a48633d777f", default-features = false, features = ["egui31"] }
+#catppuccin-egui = { version = "5", default-features = false, features = ["egui30"] }
 eframe = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true }

komorebi-themes/src/colour.rs

@@ -1,6 +1,6 @@
 use hex_color::HexColor;
 #[cfg(feature = "schemars")]
-use schemars::SchemaGenerator;
+use schemars::gen::SchemaGenerator;
 #[cfg(feature = "schemars")]
 use schemars::schema::InstanceType;
 #[cfg(feature = "schemars")]

komorebi-themes/src/generator.rs

@@ -1,6 +1,6 @@
-use crate::Base16ColourPalette;
 use crate::colour::Colour;
 use crate::colour::Hex;
+use crate::Base16ColourPalette;
 use hex_color::HexColor;
 use std::collections::VecDeque;
 use std::fmt::Display;

komorebi-themes/src/lib.rs

@@ -4,8 +4,8 @@
 pub mod colour;
 mod generator;
 
-pub use generator::ThemeVariant;
 pub use generator::generate_base16_palette;
+pub use generator::ThemeVariant;
 
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -16,14 +16,14 @@ use strum::IntoEnumIterator;
 use crate::colour::Colour;
 pub use base16_egui_themes::Base16;
 pub use catppuccin_egui;
+use eframe::egui::style::Selection;
+use eframe::egui::style::WidgetVisuals;
+use eframe::egui::style::Widgets;
 pub use eframe::egui::Color32;
 use eframe::egui::Shadow;
 use eframe::egui::Stroke;
 use eframe::egui::Style;
 use eframe::egui::Visuals;
-use eframe::egui::style::Selection;
-use eframe::egui::style::WidgetVisuals;
-use eframe::egui::style::Widgets;
 use serde_variant::to_variant_name;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]

komorebi/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "komorebi"
-version = "0.1.39"
+version = "0.1.37"
 description = "A tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
-edition = "2024"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -17,13 +17,15 @@ crossbeam-channel = { workspace = true }
 crossbeam-utils = { workspace = true }
 ctrlc = { version = "3", features = ["termination"] }
 dirs = { workspace = true }
+dunce = { workspace = true }
+getset = "0.1"
 hotwatch = { workspace = true }
 lazy_static = { workspace = true }
 miow = "0.6"
 nanoid = "0.4"
 net2 = "0.2"
 os_info = "3.10"
-parking_lot = { workspace = true }
+parking_lot = "0.12"
 paste = { workspace = true }
 powershell_script = "1.0"
 regex = "1"

komorebi/src/animation/animation_manager.rs

@@ -1,5 +1,5 @@
-use std::collections::HashMap;
 use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 
 use super::prefix::AnimationPrefix;
 

komorebi/src/animation/engine.rs

@@ -1,4 +1,4 @@
-use color_eyre::eyre;
+use color_eyre::Result;
 
 use serde::Deserialize;
 use serde::Serialize;
@@ -6,10 +6,10 @@ use std::sync::atomic::Ordering;
 use std::time::Duration;
 use std::time::Instant;
 
+use super::RenderDispatcher;
 use super::ANIMATION_DURATION_GLOBAL;
 use super::ANIMATION_FPS;
 use super::ANIMATION_MANAGER;
-use super::RenderDispatcher;
 
 #[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
@@ -55,9 +55,9 @@ impl AnimationEngine {
 
     #[allow(clippy::cast_precision_loss)]
     pub fn animate(
-        render_dispatcher: impl RenderDispatcher + Send + 'static,
+        render_dispatcher: (impl RenderDispatcher + Send + 'static),
         duration: Duration,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         std::thread::spawn(move || {
             let animation_key = render_dispatcher.get_animation_key();
             if ANIMATION_MANAGER.lock().in_progress(animation_key.as_str()) {

komorebi/src/animation/lerp.rs

@@ -1,5 +1,5 @@
-use crate::AnimationStyle;
 use crate::core::Rect;
+use crate::AnimationStyle;
 
 use super::style::apply_ease_func;
 

komorebi/src/animation/mod.rs

@@ -4,9 +4,9 @@ use crate::core::animation::AnimationStyle;
 use lazy_static::lazy_static;
 use prefix::AnimationPrefix;
 use std::collections::HashMap;
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
 
 use parking_lot::Mutex;
 

komorebi/src/animation/prefix.rs

@@ -17,5 +17,5 @@ pub enum AnimationPrefix {
 }
 
 pub fn new_animation_key(prefix: AnimationPrefix, key: String) -> String {
-    format!("{prefix}:{key}")
+    format!("{}:{}", prefix, key)
 }

komorebi/src/animation/render_dispatcher.rs

@@ -1,8 +1,8 @@
-use color_eyre::eyre;
+use color_eyre::Result;
 
 pub trait RenderDispatcher {
     fn get_animation_key(&self) -> String;
-    fn pre_render(&self) -> eyre::Result<()>;
-    fn render(&self, delta: f64) -> eyre::Result<()>;
-    fn post_render(&self) -> eyre::Result<()>;
+    fn pre_render(&self) -> Result<()>;
+    fn render(&self, delta: f64) -> Result<()>;
+    fn post_render(&self) -> Result<()>;
 }

komorebi/src/border_manager/border.rs

@@ -1,30 +1,33 @@
-use crate::WINDOWS_11;
-use crate::WindowsApi;
+use crate::border_manager::window_kind_colour;
+use crate::border_manager::RenderTarget;
+use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
-use crate::border_manager::RenderTarget;
 use crate::border_manager::STYLE;
-use crate::border_manager::WindowKind;
-use crate::border_manager::window_kind_colour;
 use crate::core::BorderStyle;
 use crate::core::Rect;
 use crate::windows_api;
+use crate::WindowsApi;
+use crate::WINDOWS_11;
 use std::collections::HashMap;
 use std::ops::Deref;
-use std::sync::LazyLock;
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
+use std::sync::LazyLock;
 use windows::Win32::Foundation::FALSE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::TRUE;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Direct2D::Common::D2D_RECT_F;
-use windows::Win32::Graphics::Direct2D::Common::D2D_SIZE_U;
 use windows::Win32::Graphics::Direct2D::Common::D2D1_ALPHA_MODE_PREMULTIPLIED;
 use windows::Win32::Graphics::Direct2D::Common::D2D1_COLOR_F;
 use windows::Win32::Graphics::Direct2D::Common::D2D1_PIXEL_FORMAT;
+use windows::Win32::Graphics::Direct2D::Common::D2D_RECT_F;
+use windows::Win32::Graphics::Direct2D::Common::D2D_SIZE_U;
+use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
+use windows::Win32::Graphics::Direct2D::ID2D1Factory;
+use windows::Win32::Graphics::Direct2D::ID2D1SolidColorBrush;
 use windows::Win32::Graphics::Direct2D::D2D1_ANTIALIAS_MODE_PER_PRIMITIVE;
 use windows::Win32::Graphics::Direct2D::D2D1_BRUSH_PROPERTIES;
 use windows::Win32::Graphics::Direct2D::D2D1_FACTORY_TYPE_MULTI_THREADED;
@@ -33,34 +36,31 @@ use windows::Win32::Graphics::Direct2D::D2D1_PRESENT_OPTIONS_IMMEDIATELY;
 use windows::Win32::Graphics::Direct2D::D2D1_RENDER_TARGET_PROPERTIES;
 use windows::Win32::Graphics::Direct2D::D2D1_RENDER_TARGET_TYPE_DEFAULT;
 use windows::Win32::Graphics::Direct2D::D2D1_ROUNDED_RECT;
-use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
-use windows::Win32::Graphics::Direct2D::ID2D1Factory;
-use windows::Win32::Graphics::Direct2D::ID2D1SolidColorBrush;
+use windows::Win32::Graphics::Dwm::DwmEnableBlurBehindWindow;
 use windows::Win32::Graphics::Dwm::DWM_BB_BLURREGION;
 use windows::Win32::Graphics::Dwm::DWM_BB_ENABLE;
 use windows::Win32::Graphics::Dwm::DWM_BLURBEHIND;
-use windows::Win32::Graphics::Dwm::DwmEnableBlurBehindWindow;
 use windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT_UNKNOWN;
 use windows::Win32::Graphics::Gdi::CreateRectRgn;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::ValidateRect;
-use windows::Win32::UI::WindowsAndMessaging::CREATESTRUCTW;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESTROY;
-use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LOCATIONCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::GWLP_USERDATA;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetSystemMetrics;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
-use windows::Win32::UI::WindowsAndMessaging::IDC_ARROW;
 use windows::Win32::UI::WindowsAndMessaging::LoadCursorW;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
-use windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN;
 use windows::Win32::UI::WindowsAndMessaging::SetCursor;
 use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
+use windows::Win32::UI::WindowsAndMessaging::CREATESTRUCTW;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESTROY;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LOCATIONCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::GWLP_USERDATA;
+use windows::Win32::UI::WindowsAndMessaging::IDC_ARROW;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN;
 use windows::Win32::UI::WindowsAndMessaging::WM_CREATE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
@@ -102,10 +102,10 @@ pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
     let hwnd = hwnd.0 as isize;
 
-    if let Ok(class) = WindowsApi::real_window_class_w(hwnd)
-        && class.starts_with("komoborder")
-    {
-        hwnds.push(hwnd);
+    if let Ok(class) = WindowsApi::real_window_class_w(hwnd) {
+        if class.starts_with("komoborder") {
+            hwnds.push(hwnd);
+        }
     }
 
     true.into()
@@ -392,63 +392,63 @@ impl Border {
                         tracing::error!("failed to update border position {error}");
                     }
 
-                    if (!rect.is_same_size_as(&old_rect) || !rect.has_same_position_as(&old_rect))
-                        && let Some(render_target) = (*border_pointer).render_target.as_ref()
-                    {
-                        let border_width = (*border_pointer).width;
-                        let border_offset = (*border_pointer).offset;
+                    if !rect.is_same_size_as(&old_rect) {
+                        if let Some(render_target) = (*border_pointer).render_target.as_ref() {
+                            let border_width = (*border_pointer).width;
+                            let border_offset = (*border_pointer).offset;
 
-                        (*border_pointer).rounded_rect.rect = D2D_RECT_F {
-                            left: (border_width / 2 - border_offset) as f32,
-                            top: (border_width / 2 - border_offset) as f32,
-                            right: (rect.right - border_width / 2 + border_offset) as f32,
-                            bottom: (rect.bottom - border_width / 2 + border_offset) as f32,
-                        };
-
-                        let _ = render_target.Resize(&D2D_SIZE_U {
-                            width: rect.right as u32,
-                            height: rect.bottom as u32,
-                        });
-
-                        let window_kind = (*border_pointer).window_kind;
-                        if let Some(brush) = (*border_pointer).brushes.get(&window_kind) {
-                            render_target.BeginDraw();
-                            render_target.Clear(None);
-
-                            // Calculate border radius based on style
-                            let style = match (*border_pointer).style {
-                                BorderStyle::System => {
-                                    if *WINDOWS_11 {
-                                        BorderStyle::Rounded
-                                    } else {
-                                        BorderStyle::Square
-                                    }
-                                }
-                                BorderStyle::Rounded => BorderStyle::Rounded,
-                                BorderStyle::Square => BorderStyle::Square,
+                            (*border_pointer).rounded_rect.rect = D2D_RECT_F {
+                                left: (border_width / 2 - border_offset) as f32,
+                                top: (border_width / 2 - border_offset) as f32,
+                                right: (rect.right - border_width / 2 + border_offset) as f32,
+                                bottom: (rect.bottom - border_width / 2 + border_offset) as f32,
                             };
 
-                            match style {
-                                BorderStyle::Rounded => {
-                                    render_target.DrawRoundedRectangle(
-                                        &(*border_pointer).rounded_rect,
-                                        brush,
-                                        border_width as f32,
-                                        None,
-                                    );
-                                }
-                                BorderStyle::Square => {
-                                    render_target.DrawRectangle(
-                                        &(*border_pointer).rounded_rect.rect,
-                                        brush,
-                                        border_width as f32,
-                                        None,
-                                    );
-                                }
-                                _ => {}
-                            }
+                            let _ = render_target.Resize(&D2D_SIZE_U {
+                                width: rect.right as u32,
+                                height: rect.bottom as u32,
+                            });
 
-                            let _ = render_target.EndDraw(None, None);
+                            let window_kind = (*border_pointer).window_kind;
+                            if let Some(brush) = (*border_pointer).brushes.get(&window_kind) {
+                                render_target.BeginDraw();
+                                render_target.Clear(None);
+
+                                // Calculate border radius based on style
+                                let style = match (*border_pointer).style {
+                                    BorderStyle::System => {
+                                        if *WINDOWS_11 {
+                                            BorderStyle::Rounded
+                                        } else {
+                                            BorderStyle::Square
+                                        }
+                                    }
+                                    BorderStyle::Rounded => BorderStyle::Rounded,
+                                    BorderStyle::Square => BorderStyle::Square,
+                                };
+
+                                match style {
+                                    BorderStyle::Rounded => {
+                                        render_target.DrawRoundedRectangle(
+                                            &(*border_pointer).rounded_rect,
+                                            brush,
+                                            border_width as f32,
+                                            None,
+                                        );
+                                    }
+                                    BorderStyle::Square => {
+                                        render_target.DrawRectangle(
+                                            &(*border_pointer).rounded_rect.rect,
+                                            brush,
+                                            border_width as f32,
+                                            None,
+                                        );
+                                    }
+                                    _ => {}
+                                }
+
+                                let _ = render_target.EndDraw(None, None);
+                            }
                         }
                     }
 

komorebi/src/border_manager/mod.rs

@@ -1,17 +1,16 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
 mod border;
-use crate::WindowManager;
-use crate::WindowsApi;
 use crate::core::BorderImplementation;
 use crate::core::BorderStyle;
 use crate::core::WindowKind;
 use crate::ring::Ring;
 use crate::windows_api;
-use crate::workspace::Workspace;
 use crate::workspace::WorkspaceLayer;
-pub use border::Border;
+use crate::WindowManager;
+use crate::WindowsApi;
 use border::border_hwnds;
+pub use border::Border;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
@@ -22,15 +21,15 @@ use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use serde::Deserialize;
 use serde::Serialize;
-use std::collections::HashMap;
 use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 use std::ops::Deref;
-use std::sync::Arc;
-use std::sync::OnceLock;
 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 strum::Display;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
@@ -170,15 +169,13 @@ fn window_kind_colour(focus_kind: WindowKind) -> u32 {
 }
 
 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);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -211,12 +208,10 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
             .iter()
             .map(|w| w.hwnd)
             .collect::<Vec<_>>();
-        let workspace_layer = state.monitors.elements()[focused_monitor_idx].workspaces()
+        let workspace_layer = *state.monitors.elements()[focused_monitor_idx].workspaces()
             [focused_workspace_idx]
-            .layer;
+            .layer();
         let foreground_window = WindowsApi::foreground_window().unwrap_or_default();
-        let layer_changed = previous_layer != workspace_layer;
-        let forced_update = matches!(notification, Notification::ForceUpdate);
 
         drop(state);
 
@@ -226,7 +221,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // 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 {
+                        if let Some(monocle) = ws.monocle_container() {
                             let window_kind = if monitor_idx != focused_monitor_idx {
                                 WindowKind::Unfocused
                             } else {
@@ -239,17 +234,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 .unwrap_or_default()
                                 .set_accent(window_kind_colour(window_kind))?;
 
-                            if ws.layer == WorkspaceLayer::Floating {
-                                for window in ws.floating_windows() {
-                                    let mut window_kind = WindowKind::Unfocused;
-
-                                    if foreground_window == window.hwnd {
-                                        window_kind = WindowKind::Floating;
-                                    }
-
-                                    window.set_accent(window_kind_colour(window_kind))?;
-                                }
-                            }
                             continue 'monitors;
                         }
 
@@ -257,7 +241,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let window_kind = if idx != ws.focused_container_idx()
                                 || monitor_idx != focused_monitor_idx
                             {
-                                if c.locked {
+                                if ws.locked_containers().contains(&idx) {
                                     WindowKind::UnfocusedLocked
                                 } else {
                                     WindowKind::Unfocused
@@ -341,11 +325,15 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             should_process_notification = true;
                         }
 
-                        if !should_process_notification
-                            && let Some(Notification::Update(ref previous)) = previous_notification
-                            && previous.unwrap_or_default() != notification_hwnd.unwrap_or_default()
-                        {
-                            should_process_notification = true;
+                        if !should_process_notification {
+                            if let Some(Notification::Update(ref previous)) = previous_notification
+                            {
+                                if previous.unwrap_or_default()
+                                    != notification_hwnd.unwrap_or_default()
+                                {
+                                    should_process_notification = true;
+                                }
+                            }
                         }
 
                         should_process_notification
@@ -354,7 +342,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 };
 
                 if !should_process_notification {
-                    tracing::debug!("monitor state matches latest snapshot, skipping notification");
+                    tracing::trace!("monitor state matches latest snapshot, skipping notification");
                     continue 'receiver;
                 }
 
@@ -381,7 +369,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // 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 {
+                        if !ws.tile() {
                             // Remove all borders on this monitor
                             remove_borders(
                                 &mut borders,
@@ -394,16 +382,16 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         }
 
                         // Handle the monocle container separately
-                        if let Some(monocle) = &ws.monocle_container {
+                        if let Some(monocle) = ws.monocle_container() {
                             let mut new_border = false;
                             let focused_window_hwnd =
                                 monocle.focused_window().map(|w| w.hwnd).unwrap_or_default();
-                            let id = monocle.id.clone();
+                            let id = monocle.id().clone();
                             let border = match borders.entry(id.clone()) {
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
                                     if let Ok(border) = Border::create(
-                                        &monocle.id,
+                                        monocle.id(),
                                         focused_window_hwnd,
                                         monitor_idx,
                                     ) {
@@ -460,48 +448,22 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             windows_borders.insert(focused_window_hwnd, id);
 
                             let border_hwnd = border.hwnd;
+                            // Remove all borders on this monitor except monocle
+                            remove_borders(
+                                &mut borders,
+                                &mut windows_borders,
+                                monitor_idx,
+                                |_, b| border_hwnd != b.hwnd,
+                            )?;
 
-                            if ws.layer == WorkspaceLayer::Floating {
-                                handle_floating_borders(
-                                    &mut borders,
-                                    &mut windows_borders,
-                                    ws,
-                                    monitor_idx,
-                                    foreground_window,
-                                    layer_changed,
-                                    forced_update,
-                                )?;
-
-                                // Remove all borders on this monitor except monocle and floating borders
-                                remove_borders(
-                                    &mut borders,
-                                    &mut windows_borders,
-                                    monitor_idx,
-                                    |_, b| {
-                                        border_hwnd != b.hwnd
-                                            && !ws
-                                                .floating_windows()
-                                                .iter()
-                                                .any(|w| w.hwnd == b.tracking_hwnd)
-                                    },
-                                )?;
-                            } else {
-                                // Remove all borders on this monitor except monocle
-                                remove_borders(
-                                    &mut borders,
-                                    &mut windows_borders,
-                                    monitor_idx,
-                                    |_, b| border_hwnd != b.hwnd,
-                                )?;
-                            }
                             continue 'monitors;
                         }
 
                         let foreground_hwnd = WindowsApi::foreground_window().unwrap_or_default();
                         let foreground_monitor_id =
                             WindowsApi::monitor_from_window(foreground_hwnd);
-                        let is_maximized =
-                            foreground_monitor_id == m.id && WindowsApi::is_zoomed(foreground_hwnd);
+                        let is_maximized = foreground_monitor_id == m.id()
+                            && WindowsApi::is_zoomed(foreground_hwnd);
 
                         if is_maximized {
                             // Remove all borders on this monitor
@@ -519,7 +481,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         let mut container_and_floating_window_ids = ws
                             .containers()
                             .iter()
-                            .map(|c| c.id.clone())
+                            .map(|c| c.id().clone())
                             .collect::<Vec<_>>();
 
                         for w in ws.floating_windows() {
@@ -537,7 +499,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         'containers: for (idx, c) in ws.containers().iter().enumerate() {
                             let focused_window_hwnd =
                                 c.focused_window().map(|w| w.hwnd).unwrap_or_default();
-                            let id = c.id.clone();
+                            let id = c.id().clone();
 
                             // Get the border entry for this container from the map or create one
                             let mut new_border = false;
@@ -545,7 +507,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
                                     if let Ok(border) =
-                                        Border::create(&c.id, focused_window_hwnd, monitor_idx)
+                                        Border::create(c.id(), focused_window_hwnd, monitor_idx)
                                     {
                                         new_border = true;
                                         entry.insert(border)
@@ -561,7 +523,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 || monitor_idx != focused_monitor_idx
                                 || focused_window_hwnd != foreground_window
                             {
-                                if c.locked {
+                                if ws.locked_containers().contains(&idx) {
                                     WindowKind::UnfocusedLocked
                                 } else {
                                     WindowKind::Unfocused
@@ -601,12 +563,15 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let rect = match WindowsApi::window_rect(focused_window_hwnd) {
                                 Ok(rect) => rect,
                                 Err(_) => {
-                                    remove_border(&c.id, &mut borders, &mut windows_borders)?;
+                                    remove_border(c.id(), &mut borders, &mut windows_borders)?;
                                     continue 'containers;
                                 }
                             };
                             border.window_rect = rect;
 
+                            let layer_changed = previous_layer != workspace_layer;
+                            let forced_update = matches!(notification, Notification::ForceUpdate);
+
                             let should_invalidate = new_border
                                 || (last_focus_state != new_focus_state)
                                 || layer_changed
@@ -626,15 +591,65 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             windows_borders.insert(focused_window_hwnd, id);
                         }
 
-                        handle_floating_borders(
-                            &mut borders,
-                            &mut windows_borders,
-                            ws,
-                            monitor_idx,
-                            foreground_window,
-                            layer_changed,
-                            forced_update,
-                        )?;
+                        {
+                            for window in ws.floating_windows() {
+                                let mut new_border = false;
+                                let id = window.hwnd.to_string();
+                                let border = match borders.entry(id.clone()) {
+                                    Entry::Occupied(entry) => entry.into_mut(),
+                                    Entry::Vacant(entry) => {
+                                        if let Ok(border) = Border::create(
+                                            &window.hwnd.to_string(),
+                                            window.hwnd,
+                                            monitor_idx,
+                                        ) {
+                                            new_border = true;
+                                            entry.insert(border)
+                                        } else {
+                                            continue 'monitors;
+                                        }
+                                    }
+                                };
+
+                                let last_focus_state = border.window_kind;
+
+                                let new_focus_state = if foreground_window == window.hwnd {
+                                    WindowKind::Floating
+                                } else {
+                                    WindowKind::Unfocused
+                                };
+
+                                border.window_kind = new_focus_state;
+
+                                // Update the border's monitor idx in case it changed
+                                border.monitor_idx = Some(monitor_idx);
+
+                                let rect = WindowsApi::window_rect(window.hwnd)?;
+                                border.window_rect = rect;
+
+                                let layer_changed = previous_layer != workspace_layer;
+                                let forced_update =
+                                    matches!(notification, Notification::ForceUpdate);
+
+                                let should_invalidate = new_border
+                                    || (last_focus_state != new_focus_state)
+                                    || layer_changed
+                                    || forced_update;
+
+                                if should_invalidate {
+                                    if forced_update && !new_border {
+                                        // Update the border brushes if there was a forced update
+                                        // notification and this is not a new border (new border's
+                                        // already have their brushes updated on creation)
+                                        border.update_brushes()?;
+                                    }
+                                    border.set_position(&rect, window.hwnd)?;
+                                    border.invalidate();
+                                }
+
+                                windows_borders.insert(window.hwnd, id);
+                            }
+                        }
                     }
                 }
             }
@@ -650,68 +665,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
     Ok(())
 }
 
-fn handle_floating_borders(
-    borders: &mut HashMap<String, Box<Border>>,
-    windows_borders: &mut HashMap<isize, String>,
-    ws: &Workspace,
-    monitor_idx: usize,
-    foreground_window: isize,
-    layer_changed: bool,
-    forced_update: bool,
-) -> color_eyre::Result<()> {
-    for window in ws.floating_windows() {
-        let mut new_border = false;
-        let id = window.hwnd.to_string();
-        let border = match borders.entry(id.clone()) {
-            Entry::Occupied(entry) => entry.into_mut(),
-            Entry::Vacant(entry) => {
-                if let Ok(border) =
-                    Border::create(&window.hwnd.to_string(), window.hwnd, monitor_idx)
-                {
-                    new_border = true;
-                    entry.insert(border)
-                } else {
-                    return Ok(());
-                }
-            }
-        };
-
-        let last_focus_state = border.window_kind;
-
-        let new_focus_state = if foreground_window == window.hwnd {
-            WindowKind::Floating
-        } else {
-            WindowKind::Unfocused
-        };
-
-        border.window_kind = new_focus_state;
-
-        // Update the border's monitor idx in case it changed
-        border.monitor_idx = Some(monitor_idx);
-
-        let rect = WindowsApi::window_rect(window.hwnd)?;
-        border.window_rect = rect;
-
-        let should_invalidate =
-            new_border || (last_focus_state != new_focus_state) || layer_changed || forced_update;
-
-        if should_invalidate {
-            if forced_update && !new_border {
-                // Update the border brushes if there was a forced update
-                // notification and this is not a new border (new border's
-                // already have their brushes updated on creation)
-                border.update_brushes()?;
-            }
-            border.set_position(&rect, window.hwnd)?;
-            border.invalidate();
-        }
-
-        windows_borders.insert(window.hwnd, id);
-    }
-
-    Ok(())
-}
-
 /// Removes all borders from monitor with index `monitor_idx` filtered by
 /// `condition`. This condition is a function that will take a reference to
 /// the container id and the border and returns a bool, if true that border

komorebi/src/com/interfaces.rs

@@ -6,17 +6,17 @@
 
 use std::ffi::c_void;
 use std::ops::Deref;
+use windows::core::IUnknown;
+use windows::core::IUnknown_Vtbl;
+use windows::core::GUID;
+use windows::core::HRESULT;
+use windows::core::HSTRING;
+use windows::core::PCWSTR;
+use windows::core::PWSTR;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::SIZE;
 use windows::Win32::UI::Shell::Common::IObjectArray;
-use windows::core::GUID;
-use windows::core::HRESULT;
-use windows::core::HSTRING;
-use windows::core::IUnknown;
-use windows::core::IUnknown_Vtbl;
-use windows::core::PCWSTR;
-use windows::core::PWSTR;
 use windows_core::BOOL;
 
 type DesktopID = GUID;
@@ -129,7 +129,7 @@ pub unsafe trait IApplicationView: IUnknown {
     pub unsafe fn get_app_user_model_id(&self, id: *mut PWSTR) -> HRESULT; // Proc17
     pub unsafe fn set_app_user_model_id(&self, id: PCWSTR) -> HRESULT;
     pub unsafe fn is_equal_by_app_user_model_id(&self, id: PCWSTR, out_result: *mut INT)
-    -> HRESULT;
+        -> HRESULT;
 
     /*** IApplicationView methods ***/
     pub unsafe fn get_view_state(&self, out_state: *mut UINT) -> HRESULT; // Proc20

komorebi/src/com/mod.rs

@@ -11,11 +11,11 @@ use interfaces::IServiceProvider;
 use std::ffi::c_void;
 
 use windows::Win32::Foundation::HWND;
-use windows::Win32::System::Com::CLSCTX_ALL;
-use windows::Win32::System::Com::COINIT_MULTITHREADED;
 use windows::Win32::System::Com::CoCreateInstance;
 use windows::Win32::System::Com::CoInitializeEx;
 use windows::Win32::System::Com::CoUninitialize;
+use windows::Win32::System::Com::CLSCTX_ALL;
+use windows::Win32::System::Com::COINIT_MULTITHREADED;
 use windows_core::Interface;
 
 struct ComInit();
@@ -64,7 +64,7 @@ fn get_iapplication_view_collection(provider: &IServiceProvider) -> IApplication
     })
 }
 
-#[unsafe(no_mangle)]
+#[no_mangle]
 pub extern "C" fn SetCloak(hwnd: HWND, cloak_type: u32, flags: i32) {
     COM_INIT.with(|_| {
         let provider = get_iservice_provider();

komorebi/src/container.rs

@@ -1,19 +1,18 @@
 use std::collections::VecDeque;
 
+use getset::Getters;
 use nanoid::nanoid;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::Lockable;
 use crate::ring::Ring;
 use crate::window::Window;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Container {
-    pub id: String,
-    #[serde(default)]
-    pub locked: bool,
+    #[getset(get = "pub")]
+    id: String,
     windows: Ring<Window>,
 }
 
@@ -23,33 +22,22 @@ impl Default for Container {
     fn default() -> Self {
         Self {
             id: nanoid!(),
-            locked: false,
             windows: Ring::default(),
         }
     }
 }
 
-impl Lockable for Container {
-    fn locked(&self) -> bool {
-        self.locked
-    }
-
-    fn set_locked(&mut self, locked: bool) -> &mut Self {
-        self.locked = locked;
-        self
-    }
-}
-
 impl Container {
     pub fn hide(&self, omit: Option<isize>) {
         for window in self.windows().iter().rev() {
             let mut should_hide = omit.is_none();
 
-            if !should_hide
-                && let Some(omit) = omit
-                && omit != window.hwnd
-            {
-                should_hide = true
+            if !should_hide {
+                if let Some(omit) = omit {
+                    if omit != window.hwnd {
+                        should_hide = true
+                    }
+                }
             }
 
             if should_hide {
@@ -81,10 +69,10 @@ impl Container {
 
     pub fn hwnd_from_exe(&self, exe: &str) -> Option<isize> {
         for window in self.windows() {
-            if let Ok(window_exe) = window.exe()
-                && exe == window_exe
-            {
-                return Option::from(window.hwnd);
+            if let Ok(window_exe) = window.exe() {
+                if exe == window_exe {
+                    return Option::from(window.hwnd);
+                }
             }
         }
 
@@ -93,10 +81,10 @@ impl Container {
 
     pub fn idx_from_exe(&self, exe: &str) -> Option<usize> {
         for (idx, window) in self.windows().iter().enumerate() {
-            if let Ok(window_exe) = window.exe()
-                && exe == window_exe
-            {
-                return Option::from(idx);
+            if let Ok(window_exe) = window.exe() {
+                if exe == window_exe {
+                    return Option::from(idx);
+                }
             }
         }
 
@@ -156,7 +144,6 @@ impl Container {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use serde_json;
 
     #[test]
     fn test_contains_window() {
@@ -263,40 +250,4 @@ mod tests {
         // Should return None since window 4 doesn't exist
         assert_eq!(container.idx_for_window(4), None);
     }
-
-    #[test]
-    fn deserializes_with_missing_locked_field_defaults_to_false() {
-        let json = r#"{
-            "id": "test-1",
-            "windows": { "elements": [], "focused": 0 }
-        }"#;
-        let container: Container = serde_json::from_str(json).expect("Should deserialize");
-
-        assert!(!container.locked);
-        assert_eq!(container.id, "test-1");
-        assert!(container.windows().is_empty());
-
-        let json = r#"{
-            "id": "test-2",
-            "windows": { "elements": [ { "hwnd": 5 }, { "hwnd": 9 } ], "focused": 1 }
-        }"#;
-        let container: Container = serde_json::from_str(json).unwrap();
-        assert_eq!(container.id, "test-2");
-        assert!(!container.locked);
-        assert_eq!(container.windows(), &[Window::from(5), Window::from(9)]);
-        assert_eq!(container.focused_window_idx(), 1);
-    }
-
-    #[test]
-    fn serializes_and_deserializes() {
-        let mut container = Container::default();
-        container.set_locked(true);
-
-        let serialized = serde_json::to_string(&container).expect("Should serialize");
-        let deserialized: Container =
-            serde_json::from_str(&serialized).expect("Should deserialize");
-
-        assert!(deserialized.locked);
-        assert_eq!(deserialized.id, container.id);
-    }
 }

komorebi/src/core/animation.rs

@@ -1,8 +1,8 @@
 use clap::ValueEnum;
 
+use serde::ser::SerializeSeq;
 use serde::Deserialize;
 use serde::Serialize;
-use serde::ser::SerializeSeq;
 use strum::Display;
 use strum::EnumString;
 

komorebi/src/core/arrangement.rs

@@ -6,16 +6,14 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::CustomLayout;
-use super::DefaultLayout;
-use super::Rect;
 use super::custom_layout::Column;
 use super::custom_layout::ColumnSplit;
 use super::custom_layout::ColumnSplitWithCapacity;
-use crate::default_layout::LayoutOptions;
+use super::CustomLayout;
+use super::DefaultLayout;
+use super::Rect;
 
 pub trait Arrangement {
-    #[allow(clippy::too_many_arguments)]
     fn calculate(
         &self,
         area: &Rect,
@@ -23,9 +21,6 @@ pub trait Arrangement {
         container_padding: Option<i32>,
         layout_flip: Option<Axis>,
         resize_dimensions: &[Option<Rect>],
-        focused_idx: usize,
-        layout_options: Option<LayoutOptions>,
-        latest_layout: &[Rect],
     ) -> Vec<Rect>;
 }
 
@@ -38,99 +33,9 @@ impl Arrangement for DefaultLayout {
         container_padding: Option<i32>,
         layout_flip: Option<Axis>,
         resize_dimensions: &[Option<Rect>],
-        focused_idx: usize,
-        layout_options: Option<LayoutOptions>,
-        latest_layout: &[Rect],
     ) -> Vec<Rect> {
         let len = usize::from(len);
         let mut dimensions = match self {
-            Self::Scrolling => {
-                let column_count = layout_options
-                    .and_then(|o| o.scrolling.map(|s| s.columns))
-                    .unwrap_or(3);
-
-                let column_width = area.right / column_count as i32;
-                let mut layouts = Vec::with_capacity(len);
-
-                let visible_columns = area.right / column_width;
-                let keep_centered = layout_options
-                    .and_then(|o| {
-                        o.scrolling
-                            .map(|s| s.center_focused_column.unwrap_or_default())
-                    })
-                    .unwrap_or(false);
-
-                let first_visible: isize = if focused_idx == 0 {
-                    // if focused idx is 0, we are at the beginning of the scrolling strip
-                    0
-                } else {
-                    let previous_first_visible = if latest_layout.is_empty() {
-                        0
-                    } else {
-                        // previous first_visible based on the left position of the first visible window
-                        let left_edge = area.left;
-                        latest_layout
-                            .iter()
-                            .position(|rect| rect.left >= left_edge)
-                            .unwrap_or(0) as isize
-                    };
-
-                    let focused_idx = focused_idx as isize;
-
-                    // if center_focused_column is enabled, and we have an odd number of visible columns,
-                    // center the focused window column
-                    if keep_centered && visible_columns % 2 == 1 {
-                        let center_offset = visible_columns as isize / 2;
-                        (focused_idx - center_offset).max(0).min(
-                            (len as isize)
-                                .saturating_sub(visible_columns as isize)
-                                .max(0),
-                        )
-                    } else {
-                        if focused_idx < previous_first_visible {
-                            // focused window is off the left edge, we need to scroll left
-                            focused_idx
-                        } else if focused_idx >= previous_first_visible + visible_columns as isize {
-                            // focused window is off the right edge, we need to scroll right
-                            // and make sure it's the last visible window
-                            (focused_idx + 1 - visible_columns as isize).max(0)
-                        } else {
-                            // focused window is already visible, we don't need to scroll
-                            previous_first_visible
-                        }
-                        .min(
-                            (len as isize)
-                                .saturating_sub(visible_columns as isize)
-                                .max(0),
-                        )
-                    }
-                };
-
-                for i in 0..len {
-                    let position = (i as isize) - first_visible;
-                    let left = area.left + (position as i32 * column_width);
-
-                    layouts.push(Rect {
-                        left,
-                        top: area.top,
-                        right: column_width,
-                        bottom: area.bottom,
-                    });
-                }
-
-                let adjustment = calculate_scrolling_adjustment(resize_dimensions);
-                layouts
-                    .iter_mut()
-                    .zip(adjustment.iter())
-                    .for_each(|(layout, adjustment)| {
-                        layout.top += adjustment.top;
-                        layout.bottom += adjustment.bottom;
-                        layout.left += adjustment.left;
-                        layout.right += adjustment.right;
-                    });
-
-                layouts
-            }
             Self::BSP => recursive_fibonacci(
                 0,
                 len,
@@ -155,9 +60,10 @@ impl Arrangement for DefaultLayout {
                 if matches!(
                     layout_flip,
                     Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) && let 2.. = len
-                {
-                    columns_reverse(&mut layouts);
+                ) {
+                    if let 2.. = len {
+                        columns_reverse(&mut layouts);
+                    }
                 }
 
                 layouts
@@ -179,9 +85,10 @@ impl Arrangement for DefaultLayout {
                 if matches!(
                     layout_flip,
                     Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) && let 2.. = len
-                {
-                    rows_reverse(&mut layouts);
+                ) {
+                    if let 2.. = len {
+                        rows_reverse(&mut layouts);
+                    }
                 }
 
                 layouts
@@ -232,23 +139,25 @@ impl Arrangement for DefaultLayout {
                 if matches!(
                     layout_flip,
                     Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) && let 2.. = len
-                {
-                    let (primary, rest) = layouts.split_at_mut(1);
-                    let primary = &mut primary[0];
+                ) {
+                    if let 2.. = len {
+                        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)
-                ) && let 3.. = len
-                {
-                    rows_reverse(&mut layouts[1..]);
+                ) {
+                    if let 3.. = len {
+                        rows_reverse(&mut layouts[1..]);
+                    }
                 }
 
                 layouts
@@ -302,23 +211,25 @@ impl Arrangement for DefaultLayout {
                 if matches!(
                     layout_flip,
                     Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) && let 2.. = len
-                {
-                    let (primary, rest) = layouts.split_at_mut(1);
-                    let primary = &mut primary[0];
+                ) {
+                    if let 2.. = len {
+                        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)
-                ) && let 3.. = len
-                {
-                    rows_reverse(&mut layouts[1..]);
+                ) {
+                    if let 3.. = len {
+                        rows_reverse(&mut layouts[1..]);
+                    }
                 }
 
                 layouts
@@ -369,23 +280,25 @@ impl Arrangement for DefaultLayout {
                 if matches!(
                     layout_flip,
                     Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) && let 2.. = len
-                {
-                    let (primary, rest) = layouts.split_at_mut(1);
-                    let primary = &mut primary[0];
+                ) {
+                    if let 2.. = len {
+                        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)
-                ) && let 3.. = len
-                {
-                    columns_reverse(&mut layouts[1..]);
+                ) {
+                    if let 3.. = len {
+                        columns_reverse(&mut layouts[1..]);
+                    }
                 }
 
                 layouts
@@ -494,9 +407,10 @@ impl Arrangement for DefaultLayout {
                 if matches!(
                     layout_flip,
                     Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) && let 4.. = len
-                {
-                    rows_reverse(&mut layouts[2..]);
+                ) {
+                    if let 4.. = len {
+                        rows_reverse(&mut layouts[2..]);
+                    }
                 }
 
                 layouts
@@ -573,9 +487,6 @@ impl Arrangement for CustomLayout {
         container_padding: Option<i32>,
         _layout_flip: Option<Axis>,
         _resize_dimensions: &[Option<Rect>],
-        _focused_idx: usize,
-        _layout_options: Option<LayoutOptions>,
-        _latest_layout: &[Rect],
     ) -> Vec<Rect> {
         let mut dimensions = vec![];
         let container_count = len.get();
@@ -630,7 +541,7 @@ impl Arrangement for CustomLayout {
                     };
 
                     match column {
-                        Column::Primary(Some(_)) => {
+                        Column::Primary(Option::Some(_)) => {
                             let main_column_area = if idx == 0 {
                                 Self::main_column_area(area, primary_right, None)
                             } else {
@@ -762,67 +673,67 @@ fn calculate_resize_adjustments(resize_dimensions: &[Option<Rect>]) -> Vec<Optio
 
     // This needs to be aware of layout flips
     for (i, opt) in resize_dimensions.iter().enumerate() {
-        if let Some(resize_ref) = opt
-            && i > 0
-        {
-            if resize_ref.left != 0 {
-                #[allow(clippy::if_not_else)]
-                let range = if i == 1 {
-                    0..1
-                } else if i & 1 != 0 {
-                    i - 1..i
-                } else {
-                    i - 2..i
-                };
+        if let Some(resize_ref) = opt {
+            if i > 0 {
+                if resize_ref.left != 0 {
+                    #[allow(clippy::if_not_else)]
+                    let range = if i == 1 {
+                        0..1
+                    } else if i & 1 != 0 {
+                        i - 1..i
+                    } else {
+                        i - 2..i
+                    };
 
-                for n in range {
-                    let should_adjust = n % 2 == 0;
-                    if should_adjust {
-                        if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
-                            adjacent_resize.right += resize_ref.left;
-                        } else {
-                            resize_adjustments[n] = Option::from(Rect {
-                                left: 0,
-                                top: 0,
-                                right: resize_ref.left,
-                                bottom: 0,
-                            });
+                    for n in range {
+                        let should_adjust = n % 2 == 0;
+                        if should_adjust {
+                            if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
+                                adjacent_resize.right += resize_ref.left;
+                            } else {
+                                resize_adjustments[n] = Option::from(Rect {
+                                    left: 0,
+                                    top: 0,
+                                    right: resize_ref.left,
+                                    bottom: 0,
+                                });
+                            }
                         }
                     }
+
+                    if let Some(rr) = resize_adjustments[i].as_mut() {
+                        rr.left = 0;
+                    }
                 }
 
-                if let Some(rr) = resize_adjustments[i].as_mut() {
-                    rr.left = 0;
-                }
-            }
+                if resize_ref.top != 0 {
+                    let range = if i == 1 {
+                        0..1
+                    } else if i & 1 == 0 {
+                        i - 1..i
+                    } else {
+                        i - 2..i
+                    };
 
-            if resize_ref.top != 0 {
-                let range = if i == 1 {
-                    0..1
-                } else if i & 1 == 0 {
-                    i - 1..i
-                } else {
-                    i - 2..i
-                };
-
-                for n in range {
-                    let should_adjust = n % 2 != 0;
-                    if should_adjust {
-                        if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
-                            adjacent_resize.bottom += resize_ref.top;
-                        } else {
-                            resize_adjustments[n] = Option::from(Rect {
-                                left: 0,
-                                top: 0,
-                                right: 0,
-                                bottom: resize_ref.top,
-                            });
+                    for n in range {
+                        let should_adjust = n % 2 != 0;
+                        if should_adjust {
+                            if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
+                                adjacent_resize.bottom += resize_ref.top;
+                            } else {
+                                resize_adjustments[n] = Option::from(Rect {
+                                    left: 0,
+                                    top: 0,
+                                    right: 0,
+                                    bottom: resize_ref.top,
+                                });
+                            }
                         }
                     }
-                }
 
-                if let Some(Some(resize)) = resize_adjustments.get_mut(i) {
-                    resize.top = 0;
+                    if let Some(Some(resize)) = resize_adjustments.get_mut(i) {
+                        resize.top = 0;
+                    }
                 }
             }
         }
@@ -907,7 +818,7 @@ fn recursive_fibonacci(
             right: resized.right,
             bottom: resized.bottom,
         }]
-    } else if !idx.is_multiple_of(2) {
+    } else if idx % 2 != 0 {
         let mut res = vec![Rect {
             left: resized.left,
             top: main_y,
@@ -1204,37 +1115,6 @@ fn calculate_ultrawide_adjustment(resize_dimensions: &[Option<Rect>]) -> Vec<Rec
     result
 }
 
-fn calculate_scrolling_adjustment(resize_dimensions: &[Option<Rect>]) -> Vec<Rect> {
-    let len = resize_dimensions.len();
-    let mut result = vec![Rect::default(); len];
-
-    if len <= 1 {
-        return result;
-    }
-
-    for (i, rect) in resize_dimensions.iter().enumerate() {
-        if let Some(rect) = rect {
-            let is_leftmost = i == 0;
-            let is_rightmost = i == len - 1;
-
-            resize_left(&mut result[i], rect.left);
-            resize_right(&mut result[i], rect.right);
-            resize_top(&mut result[i], rect.top);
-            resize_bottom(&mut result[i], rect.bottom);
-
-            if !is_leftmost && rect.left != 0 {
-                resize_right(&mut result[i - 1], rect.left);
-            }
-
-            if !is_rightmost && rect.right != 0 {
-                resize_left(&mut result[i + 1], rect.right);
-            }
-        }
-    }
-
-    result
-}
-
 fn resize_left(rect: &mut Rect, resize: i32) {
     rect.left += resize / 2;
     rect.right += -resize / 2;

komorebi/src/core/asc.rs

@@ -1,7 +1,7 @@
 use crate::config_generation::ApplicationConfiguration;
 use crate::config_generation::ApplicationOptions;
 use crate::config_generation::MatchingRule;
-use color_eyre::eyre;
+use color_eyre::Result;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -36,12 +36,12 @@ impl DerefMut for ApplicationSpecificConfiguration {
 }
 
 impl ApplicationSpecificConfiguration {
-    pub fn load(pathbuf: &PathBuf) -> eyre::Result<Self> {
+    pub fn load(pathbuf: &PathBuf) -> Result<Self> {
         let content = std::fs::read_to_string(pathbuf)?;
         Ok(serde_json::from_str(&content)?)
     }
 
-    pub fn format(pathbuf: &PathBuf) -> eyre::Result<String> {
+    pub fn format(pathbuf: &PathBuf) -> Result<String> {
         Ok(serde_json::to_string_pretty(&Self::load(pathbuf)?)?)
     }
 }

komorebi/src/core/config_generation.rs

@@ -1,5 +1,5 @@
 use clap::ValueEnum;
-use color_eyre::eyre;
+use color_eyre::Result;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -142,11 +142,11 @@ impl ApplicationConfiguration {
 pub struct ApplicationConfigurationGenerator;
 
 impl ApplicationConfigurationGenerator {
-    pub fn load(content: &str) -> eyre::Result<Vec<ApplicationConfiguration>> {
+    pub fn load(content: &str) -> Result<Vec<ApplicationConfiguration>> {
         Ok(serde_yaml::from_str(content)?)
     }
 
-    pub fn format(content: &str) -> eyre::Result<String> {
+    pub fn format(content: &str) -> Result<String> {
         let mut cfgen = Self::load(content)?;
         for cfg in &mut cfgen {
             cfg.populate_default_matching_strategies();
@@ -156,10 +156,7 @@ impl ApplicationConfigurationGenerator {
         Ok(serde_yaml::to_string(&cfgen)?)
     }
 
-    fn merge(
-        base_content: &str,
-        override_content: &str,
-    ) -> eyre::Result<Vec<ApplicationConfiguration>> {
+    fn merge(base_content: &str, override_content: &str) -> Result<Vec<ApplicationConfiguration>> {
         let base_cfgen = Self::load(base_content)?;
         let override_cfgen = Self::load(override_content)?;
 
@@ -185,7 +182,7 @@ impl ApplicationConfigurationGenerator {
     pub fn generate_pwsh(
         base_content: &str,
         override_content: Option<&str>,
-    ) -> eyre::Result<Vec<String>> {
+    ) -> Result<Vec<String>> {
         let mut cfgen = if let Some(override_content) = override_content {
             Self::merge(base_content, override_content)?
         } else {
@@ -236,10 +233,7 @@ impl ApplicationConfigurationGenerator {
         Ok(lines)
     }
 
-    pub fn generate_ahk(
-        base_content: &str,
-        override_content: Option<&str>,
-    ) -> eyre::Result<Vec<String>> {
+    pub fn generate_ahk(base_content: &str, override_content: Option<&str>) -> Result<Vec<String>> {
         let mut cfgen = if let Some(override_content) = override_content {
             Self::merge(base_content, override_content)?
         } else {

komorebi/src/core/custom_layout.rs

@@ -1,7 +1,3 @@
-use color_eyre::eyre;
-use color_eyre::eyre::bail;
-use serde::Deserialize;
-use serde::Serialize;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::BufReader;
@@ -9,6 +5,12 @@ use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::Path;
 
+use color_eyre::eyre::anyhow;
+use color_eyre::eyre::bail;
+use color_eyre::Result;
+use serde::Deserialize;
+use serde::Serialize;
+
 use super::Rect;
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
@@ -30,7 +32,7 @@ impl DerefMut for CustomLayout {
 }
 
 impl CustomLayout {
-    pub fn from_path<P: AsRef<Path>>(path: P) -> eyre::Result<Self> {
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self> {
         let path = path.as_ref();
         let layout: Self = match path.extension() {
             Some(extension) if extension == "yaml" || extension == "yml" => {
@@ -39,7 +41,7 @@ impl CustomLayout {
             Some(extension) if extension == "json" => {
                 serde_json::from_reader(BufReader::new(File::open(path)?))?
             }
-            _ => bail!("custom layouts must be json or yaml files"),
+            _ => return Err(anyhow!("custom layouts must be json or yaml files")),
         };
 
         if !layout.is_valid() {

komorebi/src/core/default_layout.rs

@@ -21,26 +21,9 @@ pub enum DefaultLayout {
     UltrawideVerticalStack,
     Grid,
     RightMainVerticalStack,
-    Scrolling,
     // NOTE: If any new layout is added, please make sure to register the same in `DefaultLayout::cycle`
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Eq, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub struct LayoutOptions {
-    /// Options related to the Scrolling layout
-    pub scrolling: Option<ScrollingLayoutOptions>,
-}
-
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Eq, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub struct ScrollingLayoutOptions {
-    /// Desired number of visible columns (default: 3)
-    pub columns: usize,
-    /// With an odd number of visible columns, keep the focused window column centered
-    pub center_focused_column: Option<bool>,
-}
-
 impl DefaultLayout {
     pub fn leftmost_index(&self, len: usize) -> usize {
         match self {
@@ -48,7 +31,6 @@ impl DefaultLayout {
                 n if n > 1 => 1,
                 _ => 0,
             },
-            Self::Scrolling => 0,
             DefaultLayout::BSP
             | DefaultLayout::Columns
             | DefaultLayout::Rows
@@ -71,7 +53,6 @@ impl DefaultLayout {
                 _ => len.saturating_sub(1),
             },
             DefaultLayout::RightMainVerticalStack => 0,
-            DefaultLayout::Scrolling => len.saturating_sub(1),
         }
     }
 
@@ -94,7 +75,6 @@ impl DefaultLayout {
                 | Self::RightMainVerticalStack
                 | Self::HorizontalStack
                 | Self::UltrawideVerticalStack
-                | Self::Scrolling
         ) {
             return None;
         };
@@ -189,15 +169,13 @@ impl DefaultLayout {
             Self::HorizontalStack => Self::UltrawideVerticalStack,
             Self::UltrawideVerticalStack => Self::Grid,
             Self::Grid => Self::RightMainVerticalStack,
-            Self::RightMainVerticalStack => Self::Scrolling,
-            Self::Scrolling => Self::BSP,
+            Self::RightMainVerticalStack => Self::BSP,
         }
     }
 
     #[must_use]
     pub const fn cycle_previous(self) -> Self {
         match self {
-            Self::Scrolling => Self::RightMainVerticalStack,
             Self::RightMainVerticalStack => Self::Grid,
             Self::Grid => Self::UltrawideVerticalStack,
             Self::UltrawideVerticalStack => Self::HorizontalStack,

komorebi/src/core/direction.rs

@@ -1,9 +1,9 @@
-use super::DefaultLayout;
-use super::OperationDirection;
 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;
 
 pub trait Direction {
     fn index_in_direction(
@@ -102,17 +102,15 @@ impl Direction for DefaultLayout {
                 Self::VerticalStack | Self::RightMainVerticalStack => idx != 0 && idx != 1,
                 Self::UltrawideVerticalStack => idx > 2,
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
-                Self::Scrolling => false,
             },
             OperationDirection::Down => match self {
-                Self::BSP => idx != count - 1 && !idx.is_multiple_of(2),
+                Self::BSP => idx != count - 1 && idx % 2 != 0,
                 Self::Columns => false,
                 Self::Rows => idx != count - 1,
                 Self::VerticalStack | Self::RightMainVerticalStack => idx != 0 && idx != count - 1,
                 Self::HorizontalStack => idx == 0,
                 Self::UltrawideVerticalStack => idx > 1 && idx != count - 1,
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
-                Self::Scrolling => false,
             },
             OperationDirection::Left => match self {
                 Self::BSP => idx != 0,
@@ -122,10 +120,9 @@ impl Direction for DefaultLayout {
                 Self::HorizontalStack => idx != 0 && idx != 1,
                 Self::UltrawideVerticalStack => idx != 1,
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
-                Self::Scrolling => idx != 0,
             },
             OperationDirection::Right => match self {
-                Self::BSP => idx.is_multiple_of(2) && idx != count - 1,
+                Self::BSP => idx % 2 == 0 && idx != count - 1,
                 Self::Columns => idx != count - 1,
                 Self::Rows => false,
                 Self::VerticalStack => idx == 0,
@@ -136,7 +133,6 @@ impl Direction for DefaultLayout {
                     _ => idx < 2,
                 },
                 Self::Grid => !is_grid_edge(op_direction, idx, count),
-                Self::Scrolling => idx != count - 1,
             },
         }
     }
@@ -149,7 +145,7 @@ impl Direction for DefaultLayout {
     ) -> usize {
         match self {
             Self::BSP => {
-                if idx.is_multiple_of(2) {
+                if idx % 2 == 0 {
                     idx - 1
                 } else {
                     idx - 2
@@ -162,7 +158,6 @@ impl Direction for DefaultLayout {
             | Self::RightMainVerticalStack => idx - 1,
             Self::HorizontalStack => 0,
             Self::Grid => grid_neighbor(op_direction, idx, count),
-            Self::Scrolling => unreachable!(),
         }
     }
 
@@ -181,7 +176,6 @@ impl Direction for DefaultLayout {
             Self::Columns => unreachable!(),
             Self::HorizontalStack => 1,
             Self::Grid => grid_neighbor(op_direction, idx, count),
-            Self::Scrolling => unreachable!(),
         }
     }
 
@@ -193,7 +187,7 @@ impl Direction for DefaultLayout {
     ) -> usize {
         match self {
             Self::BSP => {
-                if idx.is_multiple_of(2) {
+                if idx % 2 == 0 {
                     idx - 2
                 } else {
                     idx - 1
@@ -209,7 +203,6 @@ impl Direction for DefaultLayout {
                 _ => 0,
             },
             Self::Grid => grid_neighbor(op_direction, idx, count),
-            Self::Scrolling => idx - 1,
         }
     }
 
@@ -230,7 +223,6 @@ impl Direction for DefaultLayout {
                 _ => unreachable!(),
             },
             Self::Grid => grid_neighbor(op_direction, idx, count),
-            Self::Scrolling => idx + 1,
         }
     }
 }

komorebi/src/core/mod.rs

@@ -1,19 +1,18 @@
 #![warn(clippy::all)]
 #![allow(clippy::missing_errors_doc, clippy::use_self, clippy::doc_markdown)]
 
-use std::num::NonZeroUsize;
 use std::path::PathBuf;
 use std::str::FromStr;
 
 use clap::ValueEnum;
-use color_eyre::eyre;
+use color_eyre::Result;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use crate::KomorebiTheme;
 use crate::animation::prefix::AnimationPrefix;
+use crate::KomorebiTheme;
 pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
@@ -27,10 +26,10 @@ pub use default_layout::DefaultLayout;
 pub use direction::Direction;
 pub use layout::Layout;
 pub use operation_direction::OperationDirection;
-pub use pathext::PathExt;
-pub use pathext::ResolvedPathBuf;
 pub use pathext::replace_env_in_path;
 pub use pathext::resolve_option_hashmap_usize_path;
+pub use pathext::PathExt;
+pub use pathext::ResolvedPathBuf;
 pub use rect::Rect;
 
 pub mod animation;
@@ -109,7 +108,6 @@ pub enum SocketMessage {
     AdjustWorkspacePadding(Sizing, i32),
     ChangeLayout(DefaultLayout),
     CycleLayout(CycleDirection),
-    ScrollingLayoutColumns(NonZeroUsize),
     ChangeLayoutCustom(#[serde_as(as = "ResolvedPathBuf")] PathBuf),
     FlipLayout(Axis),
     ToggleWorkspaceWindowContainerBehaviour,
@@ -202,7 +200,6 @@ pub enum SocketMessage {
     StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
-    WorkspaceWorkAreaOffset(usize, usize, Rect),
     ToggleWindowBasedWorkAreaOffset,
     ResizeDelta(i32),
     InitialWorkspaceRule(ApplicationIdentifier, String, usize, usize),
@@ -248,7 +245,7 @@ pub enum SocketMessage {
 }
 
 impl SocketMessage {
-    pub fn as_bytes(&self) -> eyre::Result<Vec<u8>> {
+    pub fn as_bytes(&self) -> Result<Vec<u8>> {
         Ok(serde_json::to_string(self)?.as_bytes().to_vec())
     }
 }
@@ -256,7 +253,7 @@ impl SocketMessage {
 impl FromStr for SocketMessage {
     type Err = serde_json::Error;
 
-    fn from_str(s: &str) -> eyre::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         serde_json::from_str(s)
     }
 }
@@ -344,7 +341,6 @@ pub enum StateQuery {
     FocusedWindowIndex,
     FocusedWorkspaceName,
     FocusedWorkspaceLayout,
-    FocusedContainerKind,
     Version,
 }
 
@@ -550,9 +546,7 @@ mod tests {
     #[test]
     fn deserializes() {
         // Set a variable for testing
-        unsafe {
-            std::env::set_var("VAR", "VALUE");
-        }
+        std::env::set_var("VAR", "VALUE");
 
         let json = r#"{"type":"WorkspaceLayoutCustomRule","content":[0,0,0,"/path/%VAR%/d"]}"#;
         let message: SocketMessage = serde_json::from_str(json).unwrap();

komorebi/src/core/operation_direction.rs

@@ -6,8 +6,8 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::Axis;
 use super::direction::Direction;
+use super::Axis;
 
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]

komorebi/src/core/pathext.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::env;
 use std::ffi::OsStr;
 use std::path::Component;
 use std::path::Path;
@@ -9,9 +10,9 @@ use serde::Serialize;
 
 /// Path extension trait
 pub trait PathExt {
-    /// Resolve environment variable components in a path.
+    /// Resolve environment variables components in a path.
     ///
-    /// Resolves the following formats:
+    /// Resolves the follwing formats:
     /// - CMD: `%variable%`
     /// - PowerShell: `$Env:variable`
     /// - Bash: `$variable`.
@@ -57,7 +58,7 @@ impl<P: AsRef<Path>> PathExt for P {
                     // if component is a variable, get the value from the environment
                     if let Some(var) = var {
                         let var = unsafe { OsStr::from_encoded_bytes_unchecked(var) };
-                        if let Some(value) = std::env::var_os(var) {
+                        if let Some(value) = env::var_os(var) {
                             out.push(value);
                             continue;
                         }
@@ -126,8 +127,8 @@ impl serde_with::schemars_0_8::JsonSchemaAs<PathBuf> for ResolvedPathBuf {
         "PathBuf".to_owned()
     }
 
-    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::schema::Schema {
-        <PathBuf as schemars::JsonSchema>::json_schema(generator)
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        <PathBuf as schemars::JsonSchema>::json_schema(gen)
     }
 }
 
@@ -164,9 +165,7 @@ mod tests {
     #[test]
     fn resolves_env_vars() {
         // Set a variable for testing
-        unsafe {
-            std::env::set_var("VAR", "VALUE");
-        }
+        std::env::set_var("VAR", "VALUE");
 
         // %VAR% format
         assert_eq!(resolve("/path/%VAR%/d"), expected("/path/VALUE/d"));
@@ -184,9 +183,7 @@ mod tests {
         assert_eq!(resolve("/path/$ASD/to/d"), expected("/path/$ASD/to/d"));
 
         // Set a $env:USERPROFILE variable for testing
-        unsafe {
-            std::env::set_var("USERPROFILE", "C:\\Users\\user");
-        }
+        std::env::set_var("USERPROFILE", "C:\\Users\\user");
 
         // ~ and $HOME should be replaced with $Env:USERPROFILE
         assert_eq!(resolve("~"), expected("C:\\Users\\user"));

komorebi/src/core/rect.rs

@@ -41,10 +41,6 @@ impl Rect {
     pub fn is_same_size_as(&self, rhs: &Self) -> bool {
         self.right == rhs.right && self.bottom == rhs.bottom
     }
-
-    pub fn has_same_position_as(&self, rhs: &Self) -> bool {
-        self.left == rhs.left && self.top == rhs.top
-    }
 }
 
 impl Rect {

komorebi/src/focus_manager.rs

@@ -44,15 +44,13 @@ pub fn send_notification(hwnd: isize) {
 }
 
 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);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });

komorebi/src/lib.rs

@@ -8,7 +8,7 @@ pub mod ring;
 pub mod container;
 pub mod core;
 pub mod focus_manager;
-pub mod lockable_sequence;
+pub mod locked_deque;
 pub mod monitor;
 pub mod monitor_reconciliator;
 pub mod process_command;
@@ -39,12 +39,12 @@ use std::io::Write;
 use std::net::TcpStream;
 use std::path::PathBuf;
 use std::process::Command;
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::AtomicU64;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 pub use core::*;
 pub use komorebi_themes::colour::*;
@@ -62,7 +62,7 @@ use crate::core::config_generation::IdWithIdentifier;
 use crate::core::config_generation::MatchingRule;
 use crate::core::config_generation::MatchingStrategy;
 use crate::core::config_generation::WorkspaceMatchingRule;
-use color_eyre::eyre;
+use color_eyre::Result;
 use crossbeam_utils::atomic::AtomicCell;
 use os_info::Version;
 use parking_lot::Mutex;
@@ -72,8 +72,8 @@ use serde::Deserialize;
 use serde::Serialize;
 use uds_windows::UnixStream;
 use which::which;
-use winreg::RegKey;
 use winreg::enums::HKEY_CURRENT_USER;
+use winreg::RegKey;
 
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
@@ -200,7 +200,8 @@ lazy_static! {
 
             assert!(
                 home.is_dir(),
-                "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                home_path
             );
 
 
@@ -211,10 +212,11 @@ lazy_static! {
     pub static ref AHK_EXE: String = {
         let mut ahk: String = String::from("autohotkey.exe");
 
-        if let Ok(komorebi_ahk_exe) = std::env::var("KOMOREBI_AHK_EXE")
-            && which(&komorebi_ahk_exe).is_ok() {
+        if let Ok(komorebi_ahk_exe) = std::env::var("KOMOREBI_AHK_EXE") {
+            if which(&komorebi_ahk_exe).is_ok() {
                 ahk = komorebi_ahk_exe;
             }
+        }
 
         ahk
     };
@@ -253,14 +255,6 @@ pub static WINDOW_HANDLING_BEHAVIOUR: AtomicCell<WindowHandlingBehaviour> =
 
 shadow_rs::shadow!(build);
 
-/// A trait for types that can be marked as locked or unlocked.
-pub trait Lockable {
-    /// Returns `true` if the item is locked.
-    fn locked(&self) -> bool;
-    /// Sets the locked state of the item.
-    fn set_locked(&mut self, locked: bool) -> &mut Self;
-}
-
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     let hkcu = RegKey::predef(HKEY_CURRENT_USER);
@@ -305,7 +299,7 @@ pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     current
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum NotificationEvent {
@@ -322,17 +316,14 @@ pub enum VirtualDesktopNotification {
     LeftAssociatedVirtualDesktop,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Notification {
     pub event: NotificationEvent,
     pub state: State,
 }
 
-pub fn notify_subscribers(
-    notification: Notification,
-    state_has_been_modified: bool,
-) -> eyre::Result<()> {
+pub fn notify_subscribers(notification: Notification, state_has_been_modified: bool) -> Result<()> {
     let is_override_event = matches!(
         notification.event,
         NotificationEvent::Socket(SocketMessage::AddSubscriberSocket(_))
@@ -413,7 +404,7 @@ pub fn notify_subscribers(
     Ok(())
 }
 
-pub fn load_configuration() -> eyre::Result<()> {
+pub fn load_configuration() -> Result<()> {
     let config_pwsh = HOME_DIR.join("komorebi.ps1");
     let config_ahk = HOME_DIR.join("komorebi.ahk");
 

komorebi/src/lockable_sequence.rs

@@ -1,357 +0,0 @@
-use std::collections::VecDeque;
-
-use crate::Lockable;
-
-/// A sequence supporting insertion, removal, and swapping of elements while preserving the absolute
-/// positions of locked items.
-pub trait LockableSequence<T: Lockable> {
-    /// Inserts a value at `idx`, keeping locked elements at their absolute positions.
-    fn insert_respecting_locks(&mut self, idx: usize, value: T) -> usize;
-    /// Removes the element at `idx`, keeping locked elements at their absolute positions.
-    fn remove_respecting_locks(&mut self, idx: usize) -> Option<T>;
-    /// Swaps the elements at indices `i` and `j`, keeping locked elements at their absolute positions.
-    fn swap_respecting_locks(&mut self, i: usize, j: usize);
-}
-
-impl<T: Lockable> LockableSequence<T> for VecDeque<T> {
-    /// Insert `value` at logical index `idx`, with trying to keep locked elements
-    /// (`is_locked()`) anchored at their original positions.
-    ///
-    /// Returns the final index of the inserted element.
-    fn insert_respecting_locks(&mut self, mut idx: usize, value: T) -> usize {
-        // 1. Bounds check: if index is out of range, simply append.
-        if idx >= self.len() {
-            self.push_back(value);
-            return self.len() - 1; // last index
-        }
-
-        // 2. Normal VecDeque insertion
-        self.insert(idx, value);
-
-        // 3. Walk left-to-right once, swapping any misplaced locked element. After
-        // the VecDeque::insert all items after `idx` have moved right by one. For every locked
-        // element that is now to the right of an unlocked one, swap it back left exactly once.
-        for index in (idx + 1)..self.len() {
-            if self[index].locked() && !self[index - 1].locked() {
-                self.swap(index - 1, index);
-
-                // If the element we just inserted participated in the swap,
-                // update `idx` so we can return its final location.
-                if idx == index - 1 {
-                    idx = index;
-                }
-            }
-        }
-        idx
-    }
-
-    /// Remove element at `idx`, with trying to keep locked elements
-    /// (`is_locked()`) anchored at their original positions.
-    ///
-    /// Returns the removed element, or `None` if `idx` is out of bounds.
-    fn remove_respecting_locks(&mut self, idx: usize) -> Option<T> {
-        // 1. Bounds check: if index is out of range, do nothing.
-        if idx >= self.len() {
-            return None;
-        }
-
-        // 2. Remove the element at the requested index.
-        //    All elements after idx are now shifted left by 1.
-        let removed = self.remove(idx)?;
-
-        // 3. If less than 2 elements remain, nothing to shift.
-        if self.len() < 2 {
-            return Some(removed);
-        }
-
-        // 4. Iterate from the element just after the removed spot up to the second-to-last
-        //    element, right-to-left. This loop "fixes" locked elements that were shifted left
-        //    off their anchored positions: If a locked element now has an unlocked element
-        //    to its right, swap them back to restore locked order.
-        for index in (idx..self.len() - 1).rev() {
-            // If current is locked and the next one is not locked, swap them.
-            if self[index].locked() && !self[index + 1].locked() {
-                self.swap(index, index + 1);
-            }
-        }
-
-        // 5. Return the removed value.
-        Some(removed)
-    }
-
-    /// Swaps the elements at indices `i` and `j`, along with their `locked` status, ensuring
-    /// the lock state remains associated with the position rather than the element itself.
-    fn swap_respecting_locks(&mut self, i: usize, j: usize) {
-        self.swap(i, j);
-        let locked_i = self[i].locked();
-        let locked_j = self[j].locked();
-        self[i].set_locked(locked_j);
-        self[j].set_locked(locked_i);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[derive(Debug, PartialEq)]
-    struct TestItem {
-        val: i32,
-        locked: bool,
-    }
-
-    impl Lockable for TestItem {
-        fn locked(&self) -> bool {
-            self.locked
-        }
-
-        fn set_locked(&mut self, locked: bool) -> &mut Self {
-            self.locked = locked;
-            self
-        }
-    }
-
-    fn vals(v: &VecDeque<TestItem>) -> Vec<i32> {
-        v.iter().map(|x| x.val).collect()
-    }
-
-    fn test_deque(items: &[(i32, bool)]) -> VecDeque<TestItem> {
-        items
-            .iter()
-            .cloned()
-            .map(|(val, locked)| TestItem { val, locked })
-            .collect()
-    }
-
-    #[test]
-    fn test_insert_respecting_locks() {
-        // Test case 1: Basic insertion with locked index
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            // Insert at index 0, should shift elements while keeping index 2 locked
-            ring.insert_respecting_locks(
-                0,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            // Element '2' remains at index 2, element '1' that was at index 1 is now at index 3
-            assert_eq!(vals(&ring), vec![99, 0, 2, 1, 3, 4]);
-        }
-
-        // Test case 2: Insert at a locked index (should insert after locked)
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            // Try to insert at locked index 2, should insert at index 3 instead
-            let actual_index = ring.insert_respecting_locks(
-                2,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            assert_eq!(actual_index, 3);
-            assert_eq!(vals(&ring), vec![0, 1, 2, 99, 3, 4]);
-        }
-
-        // Test case 3: Multiple locked indices
-        {
-            // Lock index 1 and 3
-            let mut ring = test_deque(&[(0, false), (1, true), (2, false), (3, true), (4, false)]);
-            // Insert at index 0, should maintain locked indices
-            ring.insert_respecting_locks(
-                0,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            // Elements '1' and '3' remain at indices 1 and 3
-            assert_eq!(vals(&ring), vec![99, 1, 0, 3, 2, 4]);
-        }
-
-        // Test case 4: Insert at end
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            let actual_index = ring.insert_respecting_locks(
-                5,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            assert_eq!(actual_index, 5);
-            assert_eq!(vals(&ring), vec![0, 1, 2, 3, 4, 99]);
-        }
-
-        // Test case 5: Empty ring
-        {
-            let mut ring = test_deque(&[]);
-            // Insert into empty deque
-            let actual_index = ring.insert_respecting_locks(
-                0,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            assert_eq!(actual_index, 0);
-            assert_eq!(vals(&ring), vec![99]);
-        }
-
-        // Test case 6: All indices locked
-        {
-            // Lock all indices
-            let mut ring = test_deque(&[(0, true), (1, true), (2, true), (3, true), (4, true)]);
-            // Try to insert at index 2, should insert at the end
-            let actual_index = ring.insert_respecting_locks(
-                2,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            assert_eq!(actual_index, 5);
-            assert_eq!(vals(&ring), vec![0, 1, 2, 3, 4, 99]);
-        }
-
-        // Test case 7: Consecutive locked indices
-        {
-            // Lock index 2 and 3
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, true), (4, false)]);
-            // Insert at index 1, should maintain consecutive locked indices
-            ring.insert_respecting_locks(
-                1,
-                TestItem {
-                    val: 99,
-                    locked: false,
-                },
-            );
-            // Elements '2' and '3' remain at indices 2 and 3
-            assert_eq!(vals(&ring), vec![0, 99, 2, 3, 1, 4]);
-        }
-    }
-
-    #[test]
-    fn test_remove_respecting_locks() {
-        // Test case 1: Remove a non-locked index before a locked index
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            let removed = ring.remove_respecting_locks(0);
-            assert_eq!(removed.map(|x| x.val), Some(0));
-            // Elements '2' remain at index 2
-            assert_eq!(vals(&ring), vec![1, 3, 2, 4]);
-        }
-
-        // Test case 2: Remove a locked index
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            let removed = ring.remove_respecting_locks(2);
-            assert_eq!(removed.map(|x| x.val), Some(2));
-            // Elements should stay at the same places
-            assert_eq!(vals(&ring), vec![0, 1, 3, 4]);
-        }
-
-        // Test case 3: Remove an index after a locked index
-        {
-            // Lock index 1
-            let mut ring = test_deque(&[(0, false), (1, true), (2, false), (3, false), (4, false)]);
-            let removed = ring.remove_respecting_locks(3);
-            assert_eq!(removed.map(|x| x.val), Some(3));
-            // Elements should stay at the same places
-            assert_eq!(vals(&ring), vec![0, 1, 2, 4]);
-        }
-
-        // Test case 4: Multiple locked indices
-        {
-            // Lock index 1 and 3
-            let mut ring = test_deque(&[(0, false), (1, true), (2, false), (3, true), (4, false)]);
-            let removed = ring.remove_respecting_locks(0);
-            assert_eq!(removed.map(|x| x.val), Some(0));
-            // Elements '1' and '3' remain at indices '1' and '3'
-            assert_eq!(vals(&ring), vec![2, 1, 4, 3]);
-        }
-
-        // Test case 5: Remove the last element
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            let removed = ring.remove_respecting_locks(4);
-            assert_eq!(removed.map(|x| x.val), Some(4));
-            // Index 2 should still be at the same place
-            assert_eq!(vals(&ring), vec![0, 1, 2, 3]);
-        }
-
-        // Test case 6: Invalid index
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true), (3, false), (4, false)]);
-            let removed = ring.remove_respecting_locks(10);
-            assert_eq!(removed, None);
-            // Deque unchanged
-            assert_eq!(vals(&ring), vec![0, 1, 2, 3, 4]);
-        }
-
-        // Test case 7: Remove enough elements to make a locked index invalid
-        {
-            // Lock index 2
-            let mut ring = test_deque(&[(0, false), (1, false), (2, true)]);
-            ring.remove_respecting_locks(0);
-            // Index 2 should now be '1'
-            assert_eq!(vals(&ring), vec![1, 2]);
-        }
-
-        // Test case 8: Removing an element before multiple locked indices
-        {
-            // Lock index 2 and 4
-            let mut ring = test_deque(&[
-                (0, false),
-                (1, false),
-                (2, true),
-                (3, false),
-                (4, true),
-                (5, false),
-            ]);
-            let removed = ring.remove_respecting_locks(1);
-            assert_eq!(removed.map(|x| x.val), Some(1));
-            // Both indices should still be at the same place
-            assert_eq!(vals(&ring), vec![0, 3, 2, 5, 4]);
-        }
-    }
-
-    #[test]
-    fn test_swap_respecting_locks_various_cases() {
-        // Swap unlocked and locked
-        let mut ring = test_deque(&[(0, false), (1, true), (2, false), (3, false)]);
-        ring.swap_respecting_locks(0, 1);
-        assert_eq!(vals(&ring), vec![1, 0, 2, 3]);
-        assert!(!ring[0].locked);
-        assert!(ring[1].locked);
-        ring.swap_respecting_locks(0, 1);
-        assert_eq!(vals(&ring), vec![0, 1, 2, 3]);
-        assert!(!ring[0].locked);
-        assert!(ring[1].locked);
-
-        // Both locked
-        let mut ring = test_deque(&[(0, true), (1, false), (2, true)]);
-        ring.swap_respecting_locks(0, 2);
-        assert_eq!(vals(&ring), vec![2, 1, 0]);
-        assert!(ring[0].locked);
-        assert!(!ring[1].locked);
-        assert!(ring[2].locked);
-
-        // Both unlocked
-        let mut ring = test_deque(&[(0, false), (1, true), (2, false)]);
-        ring.swap_respecting_locks(0, 2);
-        assert_eq!(vals(&ring), vec![2, 1, 0]);
-        assert!(!ring[0].locked);
-        assert!(ring[1].locked);
-        assert!(!ring[2].locked);
-    }
-}

komorebi/src/locked_deque.rs

@@ -0,0 +1,316 @@
+use std::collections::BTreeSet;
+use std::collections::VecDeque;
+
+pub struct LockedDeque<'a, T> {
+    deque: &'a mut VecDeque<T>,
+    locked_indices: &'a mut BTreeSet<usize>,
+}
+
+impl<'a, T: PartialEq> LockedDeque<'a, T> {
+    pub fn new(deque: &'a mut VecDeque<T>, locked_indices: &'a mut BTreeSet<usize>) -> Self {
+        Self {
+            deque,
+            locked_indices,
+        }
+    }
+
+    pub fn insert(&mut self, index: usize, value: T) -> usize {
+        insert_respecting_locks(self.deque, self.locked_indices, index, value)
+    }
+
+    pub fn remove(&mut self, index: usize) -> Option<T> {
+        remove_respecting_locks(self.deque, self.locked_indices, index)
+    }
+}
+
+pub fn insert_respecting_locks<T>(
+    deque: &mut VecDeque<T>,
+    locked_idx: &mut BTreeSet<usize>,
+    idx: usize,
+    value: T,
+) -> usize {
+    if idx == deque.len() {
+        deque.push_back(value);
+        return idx;
+    }
+
+    let mut new_deque = VecDeque::with_capacity(deque.len() + 1);
+    let mut temp_locked_deque = VecDeque::new();
+    let mut j = 0;
+    let mut corrected_idx = idx;
+
+    for (i, el) in deque.drain(..).enumerate() {
+        if i == idx {
+            corrected_idx = j;
+        }
+        if locked_idx.contains(&i) {
+            temp_locked_deque.push_back(el);
+        } else {
+            new_deque.push_back(el);
+            j += 1;
+        }
+    }
+
+    new_deque.insert(corrected_idx, value);
+
+    for (locked_el, locked_idx) in temp_locked_deque.into_iter().zip(locked_idx.iter()) {
+        new_deque.insert(*locked_idx, locked_el);
+        if *locked_idx <= corrected_idx {
+            corrected_idx += 1;
+        }
+    }
+
+    *deque = new_deque;
+
+    corrected_idx
+}
+
+pub fn remove_respecting_locks<T>(
+    deque: &mut VecDeque<T>,
+    locked_idx: &mut BTreeSet<usize>,
+    idx: usize,
+) -> Option<T> {
+    if idx >= deque.len() {
+        return None;
+    }
+
+    let final_size = deque.len() - 1;
+
+    let mut new_deque = VecDeque::with_capacity(final_size);
+    let mut temp_locked_deque = VecDeque::new();
+    let mut removed = None;
+    let mut removed_locked_idx = None;
+
+    for (i, el) in deque.drain(..).enumerate() {
+        if i == idx {
+            removed = Some(el);
+            removed_locked_idx = locked_idx.contains(&i).then_some(i);
+        } else if locked_idx.contains(&i) {
+            temp_locked_deque.push_back(el);
+        } else {
+            new_deque.push_back(el);
+        }
+    }
+
+    if let Some(i) = removed_locked_idx {
+        let mut above = locked_idx.split_off(&i);
+        above.pop_first();
+        locked_idx.extend(above.into_iter().map(|i| i - 1));
+    }
+
+    while locked_idx.last().is_some_and(|i| *i >= final_size) {
+        locked_idx.pop_last();
+    }
+
+    let extra_invalid_idx = (new_deque.len()
+        ..(new_deque.len() + temp_locked_deque.len() - locked_idx.len()))
+        .collect::<Vec<_>>();
+
+    for (locked_el, locked_idx) in temp_locked_deque
+        .into_iter()
+        .zip(locked_idx.iter().chain(extra_invalid_idx.iter()))
+    {
+        new_deque.insert(*locked_idx, locked_el);
+    }
+
+    *deque = new_deque;
+
+    removed
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeSet;
+    use std::collections::VecDeque;
+
+    #[test]
+    fn test_insert_respecting_locks() {
+        // Test case 1: Basic insertion with locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Insert at index 0, should shift elements while keeping index 2 locked
+            insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(deque, VecDeque::from(vec![99, 0, 2, 1, 3, 4]));
+            // Element '2' remains at index 2, element '1' that was at index 1 is now at index 3
+        }
+
+        // Test case 2: Insert at a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Try to insert at locked index 2, should insert at index 3 instead
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 2, 99);
+            assert_eq!(actual_index, 3);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 99, 3, 4]));
+        }
+
+        // Test case 3: Multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+            locked.insert(3); // Lock index 3
+
+            // Insert at index 0, should maintain locked indices
+            insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(deque, VecDeque::from(vec![99, 1, 0, 3, 2, 4]));
+            // Elements '1' and '3' remain at indices 1 and 3
+        }
+
+        // Test case 4: Insert at end
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Insert at end of deque
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 5, 99);
+            assert_eq!(actual_index, 5);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4, 99]));
+        }
+
+        // Test case 5: Empty deque
+        {
+            let mut deque = VecDeque::new();
+            let mut locked = BTreeSet::new();
+
+            // Insert into empty deque
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(actual_index, 0);
+            assert_eq!(deque, VecDeque::from(vec![99]));
+        }
+
+        // Test case 6: All indices locked
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            for i in 0..5 {
+                locked.insert(i); // Lock all indices
+            }
+
+            // Try to insert at index 2, should insert at the end
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 2, 99);
+            assert_eq!(actual_index, 5);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4, 99]));
+        }
+
+        // Test case 7: Consecutive locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+            locked.insert(3); // Lock index 3
+
+            // Insert at index 1, should maintain consecutive locked indices
+            insert_respecting_locks(&mut deque, &mut locked, 1, 99);
+            assert_eq!(deque, VecDeque::from(vec![0, 99, 2, 3, 1, 4]));
+            // Elements '2' and '3' remain at indices 2 and 3
+        }
+    }
+
+    #[test]
+    fn test_remove_respecting_locks() {
+        // Test case 1: Remove a non-locked index before a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(removed, Some(0));
+            assert_eq!(deque, VecDeque::from(vec![1, 3, 2, 4]));
+            assert!(locked.contains(&2)); // Index 2 should still be locked
+        }
+
+        // Test case 2: Remove a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 2);
+            assert_eq!(removed, Some(2));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 3, 4]));
+            assert!(!locked.contains(&2)); // Index 2 should be unlocked
+        }
+
+        // Test case 3: Remove an index after a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 3);
+            assert_eq!(removed, Some(3));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 4]));
+            assert!(locked.contains(&1)); // Index 1 should still be locked
+        }
+
+        // Test case 4: Multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+            locked.insert(3); // Lock index 3
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(removed, Some(0));
+            assert_eq!(deque, VecDeque::from(vec![2, 1, 4, 3]));
+            assert!(locked.contains(&1) && locked.contains(&3)); // Both indices should still be locked
+        }
+
+        // Test case 5: Remove the last element
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 4);
+            assert_eq!(removed, Some(4));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3]));
+            assert!(locked.contains(&2)); // Index 2 should still be locked
+        }
+
+        // Test case 6: Invalid index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 10);
+            assert_eq!(removed, None);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4])); // Deque unchanged
+            assert!(locked.contains(&2)); // Lock unchanged
+        }
+
+        // Test case 7: Remove enough elements to make a locked index invalid
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(deque, VecDeque::from(vec![1, 2]));
+            assert!(!locked.contains(&2)); // Index 2 should now be invalid
+        }
+
+        // Test case 8: Removing an element before multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4, 5]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+            locked.insert(4); // Lock index 4
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 1);
+            assert_eq!(removed, Some(1));
+            assert_eq!(deque, VecDeque::from(vec![0, 3, 2, 5, 4]));
+            assert!(locked.contains(&2) && locked.contains(&4)); // Both indices should still be locked
+        }
+    }
+}

komorebi/src/main.rs

@@ -10,36 +10,31 @@
 use std::env::temp_dir;
 use std::net::Shutdown;
 use std::path::PathBuf;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 #[cfg(feature = "deadlock_detection")]
 use std::time::Duration;
 
 use clap::Parser;
 use clap::ValueEnum;
-use color_eyre::eyre;
-use color_eyre::eyre::bail;
+use color_eyre::eyre::anyhow;
+use color_eyre::Result;
 use crossbeam_utils::Backoff;
+use komorebi::animation::AnimationEngine;
 use komorebi::animation::ANIMATION_ENABLED_GLOBAL;
 use komorebi::animation::ANIMATION_ENABLED_PER_ANIMATION;
-use komorebi::animation::AnimationEngine;
 use komorebi::replace_env_in_path;
-use parking_lot::Mutex;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
+use parking_lot::Mutex;
 use serde::Deserialize;
 use sysinfo::Process;
 use sysinfo::ProcessesToUpdate;
 use tracing_appender::non_blocking::WorkerGuard;
-use tracing_subscriber::EnvFilter;
 use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::EnvFilter;
 use uds_windows::UnixStream;
 
-use komorebi::CUSTOM_FFM;
-use komorebi::DATA_DIR;
-use komorebi::HOME_DIR;
-use komorebi::INITIAL_CONFIGURATION_LOADED;
-use komorebi::SESSION_ID;
 use komorebi::border_manager;
 use komorebi::focus_manager;
 use komorebi::load_configuration;
@@ -57,29 +52,30 @@ use komorebi::window_manager::State;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
+use komorebi::CUSTOM_FFM;
+use komorebi::DATA_DIR;
+use komorebi::HOME_DIR;
+use komorebi::INITIAL_CONFIGURATION_LOADED;
+use komorebi::SESSION_ID;
 
-fn setup(log_level: LogLevel) -> eyre::Result<(WorkerGuard, WorkerGuard)> {
+fn setup(log_level: LogLevel) -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        unsafe {
-            std::env::set_var("RUST_LIB_BACKTRACE", "1");
-        }
+        std::env::set_var("RUST_LIB_BACKTRACE", "1");
     }
 
     color_eyre::install()?;
 
     if std::env::var("RUST_LOG").is_err() {
-        unsafe {
-            std::env::set_var(
-                "RUST_LOG",
-                match log_level {
-                    LogLevel::Error => "error",
-                    LogLevel::Warn => "warn",
-                    LogLevel::Info => "info",
-                    LogLevel::Debug => "debug",
-                    LogLevel::Trace => "trace",
-                },
-            );
-        }
+        std::env::set_var(
+            "RUST_LOG",
+            match log_level {
+                LogLevel::Error => "error",
+                LogLevel::Warn => "warn",
+                LogLevel::Info => "info",
+                LogLevel::Debug => "debug",
+                LogLevel::Trace => "trace",
+            },
+        );
     }
 
     let appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi_plaintext.log");
@@ -138,22 +134,20 @@ fn setup(log_level: LogLevel) -> eyre::Result<(WorkerGuard, WorkerGuard)> {
 #[tracing::instrument]
 fn detect_deadlocks() {
     // Create a background thread which checks for deadlocks every 10s
-    std::thread::spawn(move || {
-        loop {
-            tracing::info!("running deadlock detector");
-            std::thread::sleep(Duration::from_secs(5));
-            let deadlocks = deadlock::check_deadlock();
-            if deadlocks.is_empty() {
-                continue;
-            }
+    std::thread::spawn(move || loop {
+        tracing::info!("running deadlock detector");
+        std::thread::sleep(Duration::from_secs(5));
+        let deadlocks = deadlock::check_deadlock();
+        if deadlocks.is_empty() {
+            continue;
+        }
 
-            tracing::error!("{} deadlocks detected", deadlocks.len());
-            for (i, threads) in deadlocks.iter().enumerate() {
-                tracing::error!("deadlock #{}", i);
-                for t in threads {
-                    tracing::error!("thread id: {:#?}", t.thread_id());
-                    tracing::error!("{:#?}", t.backtrace());
-                }
+        tracing::error!("{} deadlocks detected", deadlocks.len());
+        for (i, threads) in deadlocks.iter().enumerate() {
+            tracing::error!("deadlock #{}", i);
+            for t in threads {
+                tracing::error!("thread id: {:#?}", t.thread_id());
+                tracing::error!("{:#?}", t.backtrace());
             }
         }
     });
@@ -196,7 +190,7 @@ struct Opts {
 
 #[tracing::instrument]
 #[allow(clippy::cognitive_complexity)]
-fn main() -> eyre::Result<()> {
+fn main() -> Result<()> {
     let opts: Opts = Opts::parse();
     CUSTOM_FFM.store(opts.focus_follows_mouse, Ordering::SeqCst);
 
@@ -216,7 +210,9 @@ fn main() -> eyre::Result<()> {
         }
 
         if set_foreground_window_retries == 0 {
-            bail!("failed call to AllowSetForegroundWindow after 5 retries");
+            return Err(anyhow!(
+                "failed call to AllowSetForegroundWindow after 5 retries"
+            ));
         }
     }
 
@@ -233,17 +229,15 @@ fn main() -> eyre::Result<()> {
     if matched_procs.len() > 1 {
         let mut len = matched_procs.len();
         for proc in matched_procs {
-            if let Some(executable_path) = proc.exe()
-                && executable_path.to_string_lossy().contains("shims")
-            {
-                len -= 1;
+            if let Some(executable_path) = proc.exe() {
+                if executable_path.to_string_lossy().contains("shims") {
+                    len -= 1;
+                }
             }
         }
 
         if len > 1 {
-            tracing::error!(
-                "komorebi.exe is already running, please exit the existing process before starting a new one"
-            );
+            tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
             std::process::exit(1);
         }
     }

komorebi/src/monitor.rs

@@ -2,9 +2,13 @@ use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::sync::atomic::Ordering;
 
-use color_eyre::eyre;
-use color_eyre::eyre::OptionExt;
+use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
+use color_eyre::Result;
+use getset::CopyGetters;
+use getset::Getters;
+use getset::MutGetters;
+use getset::Setters;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -13,40 +17,58 @@ use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::core::Rect;
 
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::DEFAULT_WORKSPACE_PADDING;
+use crate::container::Container;
+use crate::ring::Ring;
+use crate::workspace::Workspace;
+use crate::workspace::WorkspaceGlobals;
+use crate::workspace::WorkspaceLayer;
 use crate::DefaultLayout;
 use crate::FloatingLayerBehaviour;
 use crate::Layout;
 use crate::OperationDirection;
 use crate::Wallpaper;
 use crate::WindowsApi;
-use crate::container::Container;
-use crate::ring::Ring;
-use crate::workspace::Workspace;
-use crate::workspace::WorkspaceGlobals;
-use crate::workspace::WorkspaceLayer;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(
+    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, PartialEq,
+)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Monitor {
+    #[getset(get_copy = "pub", set = "pub")]
     pub id: isize,
+    #[getset(get = "pub", set = "pub")]
     pub name: String,
+    #[getset(get = "pub", set = "pub")]
     pub device: String,
+    #[getset(get = "pub", set = "pub")]
     pub device_id: String,
+    #[getset(get = "pub", set = "pub")]
     pub serial_number_id: Option<String>,
+    #[getset(get = "pub", set = "pub")]
     pub size: Rect,
+    #[getset(get = "pub", set = "pub")]
     pub work_area_size: Rect,
+    #[getset(get_copy = "pub", set = "pub")]
     pub work_area_offset: Option<Rect>,
+    #[getset(get_copy = "pub", set = "pub")]
     pub window_based_work_area_offset: Option<Rect>,
+    #[getset(get_copy = "pub", set = "pub")]
     pub window_based_work_area_offset_limit: isize,
     pub workspaces: Ring<Workspace>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[getset(get_copy = "pub", set = "pub")]
     pub last_focused_workspace: Option<usize>,
+    #[getset(get_mut = "pub")]
     pub workspace_names: HashMap<usize, String>,
+    #[getset(get_copy = "pub", set = "pub")]
     pub container_padding: Option<i32>,
+    #[getset(get_copy = "pub", set = "pub")]
     pub workspace_padding: Option<i32>,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
     pub wallpaper: Option<Wallpaper>,
+    #[getset(get_copy = "pub", set = "pub")]
     pub floating_layer_behaviour: Option<FloatingLayerBehaviour>,
 }
 
@@ -153,23 +175,23 @@ impl Monitor {
 
     pub fn focused_workspace_name(&self) -> Option<String> {
         self.focused_workspace()
-            .map(|w| w.name.clone())
+            .map(|w| w.name().clone())
             .unwrap_or(None)
     }
 
     pub fn focused_workspace_layout(&self) -> Option<Layout> {
         self.focused_workspace().and_then(|workspace| {
-            if workspace.tile {
-                Some(workspace.layout.clone())
+            if *workspace.tile() {
+                Some(workspace.layout().clone())
             } else {
                 None
             }
         })
     }
 
-    pub fn load_focused_workspace(&mut self, mouse_follows_focus: bool) -> eyre::Result<()> {
+    pub fn load_focused_workspace(&mut self, mouse_follows_focus: bool) -> Result<()> {
         let focused_idx = self.focused_workspace_idx();
-        let hmonitor = self.id;
+        let hmonitor = self.id();
         let monitor_wp = self.wallpaper.clone();
         for (i, workspace) in self.workspaces_mut().iter_mut().enumerate() {
             if i == focused_idx {
@@ -185,10 +207,10 @@ impl Monitor {
     /// Updates the `globals` field of all workspaces
     pub fn update_workspaces_globals(&mut self, offset: Option<Rect>) {
         let container_padding = self
-            .container_padding
+            .container_padding()
             .or(Some(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)));
         let workspace_padding = self
-            .workspace_padding
+            .workspace_padding()
             .or(Some(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)));
         let (border_width, border_offset) = {
             let border_enabled = BORDER_ENABLED.load(Ordering::SeqCst);
@@ -200,11 +222,11 @@ impl Monitor {
                 (0, 0)
             }
         };
-        let work_area = self.work_area_size;
+        let work_area = *self.work_area_size();
         let work_area_offset = self.work_area_offset.or(offset);
-        let window_based_work_area_offset = self.window_based_work_area_offset;
-        let window_based_work_area_offset_limit = self.window_based_work_area_offset_limit;
-        let floating_layer_behaviour = self.floating_layer_behaviour;
+        let window_based_work_area_offset = self.window_based_work_area_offset();
+        let window_based_work_area_offset_limit = self.window_based_work_area_offset_limit();
+        let floating_layer_behaviour = self.floating_layer_behaviour();
 
         for workspace in self.workspaces_mut() {
             workspace.globals = WorkspaceGlobals {
@@ -224,10 +246,10 @@ impl Monitor {
     /// Updates the `globals` field of workspace with index `workspace_idx`
     pub fn update_workspace_globals(&mut self, workspace_idx: usize, offset: Option<Rect>) {
         let container_padding = self
-            .container_padding
+            .container_padding()
             .or(Some(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)));
         let workspace_padding = self
-            .workspace_padding
+            .workspace_padding()
             .or(Some(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)));
         let (border_width, border_offset) = {
             let border_enabled = BORDER_ENABLED.load(Ordering::SeqCst);
@@ -239,11 +261,11 @@ impl Monitor {
                 (0, 0)
             }
         };
-        let work_area = self.work_area_size;
+        let work_area = *self.work_area_size();
         let work_area_offset = self.work_area_offset.or(offset);
-        let window_based_work_area_offset = self.window_based_work_area_offset;
-        let window_based_work_area_offset_limit = self.window_based_work_area_offset_limit;
-        let floating_layer_behaviour = self.floating_layer_behaviour;
+        let window_based_work_area_offset = self.window_based_work_area_offset();
+        let window_based_work_area_offset_limit = self.window_based_work_area_offset_limit();
+        let floating_layer_behaviour = self.floating_layer_behaviour();
 
         if let Some(workspace) = self.workspaces_mut().get_mut(workspace_idx) {
             workspace.globals = WorkspaceGlobals {
@@ -264,14 +286,14 @@ impl Monitor {
         &mut self,
         container: Container,
         workspace_idx: Option<usize>,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         let workspace = if let Some(idx) = workspace_idx {
             self.workspaces_mut()
                 .get_mut(idx)
-                .ok_or_eyre(format!("there is no workspace at index {idx}"))?
+                .ok_or_else(|| anyhow!("there is no workspace at index {}", idx))?
         } else {
             self.focused_workspace_mut()
-                .ok_or_eyre("there is no workspace")?
+                .ok_or_else(|| anyhow!("there is no workspace"))?
         };
 
         workspace.add_container_to_back(container);
@@ -288,21 +310,21 @@ impl Monitor {
         container: Container,
         workspace_idx: Option<usize>,
         direction: OperationDirection,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         let workspace = if let Some(idx) = workspace_idx {
             self.workspaces_mut()
                 .get_mut(idx)
-                .ok_or_eyre(format!("there is no workspace at index {idx}"))?
+                .ok_or_else(|| anyhow!("there is no workspace at index {}", idx))?
         } else {
             self.focused_workspace_mut()
-                .ok_or_eyre("there is no workspace")?
+                .ok_or_else(|| anyhow!("there is no workspace"))?
         };
 
         match direction {
             OperationDirection::Left => {
                 // insert the container into the workspace on the monitor at the back (or rightmost position)
                 // if we are moving across a boundary to the left (back = right side of the target)
-                match workspace.layout {
+                match workspace.layout() {
                     Layout::Default(layout) => match layout {
                         DefaultLayout::RightMainVerticalStack => {
                             workspace.add_container_to_front(container);
@@ -326,7 +348,7 @@ impl Monitor {
             OperationDirection::Right => {
                 // insert the container into the workspace on the monitor at the front (or leftmost position)
                 // if we are moving across a boundary to the right (front = left side of the target)
-                match workspace.layout {
+                match workspace.layout() {
                     Layout::Default(layout) => {
                         let target_index = layout.leftmost_index(workspace.containers().len());
 
@@ -390,12 +412,12 @@ impl Monitor {
         target_workspace_idx: usize,
         follow: bool,
         direction: Option<OperationDirection>,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         let workspace = self
             .focused_workspace_mut()
-            .ok_or_eyre("there is no workspace")?;
+            .ok_or_else(|| anyhow!("there is no workspace"))?;
 
-        if workspace.maximized_window.is_some() {
+        if workspace.maximized_window().is_some() {
             bail!("cannot move native maximized window to another monitor or workspace");
         }
 
@@ -418,12 +440,12 @@ impl Monitor {
                 };
 
                 target_workspace.floating_windows_mut().push_back(window);
-                target_workspace.layer = WorkspaceLayer::Floating;
+                target_workspace.set_layer(WorkspaceLayer::Floating);
             }
         } else {
             let container = workspace
                 .remove_focused_container()
-                .ok_or_eyre("there is no container")?;
+                .ok_or_else(|| anyhow!("there is no container"))?;
 
             let workspaces = self.workspaces_mut();
 
@@ -436,7 +458,7 @@ impl Monitor {
                 Some(workspace) => workspace,
             };
 
-            if target_workspace.monocle_container.is_some() {
+            if target_workspace.monocle_container().is_some() {
                 for container in target_workspace.containers_mut() {
                     container.restore();
                 }
@@ -448,7 +470,7 @@ impl Monitor {
                 target_workspace.reintegrate_monocle_container()?;
             }
 
-            target_workspace.layer = WorkspaceLayer::Tiling;
+            target_workspace.set_layer(WorkspaceLayer::Tiling);
 
             if let Some(direction) = direction {
                 self.add_container_with_direction(
@@ -469,7 +491,7 @@ impl Monitor {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> {
+    pub fn focus_workspace(&mut self, idx: usize) -> Result<()> {
         tracing::info!("focusing workspace");
 
         {
@@ -478,7 +500,7 @@ impl Monitor {
             if workspaces.get(idx).is_none() {
                 workspaces.resize(idx + 1, Workspace::default());
             }
-            self.last_focused_workspace = Some(self.workspaces.focused_idx());
+
             self.workspaces.focus(idx);
         }
 
@@ -488,8 +510,8 @@ impl Monitor {
             if name.is_some() {
                 self.workspaces_mut()
                     .get_mut(idx)
-                    .ok_or_eyre("there is no workspace")?
-                    .name = name;
+                    .ok_or_else(|| anyhow!("there is no workspace"))?
+                    .set_name(name);
             }
         }
 
@@ -500,9 +522,9 @@ impl Monitor {
         self.workspaces().len()
     }
 
-    pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> eyre::Result<()> {
-        let offset = if self.work_area_offset.is_some() {
-            self.work_area_offset
+    pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> Result<()> {
+        let offset = if self.work_area_offset().is_some() {
+            self.work_area_offset()
         } else {
             offset
         };
@@ -510,7 +532,7 @@ impl Monitor {
         let focused_workspace_idx = self.focused_workspace_idx();
         self.update_workspace_globals(focused_workspace_idx, offset);
         self.focused_workspace_mut()
-            .ok_or_eyre("there is no workspace")?
+            .ok_or_else(|| anyhow!("there is no workspace"))?
             .update()?;
 
         Ok(())
@@ -609,25 +631,6 @@ mod tests {
         assert_eq!(m.workspaces().len(), 0);
     }
 
-    #[test]
-    fn test_remove_nonexistent_workspace() {
-        let mut m = Monitor::new(
-            0,
-            Rect::default(),
-            Rect::default(),
-            "TestMonitor".to_string(),
-            "TestDevice".to_string(),
-            "TestDeviceID".to_string(),
-            Some("TestMonitorID".to_string()),
-        );
-
-        // Try to remove a workspace that doesn't exist
-        let removed_workspace = m.remove_workspace_by_idx(1);
-
-        // Should return None since there is no workspace at index 1
-        assert!(removed_workspace.is_none());
-    }
-
     #[test]
     fn test_focus_workspace() {
         let mut m = Monitor::new(
@@ -735,46 +738,6 @@ mod tests {
         assert_eq!(m.focused_workspace().unwrap().containers().len(), 2);
     }
 
-    #[test]
-    fn test_move_container_to_nonexistent_workspace() {
-        let mut m = Monitor::new(
-            0,
-            Rect::default(),
-            Rect::default(),
-            "TestMonitor".to_string(),
-            "TestDevice".to_string(),
-            "TestDeviceID".to_string(),
-            Some("TestMonitorID".to_string()),
-        );
-
-        {
-            // Create workspace 1 and add 3 containers
-            let workspace = m.focused_workspace_mut().unwrap();
-            for _ in 0..3 {
-                let container = Container::default();
-                workspace.add_container_to_back(container);
-            }
-
-            // Should have 3 containers in workspace 1
-            assert_eq!(m.focused_workspace().unwrap().containers().len(), 3);
-        }
-
-        // Should only have 1 workspace
-        assert_eq!(m.workspaces().len(), 1);
-
-        // Try to move a container to a workspace that doesn't exist
-        m.move_container_to_workspace(8, true, None).unwrap();
-
-        // Should have 9 workspaces now
-        assert_eq!(m.workspaces().len(), 9);
-
-        // Should be focused on workspace 8
-        assert_eq!(m.focused_workspace_idx(), 8);
-
-        // Should have 1 container in workspace 8
-        assert_eq!(m.focused_workspace().unwrap().containers().len(), 1);
-    }
-
     #[test]
     fn test_ensure_workspace_count_workspace_contains_two_workspaces() {
         let mut m = Monitor::new(

komorebi/src/monitor_reconciliator/hidden.rs

@@ -1,6 +1,7 @@
 use std::sync::mpsc;
 use std::time::Duration;
 
+use windows::core::PCWSTR;
 use windows::Win32::Devices::Display::GUID_DEVINTERFACE_DISPLAY_ADAPTER;
 use windows::Win32::Devices::Display::GUID_DEVINTERFACE_MONITOR;
 use windows::Win32::Devices::Display::GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL;
@@ -10,6 +11,10 @@ use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::WPARAM;
 use windows::Win32::System::Power::POWERBROADCAST_SETTING;
 use windows::Win32::System::SystemServices::GUID_LIDSWITCH_STATE_CHANGE;
+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_CONFIGCHANGED;
@@ -18,9 +23,6 @@ use windows::Win32::UI::WindowsAndMessaging::DBT_DEVICEREMOVECOMPLETE;
 use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
 use windows::Win32::UI::WindowsAndMessaging::DBT_DEVTYP_DEVICEINTERFACE;
 use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
-use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
-use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMEAUTOMATIC;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMESUSPEND;
@@ -28,7 +30,6 @@ use windows::Win32::UI::WindowsAndMessaging::PBT_APMSUSPEND;
 use windows::Win32::UI::WindowsAndMessaging::PBT_POWERSETTINGCHANGE;
 use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
-use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
 use windows::Win32::UI::WindowsAndMessaging::WM_POWERBROADCAST;
@@ -37,11 +38,10 @@ 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 windows::core::PCWSTR;
 
-use crate::WindowsApi;
 use crate::monitor_reconciliator;
 use crate::windows_api;
+use crate::WindowsApi;
 
 // This is a hidden window specifically spawned to listen to system-wide events related to monitors
 #[derive(Debug, Clone, Copy)]
@@ -224,18 +224,14 @@ impl Hidden {
                 WM_WTSSESSION_CHANGE => {
                     match wparam.0 as u32 {
                         WTS_SESSION_LOCK => {
-                            tracing::debug!(
-                                "WM_WTSSESSION_CHANGE event received with WTS_SESSION_LOCK - screen locked"
-                            );
+                            tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_LOCK - screen locked");
 
                             monitor_reconciliator::send_notification(
                                 monitor_reconciliator::MonitorNotification::SessionLocked,
                             );
                         }
                         WTS_SESSION_UNLOCK => {
-                            tracing::debug!(
-                                "WM_WTSSESSION_CHANGE event received with WTS_SESSION_UNLOCK - screen unlocked"
-                            );
+                            tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_UNLOCK - screen unlocked");
 
                             monitor_reconciliator::send_notification(
                                 monitor_reconciliator::MonitorNotification::SessionUnlocked,
@@ -255,8 +251,7 @@ impl Hidden {
                 // and resolution changes here
                 WM_DISPLAYCHANGE => {
                     tracing::debug!(
-                        "WM_DISPLAYCHANGE event received with wparam: {}- work area or display resolution changed",
-                        wparam.0
+                        "WM_DISPLAYCHANGE event received with wparam: {}- work area or display resolution changed", wparam.0
                     );
 
                     monitor_reconciliator::send_notification(
@@ -270,8 +265,8 @@ impl Hidden {
                     #[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)"
-                        );
+                                "WM_SETTINGCHANGE event received with SPI_SETWORKAREA - work area changed (probably butterytaskbar or something similar)"
+                            );
 
                         monitor_reconciliator::send_notification(
                             monitor_reconciliator::MonitorNotification::WorkAreaChanged,

komorebi/src/monitor_reconciliator/mod.rs

@@ -1,13 +1,5 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::DUPLICATE_MONITOR_SERIAL_IDS;
-use crate::Notification;
-use crate::NotificationEvent;
-use crate::State;
-use crate::WORKSPACE_MATCHING_RULES;
-use crate::WindowManager;
-use crate::WindowsApi;
 use crate::border_manager;
 use crate::config_generation::WorkspaceMatchingRule;
 use crate::core::Rect;
@@ -15,6 +7,14 @@ use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator::hidden::Hidden;
 use crate::notify_subscribers;
+use crate::Notification;
+use crate::NotificationEvent;
+use crate::State;
+use crate::WindowManager;
+use crate::WindowsApi;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::DUPLICATE_MONITOR_SERIAL_IDS;
+use crate::WORKSPACE_MATCHING_RULES;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
@@ -22,10 +22,10 @@ use parking_lot::Mutex;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
-use std::sync::Arc;
-use std::sync::OnceLock;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::OnceLock;
 
 pub mod hidden;
 
@@ -70,10 +70,10 @@ pub fn send_notification(notification: MonitorNotification) {
 pub fn insert_in_monitor_cache(serial_or_device_id: &str, monitor: Monitor) {
     let dip = DISPLAY_INDEX_PREFERENCES.read();
     let mut dip_ids = dip.values();
-    let preferred_id = if dip_ids.any(|id| id.eq(&monitor.device_id)) {
-        monitor.device_id.clone()
-    } else if dip_ids.any(|id| Some(id) == monitor.serial_number_id.as_ref()) {
-        monitor.serial_number_id.clone().unwrap_or_default()
+    let preferred_id = if dip_ids.any(|id| id == monitor.device_id()) {
+        monitor.device_id().clone()
+    } else if dip_ids.any(|id| Some(id) == monitor.serial_number_id().as_ref()) {
+        monitor.serial_number_id().clone().unwrap_or_default()
     } else {
         serial_or_device_id.to_string()
     };
@@ -100,12 +100,12 @@ where
     }
 
     for d in &all_displays {
-        if let Some(id) = &d.serial_number_id
-            && serial_id_map.get(id).copied().unwrap_or_default() > 1
-        {
-            let mut dupes = DUPLICATE_MONITOR_SERIAL_IDS.write();
-            if !dupes.contains(id) {
-                (*dupes).push(id.clone());
+        if let Some(id) = &d.serial_number_id {
+            if serial_id_map.get(id).copied().unwrap_or_default() > 1 {
+                let mut dupes = DUPLICATE_MONITOR_SERIAL_IDS.write();
+                if !dupes.contains(id) {
+                    (*dupes).push(id.clone());
+                }
             }
         }
     }
@@ -155,18 +155,16 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Re
 
     tracing::info!("created hidden window to listen for monitor-related events");
 
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone(), win32_display_data::connected_displays_all) {
-                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)
-                    }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone(), win32_display_data::connected_displays_all) {
+            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)
                 }
             }
         }
@@ -221,27 +219,27 @@ where
                     let mut should_update = false;
 
                     // Update work areas as necessary
-                    if let Ok(reference) = WindowsApi::monitor(monitor.id)
-                        && reference.work_area_size != monitor.work_area_size
-                    {
-                        monitor.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,
-                        };
+                    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;
+                            should_update = true;
+                        }
                     }
 
                     if should_update {
-                        tracing::info!("updated work area for {}", monitor.device_id);
+                        tracing::info!("updated work area for {}", monitor.device_id());
                         monitor.update_focused_workspace(offset)?;
                         border_manager::send_notification(None);
                     } else {
                         tracing::debug!(
                             "work areas match, reconciliation not required for {}",
-                            monitor.device_id
+                            monitor.device_id()
                         );
                     }
                 }
@@ -253,25 +251,25 @@ where
                     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.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,
-                            };
+                    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.size = Rect {
-                                left: reference.size.left,
-                                top: reference.size.top,
-                                right: reference.size.right,
-                                bottom: reference.size.bottom,
-                            };
+                        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;
                         }
@@ -280,7 +278,7 @@ where
                     if should_update {
                         tracing::info!(
                             "updated monitor resolution/scaling for {}",
-                            monitor.device_id
+                            monitor.device_id()
                         );
 
                         monitor.update_focused_workspace(offset)?;
@@ -288,7 +286,7 @@ where
                     } else {
                         tracing::debug!(
                             "resolutions match, reconciliation not required for {}",
-                            monitor.device_id
+                            monitor.device_id()
                         );
                     }
                 }
@@ -313,21 +311,21 @@ where
                 for monitor in wm.monitors_mut() {
                     for attached in &attached_devices {
                         let serial_number_ids_match = if let (Some(attached_snid), Some(m_snid)) =
-                            (&attached.serial_number_id, &monitor.serial_number_id)
+                            (attached.serial_number_id(), monitor.serial_number_id())
                         {
                             attached_snid.eq(m_snid)
                         } else {
                             false
                         };
 
-                        if serial_number_ids_match || attached.device_id.eq(&monitor.device_id) {
-                            monitor.id = attached.id;
-                            monitor.device = attached.device.clone();
-                            monitor.device_id = attached.device_id.clone();
-                            monitor.serial_number_id = attached.serial_number_id.clone();
-                            monitor.name = attached.name.clone();
-                            monitor.size = attached.size;
-                            monitor.work_area_size = attached.work_area_size;
+                        if serial_number_ids_match || attached.device_id().eq(monitor.device_id()) {
+                            monitor.set_id(attached.id());
+                            monitor.set_device(attached.device().clone());
+                            monitor.set_device_id(attached.device_id().clone());
+                            monitor.set_serial_number_id(attached.serial_number_id().clone());
+                            monitor.set_name(attached.name().clone());
+                            monitor.set_size(*attached.size());
+                            monitor.set_work_area_size(*attached.work_area_size());
                         }
                     }
                 }
@@ -361,13 +359,13 @@ where
 
                     for (m_idx, m) in wm.monitors().iter().enumerate() {
                         if !attached_devices.iter().any(|attached| {
-                            attached.serial_number_id.eq(&m.serial_number_id)
-                                || attached.device_id.eq(&m.device_id)
+                            attached.serial_number_id().eq(m.serial_number_id())
+                                || attached.device_id().eq(m.device_id())
                         }) {
                             let id = m
-                                .serial_number_id
+                                .serial_number_id()
                                 .as_ref()
-                                .map_or(m.device_id.clone(), |sn| sn.clone());
+                                .map_or(m.device_id().clone(), |sn| sn.clone());
 
                             newly_removed_displays.push(id.clone());
 
@@ -394,7 +392,7 @@ where
                                     }
                                 }
 
-                                if let Some(maximized) = &workspace.maximized_window {
+                                if let Some(maximized) = workspace.maximized_window() {
                                     windows_to_remove.push(maximized.hwnd);
                                     // Minimize the focused window since Windows might try
                                     // to move it to another monitor if it was focused.
@@ -403,7 +401,7 @@ where
                                     }
                                 }
 
-                                if let Some(container) = &workspace.monocle_container {
+                                if let Some(container) = workspace.monocle_container() {
                                     for window in container.windows() {
                                         windows_to_remove.push(window.hwnd);
                                     }
@@ -442,10 +440,10 @@ where
                             // the user set as preference as the id.
                             let dip = DISPLAY_INDEX_PREFERENCES.read();
                             let mut dip_ids = dip.values();
-                            let preferred_id = if dip_ids.any(|id| id.eq(&m.device_id)) {
-                                m.device_id.clone()
-                            } else if dip_ids.any(|id| Some(id) == m.serial_number_id.as_ref()) {
-                                m.serial_number_id.clone().unwrap_or_default()
+                            let preferred_id = if dip_ids.any(|id| id == m.device_id()) {
+                                m.device_id().clone()
+                            } else if dip_ids.any(|id| Some(id) == m.serial_number_id().as_ref()) {
+                                m.serial_number_id().clone().unwrap_or_default()
                             } else {
                                 id
                             };
@@ -460,8 +458,8 @@ where
                         // After we have cached them, remove them from our state
                         wm.monitors_mut().retain(|m| {
                             !newly_removed_displays.iter().any(|id| {
-                                m.serial_number_id.as_ref().is_some_and(|sn| sn == id)
-                                    || m.device_id.eq(id)
+                                m.serial_number_id().as_ref().is_some_and(|sn| sn == id)
+                                    || m.device_id() == id
                             })
                         });
                     }
@@ -492,7 +490,7 @@ where
                 let post_removal_device_ids = wm
                     .monitors()
                     .iter()
-                    .map(|m| &m.device_id)
+                    .map(Monitor::device_id)
                     .cloned()
                     .collect::<Vec<_>>();
 
@@ -515,23 +513,21 @@ where
 
                     // Look in the updated state for new monitors
                     for (i, m) in wm.monitors_mut().iter_mut().enumerate() {
-                        let device_id = &m.device_id;
+                        let device_id = m.device_id();
                         // 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;
                             let mut cached_id = String::new();
                             // Check if that device id exists in the cache for this session
                             if let Some((id, cached)) = monitor_cache.get_key_value(device_id).or(m
-                                .serial_number_id
+                                .serial_number_id()
                                 .as_ref()
                                 .and_then(|sn| monitor_cache.get_key_value(sn)))
                             {
                                 cache_hit = true;
                                 cached_id = id.clone();
 
-                                tracing::info!(
-                                    "found monitor and workspace configuration for {id} in the monitor cache, applying"
-                                );
+                                tracing::info!("found monitor and workspace configuration for {id} in the monitor cache, applying");
 
                                 // If it does, update the cached monitor info with the new one and
                                 // load the cached monitor removing any window that has since been
@@ -612,24 +608,24 @@ where
                                         }
                                     }
 
-                                    if let Some(window) = &workspace.maximized_window {
+                                    if let Some(window) = workspace.maximized_window() {
                                         if window.exe().is_err()
                                             || known_hwnds.contains_key(&window.hwnd)
                                         {
-                                            workspace.maximized_window = None;
+                                            workspace.set_maximized_window(None);
                                         } else if is_focused_workspace {
                                             WindowsApi::restore_window(window.hwnd);
                                         }
                                     }
 
-                                    if let Some(container) = &mut workspace.monocle_container {
+                                    if let Some(container) = workspace.monocle_container_mut() {
                                         container.windows_mut().retain(|window| {
                                             window.exe().is_ok()
                                                 && !known_hwnds.contains_key(&window.hwnd)
                                         });
 
                                         if container.windows().is_empty() {
-                                            workspace.monocle_container = None;
+                                            workspace.set_monocle_container(None);
                                         } else if is_focused_workspace {
                                             if let Some(window) = container.focused_window() {
                                                 WindowsApi::restore_window(window.hwnd);
@@ -661,7 +657,7 @@ where
                                     let mut workspace_matching_rules =
                                         WORKSPACE_MATCHING_RULES.lock();
                                     if let Some(rules) = workspace
-                                        .workspace_config
+                                        .workspace_config()
                                         .as_ref()
                                         .and_then(|c| c.workspace_rules.as_ref())
                                     {
@@ -676,7 +672,7 @@ where
                                     }
 
                                     if let Some(rules) = workspace
-                                        .workspace_config
+                                        .workspace_config()
                                         .as_ref()
                                         .and_then(|c| c.initial_workspace_rules.as_ref())
                                     {
@@ -738,8 +734,8 @@ where
 mod tests {
     use super::*;
     use crate::window_manager_event::WindowManagerEvent;
-    use crossbeam_channel::Sender;
     use crossbeam_channel::bounded;
+    use crossbeam_channel::Sender;
     use std::path::PathBuf;
     use uuid::Uuid;
     use windows::Win32::Devices::Display::DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY;
@@ -805,7 +801,7 @@ mod tests {
         let wm = match WindowManager::new(receiver, Some(socket_path.clone())) {
             Ok(manager) => manager,
             Err(e) => {
-                panic!("Failed to create WindowManager: {e}");
+                panic!("Failed to create WindowManager: {}", e);
             }
         };
 
@@ -833,7 +829,7 @@ mod tests {
             Ok(notification) => {
                 assert_eq!(notification, MonitorNotification::ResolutionScalingChanged);
             }
-            Err(e) => panic!("Failed to receive MonitorNotification: {e}"),
+            Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
         }
     }
 
@@ -853,7 +849,7 @@ mod tests {
         for _ in 0..20 {
             let notification = match receiver.try_recv() {
                 Ok(notification) => notification,
-                Err(e) => panic!("Failed to receive MonitorNotification: {e}"),
+                Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
             };
             assert_eq!(
                 notification,
@@ -964,7 +960,7 @@ mod tests {
             Ok(notification) => {
                 assert_eq!(notification, MonitorNotification::DisplayConnectionChange);
             }
-            Err(e) => panic!("Failed to receive MonitorNotification: {e}"),
+            Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
         }
     }
 
@@ -1010,18 +1006,18 @@ mod tests {
             assert_eq!(monitors.len(), 1, "Expected one monitor");
 
             // hmonitor
-            assert_eq!(monitors[0].id, 1);
+            assert_eq!(monitors[0].id(), 1);
 
             // device name
-            assert_eq!(monitors[0].name, String::from("DISPLAY1"));
+            assert_eq!(monitors[0].name(), &String::from("DISPLAY1"));
 
             // Device
-            assert_eq!(monitors[0].device, String::from("ABC123"));
+            assert_eq!(monitors[0].device(), &String::from("ABC123"));
 
             // Device ID
             assert_eq!(
-                monitors[0].device_id,
-                String::from("ABC123-4&123456&0&UID0")
+                monitors[0].device_id(),
+                &String::from("ABC123-4&123456&0&UID0")
             );
 
             // Check monitor serial number id

komorebi/src/process_event.rs

@@ -1,8 +1,8 @@
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
-use color_eyre::eyre;
-use color_eyre::eyre::OptionExt;
+use color_eyre::eyre::anyhow;
+use color_eyre::Result;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
 
@@ -11,18 +11,6 @@ use crate::core::Rect;
 use crate::core::Sizing;
 use crate::core::WindowContainerBehaviour;
 
-use crate::CURRENT_VIRTUAL_DESKTOP;
-use crate::DefaultLayout;
-use crate::FLOATING_APPLICATIONS;
-use crate::HIDDEN_HWNDS;
-use crate::Layout;
-use crate::Notification;
-use crate::NotificationEvent;
-use crate::REGEX_IDENTIFIERS;
-use crate::State;
-use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::VirtualDesktopNotification;
-use crate::Window;
 use crate::border_manager;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
@@ -30,13 +18,23 @@ use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
 use crate::transparency_manager;
-use crate::window::RuleDebug;
 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::WorkspaceLayer;
+use crate::Notification;
+use crate::NotificationEvent;
+use crate::State;
+use crate::VirtualDesktopNotification;
+use crate::Window;
+use crate::CURRENT_VIRTUAL_DESKTOP;
+use crate::FLOATING_APPLICATIONS;
+use crate::HIDDEN_HWNDS;
+use crate::REGEX_IDENTIFIERS;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
@@ -65,7 +63,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()))]
-    pub fn process_event(&mut self, event: WindowManagerEvent) -> eyre::Result<()> {
+    pub fn process_event(&mut self, event: WindowManagerEvent) -> Result<()> {
         if self.is_paused {
             tracing::trace!("ignoring while paused");
             return Ok(());
@@ -145,9 +143,7 @@ impl WindowManager {
                     // to be consumed by integrating gui applications like bars to know
                     // when to hide visual components which don't make sense when not on
                     // komorebi's associated virtual desktop
-                    tracing::debug!(
-                        "notifying subscribers that we have left komorebi's associated virtual desktop"
-                    );
+                    tracing::debug!("notifying subscribers that we have left komorebi's associated virtual desktop");
                     notify_subscribers(
                         Notification {
                             event: NotificationEvent::VirtualDesktop(
@@ -167,9 +163,7 @@ impl WindowManager {
                     // to be consumed by integrating gui applications like bars to know
                     // when to show visual components associated with komorebi's virtual
                     // desktop
-                    tracing::debug!(
-                        "notifying subscribers that we are back on komorebi's associated virtual desktop"
-                    );
+                    tracing::debug!("notifying subscribers that we are back on komorebi's associated virtual desktop");
                     notify_subscribers(
                         Notification {
                             event: NotificationEvent::VirtualDesktop(
@@ -207,11 +201,12 @@ impl WindowManager {
                     //
                     // 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()
-                        && class != "OleMainThreadWndClass"
-                        && self.focused_monitor_idx() != monitor_idx
-                    {
-                        self.focus_monitor(monitor_idx)?;
+                    if let Ok(class) = window.class() {
+                        if class != "OleMainThreadWndClass"
+                            && self.focused_monitor_idx() != monitor_idx
+                        {
+                            self.focus_monitor(monitor_idx)?;
+                        }
                     }
                 }
             }
@@ -306,11 +301,7 @@ impl WindowManager {
                 // don't want to trigger the full workspace updates when there are no managed
                 // containers - this makes floating windows on empty workspaces go into very
                 // annoying focus change loops which prevents users from interacting with them
-                if !matches!(
-                    self.focused_workspace()?.layout,
-                    Layout::Default(DefaultLayout::Scrolling)
-                ) && !self.focused_workspace()?.containers().is_empty()
-                {
+                if !self.focused_workspace()?.containers().is_empty() {
                     self.update_focused_workspace(self.mouse_follows_focus, false)?;
                 }
 
@@ -322,13 +313,13 @@ impl WindowManager {
 
                 match floating_window_idx {
                     None => {
-                        if let Some(w) = &workspace.maximized_window
-                            && w.hwnd == window.hwnd
-                        {
-                            return Ok(());
+                        if let Some(w) = workspace.maximized_window() {
+                            if w.hwnd == window.hwnd {
+                                return Ok(());
+                            }
                         }
 
-                        if let Some(monocle) = &workspace.monocle_container {
+                        if let Some(monocle) = workspace.monocle_container() {
                             if let Some(window) = monocle.focused_window() {
                                 window.focus(false)?;
                             }
@@ -336,19 +327,11 @@ impl WindowManager {
                             workspace.focus_container_by_window(window.hwnd)?;
                         }
 
-                        workspace.layer = WorkspaceLayer::Tiling;
-
-                        if matches!(
-                            self.focused_workspace()?.layout,
-                            Layout::Default(DefaultLayout::Scrolling)
-                        ) && !self.focused_workspace()?.containers().is_empty()
-                        {
-                            self.update_focused_workspace(self.mouse_follows_focus, false)?;
-                        }
+                        workspace.set_layer(WorkspaceLayer::Tiling);
                     }
                     Some(idx) => {
                         if let Some(_window) = workspace.floating_windows().get(idx) {
-                            workspace.layer = WorkspaceLayer::Floating;
+                            workspace.set_layer(WorkspaceLayer::Floating);
                         }
                     }
                 }
@@ -356,11 +339,10 @@ impl WindowManager {
             WindowManagerEvent::Show(_, window)
             | WindowManagerEvent::Manage(window)
             | WindowManagerEvent::Uncloak(_, window) => {
-                if matches!(event, WindowManagerEvent::Uncloak(_, _))
-                    && self.uncloack_to_ignore >= 1
+                if matches!(event, WindowManagerEvent::Uncloak(_, _)) && self.uncloak_to_ignore >= 1
                 {
                     tracing::info!("ignoring uncloak after monocle move by mouse across monitors");
-                    self.uncloack_to_ignore = self.uncloack_to_ignore.saturating_sub(1);
+                    self.uncloak_to_ignore = self.uncloak_to_ignore.saturating_sub(1);
                 } else {
                     let focused_monitor_idx = self.focused_monitor_idx();
                     let focused_workspace_idx =
@@ -392,20 +374,23 @@ impl WindowManager {
                         }
                     }
 
-                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd)
-                        && let Some(focused_workspace_idx) = self
+                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
+                        if let Some(focused_workspace_idx) = self
                             .monitors()
                             .get(*m_idx)
                             .map(|m| m.focused_workspace_idx())
-                        && *m_idx != self.focused_monitor_idx()
-                        && *w_idx != focused_workspace_idx
-                    {
-                        tracing::debug!(
-                            "ignoring show event for window already associated with another workspace"
-                        );
+                        {
+                            if *m_idx != self.focused_monitor_idx()
+                                && *w_idx != focused_workspace_idx
+                            {
+                                tracing::debug!(
+                                    "ignoring show event for window already associated with another workspace"
+                                );
 
-                        window.hide();
-                        proceed = false;
+                                window.hide();
+                                proceed = false;
+                            }
+                        }
                     }
 
                     if proceed {
@@ -415,7 +400,8 @@ impl WindowManager {
                         );
                         let workspace = self.focused_workspace_mut()?;
                         let workspace_contains_window = workspace.contains_window(window.hwnd);
-                        let monocle_container = workspace.monocle_container.clone();
+                        let monocle_container = workspace.monocle_container().clone();
+                        let mut workspace_layer = *workspace.layer();
 
                         if !workspace_contains_window && needs_reconciliation.is_none() {
                             let floating_applications = FLOATING_APPLICATIONS.lock();
@@ -458,11 +444,12 @@ impl WindowManager {
                                 let center_spawned_floats =
                                     placement.should_center() && workspace.tile;
                                 workspace.floating_windows_mut().push_back(window);
-                                workspace.layer = WorkspaceLayer::Floating;
+                                workspace.set_layer(WorkspaceLayer::Floating);
+                                workspace_layer = *workspace.layer();
                                 if center_spawned_floats {
                                     let mut floating_window = window;
                                     floating_window.center(
-                                        &workspace.globals.work_area,
+                                        &workspace.globals().work_area,
                                         placement.should_resize(),
                                     )?;
                                 }
@@ -471,15 +458,19 @@ impl WindowManager {
                                 match behaviour.current_behaviour {
                                     WindowContainerBehaviour::Create => {
                                         workspace.new_container_for_window(window);
-                                        workspace.layer = WorkspaceLayer::Tiling;
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
+                                        workspace_layer = *workspace.layer();
                                         self.update_focused_workspace(false, false)?;
                                     }
                                     WindowContainerBehaviour::Append => {
                                         workspace
                                             .focused_container_mut()
-                                            .ok_or_eyre("there is no focused container")?
+                                            .ok_or_else(|| {
+                                                anyhow!("there is no focused container")
+                                            })?
                                             .add_window(window);
-                                        workspace.layer = WorkspaceLayer::Tiling;
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
+                                        workspace_layer = *workspace.layer();
                                         self.update_focused_workspace(true, false)?;
                                         stackbar_manager::send_notification();
                                     }
@@ -504,16 +495,17 @@ impl WindowManager {
 
                         if workspace_contains_window {
                             let mut monocle_window_event = false;
-                            if let Some(ref monocle) = monocle_container
-                                && let Some(monocle_window) = monocle.focused_window()
-                                && monocle_window.hwnd == window.hwnd
-                            {
-                                monocle_window_event = true;
+                            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;
+                                    }
+                                }
                             }
 
-                            let workspace = self.focused_workspace()?;
-                            if !(monocle_window_event || workspace.layer != WorkspaceLayer::Tiling)
+                            if !monocle_window_event
                                 && monocle_container.is_some()
+                                && matches!(workspace_layer, WorkspaceLayer::Tiling)
                             {
                                 window.hide();
                             }
@@ -525,7 +517,7 @@ impl WindowManager {
                 let monitor_idx = self.focused_monitor_idx();
                 let workspace_idx = self
                     .focused_monitor()
-                    .ok_or_eyre("there is no monitor with this idx")?
+                    .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
                     .focused_workspace_idx();
 
                 WindowsApi::bring_window_to_top(window.hwnd)?;
@@ -543,19 +535,19 @@ impl WindowManager {
 
                 // If the window handles don't match then something went wrong and the pending move
                 // is not related to this current move, if so abort this operation.
-                if let Some((_, _, w_hwnd)) = pending
-                    && w_hwnd != window.hwnd
-                {
-                    color_eyre::eyre::bail!(
-                        "window handles for move operation don't match: {} != {}",
-                        w_hwnd,
-                        window.hwnd
-                    );
+                if let Some((_, _, w_hwnd)) = pending {
+                    if w_hwnd != window.hwnd {
+                        color_eyre::eyre::bail!(
+                            "window handles for move operation don't match: {} != {}",
+                            w_hwnd,
+                            window.hwnd
+                        );
+                    }
                 }
 
                 let target_monitor_idx = self
                     .monitor_idx_from_current_pos()
-                    .ok_or_eyre("cannot get monitor idx from current position")?;
+                    .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();
@@ -566,7 +558,7 @@ impl WindowManager {
                 let focused_container_idx = workspace.focused_container_idx();
                 let new_position = WindowsApi::window_rect(window.hwnd)?;
                 let old_position = *workspace
-                    .latest_layout
+                    .latest_layout()
                     .get(focused_container_idx)
                     // If the move was to another monitor with an empty workspace, the
                     // workspace here will refer to that empty workspace, which won't
@@ -578,10 +570,10 @@ impl WindowManager {
                 // This will be true if we have moved to another monitor
                 let mut moved_across_monitors = false;
 
-                if let Some((m_idx, _)) = self.known_hwnds.get(&window.hwnd)
-                    && *m_idx != target_monitor_idx
-                {
-                    moved_across_monitors = true;
+                if let Some((m_idx, _)) = self.known_hwnds.get(&window.hwnd) {
+                    if *m_idx != target_monitor_idx {
+                        moved_across_monitors = true;
+                    }
                 }
 
                 if let Some((origin_monitor_idx, origin_workspace_idx, _)) = pending {
@@ -599,10 +591,10 @@ impl WindowManager {
                             let origin_workspace = self
                                 .monitors()
                                 .get(origin_monitor_idx)
-                                .ok_or_eyre("cannot get monitor idx")?
+                                .ok_or_else(|| anyhow!("cannot get monitor idx"))?
                                 .workspaces()
                                 .get(origin_workspace_idx)
-                                .ok_or_eyre("cannot get workspace idx")?;
+                                .ok_or_else(|| anyhow!("cannot get workspace idx"))?;
 
                             let managed_window = origin_workspace.contains_window(window.hwnd);
 
@@ -614,7 +606,7 @@ impl WindowManager {
                 }
 
                 let workspace = self.focused_workspace_mut()?;
-                if (workspace.tile && workspace.contains_managed_window(window.hwnd))
+                if (*workspace.tile() && workspace.contains_managed_window(window.hwnd))
                     || moved_across_monitors
                 {
                     let resize = Rect {
@@ -642,15 +634,17 @@ impl WindowManager {
                                 let target_workspace_idx = self
                                     .monitors()
                                     .get(target_monitor_idx)
-                                    .ok_or_eyre("there is no monitor at this idx")?
+                                    .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
                                     .focused_workspace_idx();
 
                                 let target_container_idx = self
                                     .monitors()
                                     .get(target_monitor_idx)
-                                    .ok_or_eyre("there is no monitor at this idx")?
+                                    .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
                                     .focused_workspace()
-                                    .ok_or_eyre("there is no focused workspace for this monitor")?
+                                    .ok_or_else(|| {
+                                        anyhow!("there is no focused workspace for this monitor")
+                                    })?
                                     .container_idx_from_current_point()
                                     // Default to 0 in the case of an empty workspace
                                     .unwrap_or(0);
@@ -670,7 +664,7 @@ impl WindowManager {
                                 let origin_monitor = self
                                     .monitors_mut()
                                     .get_mut(origin_monitor_idx)
-                                    .ok_or_eyre("there is no monitor at this idx")?;
+                                    .ok_or_else(|| anyhow!("there is no monitor at this idx"))?;
                                 origin_monitor.focus_workspace(origin_workspace_idx)?;
                                 self.update_focused_workspace(false, false)?;
 
@@ -678,7 +672,7 @@ impl WindowManager {
                                 let target_monitor = self
                                     .monitors_mut()
                                     .get_mut(target_monitor_idx)
-                                    .ok_or_eyre("there is no monitor at this idx")?;
+                                    .ok_or_else(|| anyhow!("there is no monitor at this idx"))?;
                                 target_monitor.focus_workspace(target_workspace_idx)?;
                                 self.update_focused_workspace(false, false)?;
 
@@ -830,7 +824,7 @@ impl WindowManager {
                     .and_then(|m| m.workspaces().get(*ws_idx))
                 {
                     if let Some(monocle_with_window) = target_workspace
-                        .monocle_container
+                        .monocle_container()
                         .as_ref()
                         .and_then(|m| m.contains_window(window.hwnd).then_some(m))
                     {
@@ -843,12 +837,13 @@ impl WindowManager {
 
                         if let Some(target_container) =
                             c_idx.and_then(|c_idx| target_workspace.containers().get(c_idx))
-                            && target_container.focused_window() != Some(&window)
                         {
-                            tracing::debug!(
-                                "Needs reconciliation within a stack on the focused workspace"
-                            );
-                            needs_reconciliation = Some((*m_idx, *ws_idx));
+                            if target_container.focused_window() != Some(&window) {
+                                tracing::debug!(
+                                    "Needs reconciliation within a stack on the focused workspace"
+                                );
+                                needs_reconciliation = Some((*m_idx, *ws_idx));
+                            }
                         }
                     }
                 }
@@ -879,13 +874,13 @@ impl WindowManager {
         if let Some(monitor) = self.focused_monitor_mut() {
             if ws_idx != monitor.focused_workspace_idx() {
                 let previous_idx = monitor.focused_workspace_idx();
-                monitor.last_focused_workspace = Option::from(previous_idx);
+                monitor.set_last_focused_workspace(Option::from(previous_idx));
                 monitor.focus_workspace(ws_idx)?;
             }
             if let Some(workspace) = monitor.focused_workspace_mut() {
                 let mut layer = WorkspaceLayer::Tiling;
                 if let Some((monocle, idx)) = workspace
-                    .monocle_container
+                    .monocle_container_mut()
                     .as_mut()
                     .and_then(|m| m.idx_for_window(window.hwnd).map(|i| (m, i)))
                 {
@@ -896,14 +891,14 @@ impl WindowManager {
                     .any(|w| w.hwnd == window.hwnd)
                 {
                     layer = WorkspaceLayer::Floating;
-                } else if workspace
-                    .maximized_window
-                    .is_none_or(|w| w.hwnd != window.hwnd)
+                } else if !workspace
+                    .maximized_window()
+                    .is_some_and(|w| w.hwnd == window.hwnd)
                 {
                     // If the window is the maximized window do nothing, else we
                     // reintegrate the monocle if it exists and then focus the
                     // container
-                    if workspace.monocle_container.is_some() {
+                    if workspace.monocle_container().is_some() {
                         tracing::info!("disabling monocle");
                         for container in workspace.containers_mut() {
                             container.restore();
@@ -915,7 +910,7 @@ impl WindowManager {
                     }
                     workspace.focus_container_by_window(window.hwnd)?;
                 }
-                workspace.layer = layer;
+                workspace.set_layer(layer);
             }
             monitor.load_focused_workspace(mouse_follows_focus)?;
             monitor.update_focused_workspace(offset)?;

komorebi/src/process_movement.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
 use parking_lot::Mutex;
-use winput::Action;
 use winput::message_loop;
 use winput::message_loop::Event;
+use winput::Action;
 
 use crate::core::FocusFollowsMouseImplementation;
 

komorebi/src/reaper.rs

@@ -1,15 +1,15 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
-use crate::DATA_DIR;
-use crate::HIDING_BEHAVIOUR;
+use crate::border_manager;
+use crate::notify_subscribers;
+use crate::winevent::WinEvent;
 use crate::HidingBehaviour;
 use crate::NotificationEvent;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowManagerEvent;
-use crate::border_manager;
-use crate::notify_subscribers;
-use crate::winevent::WinEvent;
+use crate::DATA_DIR;
+use crate::HIDING_BEHAVIOUR;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
@@ -55,15 +55,13 @@ pub fn listen_for_notifications(
 ) {
     watch_for_orphans(known_hwnds);
 
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone()) {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -152,18 +150,16 @@ fn watch_for_orphans(known_hwnds: HashMap<isize, (usize, usize)>) {
         *cache = known_hwnds;
     }
 
-    std::thread::spawn(move || {
-        loop {
-            match find_orphans() {
-                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)
-                    }
+    std::thread::spawn(move || loop {
+        match find_orphans() {
+            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)
                 }
             }
         }

komorebi/src/ring.rs

@@ -43,6 +43,10 @@ impl<T> Ring<T> {
     pub fn focused_mut(&mut self) -> Option<&mut T> {
         self.elements.get_mut(self.focused)
     }
+
+    pub fn swap(&mut self, i: usize, j: usize) {
+        self.elements.swap(i, j);
+    }
 }
 
 macro_rules! impl_ring_elements {

komorebi/src/stackbar_manager/mod.rs

@@ -1,26 +1,26 @@
 mod stackbar;
 
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::WindowManager;
-use crate::WindowsApi;
 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::HashMap;
 use std::collections::hash_map::Entry;
-use std::sync::Arc;
-use std::sync::OnceLock;
+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;
 
 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
@@ -28,8 +28,8 @@ pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947);
 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::Title);
-pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::Never);
+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);
 
@@ -71,15 +71,13 @@ pub fn should_have_stackbar(window_count: usize) -> bool {
 }
 
 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);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -113,7 +111,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
             // 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 {
+                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 {
@@ -133,7 +131,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     WindowsApi::is_zoomed(WindowsApi::foreground_window().unwrap_or_default());
 
                 // Handle the monocle container separately
-                if ws.monocle_container.is_some() || is_maximized {
+                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() {
@@ -154,7 +152,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 let container_ids = ws
                     .containers()
                     .iter()
-                    .map(|c| c.id.clone())
+                    .map(|c| c.id().clone())
                     .collect::<Vec<_>>();
 
                 let mut to_remove = vec![];
@@ -172,7 +170,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 }
 
                 let container_padding = ws
-                    .container_padding
+                    .container_padding()
                     .unwrap_or_else(|| DEFAULT_CONTAINER_PADDING.load_consume());
 
                 'containers: for container in ws.containers_mut() {
@@ -183,20 +181,20 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     };
 
                     if !should_add_stackbar {
-                        if let Some(stackbar) = stackbars.get(&container.id) {
+                        if let Some(stackbar) = stackbars.get(container.id()) {
                             stackbar.destroy()?
                         }
 
-                        stackbars.remove(&container.id);
-                        stackbars_monitors.remove(&container.id);
+                        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()) {
+                    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) {
+                            if let Ok(stackbar) = Stackbar::create(container.id()) {
                                 entry.insert(stackbar)
                             } else {
                                 continue 'receiver;
@@ -204,7 +202,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         }
                     };
 
-                    stackbars_monitors.insert(container.id.clone(), monitor_idx);
+                    stackbars_monitors.insert(container.id().clone(), monitor_idx);
 
                     let rect = WindowsApi::window_rect(
                         container.focused_window().copied().unwrap_or_default().hwnd,

komorebi/src/stackbar_manager/stackbar.rs

@@ -1,6 +1,3 @@
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::WINDOWS_11;
-use crate::WindowsApi;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::STYLE;
@@ -8,6 +5,7 @@ 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;
@@ -16,13 +14,16 @@ 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::stackbar_manager::STACKBARS_CONTAINERS;
 use crate::windows_api;
+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::HINSTANCE;
 use windows::Win32::Foundation::HWND;
@@ -32,50 +33,45 @@ 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::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::DeleteObject;
 use windows::Win32::Graphics::Gdi::DrawTextW;
-use windows::Win32::Graphics::Gdi::FONT_QUALITY;
-use windows::Win32::Graphics::Gdi::FW_BOLD;
 use windows::Win32::Graphics::Gdi::GetDC;
 use windows::Win32::Graphics::Gdi::GetDeviceCaps;
-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::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::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
 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::IDC_ARROW;
-use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
-use windows::Win32::UI::WindowsAndMessaging::LoadCursorW;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
-use windows::Win32::UI::WindowsAndMessaging::SetCursor;
 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::WM_SETCURSOR;
 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 windows::core::PCWSTR;
 
 #[derive(Debug)]
 pub struct Stackbar {
@@ -316,16 +312,6 @@ impl Stackbar {
     ) -> LRESULT {
         unsafe {
             match msg {
-                WM_SETCURSOR => match LoadCursorW(None, IDC_ARROW) {
-                    Ok(cursor) => {
-                        SetCursor(Some(cursor));
-                        LRESULT(0)
-                    }
-                    Err(error) => {
-                        tracing::error!("{error}");
-                        LRESULT(1)
-                    }
-                },
                 WM_LBUTTONDOWN => {
                     let stackbars_containers = STACKBARS_CONTAINERS.lock();
                     if let Some(container) = stackbars_containers.get(&(hwnd.0 as isize)) {
@@ -353,15 +339,16 @@ impl Stackbar {
                                 // 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
-                                    && let Err(err) =
+                                if index != focused_window_idx {
+                                    if let Err(err) =
                                         window.set_position(&focused_window_rect, false)
-                                {
-                                    tracing::error!(
+                                    {
+                                        tracing::error!(
                                         "stackbar WM_LBUTTONDOWN repositioning error: hwnd {} ({})",
                                         *window,
                                         err
                                     );
+                                    }
                                 }
 
                                 // Restore the window corresponding to the tab we have clicked

komorebi/src/static_config.rs

@@ -1,33 +1,4 @@
-use crate::AspectRatio;
-use crate::Axis;
-use crate::CrossBoundaryBehaviour;
-use crate::DATA_DIR;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::DEFAULT_WORKSPACE_PADDING;
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::FLOATING_APPLICATIONS;
-use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
-use crate::FloatingLayerBehaviour;
-use crate::HIDING_BEHAVIOUR;
-use crate::IGNORE_IDENTIFIERS;
-use crate::LAYERED_WHITELIST;
-use crate::MANAGE_IDENTIFIERS;
-use crate::MONITOR_INDEX_PREFERENCES;
-use crate::NO_TITLEBAR;
-use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
-use crate::OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST;
-use crate::Placement;
-use crate::PredefinedAspectRatio;
-use crate::REGEX_IDENTIFIERS;
-use crate::ResolvedPathBuf;
-use crate::SLOW_APPLICATION_COMPENSATION_TIME;
-use crate::SLOW_APPLICATION_IDENTIFIERS;
-use crate::TRANSPARENCY_BLACKLIST;
-use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WINDOW_HANDLING_BEHAVIOUR;
-use crate::WINDOWS_11;
-use crate::WORKSPACE_MATCHING_RULES;
-use crate::WindowHandlingBehaviour;
+use crate::animation::PerAnimationPrefixConfig;
 use crate::animation::ANIMATION_DURATION_GLOBAL;
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
@@ -36,14 +7,18 @@ use crate::animation::ANIMATION_FPS;
 use crate::animation::ANIMATION_STYLE_GLOBAL;
 use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
 use crate::animation::DEFAULT_ANIMATION_FPS;
-use crate::animation::PerAnimationPrefixConfig;
 use crate::asc::ApplicationSpecificConfiguration;
 use crate::asc::AscApplicationRulesOrSchema;
 use crate::border_manager;
+use crate::border_manager::ZOrder;
 use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
-use crate::border_manager::ZOrder;
 use crate::config_generation::WorkspaceMatchingRule;
+use crate::core::config_generation::ApplicationConfiguration;
+use crate::core::config_generation::ApplicationConfigurationGenerator;
+use crate::core::config_generation::ApplicationOptions;
+use crate::core::config_generation::MatchingRule;
+use crate::core::config_generation::MatchingStrategy;
 use crate::core::AnimationStyle;
 use crate::core::BorderImplementation;
 use crate::core::BorderStyle;
@@ -59,13 +34,7 @@ use crate::core::StackbarLabel;
 use crate::core::StackbarMode;
 use crate::core::WindowContainerBehaviour;
 use crate::core::WindowManagementBehaviour;
-use crate::core::config_generation::ApplicationConfiguration;
-use crate::core::config_generation::ApplicationConfigurationGenerator;
-use crate::core::config_generation::ApplicationOptions;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
 use crate::current_virtual_desktop;
-use crate::default_layout::LayoutOptions;
 use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator;
@@ -87,7 +56,37 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
-use color_eyre::eyre;
+use crate::AspectRatio;
+use crate::Axis;
+use crate::CrossBoundaryBehaviour;
+use crate::FloatingLayerBehaviour;
+use crate::Placement;
+use crate::PredefinedAspectRatio;
+use crate::ResolvedPathBuf;
+use crate::WindowHandlingBehaviour;
+use crate::DATA_DIR;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::FLOATING_APPLICATIONS;
+use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
+use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
+use crate::LAYERED_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;
+use crate::MONITOR_INDEX_PREFERENCES;
+use crate::NO_TITLEBAR;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST;
+use crate::REGEX_IDENTIFIERS;
+use crate::SLOW_APPLICATION_COMPENSATION_TIME;
+use crate::SLOW_APPLICATION_IDENTIFIERS;
+use crate::TRANSPARENCY_BLACKLIST;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WINDOWS_11;
+use crate::WINDOW_HANDLING_BEHAVIOUR;
+use crate::WORKSPACE_MATCHING_RULES;
+use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
@@ -101,8 +100,8 @@ use std::collections::HashSet;
 use std::io::ErrorKind;
 use std::io::Write;
 use std::path::PathBuf;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
@@ -192,9 +191,6 @@ pub struct WorkspaceConfig {
     /// Layout (default: BSP)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout: Option<DefaultLayout>,
-    /// Layout-specific options (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub layout_options: Option<LayoutOptions>,
     /// END OF LIFE FEATURE: Custom Layout (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde_as(as = "Option<ResolvedPathBuf>")]
@@ -218,9 +214,6 @@ pub struct WorkspaceConfig {
     /// Permanent workspace application rules
     #[serde(skip_serializing_if = "Option::is_none")]
     pub workspace_rules: Option<Vec<MatchingRule>>,
-    /// Workspace specific work area offset (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub work_area_offset: Option<Rect>,
     /// 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>,
@@ -233,9 +226,6 @@ pub struct WorkspaceConfig {
     /// Enable or disable float override, which makes it so every new window opens in floating mode (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub float_override: Option<bool>,
-    /// Enable or disable tiling for the workspace (default: true)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tile: Option<bool>,
     /// Specify an axis on which to flip the selected layout (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout_flip: Option<Axis>,
@@ -250,7 +240,7 @@ pub struct WorkspaceConfig {
 impl From<&Workspace> for WorkspaceConfig {
     fn from(value: &Workspace) -> Self {
         let mut layout_rules = HashMap::new();
-        for (threshold, layout) in &value.layout_rules {
+        for (threshold, layout) in value.layout_rules() {
             match layout {
                 Layout::Default(value) => {
                     layout_rules.insert(*threshold, *value);
@@ -261,14 +251,14 @@ impl From<&Workspace> for WorkspaceConfig {
         let layout_rules = (!layout_rules.is_empty()).then_some(layout_rules);
 
         let mut window_container_behaviour_rules = HashMap::new();
-        for (threshold, behaviour) in value.window_container_behaviour_rules.iter().flatten() {
+        for (threshold, behaviour) in value.window_container_behaviour_rules().iter().flatten() {
             window_container_behaviour_rules.insert(*threshold, *behaviour);
         }
 
         let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
         let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
 
-        let container_padding = value.container_padding.and_then(|container_padding| {
+        let container_padding = value.container_padding().and_then(|container_padding| {
             if container_padding == default_container_padding {
                 None
             } else {
@@ -276,7 +266,7 @@ impl From<&Workspace> for WorkspaceConfig {
             }
         });
 
-        let workspace_padding = value.workspace_padding.and_then(|workspace_padding| {
+        let workspace_padding = value.workspace_padding().and_then(|workspace_padding| {
             if workspace_padding == default_workspace_padding {
                 None
             } else {
@@ -284,48 +274,43 @@ impl From<&Workspace> for WorkspaceConfig {
             }
         });
 
-        let tile = if value.tile { None } else { Some(false) };
-
         Self {
             name: value
-                .name
+                .name()
                 .clone()
                 .unwrap_or_else(|| String::from("unnamed")),
             layout: value
-                .tile
-                .then_some(match value.layout {
-                    Layout::Default(layout) => Option::from(layout),
+                .tile()
+                .then_some(match value.layout() {
+                    Layout::Default(layout) => Option::from(*layout),
                     Layout::Custom(_) => None,
                 })
                 .flatten(),
-            layout_options: value.layout_options,
             custom_layout: value
-                .workspace_config
+                .workspace_config()
                 .as_ref()
                 .and_then(|c| c.custom_layout.clone()),
             layout_rules,
             custom_layout_rules: value
-                .workspace_config
+                .workspace_config()
                 .as_ref()
                 .and_then(|c| c.custom_layout_rules.clone()),
             container_padding,
             workspace_padding,
             initial_workspace_rules: value
-                .workspace_config
+                .workspace_config()
                 .as_ref()
                 .and_then(|c| c.initial_workspace_rules.clone()),
             workspace_rules: value
-                .workspace_config
+                .workspace_config()
                 .as_ref()
                 .and_then(|c| c.workspace_rules.clone()),
-            work_area_offset: value.work_area_offset,
-            apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset),
-            window_container_behaviour: value.window_container_behaviour,
+            apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
+            window_container_behaviour: *value.window_container_behaviour(),
             window_container_behaviour_rules: Option::from(window_container_behaviour_rules),
-            float_override: value.float_override,
-            tile,
-            layout_flip: value.layout_flip,
-            floating_layer_behaviour: value.floating_layer_behaviour,
+            float_override: *value.float_override(),
+            layout_flip: value.layout_flip(),
+            floating_layer_behaviour: value.floating_layer_behaviour(),
             wallpaper: None,
         }
     }
@@ -369,7 +354,7 @@ impl From<&Monitor> for MonitorConfig {
         let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
         let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
 
-        let container_padding = value.container_padding.and_then(|container_padding| {
+        let container_padding = value.container_padding().and_then(|container_padding| {
             if container_padding == default_container_padding {
                 None
             } else {
@@ -377,7 +362,7 @@ impl From<&Monitor> for MonitorConfig {
             }
         });
 
-        let workspace_padding = value.workspace_padding.and_then(|workspace_padding| {
+        let workspace_padding = value.workspace_padding().and_then(|workspace_padding| {
             if workspace_padding == default_workspace_padding {
                 None
             } else {
@@ -387,13 +372,13 @@ 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),
+            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()),
             container_padding,
             workspace_padding,
-            wallpaper: value.wallpaper.clone(),
-            floating_layer_behaviour: value.floating_layer_behaviour,
+            wallpaper: value.wallpaper().clone(),
+            floating_layer_behaviour: value.floating_layer_behaviour(),
         }
     }
 }
@@ -412,7 +397,7 @@ pub enum AppSpecificConfigurationPath {
 #[serde_with::serde_as]
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-/// The `komorebi.json` static configuration file reference for `v0.1.39`
+/// The `komorebi.json` static configuration file reference for `v0.1.37`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -731,9 +716,7 @@ impl StaticConfig {
         }
 
         if display {
-            println!(
-                "\nEnd-of-life features will not receive any further bug fixes or updates; they should not be used\n"
-            )
+            println!("\nEnd-of-life features will not receive any further bug fixes or updates; they should not be used\n")
         }
     }
 
@@ -758,9 +741,7 @@ impl StaticConfig {
         }
 
         if display {
-            println!(
-                "\nYour configuration file contains some options that have been renamed or deprecated:\n"
-            );
+            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) {
@@ -826,7 +807,7 @@ pub struct StackbarConfig {
     /// Stackbar label
     #[serde(skip_serializing_if = "Option::is_none")]
     pub label: Option<StackbarLabel>,
-    /// Stackbar mode (default: Never)
+    /// Stackbar mode
     #[serde(skip_serializing_if = "Option::is_none")]
     pub mode: Option<StackbarMode>,
     /// Stackbar tab configuration options
@@ -952,7 +933,7 @@ impl From<&WindowManager> for StaticConfig {
 
 impl StaticConfig {
     #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
-    fn apply_globals(&mut self) -> eyre::Result<()> {
+    fn apply_globals(&mut self) -> Result<()> {
         *FLOATING_WINDOW_TOGGLE_ASPECT_RATIO.lock() = self
             .floating_window_aspect_ratio
             .unwrap_or(AspectRatio::Predefined(PredefinedAspectRatio::Standard));
@@ -1240,11 +1221,11 @@ impl StaticConfig {
         Ok(())
     }
 
-    pub fn read_raw(raw: &str) -> eyre::Result<Self> {
+    pub fn read_raw(raw: &str) -> Result<Self> {
         Ok(serde_json::from_str(raw)?)
     }
 
-    pub fn read(path: &PathBuf) -> eyre::Result<Self> {
+    pub fn read(path: &PathBuf) -> Result<Self> {
         let content = std::fs::read_to_string(path)?;
         serde_json::from_str(&content).map_err(Into::into)
     }
@@ -1254,7 +1235,7 @@ impl StaticConfig {
         path: &PathBuf,
         incoming: Receiver<WindowManagerEvent>,
         unix_listener: Option<UnixListener>,
-    ) -> eyre::Result<WindowManager> {
+    ) -> Result<WindowManager> {
         let mut value = Self::read(path)?;
         value.apply_globals()?;
 
@@ -1318,7 +1299,7 @@ impl StaticConfig {
             has_pending_raise_op: false,
             pending_move_op: Arc::new(None),
             already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
-            uncloack_to_ignore: 0,
+            uncloak_to_ignore: 0,
             known_hwnds: HashMap::new(),
         };
 
@@ -1349,8 +1330,8 @@ impl StaticConfig {
         Ok(wm)
     }
 
-    pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> eyre::Result<()> {
-        let mut value = Self::read(path)?;
+    pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> Result<()> {
+        let value = Self::read(path)?;
         let mut wm = wm.lock();
 
         let configs_with_preference: Vec<_> =
@@ -1361,189 +1342,19 @@ impl StaticConfig {
         workspace_matching_rules.clear();
         drop(workspace_matching_rules);
 
-        let monitor_count = wm.monitors().len();
-
         let offset = wm.work_area_offset;
         for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
             let preferred_config_idx = {
                 let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
-
-                display_index_preferences.iter().find_map(|(c_idx, id)| {
-                    (monitor.serial_number_id.as_ref().is_some_and(|sn| sn == id)
-                        || monitor.device_id.eq(id))
-                    .then_some(*c_idx)
-                })
-            };
-            let idx = preferred_config_idx.or({
-                // Monitor without preferred config idx.
-                // Get index of first config that is not a preferred config of some other monitor
-                // and that has not been used yet. This might return `None` as well, in that case
-                // this monitor won't have a config tied to it and will use the default values.
-                let m_config_count = value
-                    .monitors
-                    .as_ref()
-                    .map(|ms| ms.len())
-                    .unwrap_or_default();
-                (0..m_config_count)
-                    .find(|i| !configs_with_preference.contains(i) && !configs_used.contains(i))
-            });
-            if let Some(monitor_config) = value
-                .monitors
-                .as_mut()
-                .and_then(|ms| idx.and_then(|i| ms.get_mut(i)))
-            {
-                if let Some(used_config_idx) = idx {
-                    configs_used.push(used_config_idx);
-                }
-
-                monitor.ensure_workspace_count(monitor_config.workspaces.len());
-                monitor.work_area_offset = monitor_config.work_area_offset;
-                monitor.window_based_work_area_offset =
-                    monitor_config.window_based_work_area_offset;
-                monitor.window_based_work_area_offset_limit = monitor_config
-                    .window_based_work_area_offset_limit
-                    .unwrap_or(1);
-                monitor.container_padding = monitor_config.container_padding;
-                monitor.workspace_padding = monitor_config.workspace_padding;
-                monitor.wallpaper = monitor_config.wallpaper.clone();
-                monitor.floating_layer_behaviour = monitor_config.floating_layer_behaviour;
-
-                monitor.update_workspaces_globals(offset);
-                for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
-                    if let Some(workspace_config) = monitor_config.workspaces.get_mut(j) {
-                        if monitor_count > 1
-                            && matches!(workspace_config.layout, Some(DefaultLayout::Scrolling))
-                        {
-                            tracing::warn!(
-                                "scrolling layout is only supported for a single monitor; falling back to columns layout"
-                            );
-                            workspace_config.layout = Some(DefaultLayout::Columns);
-                        }
-
-                        ws.load_static_config(workspace_config)?;
-                    }
-                }
-
-                // Check if this monitor config is the preferred config for this monitor and store
-                // a copy of the monitor itself on the monitor cache if it is.
-                if idx == preferred_config_idx {
-                    let id = monitor
-                        .serial_number_id
+                let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
+                    (monitor
+                        .serial_number_id()
                         .as_ref()
-                        .map_or(&monitor.device_id, |sn| sn);
-                    monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
-                }
-
-                let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                for (j, ws) in monitor_config.workspaces.iter().enumerate() {
-                    if let Some(rules) = &ws.workspace_rules {
-                        for r in rules {
-                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                monitor_index: i,
-                                workspace_index: j,
-                                matching_rule: r.clone(),
-                                initial_only: false,
-                            });
-                        }
-                    }
-
-                    if let Some(rules) = &ws.initial_workspace_rules {
-                        for r in rules {
-                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                monitor_index: i,
-                                workspace_index: j,
-                                matching_rule: r.clone(),
-                                initial_only: true,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-
-        // Check for configs that should be tied to a specific display that isn't loaded right now
-        // and cache a monitor with those configs with the specific `serial_number_id` so that when
-        // those devices are connected later we can use the correct config from the cache.
-        if configs_with_preference.len() > configs_used.len() {
-            for i in configs_with_preference
-                .iter()
-                .filter(|i| !configs_used.contains(i))
-            {
-                let id = {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
-                    display_index_preferences.get(i).cloned()
-                };
-                if let (Some(id), Some(monitor_config)) =
-                    (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
-                {
-                    // The name, device, device_id and serial_number_id can be empty here since
-                    // once the monitor with this preferred index actually connects the
-                    // `load_monitor_information` function will update these fields.
-                    let mut m = monitor::new(
-                        0,
-                        Rect::default(),
-                        Rect::default(),
-                        "".into(),
-                        "".into(),
-                        "".into(),
-                        None,
-                    );
-
-                    m.ensure_workspace_count(monitor_config.workspaces.len());
-                    m.work_area_offset = monitor_config.work_area_offset;
-                    m.window_based_work_area_offset = monitor_config.window_based_work_area_offset;
-                    m.window_based_work_area_offset_limit = monitor_config
-                        .window_based_work_area_offset_limit
-                        .unwrap_or(1);
-                    m.container_padding = monitor_config.container_padding;
-                    m.workspace_padding = monitor_config.workspace_padding;
-                    m.floating_layer_behaviour = monitor_config.floating_layer_behaviour;
-
-                    m.update_workspaces_globals(offset);
-
-                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor_config.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
-                    }
-
-                    monitor_reconciliator::insert_in_monitor_cache(&id, m);
-                }
-            }
-        }
-
-        wm.enforce_workspace_rules()?;
-
-        if value.border == Some(true) {
-            border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
-        }
-
-        Ok(())
-    }
-
-    pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> eyre::Result<()> {
-        let mut value = Self::read(path)?;
-
-        value.apply_globals()?;
-
-        let configs_with_preference: Vec<_> =
-            DISPLAY_INDEX_PREFERENCES.read().keys().copied().collect();
-        let mut configs_used = Vec::new();
-
-        let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-        workspace_matching_rules.clear();
-        drop(workspace_matching_rules);
-
-        let offset = wm.work_area_offset;
-        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
-            let preferred_config_idx = {
-                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
-
-                display_index_preferences.iter().find_map(|(c_idx, id)| {
-                    (monitor.serial_number_id.as_ref().is_some_and(|sn| sn == id)
-                        || monitor.device_id.eq(id))
-                    .then_some(*c_idx)
-                })
+                        .is_some_and(|sn| sn == id)
+                        || monitor.device_id() == id)
+                        .then_some(*c_idx)
+                });
+                c_idx
             };
             let idx = preferred_config_idx.or({
                 // Monitor without preferred config idx.
@@ -1568,21 +1379,21 @@ impl StaticConfig {
                 }
 
                 monitor.ensure_workspace_count(monitor_config.workspaces.len());
-                if monitor.work_area_offset.is_none() {
-                    monitor.work_area_offset = monitor_config.work_area_offset;
-                }
-                monitor.window_based_work_area_offset =
-                    monitor_config.window_based_work_area_offset;
-                monitor.window_based_work_area_offset_limit = monitor_config
-                    .window_based_work_area_offset_limit
-                    .unwrap_or(1);
-                monitor.container_padding = monitor_config.container_padding;
-                monitor.workspace_padding = monitor_config.workspace_padding;
-                monitor.wallpaper = monitor_config.wallpaper.clone();
-                monitor.floating_layer_behaviour = monitor_config.floating_layer_behaviour;
+                monitor.set_work_area_offset(monitor_config.work_area_offset);
+                monitor.set_window_based_work_area_offset(
+                    monitor_config.window_based_work_area_offset,
+                );
+                monitor.set_window_based_work_area_offset_limit(
+                    monitor_config
+                        .window_based_work_area_offset_limit
+                        .unwrap_or(1),
+                );
+                monitor.set_container_padding(monitor_config.container_padding);
+                monitor.set_workspace_padding(monitor_config.workspace_padding);
+                monitor.set_wallpaper(monitor_config.wallpaper.clone());
+                monitor.set_floating_layer_behaviour(monitor_config.floating_layer_behaviour);
 
                 monitor.update_workspaces_globals(offset);
-
                 for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
                     if let Some(workspace_config) = monitor_config.workspaces.get(j) {
                         ws.load_static_config(workspace_config)?;
@@ -1593,9 +1404,9 @@ impl StaticConfig {
                 // a copy of the monitor itself on the monitor cache if it is.
                 if idx == preferred_config_idx {
                     let id = monitor
-                        .serial_number_id
+                        .serial_number_id()
                         .as_ref()
-                        .map_or(&monitor.device_id, |sn| sn);
+                        .map_or(monitor.device_id(), |sn| sn);
                     monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
                 }
 
@@ -1655,14 +1466,193 @@ impl StaticConfig {
                     );
 
                     m.ensure_workspace_count(monitor_config.workspaces.len());
-                    m.work_area_offset = monitor_config.work_area_offset;
-                    m.window_based_work_area_offset = monitor_config.window_based_work_area_offset;
-                    m.window_based_work_area_offset_limit = monitor_config
+                    m.set_work_area_offset(monitor_config.work_area_offset);
+                    m.set_window_based_work_area_offset(
+                        monitor_config.window_based_work_area_offset,
+                    );
+                    m.set_window_based_work_area_offset_limit(
+                        monitor_config
+                            .window_based_work_area_offset_limit
+                            .unwrap_or(1),
+                    );
+                    m.set_container_padding(monitor_config.container_padding);
+                    m.set_workspace_padding(monitor_config.workspace_padding);
+                    m.set_floating_layer_behaviour(monitor_config.floating_layer_behaviour);
+
+                    m.update_workspaces_globals(offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        if let Some(workspace_config) = monitor_config.workspaces.get(j) {
+                            ws.load_static_config(workspace_config)?;
+                        }
+                    }
+
+                    monitor_reconciliator::insert_in_monitor_cache(&id, m);
+                }
+            }
+        }
+
+        wm.enforce_workspace_rules()?;
+
+        if value.border == Some(true) {
+            border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
+        }
+
+        Ok(())
+    }
+
+    pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> Result<()> {
+        let mut value = Self::read(path)?;
+
+        value.apply_globals()?;
+
+        let configs_with_preference: Vec<_> =
+            DISPLAY_INDEX_PREFERENCES.read().keys().copied().collect();
+        let mut configs_used = Vec::new();
+
+        let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+        workspace_matching_rules.clear();
+        drop(workspace_matching_rules);
+
+        let offset = wm.work_area_offset;
+        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
+            let preferred_config_idx = {
+                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
+                let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
+                    (monitor
+                        .serial_number_id()
+                        .as_ref()
+                        .is_some_and(|sn| sn == id)
+                        || monitor.device_id() == id)
+                        .then_some(*c_idx)
+                });
+                c_idx
+            };
+            let idx = preferred_config_idx.or({
+                // Monitor without preferred config idx.
+                // Get index of first config that is not a preferred config of some other monitor
+                // and that has not been used yet. This might return `None` as well, in that case
+                // this monitor won't have a config tied to it and will use the default values.
+                let m_config_count = value
+                    .monitors
+                    .as_ref()
+                    .map(|ms| ms.len())
+                    .unwrap_or_default();
+                (0..m_config_count)
+                    .find(|i| !configs_with_preference.contains(i) && !configs_used.contains(i))
+            });
+            if let Some(monitor_config) = value
+                .monitors
+                .as_ref()
+                .and_then(|ms| idx.and_then(|i| ms.get(i)))
+            {
+                if let Some(used_config_idx) = idx {
+                    configs_used.push(used_config_idx);
+                }
+
+                monitor.ensure_workspace_count(monitor_config.workspaces.len());
+                if monitor.work_area_offset().is_none() {
+                    monitor.set_work_area_offset(monitor_config.work_area_offset);
+                }
+                monitor.set_window_based_work_area_offset(
+                    monitor_config.window_based_work_area_offset,
+                );
+                monitor.set_window_based_work_area_offset_limit(
+                    monitor_config
                         .window_based_work_area_offset_limit
-                        .unwrap_or(1);
-                    m.container_padding = monitor_config.container_padding;
-                    m.workspace_padding = monitor_config.workspace_padding;
-                    m.floating_layer_behaviour = monitor_config.floating_layer_behaviour;
+                        .unwrap_or(1),
+                );
+                monitor.set_container_padding(monitor_config.container_padding);
+                monitor.set_workspace_padding(monitor_config.workspace_padding);
+                monitor.set_wallpaper(monitor_config.wallpaper.clone());
+                monitor.set_floating_layer_behaviour(monitor_config.floating_layer_behaviour);
+
+                monitor.update_workspaces_globals(offset);
+
+                for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
+                    if let Some(workspace_config) = monitor_config.workspaces.get(j) {
+                        ws.load_static_config(workspace_config)?;
+                    }
+                }
+
+                // Check if this monitor config is the preferred config for this monitor and store
+                // a copy of the monitor itself on the monitor cache if it is.
+                if idx == preferred_config_idx {
+                    let id = monitor
+                        .serial_number_id()
+                        .as_ref()
+                        .map_or(monitor.device_id(), |sn| sn);
+                    monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
+                }
+
+                let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+                for (j, ws) in monitor_config.workspaces.iter().enumerate() {
+                    if let Some(rules) = &ws.workspace_rules {
+                        for r in rules {
+                            workspace_matching_rules.push(WorkspaceMatchingRule {
+                                monitor_index: i,
+                                workspace_index: j,
+                                matching_rule: r.clone(),
+                                initial_only: false,
+                            });
+                        }
+                    }
+
+                    if let Some(rules) = &ws.initial_workspace_rules {
+                        for r in rules {
+                            workspace_matching_rules.push(WorkspaceMatchingRule {
+                                monitor_index: i,
+                                workspace_index: j,
+                                matching_rule: r.clone(),
+                                initial_only: true,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
+        // Check for configs that should be tied to a specific display that isn't loaded right now
+        // and cache a monitor with those configs with the specific `serial_number_id` so that when
+        // those devices are connected later we can use the correct config from the cache.
+        if configs_with_preference.len() > configs_used.len() {
+            for i in configs_with_preference
+                .iter()
+                .filter(|i| !configs_used.contains(i))
+            {
+                let id = {
+                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
+                    display_index_preferences.get(i).cloned()
+                };
+                if let (Some(id), Some(monitor_config)) =
+                    (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
+                {
+                    // The name, device, device_id and serial_number_id can be empty here since
+                    // once the monitor with this preferred index actually connects the
+                    // `load_monitor_information` function will update these fields.
+                    let mut m = monitor::new(
+                        0,
+                        Rect::default(),
+                        Rect::default(),
+                        "".into(),
+                        "".into(),
+                        "".into(),
+                        None,
+                    );
+
+                    m.ensure_workspace_count(monitor_config.workspaces.len());
+                    m.set_work_area_offset(monitor_config.work_area_offset);
+                    m.set_window_based_work_area_offset(
+                        monitor_config.window_based_work_area_offset,
+                    );
+                    m.set_window_based_work_area_offset_limit(
+                        monitor_config
+                            .window_based_work_area_offset_limit
+                            .unwrap_or(1),
+                    );
+                    m.set_container_padding(monitor_config.container_padding);
+                    m.set_workspace_padding(monitor_config.workspace_padding);
+                    m.set_floating_layer_behaviour(monitor_config.floating_layer_behaviour);
 
                     m.update_workspaces_globals(offset);
 
@@ -1728,7 +1718,7 @@ fn populate_option(
     entry: &mut ApplicationConfiguration,
     identifiers: &mut Vec<MatchingRule>,
     regex_identifiers: &mut HashMap<String, Regex>,
-) -> eyre::Result<()> {
+) -> Result<()> {
     if entry.identifier.matching_strategy.is_none() {
         entry.identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
     }
@@ -1754,7 +1744,7 @@ fn populate_rules(
     matching_rules: &mut Vec<MatchingRule>,
     identifiers: &mut Vec<MatchingRule>,
     regex_identifiers: &mut HashMap<String, Regex>,
-) -> eyre::Result<()> {
+) -> Result<()> {
     for matching_rule in matching_rules {
         if !identifiers.contains(matching_rule) {
             match matching_rule {
@@ -1800,7 +1790,7 @@ fn handle_asc_file(
     transparency_blacklist: &mut Vec<MatchingRule>,
     slow_application_identifiers: &mut Vec<MatchingRule>,
     regex_identifiers: &mut HashMap<String, Regex>,
-) -> eyre::Result<()> {
+) -> Result<()> {
     match path.extension() {
         None => {}
         Some(ext) => match ext.to_string_lossy().to_string().as_str() {
@@ -1922,13 +1912,11 @@ mod tests {
     use crate::WorkspaceConfig;
 
     #[test]
-    #[ignore = "this fails on github actions due to rate limiting changes introduced in may 2025"]
     fn backwards_compat() {
         let root = vec!["0.1.17", "0.1.18", "0.1.19"];
         let docs = vec![
             "0.1.20", "0.1.21", "0.1.22", "0.1.23", "0.1.24", "0.1.25", "0.1.26", "0.1.27",
-            "0.1.28", "0.1.29", "0.1.30", "0.1.31", "0.1.32", "0.1.33", "0.1.34", "0.1.35",
-            "0.1.36", "0.1.37",
+            "0.1.28", "0.1.29", "0.1.30", "0.1.31", "0.1.32", "0.1.33", "0.1.34",
         ];
 
         let mut versions = vec![];
@@ -1954,9 +1942,7 @@ mod tests {
     #[test]
     fn deserialize_custom_layout_rules() {
         // set an environment variable for testing
-        unsafe {
-            std::env::set_var("VAR", "VALUE");
-        }
+        std::env::set_var("VAR", "VALUE");
 
         let config = r#"
         {

komorebi/src/theme_manager.rs

@@ -1,19 +1,19 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
-use crate::KomorebiTheme;
 use crate::border_manager;
 use crate::stackbar_manager;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
+use crate::KomorebiTheme;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
-use komorebi_themes::Base16Wrapper;
 use komorebi_themes::colour::Colour;
+use komorebi_themes::Base16Wrapper;
 use std::ops::Deref;
-use std::sync::OnceLock;
 use std::sync::atomic::Ordering;
+use std::sync::OnceLock;
 
 pub struct Notification(KomorebiTheme);
 
@@ -51,15 +51,13 @@ pub fn send_notification(theme: KomorebiTheme) {
 }
 
 pub fn listen_for_notifications() {
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications() {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications() {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });

komorebi/src/transparency_manager.rs

@@ -4,17 +4,17 @@ use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
-use std::sync::Arc;
-use std::sync::OnceLock;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU8;
+use std::sync::Arc;
+use std::sync::OnceLock;
 
-use crate::REGEX_IDENTIFIERS;
-use crate::TRANSPARENCY_BLACKLIST;
+use crate::should_act;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowsApi;
-use crate::should_act;
+use crate::REGEX_IDENTIFIERS;
+use crate::TRANSPARENCY_BLACKLIST;
 
 pub static TRANSPARENCY_ENABLED: AtomicBool = AtomicBool::new(false);
 pub static TRANSPARENCY_ALPHA: AtomicU8 = AtomicU8::new(200);
@@ -49,15 +49,13 @@ pub fn send_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);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -94,7 +92,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
             '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 {
+                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;
@@ -106,7 +104,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 }
 
                 // Monocle container is never transparent
-                if let Some(monocle) = &ws.monocle_container {
+                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() {
@@ -152,34 +150,32 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         for (window_idx, window) in c.windows().iter().enumerate() {
                             if window_idx == focused_window_idx {
                                 let mut should_make_transparent = true;
-                                if !transparency_blacklist.is_empty()
-                                    && let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) = (
+                                if !transparency_blacklist.is_empty() {
+                                    if let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) = (
                                         window.title(),
                                         window.exe(),
                                         window.class(),
                                         window.path(),
-                                    )
-                                {
-                                    let is_blacklisted = should_act(
-                                        &title,
-                                        &exe_name,
-                                        &class,
-                                        &path,
-                                        &transparency_blacklist,
-                                        &regex_identifiers,
-                                    )
-                                    .is_some();
+                                    ) {
+                                        let is_blacklisted = should_act(
+                                            &title,
+                                            &exe_name,
+                                            &class,
+                                            &path,
+                                            &transparency_blacklist,
+                                            &regex_identifiers,
+                                        )
+                                        .is_some();
 
-                                    should_make_transparent = !is_blacklisted;
+                                        should_make_transparent = !is_blacklisted;
+                                    }
                                 }
 
                                 if should_make_transparent {
                                     match window.transparent() {
                                         Err(error) => {
                                             let hwnd = foreground_hwnd;
-                                            tracing::error!(
-                                                "failed to make unfocused window {hwnd} transparent: {error}"
-                                            )
+                                            tracing::error!("failed to make unfocused window {hwnd} transparent: {error}" )
                                         }
                                         Ok(..) => {
                                             known_hwnds.lock().push(window.hwnd);

komorebi/src/window.rs

@@ -1,3 +1,31 @@
+use crate::animation::lerp::Lerp;
+use crate::animation::prefix::new_animation_key;
+use crate::animation::prefix::AnimationPrefix;
+use crate::animation::AnimationEngine;
+use crate::animation::RenderDispatcher;
+use crate::animation::ANIMATION_DURATION_GLOBAL;
+use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
+use crate::animation::ANIMATION_ENABLED_GLOBAL;
+use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
+use crate::animation::ANIMATION_MANAGER;
+use crate::animation::ANIMATION_STYLE_GLOBAL;
+use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
+use crate::border_manager;
+use crate::com::SetCloak;
+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::HidingBehaviour;
+use crate::core::Rect;
+use crate::focus_manager;
+use crate::stackbar_manager;
+use crate::styles::ExtendedWindowStyle;
+use crate::styles::WindowStyle;
+use crate::transparency_manager;
+use crate::window_manager_event::WindowManagerEvent;
+use crate::windows_api;
+use crate::windows_api::WindowsApi;
 use crate::AnimationStyle;
 use crate::FLOATING_APPLICATIONS;
 use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
@@ -12,41 +40,14 @@ use crate::REGEX_IDENTIFIERS;
 use crate::SLOW_APPLICATION_COMPENSATION_TIME;
 use crate::SLOW_APPLICATION_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
-use crate::animation::ANIMATION_DURATION_GLOBAL;
-use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
-use crate::animation::ANIMATION_ENABLED_GLOBAL;
-use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
-use crate::animation::ANIMATION_MANAGER;
-use crate::animation::ANIMATION_STYLE_GLOBAL;
-use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
-use crate::animation::AnimationEngine;
-use crate::animation::RenderDispatcher;
-use crate::animation::lerp::Lerp;
-use crate::animation::prefix::AnimationPrefix;
-use crate::animation::prefix::new_animation_key;
-use crate::border_manager;
-use crate::com::SetCloak;
-use crate::core::ApplicationIdentifier;
-use crate::core::HidingBehaviour;
-use crate::core::Rect;
-use crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
-use crate::focus_manager;
-use crate::stackbar_manager;
-use crate::styles::ExtendedWindowStyle;
-use crate::styles::WindowStyle;
-use crate::transparency_manager;
-use crate::window_manager_event::WindowManagerEvent;
-use crate::windows_api;
-use crate::windows_api::WindowsApi;
 use color_eyre::eyre;
+use color_eyre::Result;
 use crossbeam_utils::atomic::AtomicConsume;
 use regex::Regex;
+use serde::ser::SerializeStruct;
 use serde::Deserialize;
 use serde::Serialize;
 use serde::Serializer;
-use serde::ser::SerializeStruct;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
@@ -127,7 +128,7 @@ impl Display for Window {
 }
 
 impl Serialize for Window {
-    fn serialize<S>(&self, serializer: S) -> eyre::Result<S::Ok, S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
@@ -192,14 +193,14 @@ impl RenderDispatcher for MovementRenderDispatcher {
         new_animation_key(MovementRenderDispatcher::PREFIX, self.hwnd.to_string())
     }
 
-    fn pre_render(&self) -> eyre::Result<()> {
+    fn pre_render(&self) -> Result<()> {
         stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
         stackbar_manager::send_notification();
 
         Ok(())
     }
 
-    fn render(&self, progress: f64) -> eyre::Result<()> {
+    fn render(&self, progress: f64) -> Result<()> {
         let new_rect = self.start_rect.lerp(self.target_rect, progress, self.style);
 
         // we don't check WINDOW_HANDLING_BEHAVIOUR here because animations
@@ -210,7 +211,7 @@ impl RenderDispatcher for MovementRenderDispatcher {
         Ok(())
     }
 
-    fn post_render(&self) -> eyre::Result<()> {
+    fn post_render(&self) -> Result<()> {
         // we don't add the async_window_pos flag here because animations
         // are always run on a separate thread
         WindowsApi::position_window(self.hwnd, &self.target_rect, self.top, false)?;
@@ -266,7 +267,7 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
         new_animation_key(TransparencyRenderDispatcher::PREFIX, self.hwnd.to_string())
     }
 
-    fn pre_render(&self) -> eyre::Result<()> {
+    fn pre_render(&self) -> Result<()> {
         //transparent
         if !self.is_opaque {
             let window = Window::from(self.hwnd);
@@ -278,7 +279,7 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
         Ok(())
     }
 
-    fn render(&self, progress: f64) -> eyre::Result<()> {
+    fn render(&self, progress: f64) -> Result<()> {
         WindowsApi::set_transparent(
             self.hwnd,
             self.start_opacity
@@ -286,7 +287,7 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
         )
     }
 
-    fn post_render(&self) -> eyre::Result<()> {
+    fn post_render(&self) -> Result<()> {
         //opaque
         if self.is_opaque {
             let window = Window::from(self.hwnd);
@@ -345,7 +346,7 @@ impl Window {
         HWND(windows_api::as_ptr!(self.hwnd))
     }
 
-    pub fn move_to_area(&mut self, current_area: &Rect, target_area: &Rect) -> eyre::Result<()> {
+    pub fn move_to_area(&mut self, current_area: &Rect, target_area: &Rect) -> Result<()> {
         let current_rect = WindowsApi::window_rect(self.hwnd)?;
         let x_diff = target_area.left - current_area.left;
         let y_diff = target_area.top - current_area.top;
@@ -412,7 +413,7 @@ impl Window {
         Ok(())
     }
 
-    pub fn center(&mut self, work_area: &Rect, resize: bool) -> eyre::Result<()> {
+    pub fn center(&mut self, work_area: &Rect, resize: bool) -> Result<()> {
         let (target_width, target_height) = if resize {
             let (aspect_ratio_width, aspect_ratio_height) = FLOATING_WINDOW_TOGGLE_ASPECT_RATIO
                 .lock()
@@ -439,7 +440,7 @@ impl Window {
         )
     }
 
-    pub fn set_position(&self, layout: &Rect, top: bool) -> eyre::Result<()> {
+    pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
         let window_rect = WindowsApi::window_rect(self.hwnd)?;
 
         if window_rect.eq(layout) {
@@ -537,7 +538,7 @@ impl Window {
         }
     }
 
-    pub fn close(self) -> eyre::Result<()> {
+    pub fn close(self) -> Result<()> {
         WindowsApi::close_window(self.hwnd)
     }
 
@@ -565,17 +566,17 @@ impl Window {
         WindowsApi::unmaximize_window(self.hwnd);
     }
 
-    pub fn focus(self, mouse_follows_focus: bool) -> eyre::Result<()> {
+    pub fn focus(self, mouse_follows_focus: bool) -> Result<()> {
         // If the target window is already focused, do nothing.
-        if let Ok(ihwnd) = WindowsApi::foreground_window()
-            && ihwnd == self.hwnd
-        {
-            // Center cursor in Window
-            if mouse_follows_focus {
-                WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd)?)?;
-            }
+        if let Ok(ihwnd) = WindowsApi::foreground_window() {
+            if ihwnd == self.hwnd {
+                // Center cursor in Window
+                if mouse_follows_focus {
+                    WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd)?)?;
+                }
 
-            return Ok(());
+                return Ok(());
+            }
         }
 
         WindowsApi::raise_and_focus_window(self.hwnd)?;
@@ -592,7 +593,7 @@ impl Window {
         WindowsApi::foreground_window().unwrap_or_default() == self.hwnd
     }
 
-    pub fn transparent(self) -> eyre::Result<()> {
+    pub fn transparent(self) -> Result<()> {
         let animation_enabled = ANIMATION_ENABLED_PER_ANIMATION.lock();
         let transparent_enabled = animation_enabled.get(&TransparencyRenderDispatcher::PREFIX);
 
@@ -630,7 +631,7 @@ impl Window {
         }
     }
 
-    pub fn opaque(self) -> eyre::Result<()> {
+    pub fn opaque(self) -> Result<()> {
         let animation_enabled = ANIMATION_ENABLED_PER_ANIMATION.lock();
         let transparent_enabled = animation_enabled.get(&TransparencyRenderDispatcher::PREFIX);
 
@@ -665,49 +666,49 @@ impl Window {
         }
     }
 
-    pub fn set_accent(self, colour: u32) -> eyre::Result<()> {
+    pub fn set_accent(self, colour: u32) -> Result<()> {
         WindowsApi::set_window_accent(self.hwnd, Some(colour))
     }
 
-    pub fn remove_accent(self) -> eyre::Result<()> {
+    pub fn remove_accent(self) -> Result<()> {
         WindowsApi::set_window_accent(self.hwnd, None)
     }
 
     #[cfg(target_pointer_width = "64")]
-    pub fn update_style(self, style: &WindowStyle) -> eyre::Result<()> {
+    pub fn update_style(self, style: &WindowStyle) -> Result<()> {
         WindowsApi::update_style(self.hwnd, isize::try_from(style.bits())?)
     }
 
     #[cfg(target_pointer_width = "32")]
-    pub fn update_style(self, style: &WindowStyle) -> eyre::Result<()> {
+    pub fn update_style(self, style: &WindowStyle) -> Result<()> {
         WindowsApi::update_style(self.hwnd, i32::try_from(style.bits())?)
     }
 
     #[cfg(target_pointer_width = "64")]
-    pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> eyre::Result<()> {
+    pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> Result<()> {
         WindowsApi::update_ex_style(self.hwnd, isize::try_from(style.bits())?)
     }
 
     #[cfg(target_pointer_width = "32")]
-    pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> eyre::Result<()> {
+    pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> Result<()> {
         WindowsApi::update_ex_style(self.hwnd, i32::try_from(style.bits())?)
     }
 
-    pub fn style(self) -> eyre::Result<WindowStyle> {
+    pub fn style(self) -> Result<WindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd)?)?;
         Ok(WindowStyle::from_bits_truncate(bits))
     }
 
-    pub fn ex_style(self) -> eyre::Result<ExtendedWindowStyle> {
+    pub fn ex_style(self) -> Result<ExtendedWindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd)?)?;
         Ok(ExtendedWindowStyle::from_bits_truncate(bits))
     }
 
-    pub fn title(self) -> eyre::Result<String> {
+    pub fn title(self) -> Result<String> {
         WindowsApi::window_text_w(self.hwnd)
     }
 
-    pub fn path(self) -> eyre::Result<String> {
+    pub fn path(self) -> Result<String> {
         let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd);
         let handle = WindowsApi::process_handle(process_id)?;
         let path = WindowsApi::exe_path(handle);
@@ -715,7 +716,7 @@ impl Window {
         path
     }
 
-    pub fn exe(self) -> eyre::Result<String> {
+    pub fn exe(self) -> Result<String> {
         let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd);
         let handle = WindowsApi::process_handle(process_id)?;
         let exe = WindowsApi::exe(handle);
@@ -728,11 +729,11 @@ impl Window {
         process_id
     }
 
-    pub fn class(self) -> eyre::Result<String> {
+    pub fn class(self) -> Result<String> {
         WindowsApi::real_window_class_w(self.hwnd)
     }
 
-    pub fn is_cloaked(self) -> eyre::Result<bool> {
+    pub fn is_cloaked(self) -> Result<bool> {
         WindowsApi::is_window_cloaked(self.hwnd)
     }
 
@@ -740,14 +741,14 @@ impl Window {
         WindowsApi::is_window(self.hwnd)
     }
 
-    pub fn remove_title_bar(self) -> eyre::Result<()> {
+    pub fn remove_title_bar(self) -> Result<()> {
         let mut style = self.style()?;
         style.remove(WindowStyle::CAPTION);
         style.remove(WindowStyle::THICKFRAME);
         self.update_style(&style)
     }
 
-    pub fn add_title_bar(self) -> eyre::Result<()> {
+    pub fn add_title_bar(self) -> Result<()> {
         let mut style = self.style()?;
         style.insert(WindowStyle::CAPTION);
         style.insert(WindowStyle::THICKFRAME);
@@ -758,7 +759,7 @@ impl Window {
     /// it. Use raise_and_focus_window to activate and focus a window.
     /// It also checks if there is a border attached to this window and if it is
     /// it raises it as well.
-    pub fn raise(self) -> eyre::Result<()> {
+    pub fn raise(self) -> Result<()> {
         WindowsApi::raise_window(self.hwnd)?;
         if let Some(border_info) = crate::border_manager::window_border(self.hwnd) {
             WindowsApi::raise_window(border_info.border_hwnd)?;
@@ -770,7 +771,7 @@ impl Window {
     /// it.
     /// It also checks if there is a border attached to this window and if it is
     /// it lowers it as well.
-    pub fn lower(self) -> eyre::Result<()> {
+    pub fn lower(self) -> Result<()> {
         WindowsApi::lower_window(self.hwnd)?;
         if let Some(border_info) = crate::border_manager::window_border(self.hwnd) {
             WindowsApi::lower_window(border_info.border_hwnd)?;
@@ -783,7 +784,7 @@ impl Window {
         self,
         event: Option<WindowManagerEvent>,
         debug: &mut RuleDebug,
-    ) -> eyre::Result<bool> {
+    ) -> Result<bool> {
         if !self.is_window() {
             return Ok(false);
         }
@@ -816,13 +817,13 @@ impl Window {
 
         let mut allow_cloaked = false;
 
-        if let Some(event) = event
-            && matches!(
+        if let Some(event) = event {
+            if matches!(
                 event,
                 WindowManagerEvent::Hide(_, _) | WindowManagerEvent::Cloak(_, _)
-            )
-        {
-            allow_cloaked = true;
+            ) {
+                allow_cloaked = true;
+            }
         }
 
         debug.allow_cloaked = allow_cloaked;
@@ -1301,31 +1302,31 @@ pub fn should_act_individual(
         },
         Some(MatchingStrategy::Regex) => match identifier.kind {
             ApplicationIdentifier::Title => {
-                if let Some(re) = regex_identifiers.get(&identifier.id)
-                    && re.is_match(title)
-                {
-                    should_act = true;
+                if let Some(re) = regex_identifiers.get(&identifier.id) {
+                    if re.is_match(title) {
+                        should_act = true;
+                    }
                 }
             }
             ApplicationIdentifier::Class => {
-                if let Some(re) = regex_identifiers.get(&identifier.id)
-                    && re.is_match(class)
-                {
-                    should_act = true;
+                if let Some(re) = regex_identifiers.get(&identifier.id) {
+                    if re.is_match(class) {
+                        should_act = true;
+                    }
                 }
             }
             ApplicationIdentifier::Exe => {
-                if let Some(re) = regex_identifiers.get(&identifier.id)
-                    && re.is_match(exe_name)
-                {
-                    should_act = true;
+                if let Some(re) = regex_identifiers.get(&identifier.id) {
+                    if re.is_match(exe_name) {
+                        should_act = true;
+                    }
                 }
             }
             ApplicationIdentifier::Path => {
-                if let Some(re) = regex_identifiers.get(&identifier.id)
-                    && re.is_match(path)
-                {
-                    should_act = true;
+                if let Some(re) = regex_identifiers.get(&identifier.id) {
+                    if re.is_match(path) {
+                        should_act = true;
+                    }
                 }
             }
         },

komorebi/src/window_manager_event.rs

@@ -4,12 +4,12 @@ use std::fmt::Formatter;
 use serde::Deserialize;
 use serde::Serialize;
 
+use crate::window::should_act;
+use crate::window::Window;
+use crate::winevent::WinEvent;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST;
 use crate::REGEX_IDENTIFIERS;
-use crate::window::Window;
-use crate::window::should_act;
-use crate::winevent::WinEvent;
 
 #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]