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"
@@ -35,18 +35,18 @@ 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 +73,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.37"}
 
 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/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/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/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.37/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.37/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.json",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",

komorebi-bar/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.38"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -17,12 +17,12 @@ 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"

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;
@@ -48,20 +47,24 @@ 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 komorebi_themes::CatppuccinValue;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::io::Error;
 use std::io::ErrorKind;
+use std::io::Result;
 use std::io::Write;
 use std::os::windows::process::CommandExt;
 use std::path::PathBuf;
@@ -69,8 +72,8 @@ 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;
+use std::sync::Arc;
 
 const CREATE_NO_WINDOW: u32 = 0x0800_0000;
 
@@ -78,7 +81,7 @@ lazy_static! {
     static ref SESSION_STDIN: Mutex<Option<ChildStdin>> = Mutex::new(None);
 }
 
-fn start_powershell() -> eyre::Result<()> {
+fn start_powershell() -> Result<()> {
     // found running session, do nothing
     if SESSION_STDIN.lock().as_mut().is_some() {
         tracing::debug!("PowerShell session already started");
@@ -102,17 +105,17 @@ fn start_powershell() -> eyre::Result<()> {
     Ok(())
 }
 
-fn stop_powershell() -> eyre::Result<()> {
+fn stop_powershell() -> 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());
+            return Err(e);
         }
         if let Err(e) = session_stdin.flush() {
             tracing::error!(error = %e, "failed to flush PowerShell stdin");
-            return Err(e.into());
+            return Err(e);
         }
 
         tracing::debug!("PowerShell session stopped");
@@ -123,22 +126,25 @@ fn stop_powershell() -> eyre::Result<()> {
     Ok(())
 }
 
-pub fn exec_powershell(cmd: &str) -> eyre::Result<()> {
+pub fn exec_powershell(cmd: &str) -> Result<()> {
     if let Some(session_stdin) = SESSION_STDIN.lock().as_mut() {
-        if let Err(e) = writeln!(session_stdin, "{cmd}") {
+        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());
+            return Err(e);
         }
 
         if let Err(e) = session_stdin.flush() {
             tracing::error!(error = %e, "failed to flush PowerShell stdin");
-            return Err(e.into());
+            return Err(e);
         }
 
         return Ok(());
     }
 
-    Err(Error::new(ErrorKind::NotFound, "PowerShell session not started").into())
+    Err(Error::new(
+        ErrorKind::NotFound,
+        "PowerShell session not started",
+    ))
 }
 
 pub struct Komobar {
@@ -147,7 +153,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>>,
@@ -319,15 +325,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 +345,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 +374,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 +426,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();
                         }
                     }
 
@@ -456,17 +464,17 @@ impl Komobar {
             MonitorConfigOrIndex::Index(idx) => (*idx, None),
         };
 
-        let mapped_info = self.monitor_info.as_ref().map(|info| {
-            let monitor = info.borrow();
+        let mapped_state = self.komorebi_notification_state.as_ref().map(|state| {
+            let state = state.borrow();
             (
-                monitor.monitor_usr_idx_map.get(&usr_monitor_index).copied(),
-                monitor.mouse_follows_focus,
+                state.monitor_usr_idx_map.get(&usr_monitor_index).copied(),
+                state.mouse_follows_focus,
             )
         });
 
-        if let Some(info) = mapped_info {
-            self.monitor_index = info.0;
-            self.mouse_follows_focus = info.1;
+        if let Some(state) = mapped_state {
+            self.monitor_index = state.0;
+            self.mouse_follows_focus = state.1;
         }
 
         if let Some(monitor_index) = self.monitor_index {
@@ -518,15 +526,11 @@ 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;
         }
 
@@ -562,7 +566,7 @@ impl Komobar {
 
         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 +603,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 +635,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 +650,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 +679,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 +695,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 +725,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![],
@@ -843,12 +871,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 +966,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 +979,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 +989,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();
@@ -1318,66 +1344,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,7 +1,7 @@
-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;
@@ -16,7 +16,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.38`
 pub struct KomobarConfig {
     /// Bar height (default: 50)
     pub height: Option<f32>,
@@ -120,9 +120,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) {
@@ -334,7 +332,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:
@@ -370,10 +367,12 @@ pub enum MouseMessage {
     ///   }
     /// }
     /// ```
+    #[serde(untagged)]
     Komorebi(KomorebiMouseMessage),
     /// Execute a custom command.
     /// CMD (%variable%), Bash ($variable) and PowerShell ($Env:variable) variables will be resolved.
     /// Example: `komorebic toggle-pause`
+    #[serde(untagged)]
     Command(String),
 }
 
@@ -455,7 +454,7 @@ impl MouseMessage {
 
                 tracing::debug!("Sending messages: {messages:?}");
 
-                if komorebi_client::send_batch(messages).is_err() {
+                if komorebi_client::send_batch(messages.into_iter()).is_err() {
                     tracing::error!("could not send commands");
                 }
             }

komorebi-bar/src/main.rs

@@ -15,10 +15,10 @@ use eframe::egui::ViewportBuilder;
 use font_loader::system_fonts;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
+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::io::BufReader;
 use std::io::Read;
 use std::path::PathBuf;
@@ -32,8 +32,8 @@ 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;
@@ -114,14 +114,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 +137,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 +159,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 +231,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 +251,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 +263,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 +355,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 +406,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

@@ -2,6 +2,7 @@ use super::ImageIcon;
 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,7 +17,6 @@ use eframe::egui::Stroke;
 use eframe::egui::StrokeKind;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
-use eframe::egui::vec2;
 use komorebi_client::PathExt;
 use serde::Deserialize;
 use serde::Serialize;

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 => {
@@ -269,53 +270,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/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,7 +1,7 @@
 [package]
 name = "komorebi-client"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.38"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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,7 +1,7 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.39"
-edition = "2024"
+version = "0.1.38"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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/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.38"
+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.38"
 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,6 +17,7 @@ crossbeam-channel = { workspace = true }
 crossbeam-utils = { workspace = true }
 ctrlc = { version = "3", features = ["termination"] }
 dirs = { workspace = true }
+getset = "0.1"
 hotwatch = { workspace = true }
 lazy_static = { workspace = true }
 miow = "0.6"

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) || !rect.has_same_position_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,8 +1,6 @@
 #![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;
@@ -10,8 +8,10 @@ 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 +22,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 +170,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,9 +209,9 @@ 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);
@@ -226,7 +224,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,7 +237,7 @@ 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 {
+                            if ws.layer() == &WorkspaceLayer::Floating {
                                 for window in ws.floating_windows() {
                                     let mut window_kind = WindowKind::Unfocused;
 
@@ -257,7 +255,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 +339,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
@@ -381,7 +383,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 +396,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,
                                     ) {
@@ -461,7 +463,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                             let border_hwnd = border.hwnd;
 
-                            if ws.layer == WorkspaceLayer::Floating {
+                            if ws.layer() == &WorkspaceLayer::Floating {
                                 handle_floating_borders(
                                     &mut borders,
                                     &mut windows_borders,
@@ -500,8 +502,8 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         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 +521,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 +539,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 +547,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 +563,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,7 +603,7 @@ 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;
                                 }
                             };

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,12 +6,12 @@ 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 super::CustomLayout;
+use super::DefaultLayout;
+use super::Rect;
 use crate::default_layout::LayoutOptions;
 
 pub trait Arrangement {
@@ -52,83 +52,94 @@ impl Arrangement for DefaultLayout {
                 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);
+                match len {
+                    // treat < 3 windows the same as the columns layout
+                    len if len < 3 => {
+                        layouts = columns(area, len);
 
-                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 adjustment = calculate_columns_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;
+                            },
+                        );
 
-                    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
+                        if matches!(
+                            layout_flip,
+                            Some(Axis::Horizontal | Axis::HorizontalAndVertical)
+                        ) {
+                            if let 2.. = len {
+                                columns_reverse(&mut layouts);
+                            }
                         }
-                        .min(
-                            (len as isize)
-                                .saturating_sub(visible_columns as isize)
-                                .max(0),
-                        )
                     }
-                };
+                    // treat >= column_count as scrolling
+                    len => {
+                        let visible_columns = area.right / column_width;
+                        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
+                            };
 
-                for i in 0..len {
-                    let position = (i as isize) - first_visible;
-                    let left = area.left + (position as i32 * column_width);
+                            let focused_idx = focused_idx as isize;
 
-                    layouts.push(Rect {
-                        left,
-                        top: area.top,
-                        right: column_width,
-                        bottom: area.bottom,
-                    });
+                            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;
+                            },
+                        );
+                    }
                 }
 
-                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(
@@ -155,9 +166,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 +191,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 +245,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 +317,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 +386,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 +513,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
@@ -762,67 +782,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 +927,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,

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

@@ -37,8 +37,6 @@ pub struct LayoutOptions {
 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 {

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(
@@ -105,7 +105,7 @@ impl Direction for DefaultLayout {
                 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,
@@ -125,7 +125,7 @@ impl Direction for DefaultLayout {
                 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,
@@ -149,7 +149,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
@@ -193,7 +193,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

komorebi/src/core/mod.rs

@@ -6,14 +6,14 @@ 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 +27,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;
@@ -202,7 +202,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 +247,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 +255,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)
     }
 }
@@ -550,9 +549,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;
@@ -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/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(())

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,25 @@ 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::DefaultLayout;
+use crate::Layout;
+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 +65,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 +145,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 +165,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 +203,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)?;
+                        }
                     }
                 }
             }
@@ -307,7 +304,7 @@ impl WindowManager {
                 // 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,
+                    self.focused_workspace()?.layout(),
                     Layout::Default(DefaultLayout::Scrolling)
                 ) && !self.focused_workspace()?.containers().is_empty()
                 {
@@ -322,13 +319,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,10 +333,10 @@ impl WindowManager {
                             workspace.focus_container_by_window(window.hwnd)?;
                         }
 
-                        workspace.layer = WorkspaceLayer::Tiling;
+                        workspace.set_layer(WorkspaceLayer::Tiling);
 
                         if matches!(
-                            self.focused_workspace()?.layout,
+                            self.focused_workspace()?.layout(),
                             Layout::Default(DefaultLayout::Scrolling)
                         ) && !self.focused_workspace()?.containers().is_empty()
                         {
@@ -348,7 +345,7 @@ impl WindowManager {
                     }
                     Some(idx) => {
                         if let Some(_window) = workspace.floating_windows().get(idx) {
-                            workspace.layer = WorkspaceLayer::Floating;
+                            workspace.set_layer(WorkspaceLayer::Floating);
                         }
                     }
                 }
@@ -392,20 +389,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 +415,7 @@ 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();
 
                         if !workspace_contains_window && needs_reconciliation.is_none() {
                             let floating_applications = FLOATING_APPLICATIONS.lock();
@@ -458,11 +458,11 @@ 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);
                                 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 +471,17 @@ impl WindowManager {
                                 match behaviour.current_behaviour {
                                     WindowContainerBehaviour::Create => {
                                         workspace.new_container_for_window(window);
-                                        workspace.layer = WorkspaceLayer::Tiling;
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
                                         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);
                                         self.update_focused_workspace(true, false)?;
                                         stackbar_manager::send_notification();
                                     }
@@ -504,15 +506,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
+                                || workspace.layer() != &WorkspaceLayer::Tiling)
                                 && monocle_container.is_some()
                             {
                                 window.hide();
@@ -525,7 +529,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 +547,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 +570,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 +582,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 +603,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 +618,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 +646,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 +676,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 +684,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 +836,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 +849,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 +886,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 +903,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 +922,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,7 +28,7 @@ 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_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
 pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::Never);
 
 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,11 +34,6 @@ 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;
@@ -87,7 +57,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 +101,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,7 +192,7 @@ pub struct WorkspaceConfig {
     /// Layout (default: BSP)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout: Option<DefaultLayout>,
-    /// Layout-specific options (default: None)
+    /// 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)
@@ -218,9 +218,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 +230,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 +244,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 +255,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 +270,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 +278,44 @@ 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,
+            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 +359,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 +367,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 +377,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 +402,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.38`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -731,9 +721,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 +746,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) {
@@ -952,7 +938,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 +1226,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 +1240,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()?;
 
@@ -1349,7 +1335,7 @@ impl StaticConfig {
         Ok(wm)
     }
 
-    pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> eyre::Result<()> {
+    pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> Result<()> {
         let mut value = Self::read(path)?;
         let mut wm = wm.lock();
 
@@ -1367,12 +1353,15 @@ impl StaticConfig {
         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 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.
@@ -1397,16 +1386,19 @@ impl StaticConfig {
                 }
 
                 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.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() {
@@ -1414,9 +1406,7 @@ impl StaticConfig {
                         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"
-                            );
+                            tracing::warn!("scrolling layout is only supported for a single monitor; falling back to columns layout");
                             workspace_config.layout = Some(DefaultLayout::Columns);
                         }
 
@@ -1428,9 +1418,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());
                 }
 
@@ -1490,14 +1480,18 @@ 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
-                        .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.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);
 
@@ -1521,7 +1515,7 @@ impl StaticConfig {
         Ok(())
     }
 
-    pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> eyre::Result<()> {
+    pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> Result<()> {
         let mut value = Self::read(path)?;
 
         value.apply_globals()?;
@@ -1538,12 +1532,15 @@ impl StaticConfig {
         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 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.
@@ -1568,18 +1565,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;
+                if monitor.work_area_offset().is_none() {
+                    monitor.set_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_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);
 
@@ -1593,9 +1593,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 +1655,18 @@ 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
-                        .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.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 +1732,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 +1758,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 +1804,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() {
@@ -1928,7 +1932,7 @@ mod tests {
         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.36",
         ];
 
         let mut versions = vec![];
@@ -1954,9 +1958,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))]

komorebi/src/windows_api.rs

@@ -1,15 +1,18 @@
-use color_eyre::eyre;
-use color_eyre::eyre::Error;
-use color_eyre::eyre::OptionExt;
+use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
+use color_eyre::eyre::Error;
+use color_eyre::Result;
 use core::ffi::c_void;
 use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::mem::size_of;
 use std::path::Path;
-use windows::Win32::Foundation::COLORREF;
+use windows::core::Result as WindowsCrateResult;
+use windows::core::PCWSTR;
+use windows::core::PWSTR;
 use windows::Win32::Foundation::CloseHandle;
+use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HANDLE;
 use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HMODULE;
@@ -18,9 +21,8 @@ use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
-use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
-use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
+use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
 use windows::Win32::Graphics::Dwm::DWMWA_BORDER_COLOR;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
 use windows::Win32::Graphics::Dwm::DWMWA_COLOR_NONE;
@@ -28,61 +30,57 @@ use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
 use windows::Win32::Graphics::Dwm::DWMWA_WINDOW_CORNER_PREFERENCE;
 use windows::Win32::Graphics::Dwm::DWMWCP_ROUND;
 use windows::Win32::Graphics::Dwm::DWMWINDOWATTRIBUTE;
-use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
-use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
-use windows::Win32::Graphics::Gdi::HBRUSH;
-use windows::Win32::Graphics::Gdi::HDC;
-use windows::Win32::Graphics::Gdi::HMONITOR;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
-use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
-use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
-use windows::Win32::Graphics::Gdi::MONITORINFOEXW;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::RoundRect;
-use windows::Win32::System::Com::CLSCTX_ALL;
+use windows::Win32::Graphics::Gdi::HBRUSH;
+use windows::Win32::Graphics::Gdi::HDC;
+use windows::Win32::Graphics::Gdi::HMONITOR;
+use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
+use windows::Win32::Graphics::Gdi::MONITORINFOEXW;
+use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
 use windows::Win32::System::Com::CoCreateInstance;
+use windows::Win32::System::Com::CLSCTX_ALL;
 use windows::Win32::System::LibraryLoader::GetModuleHandleW;
-use windows::Win32::System::Power::HPOWERNOTIFY;
 use windows::Win32::System::Power::RegisterPowerSettingNotification;
+use windows::Win32::System::Power::HPOWERNOTIFY;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
 use windows::Win32::System::RemoteDesktop::WTSRegisterSessionNotification;
 use windows::Win32::System::Threading::GetCurrentProcessId;
 use windows::Win32::System::Threading::OpenProcess;
+use windows::Win32::System::Threading::QueryFullProcessImageNameW;
 use windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS;
 use windows::Win32::System::Threading::PROCESS_NAME_WIN32;
 use windows::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
-use windows::Win32::System::Threading::QueryFullProcessImageNameW;
-use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::HiDpi::GetDpiForMonitor;
-use windows::Win32::UI::HiDpi::MDT_EFFECTIVE_DPI;
 use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
+use windows::Win32::UI::HiDpi::MDT_EFFECTIVE_DPI;
 use windows::Win32::UI::Input::KeyboardAndMouse::GetKeyState;
+use windows::Win32::UI::Input::KeyboardAndMouse::SendInput;
 use windows::Win32::UI::Input::KeyboardAndMouse::INPUT;
 use windows::Win32::UI::Input::KeyboardAndMouse::INPUT_0;
 use windows::Win32::UI::Input::KeyboardAndMouse::INPUT_MOUSE;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEEVENTF_LEFTDOWN;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEEVENTF_LEFTUP;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEINPUT;
-use windows::Win32::UI::Input::KeyboardAndMouse::SendInput;
 use windows::Win32::UI::Input::KeyboardAndMouse::VK_LBUTTON;
 use windows::Win32::UI::Input::KeyboardAndMouse::VK_MENU;
-use windows::Win32::UI::Shell::DWPOS_FILL;
 use windows::Win32::UI::Shell::DesktopWallpaper;
 use windows::Win32::UI::Shell::IDesktopWallpaper;
+use windows::Win32::UI::Shell::DWPOS_FILL;
 use windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
 use windows::Win32::UI::WindowsAndMessaging::BringWindowToTop;
-use windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT;
 use windows::Win32::UI::WindowsAndMessaging::CreateWindowExW;
-use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
 use windows::Win32::UI::WindowsAndMessaging::EnumWindows;
-use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
-use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
-use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
 use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
@@ -93,38 +91,15 @@ use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowRect;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowTextW;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
-use windows::Win32::UI::WindowsAndMessaging::HDEVNOTIFY;
-use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
-use windows::Win32::UI::WindowsAndMessaging::HWND_TOP;
 use windows::Win32::UI::WindowsAndMessaging::IsIconic;
 use windows::Win32::UI::WindowsAndMessaging::IsWindow;
 use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
 use windows::Win32::UI::WindowsAndMessaging::IsZoomed;
-use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
 use windows::Win32::UI::WindowsAndMessaging::MoveWindow;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
-use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterDeviceNotificationW;
-use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
-use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
-use windows::Win32::UI::WindowsAndMessaging::SPI_GETACTIVEWINDOWTRACKING;
-use windows::Win32::UI::WindowsAndMessaging::SPI_GETFOREGROUNDLOCKTIMEOUT;
-use windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
-use windows::Win32::UI::WindowsAndMessaging::SPI_SETFOREGROUNDLOCKTIMEOUT;
-use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
-use windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
-use windows::Win32::UI::WindowsAndMessaging::SW_MINIMIZE;
-use windows::Win32::UI::WindowsAndMessaging::SW_NORMAL;
-use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNOACTIVATE;
-use windows::Win32::UI::WindowsAndMessaging::SWP_ASYNCWINDOWPOS;
-use windows::Win32::UI::WindowsAndMessaging::SWP_NOMOVE;
-use windows::Win32::UI::WindowsAndMessaging::SWP_NOSIZE;
-use windows::Win32::UI::WindowsAndMessaging::SWP_SHOWWINDOW;
-use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
-use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
 use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
@@ -133,6 +108,35 @@ use windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
 use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::ShowWindowAsync;
 use windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
+use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
+use windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT;
+use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
+use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
+use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
+use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
+use windows::Win32::UI::WindowsAndMessaging::HDEVNOTIFY;
+use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
+use windows::Win32::UI::WindowsAndMessaging::HWND_TOP;
+use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
+use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
+use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
+use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
+use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::SPI_GETACTIVEWINDOWTRACKING;
+use windows::Win32::UI::WindowsAndMessaging::SPI_GETFOREGROUNDLOCKTIMEOUT;
+use windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
+use windows::Win32::UI::WindowsAndMessaging::SPI_SETFOREGROUNDLOCKTIMEOUT;
+use windows::Win32::UI::WindowsAndMessaging::SWP_ASYNCWINDOWPOS;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOMOVE;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOSIZE;
+use windows::Win32::UI::WindowsAndMessaging::SWP_SHOWWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
+use windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
+use windows::Win32::UI::WindowsAndMessaging::SW_MINIMIZE;
+use windows::Win32::UI::WindowsAndMessaging::SW_NORMAL;
+use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNOACTIVATE;
+use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
+use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
 use windows::Win32::UI::WindowsAndMessaging::WM_CLOSE;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
@@ -143,28 +147,24 @@ use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
 use windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;
-use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
-use windows::core::PCWSTR;
-use windows::core::PWSTR;
-use windows::core::Result as WindowsCrateResult;
 use windows_core::BOOL;
 use windows_core::HSTRING;
 
 use crate::core::Rect;
 
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::DUPLICATE_MONITOR_SERIAL_IDS;
-use crate::MONITOR_INDEX_PREFERENCES;
-use crate::WINDOW_HANDLING_BEHAVIOUR;
-use crate::Window;
-use crate::WindowHandlingBehaviour;
-use crate::WindowManager;
 use crate::container::Container;
 use crate::monitor;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
+use crate::Window;
+use crate::WindowHandlingBehaviour;
+use crate::WindowManager;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::DUPLICATE_MONITOR_SERIAL_IDS;
+use crate::MONITOR_INDEX_PREFERENCES;
+use crate::WINDOW_HANDLING_BEHAVIOUR;
 
 macro_rules! as_ptr {
     ($value:expr) => {
@@ -207,7 +207,7 @@ impl<T, E> From<WindowsResult<T, E>> for Result<T, E> {
 }
 
 pub trait ProcessWindowsCrateResult<T> {
-    fn process(self) -> eyre::Result<T>;
+    fn process(self) -> Result<T>;
 }
 
 macro_rules! impl_process_windows_crate_integer_wrapper_result {
@@ -215,7 +215,7 @@ macro_rules! impl_process_windows_crate_integer_wrapper_result {
         paste::paste! {
             $(
                 impl ProcessWindowsCrateResult<$deref> for $input {
-                    fn process(self) -> eyre::Result<$deref> {
+                    fn process(self) -> Result<$deref> {
                         if self == $input(std::ptr::null_mut()) {
                             Err(std::io::Error::last_os_error().into())
                         } else {
@@ -233,7 +233,7 @@ impl_process_windows_crate_integer_wrapper_result!(
 );
 
 impl<T> ProcessWindowsCrateResult<T> for WindowsCrateResult<T> {
-    fn process(self) -> eyre::Result<T> {
+    fn process(self) -> Result<T> {
         match self {
             Ok(value) => Ok(value),
             Err(error) => Err(error.into()),
@@ -247,13 +247,13 @@ impl WindowsApi {
     pub fn enum_display_monitors(
         callback: MONITORENUMPROC,
         callback_data_address: isize,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         unsafe { EnumDisplayMonitors(None, None, callback, LPARAM(callback_data_address)) }
             .ok()
             .process()
     }
 
-    pub fn valid_hmonitors() -> eyre::Result<Vec<(String, isize)>> {
+    pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
         Ok(win32_display_data::connected_displays_all()
             .flatten()
             .map(|d| {
@@ -265,7 +265,7 @@ impl WindowsApi {
             .collect::<Vec<_>>())
     }
 
-    pub fn load_monitor_information(wm: &mut WindowManager) -> eyre::Result<()> {
+    pub fn load_monitor_information(wm: &mut WindowManager) -> Result<()> {
         let monitors = &mut wm.monitors;
         let monitor_usr_idx_map = &mut wm.monitor_usr_idx_map;
 
@@ -282,12 +282,12 @@ impl WindowsApi {
         }
 
         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());
+                    }
                 }
             }
         }
@@ -310,7 +310,7 @@ impl WindowsApi {
             let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
 
             for monitor in monitors.elements() {
-                if device_id.eq(&monitor.device_id) {
+                if device_id.eq(monitor.device_id()) {
                     continue 'read;
                 }
             }
@@ -335,14 +335,15 @@ impl WindowsApi {
             let mut index_preference = None;
             let monitor_index_preferences = MONITOR_INDEX_PREFERENCES.lock();
             for (index, monitor_size) in &*monitor_index_preferences {
-                if m.size == *monitor_size {
+                if m.size() == monitor_size {
                     index_preference = Option::from(index);
                 }
             }
 
             let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
             for (index, id) in &*display_index_preferences {
-                if m.serial_number_id.as_ref().is_some_and(|sn| sn == id) || id.eq(&m.device_id) {
+                if m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || id.eq(m.device_id())
+                {
                     index_preference = Option::from(index);
                 }
             }
@@ -355,7 +356,7 @@ impl WindowsApi {
                 let current_name = monitors
                     .elements_mut()
                     .get(*preference)
-                    .map_or("", |m| &m.name);
+                    .map_or("", |m| m.name());
                 if current_name == "PLACEHOLDER" {
                     let _ = monitors.elements_mut().remove(*preference);
                     monitors.elements_mut().insert(*preference, m);
@@ -367,14 +368,16 @@ impl WindowsApi {
             }
         }
 
-        monitors.elements_mut().retain(|m| m.name.ne("PLACEHOLDER"));
+        monitors
+            .elements_mut()
+            .retain(|m| m.name().ne("PLACEHOLDER"));
 
         // Rebuild monitor index map
         *monitor_usr_idx_map = HashMap::new();
         let mut added_monitor_idxs = Vec::new();
         for (index, id) in &*DISPLAY_INDEX_PREFERENCES.read() {
             if let Some(m_idx) = monitors.elements().iter().position(|m| {
-                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
             }) {
                 monitor_usr_idx_map.insert(*index, m_idx);
                 added_monitor_idxs.push(m_idx);
@@ -406,13 +409,13 @@ impl WindowsApi {
         Ok(())
     }
 
-    pub fn enum_windows(callback: WNDENUMPROC, callback_data_address: isize) -> eyre::Result<()> {
+    pub fn enum_windows(callback: WNDENUMPROC, callback_data_address: isize) -> Result<()> {
         unsafe { EnumWindows(callback, LPARAM(callback_data_address)) }.process()
     }
 
-    pub fn load_workspace_information(monitors: &mut Ring<Monitor>) -> eyre::Result<()> {
+    pub fn load_workspace_information(monitors: &mut Ring<Monitor>) -> Result<()> {
         for monitor in monitors.elements_mut() {
-            let monitor_name = monitor.name.clone();
+            let monitor_name = monitor.name().clone();
             if let Some(workspace) = monitor.workspaces_mut().front_mut() {
                 // EnumWindows will enumerate through windows on all monitors
                 Self::enum_windows(
@@ -423,7 +426,7 @@ impl WindowsApi {
                 // Ensure that the resize_dimensions Vec length matches the number of containers for
                 // the potential later calls to workspace.remove_window later in this fn
                 let len = workspace.containers().len();
-                workspace.resize_dimensions.resize(len, None);
+                workspace.resize_dimensions_mut().resize(len, None);
 
                 // We have to prune each monitor's primary workspace of undesired windows here
                 let mut windows_on_other_monitors = vec![];
@@ -445,7 +448,7 @@ impl WindowsApi {
         Ok(())
     }
 
-    pub fn allow_set_foreground_window(process_id: u32) -> eyre::Result<()> {
+    pub fn allow_set_foreground_window(process_id: u32) -> Result<()> {
         unsafe { AllowSetForegroundWindow(process_id) }.process()
     }
 
@@ -455,13 +458,13 @@ impl WindowsApi {
         unsafe { MonitorFromWindow(HWND(as_ptr!(hwnd)), MONITOR_DEFAULTTONEAREST) }.0 as isize
     }
 
-    pub fn monitor_name_from_window(hwnd: isize) -> eyre::Result<String> {
+    pub fn monitor_name_from_window(hwnd: isize) -> Result<String> {
         // MONITOR_DEFAULTTONEAREST ensures that the return value will never be NULL
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-monitorfromwindow
         Ok(Self::monitor(
             unsafe { MonitorFromWindow(HWND(as_ptr!(hwnd)), MONITOR_DEFAULTTONEAREST) }.0 as isize,
         )?
-        .name
+        .name()
         .to_string())
     }
 
@@ -479,7 +482,7 @@ impl WindowsApi {
         layout: &Rect,
         top: bool,
         with_async_window_pos: bool,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         let hwnd = HWND(as_ptr!(hwnd));
 
         let mut flags = SetWindowPosition::NO_ACTIVATE
@@ -530,13 +533,13 @@ impl WindowsApi {
         Self::set_window_pos(hwnd, &rect, HWND_TOP, flags.bits())
     }
 
-    pub fn bring_window_to_top(hwnd: isize) -> eyre::Result<()> {
+    pub fn bring_window_to_top(hwnd: isize) -> Result<()> {
         unsafe { BringWindowToTop(HWND(as_ptr!(hwnd))) }.process()
     }
 
     /// Raise the window to the top of the Z order, but do not activate or focus
     /// it. Use raise_and_focus_window to activate and focus a window.
-    pub fn raise_window(hwnd: isize) -> eyre::Result<()> {
+    pub fn raise_window(hwnd: isize) -> Result<()> {
         let mut flags = SetWindowPosition::NO_MOVE
             | SetWindowPosition::NO_SIZE
             | SetWindowPosition::NO_ACTIVATE
@@ -560,7 +563,7 @@ impl WindowsApi {
 
     /// Lower the window to the bottom of the Z order, but do not activate or focus
     /// it.
-    pub fn lower_window(hwnd: isize) -> eyre::Result<()> {
+    pub fn lower_window(hwnd: isize) -> Result<()> {
         let mut flags = SetWindowPosition::NO_MOVE
             | SetWindowPosition::NO_SIZE
             | SetWindowPosition::NO_ACTIVATE
@@ -582,7 +585,7 @@ impl WindowsApi {
         )
     }
 
-    pub fn set_border_pos(hwnd: isize, layout: &Rect, position: isize) -> eyre::Result<()> {
+    pub fn set_border_pos(hwnd: isize, layout: &Rect, position: isize) -> Result<()> {
         let mut flags = SetWindowPosition::NO_SEND_CHANGING
             | SetWindowPosition::NO_ACTIVATE
             | SetWindowPosition::NO_REDRAW
@@ -604,7 +607,7 @@ impl WindowsApi {
     }
 
     /// set_window_pos calls SetWindowPos without any accounting for Window decorations.
-    fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> eyre::Result<()> {
+    fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> Result<()> {
         unsafe {
             SetWindowPos(
                 hwnd,
@@ -620,7 +623,7 @@ impl WindowsApi {
     }
 
     /// move_windows calls MoveWindow, but cannot be called with async window pos, so it might hang
-    pub fn move_window(hwnd: isize, layout: &Rect, repaint: bool) -> eyre::Result<()> {
+    pub fn move_window(hwnd: isize, layout: &Rect, repaint: bool) -> Result<()> {
         let hwnd = HWND(as_ptr!(hwnd));
 
         let shadow_rect = Self::shadow_rect(hwnd).unwrap_or_default();
@@ -655,16 +658,15 @@ impl WindowsApi {
         Self::show_window(hwnd, SW_MINIMIZE);
     }
 
-    fn post_message(hwnd: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> eyre::Result<()> {
+    fn post_message(hwnd: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> Result<()> {
         unsafe { PostMessageW(Option::from(hwnd), message, wparam, lparam) }.process()
     }
 
-    pub fn close_window(hwnd: isize) -> eyre::Result<()> {
-        if Self::post_message(HWND(as_ptr!(hwnd)), WM_CLOSE, WPARAM(0), LPARAM(0)).is_err() {
-            bail!("could not close window");
+    pub fn close_window(hwnd: isize) -> Result<()> {
+        match Self::post_message(HWND(as_ptr!(hwnd)), WM_CLOSE, WPARAM(0), LPARAM(0)) {
+            Ok(()) => Ok(()),
+            Err(_) => Err(anyhow!("could not close window")),
         }
-
-        Ok(())
     }
 
     pub fn hide_window(hwnd: isize) {
@@ -683,11 +685,11 @@ impl WindowsApi {
         Self::show_window(hwnd, SW_MAXIMIZE);
     }
 
-    pub fn foreground_window() -> eyre::Result<isize> {
+    pub fn foreground_window() -> Result<isize> {
         unsafe { GetForegroundWindow() }.process()
     }
 
-    pub fn raise_and_focus_window(hwnd: isize) -> eyre::Result<()> {
+    pub fn raise_and_focus_window(hwnd: isize) -> Result<()> {
         let event = [INPUT {
             r#type: INPUT_MOUSE,
             ..Default::default()
@@ -715,20 +717,20 @@ impl WindowsApi {
     }
 
     #[allow(dead_code)]
-    pub fn top_window() -> eyre::Result<isize> {
+    pub fn top_window() -> Result<isize> {
         unsafe { GetTopWindow(None)? }.process()
     }
 
-    pub fn desktop_window() -> eyre::Result<isize> {
+    pub fn desktop_window() -> Result<isize> {
         unsafe { GetDesktopWindow() }.process()
     }
 
     #[allow(dead_code)]
-    pub fn next_window(hwnd: isize) -> eyre::Result<isize> {
+    pub fn next_window(hwnd: isize) -> Result<isize> {
         unsafe { GetWindow(HWND(as_ptr!(hwnd)), GW_HWNDNEXT)? }.process()
     }
 
-    pub fn alt_tab_windows() -> eyre::Result<Vec<Window>> {
+    pub fn alt_tab_windows() -> Result<Vec<Window>> {
         let mut hwnds = vec![];
         Self::enum_windows(
             Some(windows_callbacks::alt_tab_windows),
@@ -739,7 +741,7 @@ impl WindowsApi {
     }
 
     #[allow(dead_code)]
-    pub fn top_visible_window() -> eyre::Result<isize> {
+    pub fn top_visible_window() -> Result<isize> {
         let hwnd = Self::top_window()?;
         let mut next_hwnd = hwnd;
 
@@ -751,10 +753,10 @@ impl WindowsApi {
             next_hwnd = Self::next_window(next_hwnd)?;
         }
 
-        bail!("could not find next window")
+        Err(anyhow!("could not find next window"))
     }
 
-    pub fn window_rect(hwnd: isize) -> eyre::Result<Rect> {
+    pub fn window_rect(hwnd: isize) -> Result<Rect> {
         let mut rect = unsafe { std::mem::zeroed() };
 
         if Self::dwm_get_window_attribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &mut rect).is_ok() {
@@ -773,7 +775,7 @@ impl WindowsApi {
     /// the window painted region. The four values in the returned Rect can be
     /// added to a position rect to compute a size for set_window_pos that will
     /// fill the target area, ignoring shadows.
-    fn shadow_rect(hwnd: HWND) -> eyre::Result<Rect> {
+    fn shadow_rect(hwnd: HWND) -> Result<Rect> {
         let window_rect = Self::window_rect(hwnd.0 as isize)?;
 
         let mut srect = Default::default();
@@ -808,26 +810,26 @@ impl WindowsApi {
             let _ = Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
         }
     }
-    fn set_cursor_pos(x: i32, y: i32) -> eyre::Result<()> {
+    fn set_cursor_pos(x: i32, y: i32) -> Result<()> {
         unsafe { SetCursorPos(x, y) }.process()
     }
 
-    pub fn cursor_pos() -> eyre::Result<POINT> {
+    pub fn cursor_pos() -> Result<POINT> {
         let mut cursor_pos = POINT::default();
         unsafe { GetCursorPos(&mut cursor_pos) }.process()?;
 
         Ok(cursor_pos)
     }
 
-    pub fn window_from_point(point: POINT) -> eyre::Result<isize> {
+    pub fn window_from_point(point: POINT) -> Result<isize> {
         unsafe { WindowFromPoint(point) }.process()
     }
 
-    pub fn window_at_cursor_pos() -> eyre::Result<isize> {
+    pub fn window_at_cursor_pos() -> Result<isize> {
         Self::window_from_point(Self::cursor_pos()?)
     }
 
-    pub fn center_cursor_in_rect(rect: &Rect) -> eyre::Result<()> {
+    pub fn center_cursor_in_rect(rect: &Rect) -> Result<()> {
         Self::set_cursor_pos(rect.left + (rect.right / 2), rect.top + (rect.bottom / 2))
     }
 
@@ -850,17 +852,17 @@ impl WindowsApi {
         unsafe { GetCurrentProcessId() }
     }
 
-    pub fn process_id_to_session_id() -> eyre::Result<u32> {
+    pub fn process_id_to_session_id() -> Result<u32> {
         let process_id = Self::current_process_id();
         let mut session_id = 0;
 
         unsafe {
-            if ProcessIdToSessionId(process_id, &mut session_id).is_err() {
-                bail!("could not determine current session id")
+            if ProcessIdToSessionId(process_id, &mut session_id).is_ok() {
+                Ok(session_id)
+            } else {
+                Err(anyhow!("could not determine current session id"))
             }
         }
-
-        Ok(session_id)
     }
 
     #[cfg(target_pointer_width = "64")]
@@ -868,7 +870,7 @@ impl WindowsApi {
         hwnd: HWND,
         index: WINDOW_LONG_PTR_INDEX,
         new_value: isize,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         Result::from(WindowsResult::from(unsafe {
             SetWindowLongPtrW(hwnd, index, new_value)
         }))
@@ -880,7 +882,7 @@ impl WindowsApi {
         hwnd: HWND,
         index: WINDOW_LONG_PTR_INDEX,
         new_value: i32,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         Result::from(WindowsResult::from(unsafe {
             SetWindowLongPtrW(hwnd, index, new_value)
         }))
@@ -888,27 +890,27 @@ impl WindowsApi {
     }
 
     #[cfg(target_pointer_width = "64")]
-    pub fn gwl_style(hwnd: isize) -> eyre::Result<isize> {
+    pub fn gwl_style(hwnd: isize) -> Result<isize> {
         Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE)
     }
 
     #[cfg(target_pointer_width = "32")]
-    pub fn gwl_style(hwnd: isize) -> eyre::Result<i32> {
+    pub fn gwl_style(hwnd: isize) -> Result<i32> {
         Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE)
     }
 
     #[cfg(target_pointer_width = "64")]
-    pub fn gwl_ex_style(hwnd: isize) -> eyre::Result<isize> {
+    pub fn gwl_ex_style(hwnd: isize) -> Result<isize> {
         Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE)
     }
 
     #[cfg(target_pointer_width = "32")]
-    pub fn gwl_ex_style(hwnd: isize) -> eyre::Result<i32> {
+    pub fn gwl_ex_style(hwnd: isize) -> Result<i32> {
         Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE)
     }
 
     #[cfg(target_pointer_width = "64")]
-    fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> eyre::Result<isize> {
+    fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> Result<isize> {
         // Can return 0, which does not always mean that an error has occurred
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowlongptrw
         Result::from(WindowsResult::from(unsafe {
@@ -917,7 +919,7 @@ impl WindowsApi {
     }
 
     #[cfg(target_pointer_width = "32")]
-    fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> eyre::Result<i32> {
+    fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> Result<i32> {
         // Can return 0, which does not always mean that an error has occurred
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowlongptrw
         Result::from(WindowsResult::from(unsafe {
@@ -926,26 +928,26 @@ impl WindowsApi {
     }
 
     #[cfg(target_pointer_width = "64")]
-    pub fn update_style(hwnd: isize, new_value: isize) -> eyre::Result<()> {
+    pub fn update_style(hwnd: isize, new_value: isize) -> Result<()> {
         Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE, new_value)
     }
 
     #[cfg(target_pointer_width = "32")]
-    pub fn update_style(hwnd: isize, new_value: i32) -> eyre::Result<()> {
+    pub fn update_style(hwnd: isize, new_value: i32) -> Result<()> {
         Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE, new_value)
     }
 
     #[cfg(target_pointer_width = "64")]
-    pub fn update_ex_style(hwnd: isize, new_value: isize) -> eyre::Result<()> {
+    pub fn update_ex_style(hwnd: isize, new_value: isize) -> Result<()> {
         Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE, new_value)
     }
 
     #[cfg(target_pointer_width = "32")]
-    pub fn update_ex_style(hwnd: isize, new_value: i32) -> eyre::Result<()> {
+    pub fn update_ex_style(hwnd: isize, new_value: i32) -> Result<()> {
         Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE, new_value)
     }
 
-    pub fn window_text_w(hwnd: isize) -> eyre::Result<String> {
+    pub fn window_text_w(hwnd: isize) -> Result<String> {
         let mut text: [u16; 512] = [0; 512];
         match WindowsResult::from(unsafe { GetWindowTextW(HWND(as_ptr!(hwnd)), &mut text) }) {
             WindowsResult::Ok(len) => {
@@ -960,19 +962,19 @@ impl WindowsApi {
         access_rights: PROCESS_ACCESS_RIGHTS,
         inherit_handle: bool,
         process_id: u32,
-    ) -> eyre::Result<HANDLE> {
+    ) -> Result<HANDLE> {
         unsafe { OpenProcess(access_rights, inherit_handle, process_id) }.process()
     }
 
-    pub fn close_process(handle: HANDLE) -> eyre::Result<()> {
+    pub fn close_process(handle: HANDLE) -> Result<()> {
         unsafe { CloseHandle(handle) }.process()
     }
 
-    pub fn process_handle(process_id: u32) -> eyre::Result<HANDLE> {
+    pub fn process_handle(process_id: u32) -> Result<HANDLE> {
         Self::open_process(PROCESS_QUERY_INFORMATION, false, process_id)
     }
 
-    pub fn exe_path(handle: HANDLE) -> eyre::Result<String> {
+    pub fn exe_path(handle: HANDLE) -> Result<String> {
         let mut len = 260_u32;
         let mut path: Vec<u16> = vec![0; len as usize];
         let text_ptr = path.as_mut_ptr();
@@ -985,15 +987,15 @@ impl WindowsApi {
         Ok(String::from_utf16(&path[..len as usize])?)
     }
 
-    pub fn exe(handle: HANDLE) -> eyre::Result<String> {
+    pub fn exe(handle: HANDLE) -> Result<String> {
         Ok(Self::exe_path(handle)?
             .split('\\')
             .next_back()
-            .ok_or_eyre("there is no last element")?
+            .ok_or_else(|| anyhow!("there is no last element"))?
             .to_string())
     }
 
-    pub fn real_window_class_w(hwnd: isize) -> eyre::Result<String> {
+    pub fn real_window_class_w(hwnd: isize) -> Result<String> {
         const BUF_SIZE: usize = 512;
         let mut class: [u16; BUF_SIZE] = [0; BUF_SIZE];
 
@@ -1008,7 +1010,7 @@ impl WindowsApi {
         hwnd: isize,
         attribute: DWMWINDOWATTRIBUTE,
         value: &mut T,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         unsafe {
             DwmGetWindowAttribute(
                 HWND(as_ptr!(hwnd)),
@@ -1021,7 +1023,7 @@ impl WindowsApi {
         Ok(())
     }
 
-    pub fn is_window_cloaked(hwnd: isize) -> eyre::Result<bool> {
+    pub fn is_window_cloaked(hwnd: isize) -> Result<bool> {
         let mut cloaked: u32 = 0;
         Self::dwm_get_window_attribute(hwnd, DWMWA_CLOAKED, &mut cloaked)?;
 
@@ -1047,7 +1049,7 @@ impl WindowsApi {
         unsafe { IsZoomed(HWND(as_ptr!(hwnd))) }.into()
     }
 
-    pub fn monitor_info_w(hmonitor: HMONITOR) -> eyre::Result<MONITORINFOEXW> {
+    pub fn monitor_info_w(hmonitor: HMONITOR) -> Result<MONITORINFOEXW> {
         let mut ex_info = MONITORINFOEXW::default();
         ex_info.monitorInfo.cbSize = u32::try_from(std::mem::size_of::<MONITORINFOEXW>())?;
         unsafe { GetMonitorInfoW(hmonitor, &mut ex_info.monitorInfo) }
@@ -1067,7 +1069,7 @@ impl WindowsApi {
         None
     }
 
-    pub fn monitor(hmonitor: isize) -> eyre::Result<Monitor> {
+    pub fn monitor(hmonitor: isize) -> Result<Monitor> {
         for mut display in win32_display_data::connected_displays_all().flatten() {
             if display.hmonitor == hmonitor {
                 let path = display.device_path;
@@ -1110,7 +1112,7 @@ impl WindowsApi {
         bail!("could not find device_id for hmonitor: {hmonitor}");
     }
 
-    pub fn set_process_dpi_awareness_context() -> eyre::Result<()> {
+    pub fn set_process_dpi_awareness_context() -> Result<()> {
         unsafe { SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) }
             .process()
     }
@@ -1121,13 +1123,13 @@ impl WindowsApi {
         ui_param: u32,
         pv_param: *mut c_void,
         update_flags: SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS,
-    ) -> eyre::Result<()> {
+    ) -> Result<()> {
         unsafe { SystemParametersInfoW(action, ui_param, Option::from(pv_param), update_flags) }
             .process()
     }
 
     #[tracing::instrument]
-    pub fn foreground_lock_timeout() -> eyre::Result<()> {
+    pub fn foreground_lock_timeout() -> Result<()> {
         let mut value: u32 = 0;
 
         Self::system_parameters_info_w(
@@ -1140,9 +1142,7 @@ impl WindowsApi {
         tracing::info!("current value of ForegroundLockTimeout is {value}");
 
         if value != 0 {
-            tracing::info!(
-                "updating value of ForegroundLockTimeout to {value} in order to enable keyboard-driven focus updating"
-            );
+            tracing::info!("updating value of ForegroundLockTimeout to {value} in order to enable keyboard-driven focus updating");
 
             Self::system_parameters_info_w(
                 SPI_SETFOREGROUNDLOCKTIMEOUT,
@@ -1165,7 +1165,7 @@ impl WindowsApi {
     }
 
     #[allow(dead_code)]
-    pub fn focus_follows_mouse() -> eyre::Result<bool> {
+    pub fn focus_follows_mouse() -> Result<bool> {
         let mut is_enabled: BOOL = unsafe { std::mem::zeroed() };
 
         Self::system_parameters_info_w(
@@ -1179,8 +1179,7 @@ impl WindowsApi {
     }
 
     #[allow(dead_code)]
-    pub fn enable_focus_follows_mouse() -> eyre::Result<()> {
-        #[allow(clippy::manual_dangling_ptr)]
+    pub fn enable_focus_follows_mouse() -> Result<()> {
         Self::system_parameters_info_w(
             SPI_SETACTIVEWINDOWTRACKING,
             0,
@@ -1190,7 +1189,7 @@ impl WindowsApi {
     }
 
     #[allow(dead_code)]
-    pub fn disable_focus_follows_mouse() -> eyre::Result<()> {
+    pub fn disable_focus_follows_mouse() -> Result<()> {
         Self::system_parameters_info_w(
             SPI_SETACTIVEWINDOWTRACKING,
             0,
@@ -1199,7 +1198,7 @@ impl WindowsApi {
         )
     }
 
-    pub fn module_handle_w() -> eyre::Result<HMODULE> {
+    pub fn module_handle_w() -> Result<HMODULE> {
         unsafe { GetModuleHandleW(None) }.process()
     }
 
@@ -1207,11 +1206,11 @@ impl WindowsApi {
         unsafe { CreateSolidBrush(COLORREF(colour)) }
     }
 
-    pub fn register_class_w(window_class: &WNDCLASSW) -> eyre::Result<u16> {
+    pub fn register_class_w(window_class: &WNDCLASSW) -> Result<u16> {
         Result::from(WindowsResult::from(unsafe { RegisterClassW(window_class) }))
     }
 
-    pub fn dpi_for_monitor(hmonitor: isize) -> eyre::Result<f32> {
+    pub fn dpi_for_monitor(hmonitor: isize) -> Result<f32> {
         let mut dpi_x = u32::default();
         let mut dpi_y = u32::default();
 
@@ -1229,14 +1228,14 @@ impl WindowsApi {
         Ok(dpi_y as f32 / 96.0)
     }
 
-    pub fn monitors_have_same_dpi(hmonitor_a: isize, hmonitor_b: isize) -> eyre::Result<bool> {
+    pub fn monitors_have_same_dpi(hmonitor_a: isize, hmonitor_b: isize) -> Result<bool> {
         let dpi_a = Self::dpi_for_monitor(hmonitor_a)?;
         let dpi_b = Self::dpi_for_monitor(hmonitor_b)?;
 
         Ok((dpi_a - dpi_b).abs() < f32::EPSILON)
     }
 
-    pub fn round_corners(hwnd: isize) -> eyre::Result<()> {
+    pub fn round_corners(hwnd: isize) -> Result<()> {
         let round = DWMWCP_ROUND;
 
         unsafe {
@@ -1250,7 +1249,7 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn set_window_accent(hwnd: isize, color: Option<u32>) -> eyre::Result<()> {
+    pub fn set_window_accent(hwnd: isize, color: Option<u32>) -> Result<()> {
         let col_ref = COLORREF(color.unwrap_or(DWMWA_COLOR_NONE));
         unsafe {
             DwmSetWindowAttribute(
@@ -1267,7 +1266,7 @@ impl WindowsApi {
         name: PCWSTR,
         instance: isize,
         border: *mut Border,
-    ) -> eyre::Result<isize> {
+    ) -> Result<isize> {
         unsafe {
             CreateWindowExW(
                 WS_EX_TOOLWINDOW | WS_EX_TOPMOST | WS_EX_NOACTIVATE,
@@ -1287,7 +1286,7 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn set_transparent(hwnd: isize, alpha: u8) -> eyre::Result<()> {
+    pub fn set_transparent(hwnd: isize, alpha: u8) -> Result<()> {
         unsafe {
             #[allow(clippy::cast_sign_loss)]
             SetLayeredWindowAttributes(
@@ -1301,7 +1300,7 @@ impl WindowsApi {
         Ok(())
     }
 
-    pub fn get_transparent(hwnd: isize) -> eyre::Result<u8> {
+    pub fn get_transparent(hwnd: isize) -> Result<u8> {
         unsafe {
             let mut alpha: u8 = u8::default();
             let mut color_ref = COLORREF(-1i32 as u32);
@@ -1316,7 +1315,7 @@ impl WindowsApi {
         }
     }
 
-    pub fn create_hidden_window(name: PCWSTR, instance: isize) -> eyre::Result<isize> {
+    pub fn create_hidden_window(name: PCWSTR, instance: isize) -> Result<isize> {
         unsafe {
             CreateWindowExW(
                 WS_EX_NOACTIVATE,
@@ -1410,11 +1409,11 @@ impl WindowsApi {
         }
     }
 
-    pub fn wts_register_session_notification(hwnd: isize) -> eyre::Result<()> {
+    pub fn wts_register_session_notification(hwnd: isize) -> Result<()> {
         unsafe { WTSRegisterSessionNotification(HWND(as_ptr!(hwnd)), 1) }.process()
     }
 
-    pub fn set_wallpaper(path: &Path, hmonitor: isize) -> eyre::Result<()> {
+    pub fn set_wallpaper(path: &Path, hmonitor: isize) -> Result<()> {
         let path = path.canonicalize()?;
 
         let wallpaper: IDesktopWallpaper =
@@ -1438,7 +1437,7 @@ impl WindowsApi {
         Ok(())
     }
 
-    pub fn get_wallpaper(hmonitor: isize) -> eyre::Result<String> {
+    pub fn get_wallpaper(hmonitor: isize) -> Result<String> {
         let wallpaper: IDesktopWallpaper =
             unsafe { CoCreateInstance(&DesktopWallpaper, None, CLSCTX_ALL)? };
 

komorebi/src/windows_callbacks.rs

@@ -12,11 +12,11 @@ use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::WPARAM;
 use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowLongW;
+use windows::Win32::UI::WindowsAndMessaging::SendNotifyMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
-use windows::Win32::UI::WindowsAndMessaging::GetWindowLongW;
 use windows::Win32::UI::WindowsAndMessaging::OBJID_WINDOW;
-use windows::Win32::UI::WindowsAndMessaging::SendNotifyMessageW;
 use windows::Win32::UI::WindowsAndMessaging::WS_CHILD;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
@@ -33,16 +33,16 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     if is_visible && is_window && !is_minimized {
         let window = Window::from(hwnd);
 
-        if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default())
-            && should_manage
-        {
-            if is_maximized {
-                WindowsApi::restore_window(window.hwnd);
-            }
+        if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
+            if should_manage {
+                if is_maximized {
+                    WindowsApi::restore_window(window.hwnd);
+                }
 
-            let mut container = Container::default();
-            container.windows_mut().push_back(window);
-            containers.push_back(container);
+                let mut container = Container::default();
+                container.windows_mut().push_back(window);
+                containers.push_back(container);
+            }
         }
     }
 
@@ -59,10 +59,10 @@ pub extern "system" fn alt_tab_windows(hwnd: HWND, lparam: LPARAM) -> BOOL {
     if is_visible && is_window && !is_minimized {
         let window = Window::from(hwnd);
 
-        if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default())
-            && should_manage
-        {
-            windows.push(window);
+        if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
+            if should_manage {
+                windows.push(window);
+            }
         }
     }
 

komorebi/src/winevent_listener.rs

@@ -5,11 +5,11 @@ use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use windows::Win32::UI::Accessibility::SetWinEventHook;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_MAX;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_MIN;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::WINEVENT_OUTOFCONTEXT;
 use windows::Win32::UI::WindowsAndMessaging::WINEVENT_SKIPOWNPROCESS;
 

komorebic-no-console/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.39"
+version = "0.1.38"
 description = "The command-line interface (without a console) for Komorebi, 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
 

komorebic.lib.ahk

@@ -184,10 +184,6 @@ MonitorWorkAreaOffset(monitor, left, top, right, bottom) {
     RunWait("komorebic.exe monitor-work-area-offset " monitor " " left " " top " " right " " bottom, , "Hide")
 }
 
-WorkspaceWorkAreaOffset(monitor, workspace, left, top, right, bottom) {
-    RunWait("komorebic.exe workspace-work-area-offset " monitor " "workspace" " left " " top " " right " " bottom, , "Hide")
-}
-
 AdjustContainerPadding(sizing, adjustment) {
     RunWait("komorebic.exe adjust-container-padding " sizing " " adjustment, , "Hide")
 }

komorebic/Cargo.toml

@@ -1,9 +1,9 @@
 [package]
 name = "komorebic"
-version = "0.1.39"
+version = "0.1.38"
 description = "The command-line interface for Komorebi, 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
 

komorebic/src/main.rs

@@ -2,11 +2,10 @@
 #![allow(clippy::missing_errors_doc, clippy::doc_markdown)]
 
 use chrono::Utc;
-use komorebi_client::PathExt;
 use komorebi_client::replace_env_in_path;
+use komorebi_client::PathExt;
 use std::fs::File;
 use std::fs::OpenOptions;
-use std::io;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Write;
@@ -20,15 +19,15 @@ use std::time::Duration;
 use clap::CommandFactory;
 use clap::Parser;
 use clap::ValueEnum;
-use color_eyre::eyre;
-use color_eyre::eyre::OptionExt;
+use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
+use color_eyre::Result;
 use dirs::data_local_dir;
 use fs_tail::TailedFile;
-use komorebi_client::AppSpecificConfigurationPath;
-use komorebi_client::ApplicationSpecificConfiguration;
 use komorebi_client::send_message;
 use komorebi_client::send_query;
+use komorebi_client::AppSpecificConfigurationPath;
+use komorebi_client::ApplicationSpecificConfiguration;
 use lazy_static::lazy_static;
 use miette::NamedSource;
 use miette::Report;
@@ -39,9 +38,9 @@ use serde::Deserialize;
 use sysinfo::ProcessesToUpdate;
 use which::which;
 use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
-use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 
 use komorebi_client::ApplicationConfigurationGenerator;
 use komorebi_client::ApplicationIdentifier;
@@ -93,7 +92,8 @@ lazy_static! {
 
                 assert!(
                     whkd_config_home.is_dir(),
-                    "$Env:WHKD_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                    "$Env:WHKD_CONFIG_HOME is set to '{}', which is not a valid directory",
+                    home_path
                 );
 
                 whkd_config_home
@@ -429,22 +429,6 @@ struct MonitorWorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Parser)]
-struct WorkspaceWorkAreaOffset {
-    /// Monitor index (zero-indexed)
-    monitor: usize,
-    /// Workspace index (zero-indexed)
-    workspace: usize,
-    /// Size of the left work area offset (set right to left * 2 to maintain right padding)
-    left: i32,
-    /// Size of the top work area offset (set bottom to the same value to maintain bottom padding)
-    top: i32,
-    /// Size of the right work area offset
-    right: i32,
-    /// Size of the bottom work area offset
-    bottom: i32,
-}
-
 #[derive(Parser)]
 struct MonitorIndexPreference {
     /// Preferred monitor index (zero-indexed)
@@ -1205,9 +1189,6 @@ enum SubCommand {
     /// Set offsets for a monitor to exclude parts of the work area from tiling
     #[clap(arg_required_else_help = true)]
     MonitorWorkAreaOffset(MonitorWorkAreaOffset),
-    /// Set offsets for a workspace to exclude parts of the work area from tiling
-    #[clap(arg_required_else_help = true)]
-    WorkspaceWorkAreaOffset(WorkspaceWorkAreaOffset),
     /// Toggle application of the window-based work area offset for the focused workspace
     ToggleWindowBasedWorkAreaOffset,
     /// Set container padding on the focused workspace
@@ -1327,7 +1308,7 @@ enum SubCommand {
     ToggleWorkspaceFloatOverride,
     /// Toggle between the Tiling and Floating layers on the focused workspace
     ToggleWorkspaceLayer,
-    /// Toggle the paused state for all window tiling
+    /// Toggle window tiling on the focused workspace
     TogglePause,
     /// Toggle window tiling on the focused workspace
     ToggleTiling,
@@ -1527,7 +1508,7 @@ fn print_query(message: &SocketMessage) {
     }
 }
 
-fn startup_dir() -> eyre::Result<PathBuf> {
+fn startup_dir() -> Result<PathBuf> {
     let startup = dirs::home_dir()
         .expect("unable to obtain user's home folder")
         .join("AppData")
@@ -1546,7 +1527,7 @@ fn startup_dir() -> eyre::Result<PathBuf> {
 }
 
 #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
-fn main() -> eyre::Result<()> {
+fn main() -> Result<()> {
     let opts: Opts = Opts::parse();
 
     match opts.subcmd {
@@ -1581,33 +1562,6 @@ fn main() -> eyre::Result<()> {
             }
         }
         SubCommand::Quickstart => {
-            fn write_file_with_prompt(
-                path: &PathBuf,
-                content: &str,
-                created_files: &mut Vec<String>,
-            ) -> eyre::Result<()> {
-                if path.exists() {
-                    print!(
-                        "{} will be overwritten, do you want to continue? (y/N): ",
-                        path.display()
-                    );
-                    io::stdout().flush()?;
-                    let mut input = String::new();
-                    io::stdin().read_line(&mut input)?;
-                    let trimmed = input.trim().to_lowercase();
-                    if trimmed == "y" || trimmed == "yes" {
-                        std::fs::write(path, content)?;
-                        created_files.push(path.display().to_string());
-                    } else {
-                        println!("Skipping {}", path.display());
-                    }
-                } else {
-                    std::fs::write(path, content)?;
-                    created_files.push(path.display().to_string());
-                }
-                Ok(())
-            }
-
             let local_appdata_dir = data_local_dir().expect("could not find localdata dir");
             let data_dir = local_appdata_dir.join("komorebi");
             std::fs::create_dir_all(&*WHKD_CONFIG_DIR)?;
@@ -1623,30 +1577,17 @@ fn main() -> eyre::Result<()> {
                     komorebi_json.replace("Env:USERPROFILE", "Env:KOMOREBI_CONFIG_HOME");
             }
 
-            let komorebi_path = HOME_DIR.join("komorebi.json");
-            let bar_path = HOME_DIR.join("komorebi.bar.json");
-            let applications_path = HOME_DIR.join("applications.json");
-            let whkdrc_path = WHKD_CONFIG_DIR.join("whkdrc");
-
-            let mut written_files = Vec::new();
-
-            write_file_with_prompt(&komorebi_path, &komorebi_json, &mut written_files)?;
-            write_file_with_prompt(&bar_path, &komorebi_bar_json, &mut written_files)?;
+            std::fs::write(HOME_DIR.join("komorebi.json"), komorebi_json)?;
+            std::fs::write(HOME_DIR.join("komorebi.bar.json"), komorebi_bar_json)?;
 
             let applications_json = include_str!("../applications.json");
-            write_file_with_prompt(&applications_path, applications_json, &mut written_files)?;
+            std::fs::write(HOME_DIR.join("applications.json"), applications_json)?;
 
             let whkdrc = include_str!("../../docs/whkdrc.sample");
-            write_file_with_prompt(&whkdrc_path, whkdrc, &mut written_files)?;
-            if written_files.is_empty() {
-                println!("\nNo files were written.")
-            } else {
-                println!(
-                    "\nThe following example files were written:\n{}",
-                    written_files.join("\n")
-                );
-            }
-            println!("\nYou can now run komorebic start --whkd --bar");
+            std::fs::write(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;
+
+            println!("Example komorebi.json, komorebi.bar.json, whkdrc and latest applications.json files created");
+            println!("You can now run komorebic start --whkd --bar");
         }
         SubCommand::EnableAutostart(args) => {
             let mut current_exe = std::env::current_exe().expect("unable to get exec path");
@@ -1691,12 +1632,8 @@ fn main() -> eyre::Result<()> {
                 .env("TARGET_ARGS", arguments)
                 .output()?;
 
-            println!(
-                "NOTE: If your komorebi.json file contains a reference to $Env:KOMOREBI_CONFIG_HOME,"
-            );
-            println!(
-                "you need to add this to System Properties > Environment Variables > User Variables"
-            );
+            println!("NOTE: If your komorebi.json file contains a reference to $Env:KOMOREBI_CONFIG_HOME,");
+            println!("you need to add this to System Properties > Environment Variables > User Variables");
             println!("in order for the autostart command to work properly");
         }
         SubCommand::DisableAutostart => {
@@ -1760,23 +1697,16 @@ fn main() -> eyre::Result<()> {
                     println!("{:?}", Report::new(diagnostic));
                 }
 
-                println!(
-                    "Found komorebi.json; this file can be passed to the start command with the --config flag\n"
-                );
+                println!("Found komorebi.json; this file can be passed to the start command with the --config flag\n");
 
                 if let Ok(config) = StaticConfig::read(&static_config) {
                     match config.app_specific_configuration_path {
                         None => {
-                            println!(
-                                "Application specific configuration file path has not been set. Try running 'komorebic fetch-asc'\n"
-                            );
+                            println!("Application specific configuration file path has not been set. Try running 'komorebic fetch-asc'\n");
                         }
                         Some(AppSpecificConfigurationPath::Single(path)) => {
                             if !path.exists() {
-                                println!(
-                                    "Application specific configuration file path '{}' does not exist. Try running 'komorebic fetch-asc'\n",
-                                    path.display()
-                                );
+                                println!("Application specific configuration file path '{}' does not exist. Try running 'komorebic fetch-asc'\n", path.display());
                             }
                         }
                         _ => {}
@@ -1794,14 +1724,9 @@ fn main() -> eyre::Result<()> {
                 StaticConfig::end_of_life(&raw);
 
                 if config_whkd.exists() {
-                    println!(
-                        "Found {}; key bindings will be loaded from here when whkd is started, and you can start it automatically using the --whkd flag\n",
-                        config_whkd.to_string_lossy()
-                    );
+                    println!("Found {}; key bindings will be loaded from here when whkd is started, and you can start it automatically using the --whkd flag\n", config_whkd.to_string_lossy());
                 } else {
-                    println!(
-                        "No ~/.config/whkdrc found; you may not be able to control komorebi with your keyboard\n"
-                    );
+                    println!("No ~/.config/whkdrc found; you may not be able to control komorebi with your keyboard\n");
                 }
             } else if config_pwsh.exists() {
                 println!("Found komorebi.ps1; this file will be autoloaded by komorebi\n");
@@ -1811,17 +1736,13 @@ fn main() -> eyre::Result<()> {
                         config_whkd.to_string_lossy()
                     );
                 } else {
-                    println!(
-                        "No ~/.config/whkdrc found; you may not be able to control komorebi with your keyboard\n"
-                    );
+                    println!("No ~/.config/whkdrc found; you may not be able to control komorebi with your keyboard\n");
                 }
             } else if config_ahk.exists() {
                 println!("Found komorebi.ahk; this file will be autoloaded by komorebi\n");
             } else {
                 println!("No komorebi configuration found in {home_display}\n");
-                println!(
-                    "If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration\n"
-                );
+                println!("If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration\n");
             }
 
             let client = reqwest::blocking::Client::new();
@@ -1843,9 +1764,7 @@ fn main() -> eyre::Result<()> {
                 {
                     let trimmed = release.tag_name.trim_start_matches("v");
                     if trimmed > version {
-                        println!(
-                            "An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}"
-                        );
+                        println!("An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}");
                     }
                 }
             }
@@ -2020,20 +1939,6 @@ fn main() -> eyre::Result<()> {
                 bottom: arg.bottom,
             }))?;
         }
-
-        SubCommand::WorkspaceWorkAreaOffset(arg) => {
-            send_message(&SocketMessage::WorkspaceWorkAreaOffset(
-                arg.monitor,
-                arg.workspace,
-                Rect {
-                    left: arg.left,
-                    top: arg.top,
-                    right: arg.right,
-                    bottom: arg.bottom,
-                },
-            ))?;
-        }
-
         SubCommand::ToggleWindowBasedWorkAreaOffset => {
             send_message(&SocketMessage::ToggleWindowBasedWorkAreaOffset)?;
         }
@@ -2182,53 +2087,46 @@ fn main() -> eyre::Result<()> {
         SubCommand::Start(arg) => {
             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()
-            {
-                ahk = komorebi_ahk_exe;
+            if let Ok(komorebi_ahk_exe) = std::env::var("KOMOREBI_AHK_EXE") {
+                if which(&komorebi_ahk_exe).is_ok() {
+                    ahk = komorebi_ahk_exe;
+                }
             }
 
             if arg.whkd && which("whkd").is_err() {
-                bail!(
-                    "could not find whkd, please make sure it is installed before using the --whkd flag"
-                );
+                bail!("could not find whkd, please make sure it is installed before using the --whkd flag");
             }
 
             if arg.masir && which("masir").is_err() {
-                bail!(
-                    "could not find masir, please make sure it is installed before using the --masir flag"
-                );
+                bail!("could not find masir, please make sure it is installed before using the --masir flag");
             }
 
             if arg.ahk && which(&ahk).is_err() {
-                bail!(
-                    "could not find autohotkey, please make sure it is installed before using the --ahk flag"
-                );
+                bail!("could not find autohotkey, please make sure it is installed before using the --ahk flag");
             }
 
             let mut buf: PathBuf;
 
             // The komorebi.ps1 shim will only exist in the Path if installed by Scoop
-            let exec =
-                if let Ok(output) = Command::new("where.exe").arg("komorebi.ps1").output() {
-                    let stdout = String::from_utf8(output.stdout)?;
-                    match stdout.trim() {
-                        "" => None,
-                        // It's possible that a komorebi.ps1 config will be in %USERPROFILE% - ignore this
-                        stdout if !stdout.contains("scoop") => None,
-                        stdout => {
-                            buf = PathBuf::from(stdout);
-                            buf.pop(); // %USERPROFILE%\scoop\shims
-                            buf.pop(); // %USERPROFILE%\scoop
-                            buf.push("apps\\komorebi\\current\\komorebi.exe"); //%USERPROFILE%\scoop\komorebi\current\komorebi.exe
-                            Some(buf.to_str().ok_or_eyre(
-                                "cannot create a string from the scoop komorebi path",
-                            )?)
-                        }
+            let exec = if let Ok(output) = Command::new("where.exe").arg("komorebi.ps1").output() {
+                let stdout = String::from_utf8(output.stdout)?;
+                match stdout.trim() {
+                    "" => None,
+                    // It's possible that a komorebi.ps1 config will be in %USERPROFILE% - ignore this
+                    stdout if !stdout.contains("scoop") => None,
+                    stdout => {
+                        buf = PathBuf::from(stdout);
+                        buf.pop(); // %USERPROFILE%\scoop\shims
+                        buf.pop(); // %USERPROFILE%\scoop
+                        buf.push("apps\\komorebi\\current\\komorebi.exe"); //%USERPROFILE%\scoop\komorebi\current\komorebi.exe
+                        Some(buf.to_str().ok_or_else(|| {
+                            anyhow!("cannot create a string from the scoop komorebi path")
+                        })?)
                     }
-                } else {
-                    None
-                };
+                }
+            } else {
+                None
+            };
 
             let mut flags = vec![];
             if let Some(config) = &arg.config {
@@ -2360,18 +2258,33 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                 komorebi_json.is_file().then_some(komorebi_json)
             });
 
-            if arg.bar
-                && let Some(config) = &static_config
-            {
-                let mut config = StaticConfig::read(config)?;
-                if let Some(display_bar_configurations) = &mut config.bar_configurations {
-                    for config_file_path in &mut *display_bar_configurations {
-                        let script = format!(
-                            r#"Start-Process "komorebi-bar" '"--config" "{}"' -WindowStyle hidden"#,
-                            config_file_path.to_string_lossy()
-                        );
+            if arg.bar {
+                if let Some(config) = &static_config {
+                    let mut config = StaticConfig::read(config)?;
+                    if let Some(display_bar_configurations) = &mut config.bar_configurations {
+                        for config_file_path in &mut *display_bar_configurations {
+                            let script = format!(
+                                r#"Start-Process "komorebi-bar" '"--config" "{}"' -WindowStyle hidden"#,
+                                config_file_path.to_string_lossy()
+                            );
 
-                        match powershell_script::run(&script) {
+                            match powershell_script::run(&script) {
+                                Ok(_) => {
+                                    println!("{script}");
+                                }
+                                Err(error) => {
+                                    println!("Error: {error}");
+                                }
+                            }
+                        }
+                    } else {
+                        let script = r"
+if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
+{
+  Start-Process komorebi-bar -WindowStyle hidden
+}
+                ";
+                        match powershell_script::run(script) {
                             Ok(_) => {
                                 println!("{script}");
                             }
@@ -2380,21 +2293,6 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                             }
                         }
                     }
-                } else {
-                    let script = r"
-if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
-{
-  Start-Process komorebi-bar -WindowStyle hidden
-}
-                ";
-                    match powershell_script::run(script) {
-                        Ok(_) => {
-                            println!("{script}");
-                        }
-                        Err(error) => {
-                            println!("Error: {error}");
-                        }
-                    }
                 }
             }
 
@@ -2417,28 +2315,18 @@ if (!(Get-Process masir -ErrorAction SilentlyContinue))
 
             println!("\nThank you for using komorebi!\n");
             println!("# Commercial Use License");
-            println!(
-                "* View licensing options https://lgug2z.com/software/komorebi - A commercial use license is required to use komorebi at work"
-            );
+            println!("* View licensing options https://lgug2z.com/software/komorebi - A commercial use license is required to use komorebi at work");
             println!("\n# Personal Use Sponsorship");
-            println!(
-                "* Become a sponsor https://github.com/sponsors/LGUG2Z - $5/month makes a big difference"
-            );
+            println!("* Become a sponsor https://github.com/sponsors/LGUG2Z - $5/month makes a big difference");
             println!("* Leave a tip https://ko-fi.com/lgug2z - An alternative to GitHub Sponsors");
             println!("\n# Community");
-            println!(
-                "* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops"
-            );
+            println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
             println!(
                 "* Subscribe to https://youtube.com/@LGUG2Z - Development videos, feature previews and release overviews"
             );
-            println!(
-                "* Explore the Awesome Komorebi list https://github.com/LGUG2Z/awesome-komorebi - Projects in the komorebi ecosystem"
-            );
+            println!("* Explore the Awesome Komorebi list https://github.com/LGUG2Z/awesome-komorebi - Projects in the komorebi ecosystem");
             println!("\n# Documentation");
-            println!(
-                "* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands"
-            );
+            println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");
 
             let bar_config = arg.config.or_else(|| {
                 let bar_json = HOME_DIR.join("komorebi.bar.json");
@@ -2477,9 +2365,7 @@ if (!(Get-Process masir -ErrorAction SilentlyContinue))
                 {
                     let trimmed = release.tag_name.trim_start_matches("v");
                     if trimmed > version {
-                        println!(
-                            "An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}"
-                        );
+                        println!("An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}");
                     }
                 }
             }
@@ -3126,9 +3012,7 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
 
             file.write_all(formatted_content.as_bytes())?;
 
-            println!(
-                "File successfully formatted for PRs to https://github.com/LGUG2Z/komorebi-application-specific-configuration"
-            );
+            println!("File successfully formatted for PRs to https://github.com/LGUG2Z/komorebi-application-specific-configuration");
         }
         SubCommand::FetchAppSpecificConfiguration => {
             let content = reqwest::blocking::get("https://raw.githubusercontent.com/LGUG2Z/komorebi-application-specific-configuration/master/applications.json")?
@@ -3144,12 +3028,10 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
 
             file.write_all(content.as_bytes())?;
 
+            println!("Latest version of applications.json from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n");
             println!(
-                "Latest version of applications.json from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n"
-            );
-            println!(
-                "You can add this to your komorebi.json static configuration file like this: \n\n\"app_specific_configuration_path\": \"{}\"",
-                output_file.display().to_string().replace("\\", "/")
+               "You can add this to your komorebi.json static configuration file like this: \n\n\"app_specific_configuration_path\": \"{}\"",
+               output_file.display().to_string().replace("\\", "/")
             );
         }
         SubCommand::ApplicationSpecificConfigurationSchema => {
@@ -3179,14 +3061,14 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
         SubCommand::StaticConfigSchema => {
             #[cfg(feature = "schemars")]
             {
-                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::<StaticConfig>();
+                let gen = settings.into_generator();
+                let socket_message = gen.into_root_schema_for::<StaticConfig>();
                 let schema = serde_json::to_string_pretty(&socket_message)?;
                 println!("{schema}");
             }

mkdocs.yml

@@ -158,7 +158,6 @@ nav:
       - cli/invisible-borders.md
       - cli/global-work-area-offset.md
       - cli/monitor-work-area-offset.md
-      - cli/workspace-work-area-offset.md
       - cli/toggle-window-based-work-area-offset.md
       - cli/focused-workspace-container-padding.md
       - cli/focused-workspace-padding.md
@@ -166,7 +165,6 @@ nav:
       - cli/adjust-workspace-padding.md
       - cli/change-layout.md
       - cli/cycle-layout.md
-      - cli/scrolling-layout-columns.md
       - cli/flip-layout.md
       - cli/promote.md
       - cli/promote-focus.md
@@ -255,4 +253,4 @@ nav:
       - cli/static-config-schema.md
       - cli/generate-static-config.md
       - cli/enable-autostart.md
-      - cli/disable-autostart.md
+      - cli/disable-autostart.md

schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "StaticConfig",
-  "description": "The `komorebi.json` static configuration file reference for `v0.1.39`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.37`",
   "type": "object",
   "properties": {
     "animation": {
@@ -1804,7 +1804,7 @@
                   ]
                 },
                 "layout_options": {
-                  "description": "Layout-specific options (default: None)",
+                  "description": "Layout-specific options(default: None)",
                   "type": "object",
                   "properties": {
                     "scrolling": {
@@ -1814,10 +1814,6 @@
                         "columns"
                       ],
                       "properties": {
-                        "center_focused_column": {
-                          "description": "With an odd number of visible columns, keep the focused window column centered",
-                          "type": "boolean"
-                        },
                         "columns": {
                           "description": "Desired number of visible columns (default: 3)",
                           "type": "integer",
@@ -1850,10 +1846,6 @@
                   "description": "Name",
                   "type": "string"
                 },
-                "tile": {
-                  "description": "Enable or disable tiling for the workspace (default: true)",
-                  "type": "boolean"
-                },
                 "wallpaper": {
                   "description": "Specify a wallpaper for this workspace",
                   "type": "object",
@@ -2146,38 +2138,6 @@
                     ]
                   }
                 },
-                "work_area_offset": {
-                  "description": "Workspace specific work area offset (default: None)",
-                  "type": "object",
-                  "required": [
-                    "bottom",
-                    "left",
-                    "right",
-                    "top"
-                  ],
-                  "properties": {
-                    "bottom": {
-                      "description": "The bottom point in a Win32 Rect",
-                      "type": "integer",
-                      "format": "int32"
-                    },
-                    "left": {
-                      "description": "The left point in a Win32 Rect",
-                      "type": "integer",
-                      "format": "int32"
-                    },
-                    "right": {
-                      "description": "The right point in a Win32 Rect",
-                      "type": "integer",
-                      "format": "int32"
-                    },
-                    "top": {
-                      "description": "The top point in a Win32 Rect",
-                      "type": "integer",
-                      "format": "int32"
-                    }
-                  }
-                },
                 "workspace_padding": {
                   "description": "Workspace padding (default: global)",
                   "type": "integer",