refactor(cargo): upgrade to rust edition 2024

Cargo.toml

@@ -71,4 +71,17 @@ features = [
     "Win32_System_WindowsProgramming",
     "Media",
     "Media_Control"
-]
+]
+
+[profile.dev-jeezy]
+inherits = "dev"
+debug = false
+opt-level = 1
+
+[profile.dev-jeezy.package."*"]
+opt-level = 3
+
+[profile.release-jeezy]
+inherits = "release"
+incremental = true
+codegen-units = 256

README.md

@@ -7,9 +7,9 @@ Tiling Window Management for Windows.
     <img alt="Tech for Palestine" src="https://badge.techforpalestine.org/default">
   </a>
   <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/LGUG2Z/komorebi/.github/workflows/windows.yaml">
+  <img alt="GitHub" src="https://img.shields.io/github/license/LGUG2Z/komorebi">
   <img alt="GitHub all releases" src="https://img.shields.io/github/downloads/LGUG2Z/komorebi/total">
   <img alt="GitHub commits since latest release (by date) for a branch" src="https://img.shields.io/github/commits-since/LGUG2Z/komorebi/latest">
-  <img alt="Active Individual Commercial Use Licenses" src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flgug2z-ecstaticmagentacheetah.web.val.run&query=%24.&label=active%20individual%20commercial%20use%20licenses&cacheSeconds=3600&link=https%3A%2F%2Flgug2z.com%2Fsoftware%2Fkomorebi">
   <a href="https://discord.gg/mGkn66PHkx">
     <img alt="Discord" src="https://img.shields.io/discord/898554690126630914">
   </a>

justfile

@@ -19,31 +19,22 @@ install-targets *targets:
     "{{ targets }}" -split ' ' | ForEach-Object { just install-target $_ }
 
 install-target target:
-    cargo +stable install --path {{ target }} --locked --no-default-features
-
-install-targets-with-jsonschema *targets:
-    "{{ targets }}" -split ' ' | ForEach-Object { just install-target-with-jsonschema $_ }
-
-install-target-with-jsonschema target:
     cargo +stable install --path {{ target }} --locked
 
 install:
     just install-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
-install-with-jsonschema:
-    just install-targets-with-jsonschema komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
-
 build-targets *targets:
     "{{ targets }}" -split ' ' | ForEach-Object { just build-target $_ }
 
 build-target target:
-    cargo +stable build --package {{ target }} --locked --release --no-default-features
+    cargo +stable build --package {{ target }} --locked --profile release-jeezy
 
 build:
     just build-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
 copy-target target:
-    cp .\target\release\{{ target }}.exe $Env:USERPROFILE\.cargo\bin
+    cp .\target\release-jeezy\{{ target }}.exe $Env:USERPROFILE\.cargo\bin
 
 copy-targets *targets:
     "{{ targets }}" -split ' ' | ForEach-Object { just copy-target $_ }
@@ -55,7 +46,7 @@ copy:
     just copy-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
 run target:
-    cargo +stable run --bin {{ target }} --locked --no-default-features
+    cargo +stable run --bin {{ target }} --locked
 
 warn target $RUST_LOG="warn":
     just run {{ target }}
@@ -70,7 +61,7 @@ trace target $RUST_LOG="trace":
     just run {{ target }}
 
 deadlock $RUST_LOG="trace":
-    cargo +stable run --bin komorebi --locked --no-default-features --features deadlock_detection
+    cargo +stable run --bin komorebi --locked --features deadlock_detection
 
 docgen:
     cargo run --package komorebic -- docgen

komorebi-bar/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "komorebi-bar"
 version = "0.1.35"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -26,7 +26,7 @@ num-derive = "0.4"
 num-traits = "0.2"
 random_word = { version = "0.4", features = ["en"] }
 reqwest = { version = "0.12", features = ["blocking"] }
-schemars = { workspace = true, optional = true }
+schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 starship-battery = "0.10"
@@ -35,8 +35,4 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 windows = { workspace = true }
 windows-core = { workspace = true }
-windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }
-
-[features]
-default = ["schemars"]
-schemars = ["dep:schemars"]
+windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }

komorebi-bar/src/bar.rs

@@ -1,9 +1,16 @@
-use crate::config::get_individual_spacing;
+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::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::komorebi::Komorebi;
 use crate::komorebi::KomorebiNotificationState;
 use crate::process_hwnd;
@@ -13,13 +20,6 @@ use crate::render::RenderConfig;
 use crate::render::RenderExt;
 use crate::widget::BarWidget;
 use crate::widget::WidgetConfig;
-use crate::KomorebiEvent;
-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;
@@ -47,16 +47,16 @@ use komorebi_client::KomorebiTheme;
 use komorebi_client::MonitorNotification;
 use komorebi_client::NotificationEvent;
 use komorebi_client::SocketMessage;
-use komorebi_themes::catppuccin_egui;
 use komorebi_themes::Base16Value;
 use komorebi_themes::Catppuccin;
 use komorebi_themes::CatppuccinValue;
+use komorebi_themes::catppuccin_egui;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 
 pub struct Komobar {
     pub hwnd: Option<isize>,
@@ -373,10 +373,14 @@ impl Komobar {
                 }
             }
         } 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...");
+            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;
         }
 
@@ -419,7 +423,9 @@ 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 {

komorebi-bar/src/battery.rs

@@ -2,23 +2,23 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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 schemars::JsonSchema;
 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;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct BatteryConfig {
     /// Enable the Battery widget
     pub enable: bool,

komorebi-bar/src/config.rs

@@ -1,18 +1,18 @@
+use crate::DEFAULT_PADDING;
 use crate::render::Grouping;
 use crate::widget::WidgetConfig;
-use crate::DEFAULT_PADDING;
 use eframe::egui::Pos2;
 use eframe::egui::TextBuffer;
 use eframe::egui::Vec2;
 use komorebi_client::KomorebiTheme;
 use komorebi_client::Rect;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::path::PathBuf;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 /// The `komorebi.bar.json` configuration file reference for `v0.1.35`
 pub struct KomobarConfig {
     /// Bar height (default: 50)
@@ -115,7 +115,9 @@ 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) {
@@ -136,8 +138,7 @@ impl KomobarConfig {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct PositionConfig {
     /// The desired starting position of the bar (0,0 = top left of the screen)
     #[serde(alias = "position")]
@@ -147,15 +148,13 @@ pub struct PositionConfig {
     pub end: Option<Position>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct FrameConfig {
     /// Margin inside the painted frame
     pub inner_margin: Position,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum MonitorConfigOrIndex {
     /// The monitor index where you want the bar to show
@@ -164,8 +163,7 @@ pub enum MonitorConfigOrIndex {
     MonitorConfig(MonitorConfig),
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct MonitorConfig {
     /// Komorebi monitor index of the monitor on which to render the bar
     pub index: usize,
@@ -176,8 +174,7 @@ pub struct MonitorConfig {
 pub type Padding = SpacingKind;
 pub type Margin = SpacingKind;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 // WARNING: To any developer messing with this code in the future: The order here matters!
 // `Grouped` needs to come last, otherwise serde might mistaken an `IndividualSpacingConfig` for a
@@ -228,23 +225,20 @@ impl SpacingKind {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GroupedSpacingConfig {
     pub vertical: Option<GroupedSpacingOptions>,
     pub horizontal: Option<GroupedSpacingOptions>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum GroupedSpacingOptions {
     Symmetrical(f32),
     Split(f32, f32),
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct IndividualSpacingConfig {
     pub top: f32,
     pub bottom: f32,
@@ -346,8 +340,7 @@ impl KomobarConfig {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct Position {
     /// X coordinate
     pub x: f32,
@@ -373,8 +366,7 @@ impl From<Position> for Pos2 {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "palette")]
 pub enum KomobarTheme {
     /// A theme from catppuccin-egui
@@ -410,8 +402,7 @@ impl From<KomorebiTheme> for KomobarTheme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum LabelPrefix {
     /// Show no prefix
     None,
@@ -423,8 +414,7 @@ pub enum LabelPrefix {
     IconAndText,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum DisplayFormat {
     /// Show only icon
     Icon,
@@ -440,8 +430,7 @@ pub enum DisplayFormat {
 
 macro_rules! extend_enum {
     ($existing_enum:ident, $new_enum:ident, { $($(#[$meta:meta])* $variant:ident),* $(,)? }) => {
-        #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
-        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+        #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize, schemars::JsonSchema, PartialEq)]
         pub enum $new_enum {
             // Add new variants
             $(
@@ -473,11 +462,12 @@ extend_enum!(DisplayFormat, WorkspacesDisplayFormat, {
 
 #[cfg(test)]
 mod tests {
+    use schemars::JsonSchema;
     use serde::Deserialize;
     use serde::Serialize;
     use serde_json::json;
 
-    #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
+    #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
     pub enum OriginalDisplayFormat {
         /// Show None Of The Things
         NoneOfTheThings,

komorebi-bar/src/cpu.rs

@@ -2,12 +2,13 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -16,8 +17,7 @@ use std::time::Instant;
 use sysinfo::RefreshKind;
 use sysinfo::System;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CpuConfig {
     /// Enable the Cpu widget
     pub enable: bool,

komorebi-bar/src/date.rs

@@ -2,19 +2,19 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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::WidgetText;
+use eframe::egui::text::LayoutJob;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 /// Custom format with additive modifiers for integer format specifiers
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CustomModifiers {
     /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
     format: String,
@@ -55,8 +55,7 @@ impl CustomModifiers {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct DateConfig {
     /// Enable the Date widget
     pub enable: bool,
@@ -76,8 +75,7 @@ impl From<DateConfig> for Date {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum DateFormat {
     /// Month/Date/Year format (09/08/24)
     MonthDateYear,

komorebi-bar/src/keyboard.rs

@@ -1,13 +1,14 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::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::WidgetText;
+use eframe::egui::text::LayoutJob;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::time::Duration;
@@ -22,8 +23,7 @@ use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 const DEFAULT_DATA_REFRESH_INTERVAL: u64 = 1;
 const ERROR_TEXT: &str = "Error";
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KeyboardConfig {
     /// Enable the Input widget
     pub enable: bool,

komorebi-bar/src/komorebi.rs

@@ -1,3 +1,6 @@
+use crate::ICON_CACHE;
+use crate::MAX_LABEL_WIDTH;
+use crate::MONITOR_INDEX;
 use crate::bar::apply_theme;
 use crate::config::DisplayFormat;
 use crate::config::KomobarTheme;
@@ -8,10 +11,6 @@ use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
 use crate::widget::BarWidget;
-use crate::ICON_CACHE;
-use crate::MAX_LABEL_WIDTH;
-use crate::MONITOR_INDEX;
-use eframe::egui::vec2;
 use eframe::egui::Color32;
 use eframe::egui::ColorImage;
 use eframe::egui::Context;
@@ -28,6 +27,7 @@ use eframe::egui::TextureHandle;
 use eframe::egui::TextureOptions;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
+use eframe::egui::vec2;
 use image::RgbaImage;
 use komorebi_client::Container;
 use komorebi_client::NotificationEvent;
@@ -37,6 +37,7 @@ use komorebi_client::SocketMessage;
 use komorebi_client::Window;
 use komorebi_client::Workspace;
 use komorebi_client::WorkspaceLayer;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::cell::RefCell;
@@ -46,8 +47,7 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiConfig {
     /// Configure the Workspaces widget
     pub workspaces: Option<KomorebiWorkspacesConfig>,
@@ -61,8 +61,7 @@ pub struct KomorebiConfig {
     pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiWorkspacesConfig {
     /// Enable the Komorebi Workspaces widget
     pub enable: bool,
@@ -72,8 +71,7 @@ pub struct KomorebiWorkspacesConfig {
     pub display: Option<WorkspacesDisplayFormat>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiLayoutConfig {
     /// Enable the Komorebi Layout widget
     pub enable: bool,
@@ -83,19 +81,13 @@ pub struct KomorebiLayoutConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiWorkspaceLayerConfig {
     /// Enable the Komorebi Workspace Layer widget
     pub enable: bool,
-    /// Display format of the current layer
-    pub display: Option<DisplayFormat>,
-    /// Show the widget event if the layer is Tiling
-    pub show_when_tiling: Option<bool>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiFocusedWindowConfig {
     /// Enable the Komorebi Focused Window widget
     pub enable: bool,
@@ -105,8 +97,7 @@ pub struct KomorebiFocusedWindowConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct KomorebiConfigurationSwitcherConfig {
     /// Enable the Komorebi Configurations widget
     pub enable: bool,
@@ -321,106 +312,29 @@ impl BarWidget for Komorebi {
                     .map(|(_, _, layer)| layer);
 
                 if let Some(layer) = layer {
-                    if (layer_config.show_when_tiling.unwrap_or_default()
-                        && matches!(layer, WorkspaceLayer::Tiling))
-                        || matches!(layer, WorkspaceLayer::Floating)
-                    {
-                        let display_format = layer_config.display.unwrap_or(DisplayFormat::Text);
-                        let size = Vec2::splat(config.icon_font_id.size);
-
-                        config.apply_on_widget(false, ui, |ui| {
-                            let layer_frame = SelectableFrame::new(false)
-                                .show(ui, |ui| {
-                                    if display_format != DisplayFormat::Text {
-                                        if matches!(layer, WorkspaceLayer::Tiling) {
-                                            let (response, painter) =
-                                                ui.allocate_painter(size, Sense::hover());
-                                            let color = ui.style().visuals.text_color();
-                                            let stroke = Stroke::new(1.0, color);
-                                            let mut rect = response.rect;
-                                            let corner =
-                                                CornerRadius::same((rect.width() * 0.1) as u8);
-                                            rect = rect.shrink(stroke.width);
-
-                                            // tiling
-                                            let mut rect_left = response.rect;
-                                            rect_left.set_width(rect.width() * 0.48);
-                                            rect_left.set_height(rect.height() * 0.98);
-                                            let mut rect_right = rect_left;
-                                            rect_left = rect_left.translate(Vec2::new(
-                                                rect.width() * 0.01 + stroke.width,
-                                                rect.width() * 0.01 + stroke.width,
-                                            ));
-                                            rect_right = rect_right.translate(Vec2::new(
-                                                rect.width() * 0.51 + stroke.width,
-                                                rect.width() * 0.01 + stroke.width,
-                                            ));
-                                            painter.rect_filled(rect_left, corner, color);
-                                            painter.rect_stroke(
-                                                rect_right,
-                                                corner,
-                                                stroke,
-                                                StrokeKind::Outside,
-                                            );
-                                        } else {
-                                            let (response, painter) =
-                                                ui.allocate_painter(size, Sense::hover());
-                                            let color = ui.style().visuals.text_color();
-                                            let stroke = Stroke::new(1.0, color);
-                                            let mut rect = response.rect;
-                                            let corner =
-                                                CornerRadius::same((rect.width() * 0.1) as u8);
-                                            rect = rect.shrink(stroke.width);
-
-                                            // floating
-                                            let mut rect_left = response.rect;
-                                            rect_left.set_width(rect.width() * 0.65);
-                                            rect_left.set_height(rect.height() * 0.65);
-                                            let mut rect_right = rect_left;
-                                            rect_left = rect_left.translate(Vec2::new(
-                                                rect.width() * 0.01 + stroke.width,
-                                                rect.width() * 0.01 + stroke.width,
-                                            ));
-                                            rect_right = rect_right.translate(Vec2::new(
-                                                rect.width() * 0.34 + stroke.width,
-                                                rect.width() * 0.34 + stroke.width,
-                                            ));
-                                            painter.rect_filled(rect_left, corner, color);
-                                            painter.rect_stroke(
-                                                rect_right,
-                                                corner,
-                                                stroke,
-                                                StrokeKind::Outside,
-                                            );
-                                        }
-                                    }
-
-                                    if display_format != DisplayFormat::Icon {
-                                        ui.add(Label::new(layer.to_string()).selectable(false));
-                                    }
-                                })
-                                .on_hover_text(layer.to_string());
-
-                            if layer_frame.clicked()
-                                && komorebi_client::send_batch([
-                                    SocketMessage::MouseFollowsFocus(false),
-                                    SocketMessage::ToggleWorkspaceLayer,
-                                    SocketMessage::MouseFollowsFocus(
-                                        komorebi_notification_state.mouse_follows_focus,
-                                    ),
-                                ])
-                                .is_err()
-                            {
-                                tracing::error!(
-                                    "could not send the following batch of messages to komorebi:\n\
-                                                MouseFollowsFocus(false),
-                                                ToggleWorkspaceLayer,
-                                                MouseFollowsFocus({})",
+                    let name = layer.to_string();
+                    config.apply_on_widget(false, ui, |ui| {
+                        if SelectableFrame::new(false)
+                            .show(ui, |ui| ui.add(Label::new(name).selectable(false)))
+                            .clicked()
+                            && komorebi_client::send_batch([
+                                SocketMessage::MouseFollowsFocus(false),
+                                SocketMessage::ToggleWorkspaceLayer,
+                                SocketMessage::MouseFollowsFocus(
                                     komorebi_notification_state.mouse_follows_focus,
-                                );
-                            }
-                        });
-                    }
+                                ),
+                            ])
+                            .is_err()
+                        {
+                            tracing::error!(
+                                "could not send the following batch of messages to komorebi:\n\
+                                            MouseFollowsFocus(false),
+                                            ToggleWorkspaceLayer,
+                                            MouseFollowsFocus({})",
+                                komorebi_notification_state.mouse_follows_focus,
+                            );
+                        }
+                    });
                 }
             }
         }
@@ -685,9 +599,13 @@ impl KomorebiNotificationState {
                                 grouping,
                                 render_config,
                             );
-                            tracing::info!("removed theme from updated komorebi.json and applied default theme");
+                            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");
+                            tracing::warn!(
+                                "theme was removed from updated komorebi.json but there was no default theme to apply"
+                            );
                         }
                     }
                 }

komorebi-bar/src/komorebi_layout.rs

@@ -2,7 +2,6 @@ use crate::config::DisplayFormat;
 use crate::komorebi::KomorebiLayoutConfig;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use eframe::egui::vec2;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
 use eframe::egui::FontId;
@@ -13,17 +12,18 @@ 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 schemars::JsonSchema;
 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;
 
-#[derive(Copy, Clone, Debug, Serialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, JsonSchema, PartialEq)]
 #[serde(untagged)]
 pub enum KomorebiLayout {
     Default(komorebi_client::DefaultLayout),

komorebi-bar/src/main.rs

@@ -30,23 +30,24 @@ use hotwatch::Hotwatch;
 use image::RgbaImage;
 use komorebi_client::SocketMessage;
 use komorebi_client::SubscribeOptions;
+use schemars::r#gen::SchemaSettings;
 use std::collections::HashMap;
 use std::io::BufReader;
 use std::io::Read;
 use std::path::PathBuf;
+use std::sync::LazyLock;
+use std::sync::Mutex;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
-use std::sync::LazyLock;
-use std::sync::Mutex;
 use std::time::Duration;
 use tracing_subscriber::EnvFilter;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::System::Threading::GetCurrentProcessId;
 use windows::Win32::System::Threading::GetCurrentThreadId;
-use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
 use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
+use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
 use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 use windows_core::BOOL;
@@ -124,16 +125,15 @@ fn main() -> color_eyre::Result<()> {
 
     let opts: Opts = Opts::parse();
 
-    #[cfg(feature = "schemars")]
     if opts.schema {
-        let settings = schemars::gen::SchemaSettings::default().with(|s| {
+        let settings = SchemaSettings::default().with(|s| {
             s.option_nullable = false;
             s.option_add_null_type = false;
             s.inline_subschemas = true;
         });
 
-        let gen = settings.into_generator();
-        let socket_message = gen.into_root_schema_for::<KomobarConfig>();
+        let r#gen = settings.into_generator();
+        let socket_message = r#gen.into_root_schema_for::<KomobarConfig>();
         let schema = serde_json::to_string_pretty(&socket_message)?;
 
         println!("{schema}");
@@ -149,13 +149,15 @@ fn main() -> color_eyre::Result<()> {
     }
 
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        std::env::set_var("RUST_LIB_BACKTRACE", "1");
+        // TODO: Audit that the environment access only happens in single-threaded code.
+        unsafe { std::env::set_var("RUST_LIB_BACKTRACE", "1") };
     }
 
     color_eyre::install()?;
 
     if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
+        // TODO: Audit that the environment access only happens in single-threaded code.
+        unsafe { std::env::set_var("RUST_LOG", "info") };
     }
 
     tracing::subscriber::set_global_default(
@@ -349,7 +351,7 @@ fn main() -> color_eyre::Result<()> {
 
             let ctx_komorebi = cc.egui_ctx.clone();
             std::thread::spawn(move || {
-                let subscriber_name = format!("komorebi-bar-{}", random_word::gen(random_word::Lang::En));
+                let subscriber_name = format!("komorebi-bar-{}", random_word::r#gen(random_word::Lang::En));
 
                 let listener = komorebi_client::subscribe_with_options(&subscriber_name, SubscribeOptions {
                     filter_state_changes: true,

komorebi-bar/src/media.rs

@@ -1,22 +1,22 @@
+use crate::MAX_LABEL_WIDTH;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
 use crate::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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::sync::atomic::Ordering;
 use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct MediaConfig {
     /// Enable the Media widget
     pub enable: bool,

komorebi-bar/src/memory.rs

@@ -2,12 +2,13 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -16,8 +17,7 @@ use std::time::Instant;
 use sysinfo::RefreshKind;
 use sysinfo::System;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct MemoryConfig {
     /// Enable the Memory widget
     pub enable: bool,

komorebi-bar/src/network.rs

@@ -2,13 +2,14 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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 num_derive::FromPrimitive;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::fmt;
@@ -17,8 +18,7 @@ use std::time::Duration;
 use std::time::Instant;
 use sysinfo::Networks;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct NetworkConfig {
     /// Enable the Network widget
     pub enable: bool,

komorebi-bar/src/render.rs

@@ -11,16 +11,16 @@ use eframe::egui::Margin;
 use eframe::egui::Shadow;
 use eframe::egui::TextStyle;
 use eframe::egui::Ui;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
+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);
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "kind")]
 pub enum Grouping {
     /// No grouping is applied
@@ -339,8 +339,7 @@ impl RenderConfig {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GroupingConfig {
     /// Styles for the grouping
     pub style: Option<GroupingStyle>,
@@ -350,8 +349,7 @@ pub struct GroupingConfig {
     pub rounding: Option<RoundingConfig>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum GroupingStyle {
     #[serde(alias = "CtByte")]
     Default,
@@ -371,8 +369,7 @@ pub enum GroupingStyle {
     DefaultWithGlowB0O1S2,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum RoundingConfig {
     /// All 4 corners are the same    

komorebi-bar/src/selected_frame.rs

@@ -1,10 +1,8 @@
-use eframe::egui::Color32;
 use eframe::egui::CursorIcon;
 use eframe::egui::Frame;
 use eframe::egui::Margin;
 use eframe::egui::Response;
 use eframe::egui::Sense;
-use eframe::egui::Stroke;
 use eframe::egui::Ui;
 
 /// Same as SelectableLabel, but supports all content
@@ -25,34 +23,26 @@ impl SelectableFrame {
                 let response = ui.interact(ui.max_rect(), ui.unique_id(), Sense::click());
 
                 if ui.is_rect_visible(response.rect) {
-                    // take into account the stroke width
                     let inner_margin = Margin::symmetric(
-                        ui.style().spacing.button_padding.x as i8 - 1,
-                        ui.style().spacing.button_padding.y as i8 - 1,
+                        ui.style().spacing.button_padding.x as i8,
+                        ui.style().spacing.button_padding.y as i8,
                     );
 
-                    // since the stroke is drawn inside the frame, we always reserve space for it
-                    if response.hovered() || response.highlighted() || response.has_focus() {
+                    if selected
+                        || response.hovered()
+                        || response.highlighted()
+                        || response.has_focus()
+                    {
                         let visuals = ui.style().interact_selectable(&response, selected);
 
                         Frame::NONE
-                            .stroke(Stroke::new(1.0, visuals.bg_stroke.color))
-                            .corner_radius(visuals.corner_radius)
-                            .fill(visuals.bg_fill)
-                            .inner_margin(inner_margin)
-                            .show(ui, add_contents);
-                    } else if selected {
-                        let visuals = ui.style().interact_selectable(&response, selected);
-
-                        Frame::NONE
-                            .stroke(Stroke::new(1.0, visuals.bg_fill))
+                            .stroke(visuals.bg_stroke)
                             .corner_radius(visuals.corner_radius)
                             .fill(visuals.bg_fill)
                             .inner_margin(inner_margin)
                             .show(ui, add_contents);
                     } else {
                         Frame::NONE
-                            .stroke(Stroke::new(1.0, Color32::TRANSPARENT))
                             .inner_margin(inner_margin)
                             .show(ui, add_contents);
                     }

komorebi-bar/src/storage.rs

@@ -2,12 +2,13 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -15,8 +16,7 @@ use std::time::Duration;
 use std::time::Instant;
 use sysinfo::Disks;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct StorageConfig {
     /// Enable the Storage widget
     pub enable: bool,

komorebi-bar/src/time.rs

@@ -3,7 +3,6 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
-use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
@@ -13,12 +12,13 @@ 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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct TimeConfig {
     /// Enable the Time widget
     pub enable: bool,
@@ -38,8 +38,7 @@ impl From<TimeConfig> for Time {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum TimeFormat {
     /// Twelve-hour format (with seconds)
     TwelveHour,

komorebi-bar/src/update.rs

@@ -2,20 +2,20 @@ use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
 use std::time::Duration;
 use std::time::Instant;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct UpdateConfig {
     /// Enable the Update widget
     pub enable: bool,

komorebi-bar/src/widget.rs

@@ -23,6 +23,7 @@ use crate::update::Update;
 use crate::update::UpdateConfig;
 use eframe::egui::Context;
 use eframe::egui::Ui;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -30,8 +31,7 @@ pub trait BarWidget {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig);
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum WidgetConfig {
     Battery(BatteryConfig),
     Cpu(CpuConfig),

komorebi-client/Cargo.toml

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

komorebi-client/src/lib.rs

@@ -1,8 +1,27 @@
 #![warn(clippy::all)]
 #![allow(clippy::missing_errors_doc)]
 
-pub use komorebi::animation::prefix::AnimationPrefix;
+pub use komorebi::AnimationsConfig;
+pub use komorebi::AspectRatio;
+pub use komorebi::BorderColours;
+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::RuleDebug;
+pub use komorebi::StackbarConfig;
+pub use komorebi::State;
+pub use komorebi::StaticConfig;
+pub use komorebi::SubscribeOptions;
+pub use komorebi::TabsConfig;
+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::asc::ApplicationSpecificConfiguration;
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;
@@ -12,8 +31,6 @@ 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::resolve_home_path;
 pub use komorebi::core::AnimationStyle;
 pub use komorebi::core::ApplicationIdentifier;
 pub use komorebi::core::Arrangement;
@@ -42,6 +59,8 @@ 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::resolve_home_path;
 pub use komorebi::monitor::Monitor;
 pub use komorebi::monitor_reconciliator::MonitorNotification;
 pub use komorebi::ring::Ring;
@@ -50,25 +69,6 @@ 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::AspectRatio;
-pub use komorebi::BorderColours;
-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::RuleDebug;
-pub use komorebi::StackbarConfig;
-pub use komorebi::State;
-pub use komorebi::StaticConfig;
-pub use komorebi::SubscribeOptions;
-pub use komorebi::TabsConfig;
-pub use komorebi::WindowContainerBehaviour;
-pub use komorebi::WindowsApi;
-pub use komorebi::WorkspaceConfig;
 
 use komorebi::DATA_DIR;
 

komorebi-gui/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "komorebi-gui"
 version = "0.1.35"
-edition = "2021"
+edition = "2024"
 
 # 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;
@@ -101,7 +101,7 @@ impl From<&komorebi_client::Workspace> for WorkspaceConfig {
         let name = value
             .name()
             .to_owned()
-            .unwrap_or_else(|| random_word::gen(random_word::Lang::En).to_string());
+            .unwrap_or_else(|| random_word::r#gen(random_word::Lang::En).to_string());
 
         Self {
             layout,
@@ -248,10 +248,11 @@ impl eframe::App for KomorebiGui {
                     ui.collapsing("Window Rules", |ui| {
                         let window = Window::from(self.debug_hwnd);
 
-                        let label = if let (Ok(title), Ok(exe)) = (window.title(), window.exe()) {
-                            format!("{title} ({exe})")
-                        } else {
-                            String::from("Select a Window")
+                        let label = match (window.title(), window.exe()) {
+                            (Ok(title), Ok(exe)) => {
+                                format!("{title} ({exe})")
+                            }
+                            _ => String::from("Select a Window"),
                         };
 
                         if ui.button("Refresh Windows").clicked() {

komorebi-themes/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "komorebi-themes"
 version = "0.1.35"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "96f26c88d83781f234d42222293ec73d23a39ad8" }

komorebi/Cargo.toml

@@ -3,7 +3,7 @@ name = "komorebi"
 version = "0.1.35"
 description = "A tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -29,7 +29,7 @@ os_info = "3.10"
 parking_lot = "0.12"
 paste = { workspace = true }
 regex = "1"
-schemars = { workspace = true, optional = true }
+schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }
@@ -57,6 +57,4 @@ shadow-rs = { workspace = true }
 reqwest = { version = "0.12", features = ["blocking"] }
 
 [features]
-default = ["schemars"]
 deadlock_detection = ["parking_lot/deadlock_detection"]
-schemars = ["dep:schemars"]

komorebi/src/animation/animation_manager.rs

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

komorebi/src/animation/engine.rs

@@ -1,18 +1,19 @@
 use color_eyre::Result;
 
+use schemars::JsonSchema;
+
 use serde::Deserialize;
 use serde::Serialize;
 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))]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct AnimationEngine;
 
 impl AnimationEngine {

komorebi/src/animation/lerp.rs

@@ -1,5 +1,5 @@
-use crate::core::Rect;
 use crate::AnimationStyle;
+use crate::core::Rect;
 
 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;
 
@@ -18,12 +18,11 @@ pub mod prefix;
 pub mod render_dispatcher;
 pub use render_dispatcher::RenderDispatcher;
 pub mod style;
-
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(untagged)]
 pub enum PerAnimationPrefixConfig<T> {
     Prefix(HashMap<AnimationPrefix, T>),

komorebi/src/animation/prefix.rs

@@ -1,14 +1,24 @@
 use clap::ValueEnum;
-
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
 #[derive(
-    Copy, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Display, EnumString, ValueEnum,
+    Copy,
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum AnimationPrefix {

komorebi/src/border_manager/border.rs

@@ -1,37 +1,34 @@
-use crate::border_manager::window_kind_colour;
-use crate::border_manager::RenderTarget;
-use crate::border_manager::WindowKind;
+use crate::WINDOWS_11;
+use crate::WindowsApi;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::FOCUS_STATE;
 use crate::border_manager::RENDER_TARGETS;
+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 color_eyre::eyre::anyhow;
 use std::collections::HashMap;
 use std::ops::Deref;
-use std::sync::atomic::Ordering;
-use std::sync::mpsc;
 use std::sync::LazyLock;
 use std::sync::OnceLock;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc;
 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;
@@ -40,28 +37,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::Dwm::DwmEnableBlurBehindWindow;
+use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
+use windows::Win32::Graphics::Direct2D::ID2D1Factory;
+use windows::Win32::Graphics::Direct2D::ID2D1SolidColorBrush;
 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::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetSystemMetrics;
-use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
-use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
-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::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::GetSystemMetrics;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
 use windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN;
+use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
+use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::WM_CREATE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;

komorebi/src/border_manager/mod.rs

@@ -1,35 +1,36 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
 mod border;
+use crate::Colour;
+use crate::Rgb;
+use crate::WindowManager;
+use crate::WindowsApi;
 use crate::core::BorderImplementation;
 use crate::core::BorderStyle;
 use crate::core::WindowKind;
 use crate::ring::Ring;
 use crate::workspace::WorkspaceLayer;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::Colour;
-use crate::Rgb;
-use crate::WindowManager;
-use crate::WindowsApi;
-use border::border_hwnds;
 pub use border::Border;
+use border::border_hwnds;
 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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::collections::hash_map::Entry;
 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::Graphics::Direct2D::ID2D1HwndRenderTarget;
 
@@ -145,13 +146,15 @@ 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);
+                }
             }
         }
     });
@@ -347,14 +350,17 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let border = match borders.entry(monocle.id().clone()) {
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
-                                    if let Ok(border) = Border::create(
+                                    match Border::create(
                                         monocle.id(),
                                         monocle.focused_window().copied().unwrap_or_default().hwnd,
                                     ) {
-                                        new_border = true;
-                                        entry.insert(border)
-                                    } else {
-                                        continue 'monitors;
+                                        Ok(border) => {
+                                            new_border = true;
+                                            entry.insert(border)
+                                        }
+                                        _ => {
+                                            continue 'monitors;
+                                        }
                                     }
                                 }
                             };
@@ -482,12 +488,14 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let border = match borders.entry(c.id().clone()) {
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
-                                    if let Ok(border) = Border::create(c.id(), focused_window_hwnd)
-                                    {
-                                        new_border = true;
-                                        entry.insert(border)
-                                    } else {
-                                        continue 'monitors;
+                                    match Border::create(c.id(), focused_window_hwnd) {
+                                        Ok(border) => {
+                                            new_border = true;
+                                            entry.insert(border)
+                                        }
+                                        _ => {
+                                            continue 'monitors;
+                                        }
                                     }
                                 }
                             };
@@ -514,31 +522,34 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             // tracking the correct window.
                             if border.tracking_hwnd != focused_window_hwnd {
                                 // Create new border
-                                if let Ok(b) = Border::create(
+                                match Border::create(
                                     c.id(),
                                     c.focused_window().copied().unwrap_or_default().hwnd,
                                 ) {
-                                    // Destroy previously stacked border window and remove its hwnd
-                                    // and tracking_hwnd.
-                                    border.destroy()?;
-                                    focus_state.remove(&border.hwnd);
-                                    if let Some(previous) =
-                                        windows_borders.get(&border.tracking_hwnd)
-                                    {
-                                        // Only remove the border from `windows_borders` if it
-                                        // still is the same border, if it isn't then it means it
-                                        // was already updated by another border for that window
-                                        // and in that case we don't want to remove it.
-                                        if previous.hwnd == border.hwnd {
-                                            windows_borders.remove(&border.tracking_hwnd);
+                                    Ok(b) => {
+                                        // Destroy previously stacked border window and remove its hwnd
+                                        // and tracking_hwnd.
+                                        border.destroy()?;
+                                        focus_state.remove(&border.hwnd);
+                                        if let Some(previous) =
+                                            windows_borders.get(&border.tracking_hwnd)
+                                        {
+                                            // Only remove the border from `windows_borders` if it
+                                            // still is the same border, if it isn't then it means it
+                                            // was already updated by another border for that window
+                                            // and in that case we don't want to remove it.
+                                            if previous.hwnd == border.hwnd {
+                                                windows_borders.remove(&border.tracking_hwnd);
+                                            }
                                         }
-                                    }
 
-                                    // Replace with new border
-                                    new_border = true;
-                                    *border = b;
-                                } else {
-                                    continue 'monitors;
+                                        // Replace with new border
+                                        new_border = true;
+                                        *border = b;
+                                    }
+                                    _ => {
+                                        continue 'monitors;
+                                    }
                                 }
                             }
 
@@ -590,13 +601,15 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 let border = match borders.entry(window.hwnd.to_string()) {
                                     Entry::Occupied(entry) => entry.into_mut(),
                                     Entry::Vacant(entry) => {
-                                        if let Ok(border) =
-                                            Border::create(&window.hwnd.to_string(), window.hwnd)
+                                        match Border::create(&window.hwnd.to_string(), window.hwnd)
                                         {
-                                            new_border = true;
-                                            entry.insert(border)
-                                        } else {
-                                            continue 'monitors;
+                                            Ok(border) => {
+                                                new_border = true;
+                                                entry.insert(border)
+                                            }
+                                            _ => {
+                                                continue 'monitors;
+                                            }
                                         }
                                     }
                                 };
@@ -697,8 +710,7 @@ fn remove_border(
     Ok(())
 }
 
-#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ZOrder {
     Top,
     NoTopMost,

komorebi/src/colour.rs

@@ -1,19 +1,14 @@
 use hex_color::HexColor;
 use komorebi_themes::Color32;
-#[cfg(feature = "schemars")]
-use schemars::gen::SchemaGenerator;
-#[cfg(feature = "schemars")]
+use schemars::JsonSchema;
+use schemars::r#gen::SchemaGenerator;
 use schemars::schema::InstanceType;
-#[cfg(feature = "schemars")]
 use schemars::schema::Schema;
-#[cfg(feature = "schemars")]
 use schemars::schema::SchemaObject;
-
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(untagged)]
 pub enum Colour {
     /// Colour represented as RGB
@@ -59,8 +54,7 @@ impl From<Colour> for Color32 {
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Hex(HexColor);
 
-#[cfg(feature = "schemars")]
-impl schemars::JsonSchema for Hex {
+impl JsonSchema for Hex {
     fn schema_name() -> String {
         String::from("Hex")
     }
@@ -84,8 +78,7 @@ impl From<Colour> for u32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct Rgb {
     /// Red
     pub r: u32,

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
     })
 }
 
-#[no_mangle]
+#[unsafe(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

@@ -2,14 +2,14 @@ use std::collections::VecDeque;
 
 use getset::Getters;
 use nanoid::nanoid;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::ring::Ring;
 use crate::window::Window;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters, JsonSchema)]
 pub struct Container {
     #[getset(get = "pub")]
     id: String,

komorebi/src/core/animation.rs

@@ -1,12 +1,22 @@
 use clap::ValueEnum;
-
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
+)]
 pub enum AnimationStyle {
     Linear,
     EaseInSine,

komorebi/src/core/arrangement.rs

@@ -1,17 +1,18 @@
 use std::num::NonZeroUsize;
 
 use clap::ValueEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::custom_layout::Column;
-use super::custom_layout::ColumnSplit;
-use super::custom_layout::ColumnSplitWithCapacity;
 use super::CustomLayout;
 use super::DefaultLayout;
 use super::Rect;
+use super::custom_layout::Column;
+use super::custom_layout::ColumnSplit;
+use super::custom_layout::ColumnSplitWithCapacity;
 
 pub trait Arrangement {
     fn calculate(
@@ -602,8 +603,18 @@ impl Arrangement for CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
+)]
 pub enum Axis {
     Horizontal,
     Vertical,

komorebi/src/core/asc.rs

@@ -2,6 +2,7 @@ use crate::config_generation::ApplicationConfiguration;
 use crate::config_generation::ApplicationOptions;
 use crate::config_generation::MatchingRule;
 use color_eyre::Result;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -9,12 +10,10 @@ use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::PathBuf;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ApplicationSpecificConfiguration(pub BTreeMap<String, AscApplicationRulesOrSchema>);
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum AscApplicationRulesOrSchema {
     AscApplicationRules(AscApplicationRules),
@@ -47,8 +46,7 @@ impl ApplicationSpecificConfiguration {
 }
 
 /// Rules that determine how an application is handled
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct AscApplicationRules {
     /// Rules to ignore specific windows
     #[serde(skip_serializing_if = "Option::is_none")]

komorebi/src/core/config_generation.rs

@@ -1,5 +1,6 @@
 use clap::ValueEnum;
 use color_eyre::Result;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -7,8 +8,9 @@ use strum::EnumString;
 
 use super::ApplicationIdentifier;
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+)]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum ApplicationOptions {
@@ -50,16 +52,14 @@ impl ApplicationOptions {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum MatchingRule {
     Simple(IdWithIdentifier),
     Composite(Vec<IdWithIdentifier>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct WorkspaceMatchingRule {
     pub monitor_index: usize,
     pub workspace_index: usize,
@@ -67,8 +67,7 @@ pub struct WorkspaceMatchingRule {
     pub initial_only: bool,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct IdWithIdentifier {
     pub kind: ApplicationIdentifier,
     pub id: String,
@@ -76,8 +75,7 @@ pub struct IdWithIdentifier {
     pub matching_strategy: Option<MatchingStrategy>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display, JsonSchema)]
 pub enum MatchingStrategy {
     Legacy,
     Equals,
@@ -91,8 +89,7 @@ pub enum MatchingStrategy {
     DoesNotContain,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct IdWithIdentifierAndComment {
     pub kind: ApplicationIdentifier,
     pub id: String,
@@ -112,8 +109,7 @@ impl From<IdWithIdentifierAndComment> for IdWithIdentifier {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ApplicationConfiguration {
     pub name: String,
     pub identifier: IdWithIdentifier,
@@ -137,8 +133,7 @@ impl ApplicationConfiguration {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ApplicationConfigurationGenerator;
 
 impl ApplicationConfigurationGenerator {

komorebi/src/core/custom_layout.rs

@@ -5,16 +5,16 @@ use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::Path;
 
+use color_eyre::Result;
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
-use color_eyre::Result;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::Rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct CustomLayout(Vec<Column>);
 
 impl Deref for CustomLayout {
@@ -250,8 +250,7 @@ impl CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(tag = "column", content = "configuration")]
 pub enum Column {
     Primary(Option<ColumnWidth>),
@@ -259,21 +258,18 @@ pub enum Column {
     Tertiary(ColumnSplit),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ColumnWidth {
     WidthPercentage(f32),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ColumnSplit {
     Horizontal,
     Vertical,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ColumnSplitWithCapacity {
     Horizontal(usize),
     Vertical(usize),

komorebi/src/core/cycle_direction.rs

@@ -1,13 +1,15 @@
 use std::num::NonZeroUsize;
 
 use clap::ValueEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+)]
 pub enum CycleDirection {
     Previous,
     Next,

komorebi/src/core/default_layout.rs

@@ -1,4 +1,5 @@
 use clap::ValueEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -9,9 +10,18 @@ use super::Rect;
 use super::Sizing;
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Eq, PartialEq, Display, EnumString, ValueEnum,
+    Clone,
+    Copy,
+    Debug,
+    Serialize,
+    Deserialize,
+    Eq,
+    PartialEq,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum DefaultLayout {
     BSP,
     Columns,

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(

komorebi/src/core/layout.rs

@@ -1,3 +1,4 @@
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -6,8 +7,7 @@ use super::CustomLayout;
 use super::DefaultLayout;
 use super::Direction;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum Layout {
     Default(DefaultLayout),
     Custom(CustomLayout),

komorebi/src/core/mod.rs

@@ -6,15 +6,16 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use clap::ValueEnum;
-use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use color_eyre::eyre::anyhow;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use crate::animation::prefix::AnimationPrefix;
 use crate::KomorebiTheme;
+use crate::animation::prefix::AnimationPrefix;
 pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
@@ -44,8 +45,7 @@ pub mod operation_direction;
 pub mod pathext;
 pub mod rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, Display, JsonSchema)]
 #[serde(tag = "type", content = "content")]
 pub enum SocketMessage {
     // Window / Container Commands
@@ -241,23 +241,24 @@ impl FromStr for SocketMessage {
     }
 }
 
-#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct SubscribeOptions {
     /// Only emit notifications when the window manager state has changed
     pub filter_state_changes: bool,
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema, ValueEnum,
+)]
 pub enum StackbarMode {
     Always,
     Never,
     OnStack,
 }
 
-#[derive(Debug, Copy, Default, Clone, Eq, PartialEq, Display, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Debug, Copy, Default, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
+)]
 pub enum StackbarLabel {
     #[default]
     Process,
@@ -265,9 +266,18 @@ pub enum StackbarLabel {
 }
 
 #[derive(
-    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, ValueEnum,
+    Default,
+    Copy,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Display,
+    Serialize,
+    Deserialize,
+    JsonSchema,
+    ValueEnum,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum BorderStyle {
     #[default]
     /// Use the system border style
@@ -279,9 +289,18 @@ pub enum BorderStyle {
 }
 
 #[derive(
-    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, ValueEnum,
+    Default,
+    Copy,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Display,
+    Serialize,
+    Deserialize,
+    JsonSchema,
+    ValueEnum,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum BorderImplementation {
     #[default]
     /// Use the adjustable komorebi border implementation
@@ -291,9 +310,19 @@ pub enum BorderImplementation {
 }
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq, Eq, Hash,
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
+    Eq,
+    Hash,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum WindowKind {
     Single,
     Stack,
@@ -302,8 +331,9 @@ pub enum WindowKind {
     Floating,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+)]
 pub enum StateQuery {
     FocusedMonitorIndex,
     FocusedWorkspaceIndex,
@@ -313,9 +343,18 @@ pub enum StateQuery {
 }
 
 #[derive(
-    Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum,
+    Copy,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ApplicationIdentifier {
     #[serde(alias = "exe")]
     Exe,
@@ -327,8 +366,18 @@ pub enum ApplicationIdentifier {
     Path,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+)]
 pub enum FocusFollowsMouseImplementation {
     /// A custom FFM implementation (slightly more CPU-intensive)
     Komorebi,
@@ -336,8 +385,7 @@ pub enum FocusFollowsMouseImplementation {
     Windows,
 }
 
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct WindowManagementBehaviour {
     /// The current WindowContainerBehaviour to be used
     pub current_behaviour: WindowContainerBehaviour,
@@ -348,9 +396,18 @@ pub struct WindowManagementBehaviour {
 }
 
 #[derive(
-    Clone, Copy, Debug, Default, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq,
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum WindowContainerBehaviour {
     /// Create a new container for each new window
     #[default]
@@ -359,8 +416,18 @@ pub enum WindowContainerBehaviour {
     Append,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+)]
 pub enum MoveBehaviour {
     /// Swap the window container with the window container at the edge of the adjacent monitor
     Swap,
@@ -370,8 +437,18 @@ pub enum MoveBehaviour {
     NoOp,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
+)]
 pub enum CrossBoundaryBehaviour {
     /// Attempt to perform actions across a workspace boundary
     Workspace,
@@ -379,8 +456,18 @@ pub enum CrossBoundaryBehaviour {
     Monitor,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
+)]
 pub enum HidingBehaviour {
     /// Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)
     Hide,
@@ -390,8 +477,18 @@ pub enum HidingBehaviour {
     Cloak,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+)]
 pub enum OperationBehaviour {
     /// Process komorebic commands on temporarily unmanaged/floated windows
     Op,
@@ -399,8 +496,9 @@ pub enum OperationBehaviour {
     NoOp,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+)]
 pub enum Sizing {
     Increase,
     Decrease,

komorebi/src/core/operation_direction.rs

@@ -1,16 +1,18 @@
 use std::num::NonZeroUsize;
 
 use clap::ValueEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::direction::Direction;
 use super::Axis;
+use super::direction::Direction;
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+)]
 pub enum OperationDirection {
     Left,
     Right,

komorebi/src/core/rect.rs

@@ -1,9 +1,9 @@
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use windows::Win32::Foundation::RECT;
 
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq, JsonSchema)]
 pub struct Rect {
     /// The left point in a Win32 Rect
     pub left: i32,

komorebi/src/focus_manager.rs

@@ -44,13 +44,15 @@ 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

@@ -40,12 +40,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 colour::*;
 pub use core::*;
@@ -66,12 +66,13 @@ use color_eyre::Result;
 use os_info::Version;
 use parking_lot::Mutex;
 use regex::Regex;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use uds_windows::UnixStream;
 use which::which;
-use winreg::enums::HKEY_CURRENT_USER;
 use winreg::RegKey;
+use winreg::enums::HKEY_CURRENT_USER;
 
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
@@ -279,8 +280,7 @@ pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     current
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(untagged)]
 pub enum NotificationEvent {
     WindowManager(WindowManagerEvent),
@@ -288,8 +288,7 @@ pub enum NotificationEvent {
     Monitor(MonitorNotification),
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct Notification {
     pub event: NotificationEvent,
     pub state: State,

komorebi/src/main.rs

@@ -10,27 +10,32 @@
 use std::env::temp_dir;
 use std::net::Shutdown;
 use std::path::PathBuf;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 #[cfg(feature = "deadlock_detection")]
 use std::time::Duration;
 
 use clap::Parser;
 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 parking_lot::Mutex;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
-use parking_lot::Mutex;
 use sysinfo::Process;
 use sysinfo::ProcessesToUpdate;
 use tracing_appender::non_blocking::WorkerGuard;
-use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
+use tracing_subscriber::layer::SubscriberExt;
 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;
@@ -49,23 +54,20 @@ use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
 use komorebi::workspace_reconciliator;
-use komorebi::CUSTOM_FFM;
-use komorebi::DATA_DIR;
-use komorebi::HOME_DIR;
-use komorebi::INITIAL_CONFIGURATION_LOADED;
-use komorebi::SESSION_ID;
 
 shadow_rs::shadow!(build);
 
 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        std::env::set_var("RUST_LIB_BACKTRACE", "1");
+        // TODO: Audit that the environment access only happens in single-threaded code.
+        unsafe { std::env::set_var("RUST_LIB_BACKTRACE", "1") };
     }
 
     color_eyre::install()?;
 
     if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
+        // TODO: Audit that the environment access only happens in single-threaded code.
+        unsafe { std::env::set_var("RUST_LOG", "info") };
     }
 
     let appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi_plaintext.log");
@@ -124,20 +126,22 @@ fn setup() -> 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());
+                }
             }
         }
     });
@@ -192,7 +196,9 @@ fn main() -> Result<()> {
         }
 
         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,32 +2,41 @@ use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::sync::atomic::Ordering;
 
+use color_eyre::Result;
 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 schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::core::Rect;
 
-use crate::container::Container;
-use crate::ring::Ring;
-use crate::workspace::Workspace;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::DefaultLayout;
 use crate::Layout;
 use crate::OperationDirection;
 use crate::WindowsApi;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::DEFAULT_WORKSPACE_PADDING;
+use crate::container::Container;
+use crate::ring::Ring;
+use crate::workspace::Workspace;
 
 #[derive(
-    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, PartialEq,
+    Debug,
+    Clone,
+    Serialize,
+    Deserialize,
+    Getters,
+    CopyGetters,
+    MutGetters,
+    Setters,
+    JsonSchema,
+    PartialEq,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
     pub id: isize,

komorebi/src/monitor_reconciliator/hidden.rs

@@ -1,7 +1,6 @@
 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;
@@ -11,10 +10,6 @@ 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;
@@ -23,6 +18,9 @@ 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;
@@ -30,6 +28,7 @@ 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;
@@ -38,10 +37,11 @@ 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,14 +224,18 @@ 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,
@@ -251,7 +255,8 @@ 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(
@@ -265,8 +270,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,5 +1,11 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
+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;
@@ -7,28 +13,22 @@ 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::WORKSPACE_MATCHING_RULES;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
 
 pub mod hidden;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type", content = "content")]
 pub enum MonitorNotification {
     ResolutionScalingChanged,
@@ -112,16 +112,18 @@ 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()) {
-            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()) {
+                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)
+                    }
                 }
             }
         }
@@ -461,7 +463,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 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

komorebi/src/process_command.rs

@@ -1,8 +1,3 @@
-use color_eyre::eyre::anyhow;
-use color_eyre::Result;
-use miow::pipe::connect;
-use net2::TcpStreamExt;
-use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::fs::File;
 use std::fs::OpenOptions;
@@ -13,17 +8,22 @@ use std::net::TcpListener;
 use std::net::TcpStream;
 use std::num::NonZeroUsize;
 use std::str::FromStr;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
+
+use color_eyre::Result;
+use color_eyre::eyre::anyhow;
+use miow::pipe::connect;
+use net2::TcpStreamExt;
+use parking_lot::Mutex;
+use schemars::r#gen::SchemaSettings;
+use schemars::schema_for;
 use uds_windows::UnixStream;
 
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
 use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
-use crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
 use crate::core::ApplicationIdentifier;
 use crate::core::Axis;
 use crate::core::BorderImplementation;
@@ -37,7 +37,34 @@ use crate::core::SocketMessage;
 use crate::core::StateQuery;
 use crate::core::WindowContainerBehaviour;
 use crate::core::WindowKind;
+use crate::core::config_generation::ApplicationConfiguration;
+use crate::core::config_generation::IdWithIdentifier;
+use crate::core::config_generation::MatchingRule;
+use crate::core::config_generation::MatchingStrategy;
 
+use crate::CUSTOM_FFM;
+use crate::DATA_DIR;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::GlobalState;
+use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
+use crate::INITIAL_CONFIGURATION_LOADED;
+use crate::LAYERED_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;
+use crate::MONITOR_INDEX_PREFERENCES;
+use crate::NO_TITLEBAR;
+use crate::Notification;
+use crate::NotificationEvent;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::REMOVE_TITLEBARS;
+use crate::SUBSCRIPTION_PIPES;
+use crate::SUBSCRIPTION_SOCKET_OPTIONS;
+use crate::SUBSCRIPTION_SOCKETS;
+use crate::State;
+use crate::TCP_CONNECTIONS;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WINDOWS_11;
+use crate::WORKSPACE_MATCHING_RULES;
 use crate::animation::ANIMATION_DURATION_GLOBAL;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
 use crate::animation::ANIMATION_FPS;
@@ -64,29 +91,6 @@ use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
 use crate::workspace::WorkspaceLayer;
 use crate::workspace::WorkspaceWindowLocation;
-use crate::GlobalState;
-use crate::Notification;
-use crate::NotificationEvent;
-use crate::State;
-use crate::CUSTOM_FFM;
-use crate::DATA_DIR;
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::HIDING_BEHAVIOUR;
-use crate::IGNORE_IDENTIFIERS;
-use crate::INITIAL_CONFIGURATION_LOADED;
-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::REMOVE_TITLEBARS;
-use crate::SUBSCRIPTION_PIPES;
-use crate::SUBSCRIPTION_SOCKETS;
-use crate::SUBSCRIPTION_SOCKET_OPTIONS;
-use crate::TCP_CONNECTIONS;
-use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WINDOWS_11;
-use crate::WORKSPACE_MATCHING_RULES;
 use stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use stackbar_manager::STACKBAR_LABEL;
 use stackbar_manager::STACKBAR_MODE;
@@ -97,42 +101,44 @@ use stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 
 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        let wm = wm.clone();
+    std::thread::spawn(move || {
+        loop {
+            let wm = wm.clone();
 
-        let _ = std::thread::spawn(move || {
-            let listener = wm
-                .lock()
-                .command_listener
-                .try_clone()
-                .expect("could not clone unix listener");
+            let _ = std::thread::spawn(move || {
+                let listener = wm
+                    .lock()
+                    .command_listener
+                    .try_clone()
+                    .expect("could not clone unix listener");
 
-            tracing::info!("listening on komorebi.sock");
-            for client in listener.incoming() {
-                match client {
-                    Ok(stream) => {
-                        let wm_clone = wm.clone();
-                        std::thread::spawn(move || {
-                            match stream.set_read_timeout(Some(Duration::from_secs(1))) {
-                                Ok(()) => {}
-                                Err(error) => tracing::error!("{}", error),
-                            }
-                            match read_commands_uds(&wm_clone, stream) {
-                                Ok(()) => {}
-                                Err(error) => tracing::error!("{}", error),
-                            }
-                        });
-                    }
-                    Err(error) => {
-                        tracing::error!("{}", error);
-                        break;
+                tracing::info!("listening on komorebi.sock");
+                for client in listener.incoming() {
+                    match client {
+                        Ok(stream) => {
+                            let wm_clone = wm.clone();
+                            std::thread::spawn(move || {
+                                match stream.set_read_timeout(Some(Duration::from_secs(1))) {
+                                    Ok(()) => {}
+                                    Err(error) => tracing::error!("{}", error),
+                                }
+                                match read_commands_uds(&wm_clone, stream) {
+                                    Ok(()) => {}
+                                    Err(error) => tracing::error!("{}", error),
+                                }
+                            });
+                        }
+                        Err(error) => {
+                            tracing::error!("{}", error);
+                            break;
+                        }
                     }
                 }
-            }
-        })
-        .join();
+            })
+            .join();
 
-        tracing::error!("restarting failed thread");
+            tracing::error!("restarting failed thread");
+        }
     });
 }
 
@@ -1210,7 +1216,7 @@ impl WindowManager {
                 let container_len = workspace.containers().len();
                 let no_layout_rules = workspace.layout_rules().is_empty();
 
-                if let Layout::Custom(ref mut custom) = workspace.layout_mut() {
+                if let Layout::Custom(custom) = workspace.layout_mut() {
                     if matches!(axis, Axis::Horizontal) {
                         #[allow(clippy::cast_precision_loss)]
                         let percentage = custom
@@ -1372,7 +1378,9 @@ impl WindowManager {
                                     self.focus_follows_mouse = None;
                                 }
                                 Some(FocusFollowsMouseImplementation::Windows) => {
-                                    tracing::warn!("ignoring command that could mix different focus follows mouse implementations");
+                                    tracing::warn!(
+                                        "ignoring command that could mix different focus follows mouse implementations"
+                                    );
                                 }
                             }
                         }
@@ -1396,7 +1404,9 @@ impl WindowManager {
                                     self.focus_follows_mouse = None;
                                 }
                                 Some(FocusFollowsMouseImplementation::Komorebi) => {
-                                    tracing::warn!("ignoring command that could mix different focus follows mouse implementations");
+                                    tracing::warn!(
+                                        "ignoring command that could mix different focus follows mouse implementations"
+                                    );
                                 }
                             }
                         }
@@ -1529,7 +1539,7 @@ impl WindowManager {
                     !workspace.apply_window_based_work_area_offset(),
                 );
 
-                self.retile_all(true)?;
+                self.retile_all(false)?;
             }
             SocketMessage::QuickSave => {
                 let workspace = self.focused_workspace()?;
@@ -1638,33 +1648,41 @@ impl WindowManager {
             }
             SocketMessage::ToggleWorkspaceWindowContainerBehaviour => {
                 let current_global_behaviour = self.window_management_behaviour.current_behaviour;
-                if let Some(behaviour) = self
+                match self
                     .focused_workspace_mut()?
                     .window_container_behaviour_mut()
                 {
-                    match behaviour {
+                    Some(behaviour) => match behaviour {
                         WindowContainerBehaviour::Create => {
                             *behaviour = WindowContainerBehaviour::Append
                         }
                         WindowContainerBehaviour::Append => {
                             *behaviour = WindowContainerBehaviour::Create
                         }
+                    },
+                    _ => {
+                        self.focused_workspace_mut()?
+                            .set_window_container_behaviour(Some(match current_global_behaviour {
+                                WindowContainerBehaviour::Create => {
+                                    WindowContainerBehaviour::Append
+                                }
+                                WindowContainerBehaviour::Append => {
+                                    WindowContainerBehaviour::Create
+                                }
+                            }));
                     }
-                } else {
-                    self.focused_workspace_mut()?
-                        .set_window_container_behaviour(Some(match current_global_behaviour {
-                            WindowContainerBehaviour::Create => WindowContainerBehaviour::Append,
-                            WindowContainerBehaviour::Append => WindowContainerBehaviour::Create,
-                        }));
                 };
             }
             SocketMessage::ToggleWorkspaceFloatOverride => {
                 let current_global_override = self.window_management_behaviour.float_override;
-                if let Some(float_override) = self.focused_workspace_mut()?.float_override_mut() {
-                    *float_override = !*float_override;
-                } else {
-                    self.focused_workspace_mut()?
-                        .set_float_override(Some(!current_global_override));
+                match self.focused_workspace_mut()?.float_override_mut() {
+                    Some(float_override) => {
+                        *float_override = !*float_override;
+                    }
+                    _ => {
+                        self.focused_workspace_mut()?
+                            .set_float_override(Some(!current_global_override));
+                    }
                 };
             }
             SocketMessage::WindowHidingBehaviour(behaviour) => {
@@ -1824,49 +1842,35 @@ impl WindowManager {
                 *STACKBAR_FONT_FAMILY.lock() = font_family.clone();
             }
             SocketMessage::ApplicationSpecificConfigurationSchema => {
-                #[cfg(feature = "schemars")]
-                {
-                    let asc = schemars::schema_for!(
-                        Vec<crate::core::config_generation::ApplicationConfiguration>
-                    );
-                    let schema = serde_json::to_string_pretty(&asc)?;
+                let asc = schema_for!(Vec<ApplicationConfiguration>);
+                let schema = serde_json::to_string_pretty(&asc)?;
 
-                    reply.write_all(schema.as_bytes())?;
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::NotificationSchema => {
-                #[cfg(feature = "schemars")]
-                {
-                    let notification = schemars::schema_for!(Notification);
-                    let schema = serde_json::to_string_pretty(&notification)?;
+                let notification = schema_for!(Notification);
+                let schema = serde_json::to_string_pretty(&notification)?;
 
-                    reply.write_all(schema.as_bytes())?;
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::SocketSchema => {
-                #[cfg(feature = "schemars")]
-                {
-                    let socket_message = schemars::schema_for!(SocketMessage);
-                    let schema = serde_json::to_string_pretty(&socket_message)?;
+                let socket_message = schema_for!(SocketMessage);
+                let schema = serde_json::to_string_pretty(&socket_message)?;
 
-                    reply.write_all(schema.as_bytes())?;
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::StaticConfigSchema => {
-                #[cfg(feature = "schemars")]
-                {
-                    let settings = schemars::gen::SchemaSettings::default().with(|s| {
-                        s.option_nullable = false;
-                        s.option_add_null_type = false;
-                        s.inline_subschemas = true;
-                    });
+                let settings = SchemaSettings::default().with(|s| {
+                    s.option_nullable = false;
+                    s.option_add_null_type = false;
+                    s.inline_subschemas = true;
+                });
 
-                    let gen = settings.into_generator();
-                    let socket_message = gen.into_root_schema_for::<StaticConfig>();
-                    let schema = serde_json::to_string_pretty(&socket_message)?;
+                let r#gen = settings.into_generator();
+                let socket_message = r#gen.into_root_schema_for::<StaticConfig>();
+                let schema = serde_json::to_string_pretty(&socket_message)?;
 
-                    reply.write_all(schema.as_bytes())?;
-                }
+                reply.write_all(schema.as_bytes())?;
             }
             SocketMessage::GenerateStaticConfig => {
                 let config = serde_json::to_string_pretty(&StaticConfig::from(&*self))?;

komorebi/src/process_event.rs

@@ -1,10 +1,10 @@
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 use std::time::Instant;
 
-use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use color_eyre::eyre::anyhow;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
 
@@ -13,6 +13,13 @@ use crate::core::Rect;
 use crate::core::Sizing;
 use crate::core::WindowContainerBehaviour;
 
+use crate::FLOATING_APPLICATIONS;
+use crate::HIDDEN_HWNDS;
+use crate::Notification;
+use crate::NotificationEvent;
+use crate::REGEX_IDENTIFIERS;
+use crate::State;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::border_manager;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
@@ -20,8 +27,8 @@ use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
 use crate::transparency_manager;
-use crate::window::should_act;
 use crate::window::RuleDebug;
+use crate::window::should_act;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -30,13 +37,6 @@ use crate::workspace::WorkspaceLayer;
 use crate::workspace_reconciliator;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
-use crate::Notification;
-use crate::NotificationEvent;
-use crate::State;
-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>>) {
@@ -661,7 +661,7 @@ impl WindowManager {
                         let mut ops = vec![];
 
                         macro_rules! resize_op {
-                            ($coordinate:expr, $comparator:tt, $direction:expr) => {{
+                            ($coordinate:expr_2021, $comparator:tt, $direction:expr_2021) => {{
                                 let adjusted = $coordinate * 2;
                                 let sizing = if adjusted $comparator 0 {
                                     Sizing::Decrease

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,13 +1,13 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
-use crate::border_manager;
-use crate::notify_subscribers;
-use crate::winevent::WinEvent;
+use crate::DATA_DIR;
 use crate::NotificationEvent;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowManagerEvent;
-use crate::DATA_DIR;
+use crate::border_manager;
+use crate::notify_subscribers;
+use crate::winevent::WinEvent;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
@@ -53,13 +53,15 @@ 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);
+                }
             }
         }
     });
@@ -148,16 +150,18 @@ 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

@@ -1,10 +1,10 @@
 use std::collections::VecDeque;
 
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct Ring<T> {
     elements: VecDeque<T>,
     focused: usize,

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::hash_map::Entry;
 use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+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;
 
 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
@@ -71,13 +71,15 @@ 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);
+                }
             }
         }
     });
@@ -193,13 +195,12 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // Get the stackbar entry for this container from the map or create one
                     let stackbar = match stackbars.entry(container.id().clone()) {
                         Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(stackbar) = Stackbar::create(container.id()) {
-                                entry.insert(stackbar)
-                            } else {
+                        Entry::Vacant(entry) => match Stackbar::create(container.id()) {
+                            Ok(stackbar) => entry.insert(stackbar),
+                            _ => {
                                 continue 'receiver;
                             }
-                        }
+                        },
                     };
 
                     stackbars_monitors.insert(container.id().clone(), monitor_idx);

komorebi/src/stackbar_manager/stackbar.rs

@@ -1,3 +1,6 @@
+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;
@@ -5,7 +8,6 @@ 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;
@@ -14,16 +16,13 @@ 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;
@@ -33,38 +32,38 @@ 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::LWA_COLORKEY;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
 use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
-use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_LBUTTONDOWN;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
@@ -72,6 +71,7 @@ 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 {
@@ -342,10 +342,10 @@ impl Stackbar {
                                         window.set_position(&focused_window_rect, false)
                                     {
                                         tracing::error!(
-                                        "stackbar WM_LBUTTONDOWN repositioning error: hwnd {} ({})",
-                                        *window,
-                                        err
-                                    );
+                                            "stackbar WM_LBUTTONDOWN repositioning error: hwnd {} ({})",
+                                            *window,
+                                            err
+                                        );
                                     }
                                 }
 

komorebi/src/static_config.rs

@@ -1,4 +1,28 @@
-use crate::animation::PerAnimationPrefixConfig;
+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::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::PredefinedAspectRatio;
+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::WORKSPACE_MATCHING_RULES;
 use crate::animation::ANIMATION_DURATION_GLOBAL;
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
@@ -7,35 +31,15 @@ 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::asc::ApplicationSpecificConfiguration;
-use crate::asc::AscApplicationRulesOrSchema;
+use crate::animation::PerAnimationPrefixConfig;
 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::colour::Colour;
-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::resolve_home_path;
-use crate::core::AnimationStyle;
 use crate::core::BorderImplementation;
-use crate::core::BorderStyle;
-use crate::core::DefaultLayout;
-use crate::core::FocusFollowsMouseImplementation;
-use crate::core::HidingBehaviour;
-use crate::core::Layout;
-use crate::core::MoveBehaviour;
-use crate::core::OperationBehaviour;
-use crate::core::Rect;
-use crate::core::SocketMessage;
 use crate::core::StackbarLabel;
 use crate::core::StackbarMode;
-use crate::core::WindowContainerBehaviour;
-use crate::core::WindowManagementBehaviour;
 use crate::current_virtual_desktop;
 use crate::monitor;
 use crate::monitor::Monitor;
@@ -57,37 +61,35 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
-use crate::AspectRatio;
-use crate::Axis;
-use crate::CrossBoundaryBehaviour;
-use crate::PredefinedAspectRatio;
-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::WORKSPACE_MATCHING_RULES;
+
+use crate::asc::ApplicationSpecificConfiguration;
+use crate::asc::AscApplicationRulesOrSchema;
+use crate::config_generation::WorkspaceMatchingRule;
+use crate::core::AnimationStyle;
+use crate::core::BorderStyle;
+use crate::core::DefaultLayout;
+use crate::core::FocusFollowsMouseImplementation;
+use crate::core::HidingBehaviour;
+use crate::core::Layout;
+use crate::core::MoveBehaviour;
+use crate::core::OperationBehaviour;
+use crate::core::Rect;
+use crate::core::SocketMessage;
+use crate::core::WindowContainerBehaviour;
+use 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::core::resolve_home_path;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
 use parking_lot::Mutex;
 use regex::Regex;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
@@ -95,13 +97,12 @@ use std::collections::HashSet;
 use std::io::ErrorKind;
 use std::io::Write;
 use std::path::PathBuf;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct BorderColours {
     /// Border colour when the container contains a single window
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -120,8 +121,7 @@ pub struct BorderColours {
     pub unfocused: Option<Colour>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct WorkspaceConfig {
     /// Name
     pub name: String,
@@ -243,8 +243,7 @@ impl From<&Workspace> for WorkspaceConfig {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct MonitorConfig {
     /// Workspace configurations
     pub workspaces: Vec<WorkspaceConfig>,
@@ -302,8 +301,7 @@ impl From<&Monitor> for MonitorConfig {
     }
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
 /// The `komorebi.json` static configuration file reference for `v0.1.35`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
@@ -451,8 +449,7 @@ pub struct StaticConfig {
     pub floating_window_aspect_ratio: Option<AspectRatio>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct AnimationsConfig {
     /// Enable or disable animations (default: false)
     pub enabled: PerAnimationPrefixConfig<bool>,
@@ -467,8 +464,7 @@ pub struct AnimationsConfig {
     pub fps: Option<u64>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(tag = "palette")]
 pub enum KomorebiTheme {
     /// A theme from catppuccin-egui
@@ -559,7 +555,9 @@ 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"
+            )
         }
     }
 
@@ -584,7 +582,9 @@ 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) {
@@ -618,8 +618,7 @@ impl StaticConfig {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct TabsConfig {
     /// Width of a stackbar tab
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -641,8 +640,7 @@ pub struct TabsConfig {
     pub font_size: Option<i32>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct StackbarConfig {
     /// Stackbar height
     #[serde(skip_serializing_if = "Option::is_none")]

komorebi/src/theme_manager.rs

@@ -1,18 +1,18 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
+use crate::Colour;
+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::Colour;
-use crate::KomorebiTheme;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
 use std::ops::Deref;
-use std::sync::atomic::Ordering;
 use std::sync::OnceLock;
+use std::sync::atomic::Ordering;
 
 pub struct Notification(KomorebiTheme);
 
@@ -50,13 +50,15 @@ 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::atomic::AtomicBool;
-use std::sync::atomic::AtomicU8;
 use std::sync::Arc;
 use std::sync::OnceLock;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicU8;
 
-use crate::should_act;
+use crate::REGEX_IDENTIFIERS;
+use crate::TRANSPARENCY_BLACKLIST;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowsApi;
-use crate::REGEX_IDENTIFIERS;
-use crate::TRANSPARENCY_BLACKLIST;
+use crate::should_act;
 
 pub static TRANSPARENCY_ENABLED: AtomicBool = AtomicBool::new(false);
 pub static TRANSPARENCY_ALPHA: AtomicU8 = AtomicU8::new(200);
@@ -49,13 +49,15 @@ 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);
+                }
             }
         }
     });
@@ -175,7 +177,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     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,8 +1,7 @@
-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::AnimationStyle;
+use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
+use crate::SLOW_APPLICATION_COMPENSATION_TIME;
+use crate::SLOW_APPLICATION_IDENTIFIERS;
 use crate::animation::ANIMATION_DURATION_GLOBAL;
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
@@ -10,43 +9,15 @@ 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::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;
-use crate::HIDDEN_HWNDS;
-use crate::HIDING_BEHAVIOUR;
-use crate::IGNORE_IDENTIFIERS;
-use crate::LAYERED_WHITELIST;
-use crate::MANAGE_IDENTIFIERS;
-use crate::NO_TITLEBAR;
-use crate::PERMAIGNORE_CLASSES;
-use crate::REGEX_IDENTIFIERS;
-use crate::SLOW_APPLICATION_COMPENSATION_TIME;
-use crate::SLOW_APPLICATION_IDENTIFIERS;
-use crate::WSL2_UI_PROCESSES;
-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 std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
@@ -56,15 +27,47 @@ use std::sync::atomic::AtomicI32;
 use std::sync::atomic::Ordering;
 use std::thread;
 use std::time::Duration;
+
+use crate::core::config_generation::IdWithIdentifier;
+use crate::core::config_generation::MatchingRule;
+use crate::core::config_generation::MatchingStrategy;
+use color_eyre::Result;
+use color_eyre::eyre;
+use crossbeam_utils::atomic::AtomicConsume;
+use regex::Regex;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use serde::Serializer;
+use serde::ser::SerializeStruct;
 use strum::Display;
 use strum::EnumString;
 use windows::Win32::Foundation::HWND;
 
+use crate::core::ApplicationIdentifier;
+use crate::core::HidingBehaviour;
+use crate::core::Rect;
+
+use crate::FLOATING_APPLICATIONS;
+use crate::HIDDEN_HWNDS;
+use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
+use crate::LAYERED_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;
+use crate::NO_TITLEBAR;
+use crate::PERMAIGNORE_CLASSES;
+use crate::REGEX_IDENTIFIERS;
+use crate::WSL2_UI_PROCESSES;
+use crate::styles::ExtendedWindowStyle;
+use crate::styles::WindowStyle;
+use crate::transparency_manager;
+use crate::window_manager_event::WindowManagerEvent;
+use crate::windows_api::WindowsApi;
+
 pub static MINIMUM_WIDTH: AtomicI32 = AtomicI32::new(0);
 pub static MINIMUM_HEIGHT: AtomicI32 = AtomicI32::new(0);
 
-#[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema, PartialEq)]
 pub struct Window {
     pub hwnd: isize,
 }
@@ -84,8 +87,7 @@ impl From<HWND> for Window {
 }
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, Clone, Serialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Clone, Serialize, JsonSchema)]
 pub struct WindowDetails {
     pub title: String,
     pub exe: String,
@@ -297,8 +299,9 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
     }
 }
 
-#[derive(Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
+)]
 #[serde(untagged)]
 pub enum AspectRatio {
     /// A predefined aspect ratio
@@ -313,8 +316,9 @@ impl Default for AspectRatio {
     }
 }
 
-#[derive(Copy, Clone, Debug, Default, Display, EnumString, Serialize, Deserialize, PartialEq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(
+    Copy, Clone, Debug, Default, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
+)]
 pub enum PredefinedAspectRatio {
     /// 21:9
     Ultrawide,
@@ -882,7 +886,7 @@ fn window_is_eligible(
     let regex_identifiers = REGEX_IDENTIFIERS.lock();
 
     let ignore_identifiers = IGNORE_IDENTIFIERS.lock();
-    let should_ignore = if let Some(rule) = should_act(
+    let should_ignore = match should_act(
         title,
         exe_name,
         class,
@@ -890,14 +894,15 @@ fn window_is_eligible(
         &ignore_identifiers,
         &regex_identifiers,
     ) {
-        debug.matches_ignore_identifier = Some(rule);
-        true
-    } else {
-        false
+        Some(rule) => {
+            debug.matches_ignore_identifier = Some(rule);
+            true
+        }
+        _ => false,
     };
 
     let manage_identifiers = MANAGE_IDENTIFIERS.lock();
-    let managed_override = if let Some(rule) = should_act(
+    let managed_override = match should_act(
         title,
         exe_name,
         class,
@@ -905,10 +910,11 @@ fn window_is_eligible(
         &manage_identifiers,
         &regex_identifiers,
     ) {
-        debug.matches_managed_override = Some(rule);
-        true
-    } else {
-        false
+        Some(rule) => {
+            debug.matches_managed_override = Some(rule);
+            true
+        }
+        _ => false,
     };
 
     let floating_identifiers = FLOATING_APPLICATIONS.lock();
@@ -928,7 +934,7 @@ fn window_is_eligible(
     }
 
     let layered_whitelist = LAYERED_WHITELIST.lock();
-    let mut allow_layered = if let Some(rule) = should_act(
+    let mut allow_layered = match should_act(
         title,
         exe_name,
         class,
@@ -936,10 +942,11 @@ fn window_is_eligible(
         &layered_whitelist,
         &regex_identifiers,
     ) {
-        debug.matches_layered_whitelist = Some(rule);
-        true
-    } else {
-        false
+        Some(rule) => {
+            debug.matches_layered_whitelist = Some(rule);
+            true
+        }
+        _ => false,
     };
 
     let known_layered_hwnds = transparency_manager::known_hwnds();
@@ -966,7 +973,7 @@ fn window_is_eligible(
     };
 
     let titlebars_removed = NO_TITLEBAR.lock();
-    let allow_titlebar_removed = if let Some(rule) = should_act(
+    let allow_titlebar_removed = match should_act(
         title,
         exe_name,
         class,
@@ -974,10 +981,11 @@ fn window_is_eligible(
         &titlebars_removed,
         &regex_identifiers,
     ) {
-        debug.matches_no_titlebar = Some(rule);
-        true
-    } else {
-        false
+        Some(rule) => {
+            debug.matches_no_titlebar = Some(rule);
+            true
+        }
+        _ => false,
     };
 
     {

komorebi/src/window_manager.rs

@@ -8,27 +8,26 @@ use std::net::Shutdown;
 use std::num::NonZeroUsize;
 use std::path::Path;
 use std::path::PathBuf;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use std::sync::atomic::Ordering;
 
+use color_eyre::Result;
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
-use color_eyre::Result;
 use crossbeam_channel::Receiver;
-use hotwatch::notify::ErrorKind as NotifyErrorKind;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
+use hotwatch::notify::ErrorKind as NotifyErrorKind;
 use parking_lot::Mutex;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
-use crate::animation::AnimationEngine;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
 use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
-use crate::core::config_generation::MatchingRule;
-use crate::core::custom_layout::CustomLayout;
+use crate::animation::AnimationEngine;
 use crate::core::Arrangement;
 use crate::core::Axis;
 use crate::core::BorderImplementation;
@@ -46,7 +45,30 @@ use crate::core::Sizing;
 use crate::core::StackbarLabel;
 use crate::core::WindowContainerBehaviour;
 use crate::core::WindowManagementBehaviour;
+use crate::core::config_generation::MatchingRule;
+use crate::core::custom_layout::CustomLayout;
 
+use crate::BorderColours;
+use crate::CUSTOM_FFM;
+use crate::Colour;
+use crate::CrossBoundaryBehaviour;
+use crate::DATA_DIR;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::HIDING_BEHAVIOUR;
+use crate::HOME_DIR;
+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::REGEX_IDENTIFIERS;
+use crate::REMOVE_TITLEBARS;
+use crate::Rgb;
+use crate::SUBSCRIPTION_SOCKETS;
+use crate::TRANSPARENCY_BLACKLIST;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WORKSPACE_MATCHING_RULES;
 use crate::border_manager;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
@@ -77,27 +99,6 @@ use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
 use crate::workspace::Workspace;
 use crate::workspace::WorkspaceLayer;
-use crate::BorderColours;
-use crate::Colour;
-use crate::CrossBoundaryBehaviour;
-use crate::Rgb;
-use crate::CUSTOM_FFM;
-use crate::DATA_DIR;
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::HIDING_BEHAVIOUR;
-use crate::HOME_DIR;
-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::REGEX_IDENTIFIERS;
-use crate::REMOVE_TITLEBARS;
-use crate::SUBSCRIPTION_SOCKETS;
-use crate::TRANSPARENCY_BLACKLIST;
-use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WORKSPACE_MATCHING_RULES;
 
 #[derive(Debug)]
 pub struct WindowManager {
@@ -125,8 +126,7 @@ pub struct WindowManager {
 }
 
 #[allow(clippy::struct_excessive_bools)]
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct State {
     pub monitors: Ring<Monitor>,
     pub monitor_usr_idx_map: HashMap<usize, usize>,
@@ -191,8 +191,7 @@ impl State {
 }
 
 #[allow(clippy::struct_excessive_bools)]
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GlobalState {
     pub border_enabled: bool,
     pub border_colours: BorderColours,
@@ -1318,32 +1317,41 @@ impl WindowManager {
             .update_focused_workspace(offset)?;
 
         if follow_focus {
-            if let Some(window) = self.focused_workspace()?.maximized_window() {
-                if trigger_focus {
-                    window.focus(self.mouse_follows_focus)?;
-                }
-            } else if let Some(container) = self.focused_workspace()?.monocle_container() {
-                if let Some(window) = container.focused_window() {
+            match self.focused_workspace()?.maximized_window() {
+                Some(window) => {
                     if trigger_focus {
                         window.focus(self.mouse_follows_focus)?;
                     }
                 }
-            } else if let Ok(window) = self.focused_window_mut() {
-                if trigger_focus {
-                    window.focus(self.mouse_follows_focus)?;
-                }
-            } else {
-                let desktop_window = Window::from(WindowsApi::desktop_window()?);
-
-                let rect = self.focused_monitor_size()?;
-                WindowsApi::center_cursor_in_rect(&rect)?;
-
-                match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
-                    Ok(()) => {}
-                    Err(error) => {
-                        tracing::warn!("{} {}:{}", error, file!(), line!());
+                _ => match self.focused_workspace()?.monocle_container() {
+                    Some(container) => {
+                        if let Some(window) = container.focused_window() {
+                            if trigger_focus {
+                                window.focus(self.mouse_follows_focus)?;
+                            }
+                        }
                     }
-                }
+                    _ => match self.focused_window_mut() {
+                        Ok(window) => {
+                            if trigger_focus {
+                                window.focus(self.mouse_follows_focus)?;
+                            }
+                        }
+                        _ => {
+                            let desktop_window = Window::from(WindowsApi::desktop_window()?);
+
+                            let rect = self.focused_monitor_size()?;
+                            WindowsApi::center_cursor_in_rect(&rect)?;
+
+                            match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
+                                Ok(()) => {}
+                                Err(error) => {
+                                    tracing::warn!("{} {}:{}", error, file!(), line!());
+                                }
+                            }
+                        }
+                    },
+                },
             }
         } else {
             if self.focused_workspace()?.is_empty() {
@@ -2512,12 +2520,10 @@ impl WindowManager {
 
         tracing::info!("cycling container windows");
 
-        let container =
-            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
-                container
-            } else {
-                self.focused_container_mut()?
-            };
+        let container = match self.focused_workspace_mut()?.monocle_container_mut() {
+            Some(container) => container,
+            _ => self.focused_container_mut()?,
+        };
 
         let len = NonZeroUsize::new(container.windows().len())
             .ok_or_else(|| anyhow!("there must be at least one window in a container"))?;
@@ -2544,12 +2550,10 @@ impl WindowManager {
 
         tracing::info!("cycling container window index");
 
-        let container =
-            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
-                container
-            } else {
-                self.focused_container_mut()?
-            };
+        let container = match self.focused_workspace_mut()?.monocle_container_mut() {
+            Some(container) => container,
+            _ => self.focused_container_mut()?,
+        };
 
         let len = NonZeroUsize::new(container.windows().len())
             .ok_or_else(|| anyhow!("there must be at least one window in a container"))?;
@@ -2574,12 +2578,10 @@ impl WindowManager {
 
         tracing::info!("focusing container window at index {idx}");
 
-        let container =
-            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
-                container
-            } else {
-                self.focused_container_mut()?
-            };
+        let container = match self.focused_workspace_mut()?.monocle_container_mut() {
+            Some(container) => container,
+            _ => self.focused_container_mut()?,
+        };
 
         let len = NonZeroUsize::new(container.windows().len())
             .ok_or_else(|| anyhow!("there must be at least one window in a container"))?;

komorebi/src/window_manager_event.rs

@@ -1,18 +1,18 @@
 use std::fmt::Display;
 use std::fmt::Formatter;
 
+use schemars::JsonSchema;
 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))]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type", content = "content")]
 pub enum WindowManagerEvent {
     Destroy(WinEvent, Window),

komorebi/src/windows_api.rs

@@ -4,15 +4,12 @@ use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::mem::size_of;
 
+use color_eyre::Result;
+use color_eyre::eyre::Error;
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
-use color_eyre::eyre::Error;
-use color_eyre::Result;
-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::CloseHandle;
 use windows::Win32::Foundation::HANDLE;
 use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HMODULE;
@@ -21,8 +18,9 @@ use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
-use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use windows::Win32::Graphics::Dwm::DWMWA_BORDER_COLOR;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
 use windows::Win32::Graphics::Dwm::DWMWA_COLOR_NONE;
@@ -30,52 +28,56 @@ 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::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::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::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::LibraryLoader::GetModuleHandleW;
-use windows::Win32::System::Power::RegisterPowerSettingNotification;
 use windows::Win32::System::Power::HPOWERNOTIFY;
+use windows::Win32::System::Power::RegisterPowerSettingNotification;
 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::UI::HiDpi::GetDpiForMonitor;
-use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+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::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::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;
@@ -86,15 +88,37 @@ 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_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;
@@ -102,34 +126,6 @@ use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
 use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 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_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;
@@ -140,23 +136,27 @@ 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 crate::core::Rect;
 
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::MONITOR_INDEX_PREFERENCES;
+use crate::Window;
+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::WindowManager;
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::MONITOR_INDEX_PREFERENCES;
 
 macro_rules! as_ptr {
-    ($value:expr) => {
+    ($value:expr_2021) => {
         $value as *mut core::ffi::c_void
     };
 }
@@ -1037,7 +1037,9 @@ 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,

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;

komorebi/src/winevent.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::use_self)]
 
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -88,8 +89,7 @@ use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Display)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Display, JsonSchema)]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {

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;
 

komorebi/src/workspace.rs

@@ -4,12 +4,13 @@ use std::fmt::Formatter;
 use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
 
-use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use color_eyre::eyre::anyhow;
 use getset::CopyGetters;
 use getset::Getters;
 use getset::MutGetters;
 use getset::Setters;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -21,6 +22,13 @@ use crate::core::Layout;
 use crate::core::OperationDirection;
 use crate::core::Rect;
 
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
+use crate::INITIAL_CONFIGURATION_LOADED;
+use crate::NO_TITLEBAR;
+use crate::REGEX_IDENTIFIERS;
+use crate::REMOVE_TITLEBARS;
+use crate::WindowContainerBehaviour;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::container::Container;
@@ -32,19 +40,20 @@ use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::window::WindowDetails;
 use crate::windows_api::WindowsApi;
-use crate::WindowContainerBehaviour;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::DEFAULT_WORKSPACE_PADDING;
-use crate::INITIAL_CONFIGURATION_LOADED;
-use crate::NO_TITLEBAR;
-use crate::REGEX_IDENTIFIERS;
-use crate::REMOVE_TITLEBARS;
 
 #[allow(clippy::struct_field_names)]
 #[derive(
-    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, PartialEq,
+    Debug,
+    Clone,
+    Serialize,
+    Deserialize,
+    Getters,
+    CopyGetters,
+    MutGetters,
+    Setters,
+    JsonSchema,
+    PartialEq,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
     pub name: Option<String>,
@@ -94,8 +103,7 @@ pub struct Workspace {
     pub workspace_config: Option<WorkspaceConfig>,
 }
 
-#[derive(Debug, Default, Copy, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[derive(Debug, Default, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
 pub enum WorkspaceLayer {
     #[default]
     Tiling,
@@ -161,9 +169,9 @@ pub enum WorkspaceWindowLocation {
     CopyGetters,
     MutGetters,
     Setters,
+    JsonSchema,
     PartialEq,
 )]
-#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 /// Settings setup either by the parent monitor or by the `WindowManager`
 pub struct WorkspaceGlobals {
     pub container_padding: Option<i32>,

komorebi/src/workspace_reconciliator.rs

@@ -1,7 +1,7 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
-use crate::border_manager;
 use crate::WindowManager;
+use crate::border_manager;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
@@ -51,16 +51,18 @@ pub fn send_notification(monitor_idx: usize, workspace_idx: usize) {
 }
 
 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) => {
-                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()) {
+                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)
+                    }
                 }
             }
         }

komorebic-no-console/Cargo.toml

@@ -3,7 +3,7 @@ name = "komorebic-no-console"
 version = "0.1.35"
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

komorebic/Cargo.toml

@@ -3,7 +3,7 @@ name = "komorebic"
 version = "0.1.35"
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -21,7 +21,7 @@ miette = { version = "7", features = ["fancy"] }
 paste = { workspace = true }
 powershell_script = "1.0"
 reqwest = { version = "0.12", features = ["blocking"] }
-schemars = { workspace = true, optional = true }
+schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 shadow-rs = { workspace = true }
@@ -34,9 +34,5 @@ windows = { workspace = true }
 reqwest = { version = "0.12", features = ["blocking"] }
 shadow-rs = { workspace = true }
 
-[features]
-default = ["schemars"]
-schemars = ["dep:schemars"]
-
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(FALSE)'] }

komorebic/src/main.rs

@@ -17,28 +17,31 @@ use std::time::Duration;
 use clap::CommandFactory;
 use clap::Parser;
 use clap::ValueEnum;
+use color_eyre::Result;
 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::ApplicationSpecificConfiguration;
+use komorebi_client::Notification;
 use komorebi_client::resolve_home_path;
 use komorebi_client::send_message;
 use komorebi_client::send_query;
-use komorebi_client::ApplicationSpecificConfiguration;
 use lazy_static::lazy_static;
 use miette::NamedSource;
 use miette::Report;
 use miette::SourceOffset;
 use miette::SourceSpan;
 use paste::paste;
+use schemars::r#gen::SchemaSettings;
+use schemars::schema_for;
 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;
@@ -1538,7 +1541,9 @@ fn main() -> Result<()> {
             let whkdrc = include_str!("../../docs/whkdrc.sample");
             std::fs::write(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;
 
-            println!("Example komorebi.json, komorebi.bar.json, whkdrc and latest applications.json files created");
+            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) => {
@@ -1584,8 +1589,12 @@ fn main() -> 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 => {
@@ -1649,16 +1658,23 @@ fn main() -> 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(path) => {
                             if !Path::exists(Path::new(&path)) {
-                                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()
+                                );
                             }
                         }
                     }
@@ -1676,9 +1692,14 @@ fn main() -> 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");
@@ -1688,13 +1709,17 @@ fn main() -> 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();
@@ -1716,7 +1741,9 @@ fn main() -> 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}"
+                        );
                     }
                 }
             }
@@ -2031,38 +2058,45 @@ fn main() -> Result<()> {
             }
 
             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_else(|| {
-                            anyhow!("cannot create a string from the scoop komorebi path")
-                        })?)
+            let exec = match Command::new("where.exe").arg("komorebi.ps1").output() {
+                Ok(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
+                _ => None,
             };
 
             let mut flags = vec![];
@@ -2264,18 +2298,28 @@ 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.map_or_else(
                 || {
@@ -2322,7 +2366,9 @@ 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}"
+                        );
                     }
                 }
             }
@@ -2947,7 +2993,9 @@ 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")?
@@ -2963,50 +3011,40 @@ 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!(
-               "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("\\", "/")
+                "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("\\", "/")
             );
         }
         SubCommand::ApplicationSpecificConfigurationSchema => {
-            #[cfg(feature = "schemars")]
-            {
-                let asc = schemars::schema_for!(ApplicationSpecificConfiguration);
-                let schema = serde_json::to_string_pretty(&asc)?;
-                println!("{schema}");
-            }
+            let asc = schema_for!(ApplicationSpecificConfiguration);
+            let schema = serde_json::to_string_pretty(&asc)?;
+            println!("{schema}");
         }
         SubCommand::NotificationSchema => {
-            #[cfg(feature = "schemars")]
-            {
-                let notification = schemars::schema_for!(komorebi_client::Notification);
-                let schema = serde_json::to_string_pretty(&notification)?;
-                println!("{schema}");
-            }
+            let notification = schema_for!(Notification);
+            let schema = serde_json::to_string_pretty(&notification)?;
+            println!("{schema}");
         }
         SubCommand::SocketSchema => {
-            #[cfg(feature = "schemars")]
-            {
-                let socket_message = schemars::schema_for!(SocketMessage);
-                let schema = serde_json::to_string_pretty(&socket_message)?;
-                println!("{schema}");
-            }
+            let socket_message = schema_for!(SocketMessage);
+            let schema = serde_json::to_string_pretty(&socket_message)?;
+            println!("{schema}");
         }
         SubCommand::StaticConfigSchema => {
-            #[cfg(feature = "schemars")]
-            {
-                let settings = schemars::gen::SchemaSettings::default().with(|s| {
-                    s.option_nullable = false;
-                    s.option_add_null_type = false;
-                    s.inline_subschemas = true;
-                });
+            let settings = SchemaSettings::default().with(|s| {
+                s.option_nullable = false;
+                s.option_add_null_type = false;
+                s.inline_subschemas = true;
+            });
 
-                let gen = settings.into_generator();
-                let socket_message = gen.into_root_schema_for::<StaticConfig>();
-                let schema = serde_json::to_string_pretty(&socket_message)?;
-                println!("{schema}");
-            }
+            let r#gen = settings.into_generator();
+            let socket_message = r#gen.into_root_schema_for::<StaticConfig>();
+            let schema = serde_json::to_string_pretty(&socket_message)?;
+            println!("{schema}");
         }
         SubCommand::GenerateStaticConfig => {
             print_query(&SocketMessage::GenerateStaticConfig);

schema.bar.json

@@ -511,53 +511,9 @@
                       "enable"
                     ],
                     "properties": {
-                      "display": {
-                        "description": "Display format of the current layer",
-                        "oneOf": [
-                          {
-                            "description": "Show only icon",
-                            "type": "string",
-                            "enum": [
-                              "Icon"
-                            ]
-                          },
-                          {
-                            "description": "Show only text",
-                            "type": "string",
-                            "enum": [
-                              "Text"
-                            ]
-                          },
-                          {
-                            "description": "Show an icon and text for the selected element, and text on the rest",
-                            "type": "string",
-                            "enum": [
-                              "TextAndIconOnSelected"
-                            ]
-                          },
-                          {
-                            "description": "Show both icon and text",
-                            "type": "string",
-                            "enum": [
-                              "IconAndText"
-                            ]
-                          },
-                          {
-                            "description": "Show an icon and text for the selected element, and icons on the rest",
-                            "type": "string",
-                            "enum": [
-                              "IconAndTextOnSelected"
-                            ]
-                          }
-                        ]
-                      },
                       "enable": {
                         "description": "Enable the Komorebi Workspace Layer widget",
                         "type": "boolean"
-                      },
-                      "show_when_tiling": {
-                        "description": "Show the widget event if the layer is Tiling",
-                        "type": "boolean"
                       }
                     }
                   },
@@ -1909,53 +1865,9 @@
                       "enable"
                     ],
                     "properties": {
-                      "display": {
-                        "description": "Display format of the current layer",
-                        "oneOf": [
-                          {
-                            "description": "Show only icon",
-                            "type": "string",
-                            "enum": [
-                              "Icon"
-                            ]
-                          },
-                          {
-                            "description": "Show only text",
-                            "type": "string",
-                            "enum": [
-                              "Text"
-                            ]
-                          },
-                          {
-                            "description": "Show an icon and text for the selected element, and text on the rest",
-                            "type": "string",
-                            "enum": [
-                              "TextAndIconOnSelected"
-                            ]
-                          },
-                          {
-                            "description": "Show both icon and text",
-                            "type": "string",
-                            "enum": [
-                              "IconAndText"
-                            ]
-                          },
-                          {
-                            "description": "Show an icon and text for the selected element, and icons on the rest",
-                            "type": "string",
-                            "enum": [
-                              "IconAndTextOnSelected"
-                            ]
-                          }
-                        ]
-                      },
                       "enable": {
                         "description": "Enable the Komorebi Workspace Layer widget",
                         "type": "boolean"
-                      },
-                      "show_when_tiling": {
-                        "description": "Show the widget event if the layer is Tiling",
-                        "type": "boolean"
                       }
                     }
                   },
@@ -3240,53 +3152,9 @@
                       "enable"
                     ],
                     "properties": {
-                      "display": {
-                        "description": "Display format of the current layer",
-                        "oneOf": [
-                          {
-                            "description": "Show only icon",
-                            "type": "string",
-                            "enum": [
-                              "Icon"
-                            ]
-                          },
-                          {
-                            "description": "Show only text",
-                            "type": "string",
-                            "enum": [
-                              "Text"
-                            ]
-                          },
-                          {
-                            "description": "Show an icon and text for the selected element, and text on the rest",
-                            "type": "string",
-                            "enum": [
-                              "TextAndIconOnSelected"
-                            ]
-                          },
-                          {
-                            "description": "Show both icon and text",
-                            "type": "string",
-                            "enum": [
-                              "IconAndText"
-                            ]
-                          },
-                          {
-                            "description": "Show an icon and text for the selected element, and icons on the rest",
-                            "type": "string",
-                            "enum": [
-                              "IconAndTextOnSelected"
-                            ]
-                          }
-                        ]
-                      },
                       "enable": {
                         "description": "Enable the Komorebi Workspace Layer widget",
                         "type": "boolean"
-                      },
-                      "show_when_tiling": {
-                        "description": "Show the widget event if the layer is Tiling",
-                        "type": "boolean"
                       }
                     }
                   },