perf(cargo): make schemars derives optional

This commit makes all schemars::JsonSchema derives optional. After
analyzing the output of cargo build timings and llvm-lines, it was clear
that the majority of the 2m+ incremental dev build times was taken up by
codegen, and the majority of it by schemars.

Developers can now run cargo commands with --no-default-features to
disable schemars::JsonSchema codegen, and all justfile commands have
been updated to take this flag by default, with the exception of the
jsonschema target, which will compile with all derives required to
export the various jsonschema files.

Incremental dev build times for komorebi.exe on my machine are now at
around ~18s, while clean dev build times for the entire workspace are at
around ~1m.

Cargo.toml

@@ -71,17 +71,4 @@ 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,22 +19,31 @@ 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 --profile release-jeezy
+    cargo +stable build --package {{ target }} --locked --release --no-default-features
 
 build:
     just build-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
 copy-target target:
-    cp .\target\release-jeezy\{{ target }}.exe $Env:USERPROFILE\.cargo\bin
+    cp .\target\release\{{ target }}.exe $Env:USERPROFILE\.cargo\bin
 
 copy-targets *targets:
     "{{ targets }}" -split ' ' | ForEach-Object { just copy-target $_ }
@@ -46,7 +55,7 @@ copy:
     just copy-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
 run target:
-    cargo +stable run --bin {{ target }} --locked
+    cargo +stable run --bin {{ target }} --locked --no-default-features
 
 warn target $RUST_LOG="warn":
     just run {{ target }}
@@ -61,7 +70,7 @@ trace target $RUST_LOG="trace":
     just run {{ target }}
 
 deadlock $RUST_LOG="trace":
-    cargo +stable run --bin komorebi --locked --features deadlock_detection
+    cargo +stable run --bin komorebi --locked --no-default-features --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 = "2024"
+edition = "2021"
 
 # 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 }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 starship-battery = "0.10"
@@ -35,4 +35,8 @@ 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" }
+windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }
+
+[features]
+default = ["schemars"]
+schemars = ["dep:schemars"]

komorebi-bar/src/bar.rs

@@ -1,16 +1,9 @@
-use crate::BAR_HEIGHT;
-use crate::DEFAULT_PADDING;
-use crate::KomorebiEvent;
-use crate::MAX_LABEL_WIDTH;
-use crate::MONITOR_LEFT;
-use crate::MONITOR_RIGHT;
-use crate::MONITOR_TOP;
+use crate::config::get_individual_spacing;
 use crate::config::KomobarConfig;
 use crate::config::KomobarTheme;
 use crate::config::MonitorConfigOrIndex;
 use crate::config::Position;
 use crate::config::PositionConfig;
-use crate::config::get_individual_spacing;
 use crate::komorebi::Komorebi;
 use crate::komorebi::KomorebiNotificationState;
 use crate::process_hwnd;
@@ -20,6 +13,13 @@ 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::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 pub struct Komobar {
     pub hwnd: Option<isize>,
@@ -373,14 +373,10 @@ 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;
         }
 
@@ -423,9 +419,7 @@ impl Komobar {
         end.x -= margin.left + margin.right;
 
         if end.y == 0.0 {
-            tracing::warn!(
-                "position.end.y is set to 0.0 which will make your bar invisible on a config reload - this is usually set to 50.0 by default"
-            )
+            tracing::warn!("position.end.y is set to 0.0 which will make your bar invisible on a config reload - this is usually set to 50.0 by default")
         }
 
         self.size_rect = komorebi_client::Rect {

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, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 /// The `komorebi.bar.json` configuration file reference for `v0.1.35`
 pub struct KomobarConfig {
     /// Bar height (default: 50)
@@ -115,9 +115,7 @@ impl KomobarConfig {
         }
 
         if display {
-            println!(
-                "\nYour bar configuration file contains some options that have been renamed or deprecated:\n"
-            );
+            println!("\nYour bar configuration file contains some options that have been renamed or deprecated:\n");
             for (canonical, aliases) in map {
                 for alias in aliases {
                     if raw.contains(alias) {
@@ -138,7 +136,8 @@ impl KomobarConfig {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct PositionConfig {
     /// The desired starting position of the bar (0,0 = top left of the screen)
     #[serde(alias = "position")]
@@ -148,13 +147,15 @@ pub struct PositionConfig {
     pub end: Option<Position>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct FrameConfig {
     /// Margin inside the painted frame
     pub inner_margin: Position,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum MonitorConfigOrIndex {
     /// The monitor index where you want the bar to show
@@ -163,7 +164,8 @@ pub enum MonitorConfigOrIndex {
     MonitorConfig(MonitorConfig),
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MonitorConfig {
     /// Komorebi monitor index of the monitor on which to render the bar
     pub index: usize,
@@ -174,7 +176,8 @@ pub struct MonitorConfig {
 pub type Padding = SpacingKind;
 pub type Margin = SpacingKind;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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
@@ -225,20 +228,23 @@ impl SpacingKind {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct GroupedSpacingConfig {
     pub vertical: Option<GroupedSpacingOptions>,
     pub horizontal: Option<GroupedSpacingOptions>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum GroupedSpacingOptions {
     Symmetrical(f32),
     Split(f32, f32),
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct IndividualSpacingConfig {
     pub top: f32,
     pub bottom: f32,
@@ -340,7 +346,8 @@ impl KomobarConfig {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Position {
     /// X coordinate
     pub x: f32,
@@ -366,7 +373,8 @@ impl From<Position> for Pos2 {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "palette")]
 pub enum KomobarTheme {
     /// A theme from catppuccin-egui
@@ -402,7 +410,8 @@ impl From<KomorebiTheme> for KomobarTheme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum LabelPrefix {
     /// Show no prefix
     None,
@@ -414,7 +423,8 @@ pub enum LabelPrefix {
     IconAndText,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum DisplayFormat {
     /// Show only icon
     Icon,
@@ -430,7 +440,8 @@ 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, schemars::JsonSchema, PartialEq)]
+        #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
         pub enum $new_enum {
             // Add new variants
             $(
@@ -462,12 +473,11 @@ 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, JsonSchema, PartialEq)]
+    #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
     pub enum OriginalDisplayFormat {
         /// Show None Of The Things
         NoneOfTheThings,

komorebi-bar/src/cpu.rs

@@ -2,13 +2,12 @@ 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;
@@ -17,7 +16,8 @@ use std::time::Instant;
 use sysinfo::RefreshKind;
 use sysinfo::System;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct CustomModifiers {
     /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
     format: String,
@@ -55,7 +55,8 @@ impl CustomModifiers {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct DateConfig {
     /// Enable the Date widget
     pub enable: bool,
@@ -75,7 +76,8 @@ impl From<DateConfig> for Date {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum DateFormat {
     /// Month/Date/Year format (09/08/24)
     MonthDateYear,

komorebi-bar/src/keyboard.rs

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

komorebi-bar/src/komorebi.rs

@@ -1,6 +1,3 @@
-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;
@@ -11,6 +8,10 @@ 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;
@@ -27,7 +28,6 @@ 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,7 +37,6 @@ 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;
@@ -47,7 +46,8 @@ use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiConfig {
     /// Configure the Workspaces widget
     pub workspaces: Option<KomorebiWorkspacesConfig>,
@@ -61,7 +61,8 @@ pub struct KomorebiConfig {
     pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiWorkspacesConfig {
     /// Enable the Komorebi Workspaces widget
     pub enable: bool,
@@ -71,7 +72,8 @@ pub struct KomorebiWorkspacesConfig {
     pub display: Option<WorkspacesDisplayFormat>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiLayoutConfig {
     /// Enable the Komorebi Layout widget
     pub enable: bool,
@@ -81,13 +83,19 @@ pub struct KomorebiLayoutConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiFocusedWindowConfig {
     /// Enable the Komorebi Focused Window widget
     pub enable: bool,
@@ -97,7 +105,8 @@ pub struct KomorebiFocusedWindowConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiConfigurationSwitcherConfig {
     /// Enable the Komorebi Configurations widget
     pub enable: bool,
@@ -312,29 +321,106 @@ impl BarWidget for Komorebi {
                     .map(|(_, _, layer)| layer);
 
                 if let Some(layer) = layer {
-                    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(
+                    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({})",
                                     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,
-                            );
-                        }
-                    });
+                                );
+                            }
+                        });
+                    }
                 }
             }
         }
@@ -599,13 +685,9 @@ 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,6 +2,7 @@ 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;
@@ -12,18 +13,17 @@ 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 schemars::JsonSchema;
+use serde::de::Error;
 use serde::Deserialize;
 use serde::Deserializer;
 use serde::Serialize;
-use serde::de::Error;
 use serde_json::from_str;
 use std::fmt::Display;
 use std::fmt::Formatter;
 
-#[derive(Copy, Clone, Debug, Serialize, JsonSchema, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum KomorebiLayout {
     Default(komorebi_client::DefaultLayout),

komorebi-bar/src/main.rs

@@ -30,24 +30,23 @@ 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::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 use windows_core::BOOL;
@@ -125,15 +124,16 @@ fn main() -> color_eyre::Result<()> {
 
     let opts: Opts = Opts::parse();
 
+    #[cfg(feature = "schemars")]
     if opts.schema {
-        let settings = SchemaSettings::default().with(|s| {
+        let settings = schemars::gen::SchemaSettings::default().with(|s| {
             s.option_nullable = false;
             s.option_add_null_type = false;
             s.inline_subschemas = true;
         });
 
-        let r#gen = settings.into_generator();
-        let socket_message = r#gen.into_root_schema_for::<KomobarConfig>();
+        let gen = settings.into_generator();
+        let socket_message = gen.into_root_schema_for::<KomobarConfig>();
         let schema = serde_json::to_string_pretty(&socket_message)?;
 
         println!("{schema}");
@@ -149,15 +149,13 @@ fn main() -> color_eyre::Result<()> {
     }
 
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        // TODO: Audit that the environment access only happens in single-threaded code.
-        unsafe { std::env::set_var("RUST_LIB_BACKTRACE", "1") };
+        std::env::set_var("RUST_LIB_BACKTRACE", "1");
     }
 
     color_eyre::install()?;
 
     if std::env::var("RUST_LOG").is_err() {
-        // TODO: Audit that the environment access only happens in single-threaded code.
-        unsafe { std::env::set_var("RUST_LOG", "info") };
+        std::env::set_var("RUST_LOG", "info");
     }
 
     tracing::subscriber::set_global_default(
@@ -351,7 +349,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::r#gen(random_word::Lang::En));
+                let subscriber_name = format!("komorebi-bar-{}", random_word::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, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MediaConfig {
     /// Enable the Media widget
     pub enable: bool,

komorebi-bar/src/memory.rs

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

komorebi-bar/src/network.rs

@@ -2,14 +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 num_derive::FromPrimitive;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::fmt;
@@ -18,7 +17,8 @@ use std::time::Duration;
 use std::time::Instant;
 use sysinfo::Networks;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "kind")]
 pub enum Grouping {
     /// No grouping is applied
@@ -339,7 +339,8 @@ impl RenderConfig {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct GroupingConfig {
     /// Styles for the grouping
     pub style: Option<GroupingStyle>,
@@ -349,7 +350,8 @@ pub struct GroupingConfig {
     pub rounding: Option<RoundingConfig>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum GroupingStyle {
     #[serde(alias = "CtByte")]
     Default,
@@ -369,7 +371,8 @@ pub enum GroupingStyle {
     DefaultWithGlowB0O1S2,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum RoundingConfig {
     /// All 4 corners are the same    

komorebi-bar/src/selected_frame.rs

@@ -1,8 +1,10 @@
+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
@@ -23,26 +25,34 @@ 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,
-                        ui.style().spacing.button_padding.y as i8,
+                        ui.style().spacing.button_padding.x as i8 - 1,
+                        ui.style().spacing.button_padding.y as i8 - 1,
                     );
 
-                    if selected
-                        || response.hovered()
-                        || response.highlighted()
-                        || response.has_focus()
-                    {
+                    // since the stroke is drawn inside the frame, we always reserve space for it
+                    if response.hovered() || response.highlighted() || response.has_focus() {
                         let visuals = ui.style().interact_selectable(&response, selected);
 
                         Frame::NONE
-                            .stroke(visuals.bg_stroke)
+                            .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))
                             .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,13 +2,12 @@ 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,7 +15,8 @@ use std::time::Duration;
 use std::time::Instant;
 use sysinfo::Disks;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct StorageConfig {
     /// Enable the Storage widget
     pub enable: bool,

komorebi-bar/src/time.rs

@@ -3,6 +3,7 @@ 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;
@@ -12,13 +13,12 @@ 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, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct TimeConfig {
     /// Enable the Time widget
     pub enable: bool,
@@ -38,7 +38,8 @@ impl From<TimeConfig> for Time {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct UpdateConfig {
     /// Enable the Update widget
     pub enable: bool,

komorebi-bar/src/widget.rs

@@ -23,7 +23,6 @@ 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;
 
@@ -31,7 +30,8 @@ pub trait BarWidget {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig);
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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 = "2024"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

komorebi-client/src/lib.rs

@@ -1,27 +1,8 @@
 #![warn(clippy::all)]
 #![allow(clippy::missing_errors_doc)]
 
-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::animation::PerAnimationPrefixConfig;
 pub use komorebi::asc::ApplicationSpecificConfiguration;
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;
@@ -31,6 +12,8 @@ pub use komorebi::config_generation::IdWithIdentifierAndComment;
 pub use komorebi::config_generation::MatchingRule;
 pub use komorebi::config_generation::MatchingStrategy;
 pub use komorebi::container::Container;
+pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
+pub use komorebi::core::resolve_home_path;
 pub use komorebi::core::AnimationStyle;
 pub use komorebi::core::ApplicationIdentifier;
 pub use komorebi::core::Arrangement;
@@ -59,8 +42,6 @@ pub use komorebi::core::StackbarLabel;
 pub use komorebi::core::StackbarMode;
 pub use komorebi::core::StateQuery;
 pub use komorebi::core::WindowKind;
-pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
-pub use komorebi::core::resolve_home_path;
 pub use komorebi::monitor::Monitor;
 pub use komorebi::monitor_reconciliator::MonitorNotification;
 pub use komorebi::ring::Ring;
@@ -69,6 +50,25 @@ 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 = "2024"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

komorebi-gui/src/main.rs

@@ -1,9 +1,9 @@
 #![warn(clippy::all)]
 
 use eframe::egui;
+use eframe::egui::color_picker::Alpha;
 use eframe::egui::Color32;
 use eframe::egui::ViewportBuilder;
-use eframe::egui::color_picker::Alpha;
 use komorebi_client::BorderStyle;
 use komorebi_client::Colour;
 use komorebi_client::DefaultLayout;
@@ -101,7 +101,7 @@ impl From<&komorebi_client::Workspace> for WorkspaceConfig {
         let name = value
             .name()
             .to_owned()
-            .unwrap_or_else(|| random_word::r#gen(random_word::Lang::En).to_string());
+            .unwrap_or_else(|| random_word::gen(random_word::Lang::En).to_string());
 
         Self {
             layout,
@@ -248,11 +248,10 @@ impl eframe::App for KomorebiGui {
                     ui.collapsing("Window Rules", |ui| {
                         let window = Window::from(self.debug_hwnd);
 
-                        let label = match (window.title(), window.exe()) {
-                            (Ok(title), Ok(exe)) => {
-                                format!("{title} ({exe})")
-                            }
-                            _ => String::from("Select a Window"),
+                        let label = if let (Ok(title), Ok(exe)) = (window.title(), window.exe()) {
+                            format!("{title} ({exe})")
+                        } else {
+                            String::from("Select a Window")
                         };
 
                         if ui.button("Refresh Windows").clicked() {

komorebi-themes/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "komorebi-themes"
 version = "0.1.35"
-edition = "2024"
+edition = "2021"
 
 [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 = "2024"
+edition = "2021"
 
 # 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 }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }
@@ -57,4 +57,6 @@ 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::HashMap;
 use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 
 use super::prefix::AnimationPrefix;
 

komorebi/src/animation/engine.rs

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

komorebi/src/animation/lerp.rs

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

komorebi/src/animation/mod.rs

@@ -4,9 +4,9 @@ use crate::core::animation::AnimationStyle;
 use lazy_static::lazy_static;
 use prefix::AnimationPrefix;
 use std::collections::HashMap;
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
 
 use parking_lot::Mutex;
 
@@ -18,11 +18,12 @@ 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, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum PerAnimationPrefixConfig<T> {
     Prefix(HashMap<AnimationPrefix, T>),

komorebi/src/animation/prefix.rs

@@ -1,24 +1,14 @@
 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,
-    JsonSchema,
+    Copy, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Display, EnumString, ValueEnum,
 )]
+#[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,34 +1,37 @@
-use crate::WINDOWS_11;
-use crate::WindowsApi;
+use crate::border_manager::window_kind_colour;
+use crate::border_manager::RenderTarget;
+use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::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::LazyLock;
-use std::sync::OnceLock;
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
+use std::sync::LazyLock;
+use std::sync::OnceLock;
 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;
@@ -37,31 +40,28 @@ use windows::Win32::Graphics::Direct2D::D2D1_PRESENT_OPTIONS_IMMEDIATELY;
 use windows::Win32::Graphics::Direct2D::D2D1_RENDER_TARGET_PROPERTIES;
 use windows::Win32::Graphics::Direct2D::D2D1_RENDER_TARGET_TYPE_DEFAULT;
 use windows::Win32::Graphics::Direct2D::D2D1_ROUNDED_RECT;
-use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
-use windows::Win32::Graphics::Direct2D::ID2D1Factory;
-use windows::Win32::Graphics::Direct2D::ID2D1SolidColorBrush;
+use windows::Win32::Graphics::Dwm::DwmEnableBlurBehindWindow;
 use windows::Win32::Graphics::Dwm::DWM_BB_BLURREGION;
 use windows::Win32::Graphics::Dwm::DWM_BB_ENABLE;
 use windows::Win32::Graphics::Dwm::DWM_BLURBEHIND;
-use windows::Win32::Graphics::Dwm::DwmEnableBlurBehindWindow;
 use windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT_UNKNOWN;
 use windows::Win32::Graphics::Gdi::CreateRectRgn;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::ValidateRect;
-use windows::Win32::UI::WindowsAndMessaging::CREATESTRUCTW;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESTROY;
-use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LOCATIONCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::GWLP_USERDATA;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetSystemMetrics;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
-use windows::Win32::UI::WindowsAndMessaging::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::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::MSG;
+use windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN;
 use windows::Win32::UI::WindowsAndMessaging::WM_CREATE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;

komorebi/src/border_manager/mod.rs

@@ -1,36 +1,35 @@
 #![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;
-pub use border::Border;
+use crate::Colour;
+use crate::Rgb;
+use crate::WindowManager;
+use crate::WindowsApi;
 use border::border_hwnds;
+pub use border::Border;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
 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::HashMap;
 use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 use std::ops::Deref;
-use std::sync::Arc;
-use std::sync::OnceLock;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::OnceLock;
 use strum::Display;
 use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
 
@@ -146,15 +145,13 @@ fn window_kind_colour(focus_kind: WindowKind) -> u32 {
 }
 
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone()) {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -350,17 +347,14 @@ 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) => {
-                                    match Border::create(
+                                    if let Ok(border) = Border::create(
                                         monocle.id(),
                                         monocle.focused_window().copied().unwrap_or_default().hwnd,
                                     ) {
-                                        Ok(border) => {
-                                            new_border = true;
-                                            entry.insert(border)
-                                        }
-                                        _ => {
-                                            continue 'monitors;
-                                        }
+                                        new_border = true;
+                                        entry.insert(border)
+                                    } else {
+                                        continue 'monitors;
                                     }
                                 }
                             };
@@ -488,14 +482,12 @@ 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) => {
-                                    match Border::create(c.id(), focused_window_hwnd) {
-                                        Ok(border) => {
-                                            new_border = true;
-                                            entry.insert(border)
-                                        }
-                                        _ => {
-                                            continue 'monitors;
-                                        }
+                                    if let Ok(border) = Border::create(c.id(), focused_window_hwnd)
+                                    {
+                                        new_border = true;
+                                        entry.insert(border)
+                                    } else {
+                                        continue 'monitors;
                                     }
                                 }
                             };
@@ -522,34 +514,31 @@ 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
-                                match Border::create(
+                                if let Ok(b) = Border::create(
                                     c.id(),
                                     c.focused_window().copied().unwrap_or_default().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);
-                                            }
+                                    // 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;
-                                    }
-                                    _ => {
-                                        continue 'monitors;
-                                    }
+                                    // Replace with new border
+                                    new_border = true;
+                                    *border = b;
+                                } else {
+                                    continue 'monitors;
                                 }
                             }
 
@@ -601,15 +590,13 @@ 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) => {
-                                        match Border::create(&window.hwnd.to_string(), window.hwnd)
+                                        if let Ok(border) =
+                                            Border::create(&window.hwnd.to_string(), window.hwnd)
                                         {
-                                            Ok(border) => {
-                                                new_border = true;
-                                                entry.insert(border)
-                                            }
-                                            _ => {
-                                                continue 'monitors;
-                                            }
+                                            new_border = true;
+                                            entry.insert(border)
+                                        } else {
+                                            continue 'monitors;
                                         }
                                     }
                                 };
@@ -710,7 +697,8 @@ fn remove_border(
     Ok(())
 }
 
-#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ZOrder {
     Top,
     NoTopMost,

komorebi/src/colour.rs

@@ -1,14 +1,19 @@
 use hex_color::HexColor;
 use komorebi_themes::Color32;
-use schemars::JsonSchema;
-use schemars::r#gen::SchemaGenerator;
+#[cfg(feature = "schemars")]
+use schemars::gen::SchemaGenerator;
+#[cfg(feature = "schemars")]
 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, JsonSchema, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum Colour {
     /// Colour represented as RGB
@@ -54,7 +59,8 @@ impl From<Colour> for Color32 {
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Hex(HexColor);
 
-impl JsonSchema for Hex {
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for Hex {
     fn schema_name() -> String {
         String::from("Hex")
     }
@@ -78,7 +84,8 @@ impl From<Colour> for u32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 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
     })
 }
 
-#[unsafe(no_mangle)]
+#[no_mangle]
 pub extern "C" fn SetCloak(hwnd: HWND, cloak_type: u32, flags: i32) {
     COM_INIT.with(|_| {
         let provider = get_iservice_provider();

komorebi/src/container.rs

@@ -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, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Container {
     #[getset(get = "pub")]
     id: String,

komorebi/src/core/animation.rs

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

komorebi/src/core/arrangement.rs

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

komorebi/src/core/asc.rs

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

komorebi/src/core/config_generation.rs

@@ -1,6 +1,5 @@
 use clap::ValueEnum;
 use color_eyre::Result;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -8,9 +7,8 @@ use strum::EnumString;
 
 use super::ApplicationIdentifier;
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum ApplicationOptions {
@@ -52,14 +50,16 @@ impl ApplicationOptions {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum MatchingRule {
     Simple(IdWithIdentifier),
     Composite(Vec<IdWithIdentifier>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WorkspaceMatchingRule {
     pub monitor_index: usize,
     pub workspace_index: usize,
@@ -67,7 +67,8 @@ pub struct WorkspaceMatchingRule {
     pub initial_only: bool,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct IdWithIdentifier {
     pub kind: ApplicationIdentifier,
     pub id: String,
@@ -75,7 +76,8 @@ pub struct IdWithIdentifier {
     pub matching_strategy: Option<MatchingStrategy>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum MatchingStrategy {
     Legacy,
     Equals,
@@ -89,7 +91,8 @@ pub enum MatchingStrategy {
     DoesNotContain,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct IdWithIdentifierAndComment {
     pub kind: ApplicationIdentifier,
     pub id: String,
@@ -109,7 +112,8 @@ impl From<IdWithIdentifierAndComment> for IdWithIdentifier {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct ApplicationConfiguration {
     pub name: String,
     pub identifier: IdWithIdentifier,
@@ -133,7 +137,8 @@ impl ApplicationConfiguration {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::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 schemars::JsonSchema;
+use color_eyre::Result;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::Rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct CustomLayout(Vec<Column>);
 
 impl Deref for CustomLayout {
@@ -250,7 +250,8 @@ impl CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "column", content = "configuration")]
 pub enum Column {
     Primary(Option<ColumnWidth>),
@@ -258,18 +259,21 @@ pub enum Column {
     Tertiary(ColumnSplit),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ColumnWidth {
     WidthPercentage(f32),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ColumnSplit {
     Horizontal,
     Vertical,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ColumnSplitWithCapacity {
     Horizontal(usize),
     Vertical(usize),

komorebi/src/core/cycle_direction.rs

@@ -1,15 +1,13 @@
 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, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum CycleDirection {
     Previous,
     Next,

komorebi/src/core/default_layout.rs

@@ -1,5 +1,4 @@
 use clap::ValueEnum;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -10,18 +9,9 @@ use super::Rect;
 use super::Sizing;
 
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    Serialize,
-    Deserialize,
-    Eq,
-    PartialEq,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
+    Clone, Copy, Debug, Serialize, Deserialize, Eq, PartialEq, Display, EnumString, ValueEnum,
 )]
+#[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,4 +1,3 @@
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -7,7 +6,8 @@ use super::CustomLayout;
 use super::DefaultLayout;
 use super::Direction;
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Layout {
     Default(DefaultLayout),
     Custom(CustomLayout),

komorebi/src/core/mod.rs

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

komorebi/src/core/operation_direction.rs

@@ -1,18 +1,16 @@
 use std::num::NonZeroUsize;
 
 use clap::ValueEnum;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-use super::Axis;
 use super::direction::Direction;
+use super::Axis;
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::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, JsonSchema)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Rect {
     /// The left point in a Win32 Rect
     pub left: i32,

komorebi/src/focus_manager.rs

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

komorebi/src/lib.rs

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

komorebi/src/main.rs

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

komorebi/src/monitor_reconciliator/hidden.rs

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

komorebi/src/monitor_reconciliator/mod.rs

@@ -1,11 +1,5 @@
 #![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;
@@ -13,22 +7,28 @@ 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::Arc;
-use std::sync::OnceLock;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::OnceLock;
 
 pub mod hidden;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "type", content = "content")]
 pub enum MonitorNotification {
     ResolutionScalingChanged,
@@ -112,18 +112,16 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Re
 
     tracing::info!("created hidden window to listen for monitor-related events");
 
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone()) {
-                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)
                 }
             }
         }
@@ -463,9 +461,7 @@ 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,3 +1,8 @@
+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;
@@ -8,22 +13,17 @@ use std::net::TcpListener;
 use std::net::TcpStream;
 use std::num::NonZeroUsize;
 use std::str::FromStr;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 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,34 +37,7 @@ 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;
@@ -91,6 +64,29 @@ 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;
@@ -101,44 +97,42 @@ 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");
     });
 }
 
@@ -1216,7 +1210,7 @@ impl WindowManager {
                 let container_len = workspace.containers().len();
                 let no_layout_rules = workspace.layout_rules().is_empty();
 
-                if let Layout::Custom(custom) = workspace.layout_mut() {
+                if let Layout::Custom(ref mut custom) = workspace.layout_mut() {
                     if matches!(axis, Axis::Horizontal) {
                         #[allow(clippy::cast_precision_loss)]
                         let percentage = custom
@@ -1378,9 +1372,7 @@ 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");
                                 }
                             }
                         }
@@ -1404,9 +1396,7 @@ 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");
                                 }
                             }
                         }
@@ -1539,7 +1529,7 @@ impl WindowManager {
                     !workspace.apply_window_based_work_area_offset(),
                 );
 
-                self.retile_all(false)?;
+                self.retile_all(true)?;
             }
             SocketMessage::QuickSave => {
                 let workspace = self.focused_workspace()?;
@@ -1648,41 +1638,33 @@ impl WindowManager {
             }
             SocketMessage::ToggleWorkspaceWindowContainerBehaviour => {
                 let current_global_behaviour = self.window_management_behaviour.current_behaviour;
-                match self
+                if let Some(behaviour) = self
                     .focused_workspace_mut()?
                     .window_container_behaviour_mut()
                 {
-                    Some(behaviour) => match 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;
-                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));
-                    }
+                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));
                 };
             }
             SocketMessage::WindowHidingBehaviour(behaviour) => {
@@ -1842,35 +1824,49 @@ impl WindowManager {
                 *STACKBAR_FONT_FAMILY.lock() = font_family.clone();
             }
             SocketMessage::ApplicationSpecificConfigurationSchema => {
-                let asc = schema_for!(Vec<ApplicationConfiguration>);
-                let schema = serde_json::to_string_pretty(&asc)?;
+                #[cfg(feature = "schemars")]
+                {
+                    let asc = schemars::schema_for!(
+                        Vec<crate::core::config_generation::ApplicationConfiguration>
+                    );
+                    let schema = serde_json::to_string_pretty(&asc)?;
 
-                reply.write_all(schema.as_bytes())?;
+                    reply.write_all(schema.as_bytes())?;
+                }
             }
             SocketMessage::NotificationSchema => {
-                let notification = schema_for!(Notification);
-                let schema = serde_json::to_string_pretty(&notification)?;
+                #[cfg(feature = "schemars")]
+                {
+                    let notification = schemars::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 => {
-                let socket_message = schema_for!(SocketMessage);
-                let schema = serde_json::to_string_pretty(&socket_message)?;
+                #[cfg(feature = "schemars")]
+                {
+                    let socket_message = schemars::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 => {
-                let settings = SchemaSettings::default().with(|s| {
-                    s.option_nullable = false;
-                    s.option_add_null_type = false;
-                    s.inline_subschemas = true;
-                });
+                #[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 r#gen = settings.into_generator();
-                let socket_message = r#gen.into_root_schema_for::<StaticConfig>();
-                let schema = serde_json::to_string_pretty(&socket_message)?;
+                    let gen = settings.into_generator();
+                    let socket_message = 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::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 
-use color_eyre::Result;
 use color_eyre::eyre::anyhow;
+use color_eyre::Result;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
 
@@ -13,13 +13,6 @@ 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;
@@ -27,8 +20,8 @@ use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
 use crate::transparency_manager;
-use crate::window::RuleDebug;
 use crate::window::should_act;
+use crate::window::RuleDebug;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -37,6 +30,13 @@ 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_2021, $comparator:tt, $direction:expr_2021) => {{
+                            ($coordinate:expr, $comparator:tt, $direction:expr) => {{
                                 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::DATA_DIR;
+use crate::border_manager;
+use crate::notify_subscribers;
+use crate::winevent::WinEvent;
 use crate::NotificationEvent;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowManagerEvent;
-use crate::border_manager;
-use crate::notify_subscribers;
-use crate::winevent::WinEvent;
+use crate::DATA_DIR;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
@@ -53,15 +53,13 @@ pub fn listen_for_notifications(
 ) {
     watch_for_orphans(known_hwnds);
 
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone()) {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -150,18 +148,16 @@ fn watch_for_orphans(known_hwnds: HashMap<isize, (usize, usize)>) {
         *cache = known_hwnds;
     }
 
-    std::thread::spawn(move || {
-        loop {
-            match find_orphans() {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    if cfg!(debug_assertions) {
-                        tracing::error!("restarting failed thread: {:?}", error)
-                    } else {
-                        tracing::error!("restarting failed thread: {}", error)
-                    }
+    std::thread::spawn(move || loop {
+        match find_orphans() {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                if cfg!(debug_assertions) {
+                    tracing::error!("restarting failed thread: {:?}", error)
+                } else {
+                    tracing::error!("restarting failed thread: {}", error)
                 }
             }
         }

komorebi/src/ring.rs

@@ -1,10 +1,10 @@
 use std::collections::VecDeque;
 
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 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::HashMap;
 use std::collections::hash_map::Entry;
-use std::sync::Arc;
-use std::sync::OnceLock;
+use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::OnceLock;
 
 pub static STACKBAR_FONT_SIZE: AtomicI32 = AtomicI32::new(0); // 0 will produce the system default
 pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
@@ -71,15 +71,13 @@ pub fn should_have_stackbar(window_count: usize) -> bool {
 }
 
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone()) {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -195,12 +193,13 @@ 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) => match Stackbar::create(container.id()) {
-                            Ok(stackbar) => entry.insert(stackbar),
-                            _ => {
+                        Entry::Vacant(entry) => {
+                            if let Ok(stackbar) = Stackbar::create(container.id()) {
+                                entry.insert(stackbar)
+                            } else {
                                 continue 'receiver;
                             }
-                        },
+                        }
                     };
 
                     stackbars_monitors.insert(container.id().clone(), monitor_idx);

komorebi/src/stackbar_manager/stackbar.rs

@@ -1,6 +1,3 @@
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::WINDOWS_11;
-use crate::WindowsApi;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::STYLE;
@@ -8,6 +5,7 @@ use crate::container::Container;
 use crate::core::BorderStyle;
 use crate::core::Rect;
 use crate::core::StackbarLabel;
+use crate::stackbar_manager::STACKBARS_CONTAINERS;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
 use crate::stackbar_manager::STACKBAR_FONT_SIZE;
@@ -16,13 +14,16 @@ use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
 use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
 use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBARS_CONTAINERS;
 use crate::windows_api;
+use crate::WindowsApi;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::WINDOWS_11;
 use crossbeam_utils::atomic::AtomicConsume;
 use std::os::windows::ffi::OsStrExt;
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::time::Duration;
+use windows::core::PCWSTR;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HWND;
@@ -32,38 +33,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;
@@ -71,7 +72,6 @@ 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,28 +1,4 @@
-use crate::AspectRatio;
-use crate::Axis;
-use crate::CrossBoundaryBehaviour;
-use crate::DATA_DIR;
-use crate::DEFAULT_CONTAINER_PADDING;
-use crate::DEFAULT_WORKSPACE_PADDING;
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::FLOATING_APPLICATIONS;
-use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
-use crate::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::PerAnimationPrefixConfig;
 use crate::animation::ANIMATION_DURATION_GLOBAL;
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
@@ -31,15 +7,35 @@ use crate::animation::ANIMATION_FPS;
 use crate::animation::ANIMATION_STYLE_GLOBAL;
 use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
 use crate::animation::DEFAULT_ANIMATION_FPS;
-use crate::animation::PerAnimationPrefixConfig;
+use crate::asc::ApplicationSpecificConfiguration;
+use crate::asc::AscApplicationRulesOrSchema;
 use crate::border_manager;
+use crate::border_manager::ZOrder;
 use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
-use crate::border_manager::ZOrder;
 use crate::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;
@@ -61,35 +57,37 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
-
-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 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 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;
@@ -97,12 +95,13 @@ use std::collections::HashSet;
 use std::io::ErrorKind;
 use std::io::Write;
 use std::path::PathBuf;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct BorderColours {
     /// Border colour when the container contains a single window
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -121,7 +120,8 @@ pub struct BorderColours {
     pub unfocused: Option<Colour>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WorkspaceConfig {
     /// Name
     pub name: String,
@@ -243,7 +243,8 @@ impl From<&Workspace> for WorkspaceConfig {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MonitorConfig {
     /// Workspace configurations
     pub workspaces: Vec<WorkspaceConfig>,
@@ -301,7 +302,8 @@ impl From<&Monitor> for MonitorConfig {
     }
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 /// The `komorebi.json` static configuration file reference for `v0.1.35`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
@@ -449,7 +451,8 @@ pub struct StaticConfig {
     pub floating_window_aspect_ratio: Option<AspectRatio>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct AnimationsConfig {
     /// Enable or disable animations (default: false)
     pub enabled: PerAnimationPrefixConfig<bool>,
@@ -464,7 +467,8 @@ pub struct AnimationsConfig {
     pub fps: Option<u64>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "palette")]
 pub enum KomorebiTheme {
     /// A theme from catppuccin-egui
@@ -555,9 +559,7 @@ impl StaticConfig {
         }
 
         if display {
-            println!(
-                "\nEnd-of-life features will not receive any further bug fixes or updates; they should not be used\n"
-            )
+            println!("\nEnd-of-life features will not receive any further bug fixes or updates; they should not be used\n")
         }
     }
 
@@ -582,9 +584,7 @@ impl StaticConfig {
         }
 
         if display {
-            println!(
-                "\nYour configuration file contains some options that have been renamed or deprecated:\n"
-            );
+            println!("\nYour configuration file contains some options that have been renamed or deprecated:\n");
             for (canonical, aliases) in map {
                 for alias in aliases {
                     if raw.contains(alias) {
@@ -618,7 +618,8 @@ impl StaticConfig {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct TabsConfig {
     /// Width of a stackbar tab
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -640,7 +641,8 @@ pub struct TabsConfig {
     pub font_size: Option<i32>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 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::OnceLock;
 use std::sync::atomic::Ordering;
+use std::sync::OnceLock;
 
 pub struct Notification(KomorebiTheme);
 
@@ -50,15 +50,13 @@ pub fn send_notification(theme: KomorebiTheme) {
 }
 
 pub fn listen_for_notifications() {
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications() {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications() {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });

komorebi/src/transparency_manager.rs

@@ -4,17 +4,17 @@ use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
-use std::sync::Arc;
-use std::sync::OnceLock;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU8;
+use std::sync::Arc;
+use std::sync::OnceLock;
 
-use crate::REGEX_IDENTIFIERS;
-use crate::TRANSPARENCY_BLACKLIST;
+use crate::should_act;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowsApi;
-use crate::should_act;
+use crate::REGEX_IDENTIFIERS;
+use crate::TRANSPARENCY_BLACKLIST;
 
 pub static TRANSPARENCY_ENABLED: AtomicBool = AtomicBool::new(false);
 pub static TRANSPARENCY_ALPHA: AtomicU8 = AtomicU8::new(200);
@@ -49,15 +49,13 @@ pub fn send_notification() {
 }
 
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || {
-        loop {
-            match handle_notifications(wm.clone()) {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
             }
         }
     });
@@ -177,9 +175,7 @@ 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,7 +1,8 @@
-use crate::AnimationStyle;
-use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
-use crate::SLOW_APPLICATION_COMPENSATION_TIME;
-use crate::SLOW_APPLICATION_IDENTIFIERS;
+use crate::animation::lerp::Lerp;
+use crate::animation::prefix::new_animation_key;
+use crate::animation::prefix::AnimationPrefix;
+use crate::animation::AnimationEngine;
+use crate::animation::RenderDispatcher;
 use crate::animation::ANIMATION_DURATION_GLOBAL;
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_GLOBAL;
@@ -9,15 +10,43 @@ 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;
@@ -27,47 +56,15 @@ 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, JsonSchema, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Window {
     pub hwnd: isize,
 }
@@ -87,7 +84,8 @@ impl From<HWND> for Window {
 }
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WindowDetails {
     pub title: String,
     pub exe: String,
@@ -299,9 +297,8 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
     }
 }
 
-#[derive(
-    Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
-)]
+#[derive(Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum AspectRatio {
     /// A predefined aspect ratio
@@ -316,9 +313,8 @@ impl Default for AspectRatio {
     }
 }
 
-#[derive(
-    Copy, Clone, Debug, Default, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
-)]
+#[derive(Copy, Clone, Debug, Default, Display, EnumString, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum PredefinedAspectRatio {
     /// 21:9
     Ultrawide,
@@ -886,7 +882,7 @@ fn window_is_eligible(
     let regex_identifiers = REGEX_IDENTIFIERS.lock();
 
     let ignore_identifiers = IGNORE_IDENTIFIERS.lock();
-    let should_ignore = match should_act(
+    let should_ignore = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
@@ -894,15 +890,14 @@ fn window_is_eligible(
         &ignore_identifiers,
         &regex_identifiers,
     ) {
-        Some(rule) => {
-            debug.matches_ignore_identifier = Some(rule);
-            true
-        }
-        _ => false,
+        debug.matches_ignore_identifier = Some(rule);
+        true
+    } else {
+        false
     };
 
     let manage_identifiers = MANAGE_IDENTIFIERS.lock();
-    let managed_override = match should_act(
+    let managed_override = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
@@ -910,11 +905,10 @@ fn window_is_eligible(
         &manage_identifiers,
         &regex_identifiers,
     ) {
-        Some(rule) => {
-            debug.matches_managed_override = Some(rule);
-            true
-        }
-        _ => false,
+        debug.matches_managed_override = Some(rule);
+        true
+    } else {
+        false
     };
 
     let floating_identifiers = FLOATING_APPLICATIONS.lock();
@@ -934,7 +928,7 @@ fn window_is_eligible(
     }
 
     let layered_whitelist = LAYERED_WHITELIST.lock();
-    let mut allow_layered = match should_act(
+    let mut allow_layered = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
@@ -942,11 +936,10 @@ fn window_is_eligible(
         &layered_whitelist,
         &regex_identifiers,
     ) {
-        Some(rule) => {
-            debug.matches_layered_whitelist = Some(rule);
-            true
-        }
-        _ => false,
+        debug.matches_layered_whitelist = Some(rule);
+        true
+    } else {
+        false
     };
 
     let known_layered_hwnds = transparency_manager::known_hwnds();
@@ -973,7 +966,7 @@ fn window_is_eligible(
     };
 
     let titlebars_removed = NO_TITLEBAR.lock();
-    let allow_titlebar_removed = match should_act(
+    let allow_titlebar_removed = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
@@ -981,11 +974,10 @@ fn window_is_eligible(
         &titlebars_removed,
         &regex_identifiers,
     ) {
-        Some(rule) => {
-            debug.matches_no_titlebar = Some(rule);
-            true
-        }
-        _ => false,
+        debug.matches_no_titlebar = Some(rule);
+        true
+    } else {
+        false
     };
 
     {

komorebi/src/window_manager.rs

@@ -8,26 +8,27 @@ use std::net::Shutdown;
 use std::num::NonZeroUsize;
 use std::path::Path;
 use std::path::PathBuf;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
-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::animation::AnimationEngine;
+use crate::core::config_generation::MatchingRule;
+use crate::core::custom_layout::CustomLayout;
 use crate::core::Arrangement;
 use crate::core::Axis;
 use crate::core::BorderImplementation;
@@ -45,30 +46,7 @@ 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;
@@ -99,6 +77,27 @@ 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 {
@@ -126,7 +125,8 @@ pub struct WindowManager {
 }
 
 #[allow(clippy::struct_excessive_bools)]
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct State {
     pub monitors: Ring<Monitor>,
     pub monitor_usr_idx_map: HashMap<usize, usize>,
@@ -191,7 +191,8 @@ impl State {
 }
 
 #[allow(clippy::struct_excessive_bools)]
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct GlobalState {
     pub border_enabled: bool,
     pub border_colours: BorderColours,
@@ -1317,41 +1318,32 @@ impl WindowManager {
             .update_focused_workspace(offset)?;
 
         if follow_focus {
-            match self.focused_workspace()?.maximized_window() {
-                Some(window) => {
+            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() {
                     if trigger_focus {
                         window.focus(self.mouse_follows_focus)?;
                     }
                 }
-                _ => match self.focused_workspace()?.monocle_container() {
-                    Some(container) => {
-                        if let Some(window) = container.focused_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_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() {
@@ -2520,10 +2512,12 @@ impl WindowManager {
 
         tracing::info!("cycling container windows");
 
-        let container = match self.focused_workspace_mut()?.monocle_container_mut() {
-            Some(container) => container,
-            _ => self.focused_container_mut()?,
-        };
+        let container =
+            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
+                container
+            } else {
+                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"))?;
@@ -2550,10 +2544,12 @@ impl WindowManager {
 
         tracing::info!("cycling container window index");
 
-        let container = match self.focused_workspace_mut()?.monocle_container_mut() {
-            Some(container) => container,
-            _ => self.focused_container_mut()?,
-        };
+        let container =
+            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
+                container
+            } else {
+                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"))?;
@@ -2578,10 +2574,12 @@ impl WindowManager {
 
         tracing::info!("focusing container window at index {idx}");
 
-        let container = match self.focused_workspace_mut()?.monocle_container_mut() {
-            Some(container) => container,
-            _ => self.focused_container_mut()?,
-        };
+        let container =
+            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
+                container
+            } else {
+                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, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "type", content = "content")]
 pub enum WindowManagerEvent {
     Destroy(WinEvent, Window),

komorebi/src/windows_api.rs

@@ -4,12 +4,15 @@ 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 windows::Win32::Foundation::COLORREF;
+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::HANDLE;
 use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HMODULE;
@@ -18,9 +21,8 @@ use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
-use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
-use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
+use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
 use windows::Win32::Graphics::Dwm::DWMWA_BORDER_COLOR;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
 use windows::Win32::Graphics::Dwm::DWMWA_COLOR_NONE;
@@ -28,56 +30,52 @@ use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
 use windows::Win32::Graphics::Dwm::DWMWA_WINDOW_CORNER_PREFERENCE;
 use windows::Win32::Graphics::Dwm::DWMWCP_ROUND;
 use windows::Win32::Graphics::Dwm::DWMWINDOWATTRIBUTE;
-use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
-use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
-use windows::Win32::Graphics::Gdi::HBRUSH;
-use windows::Win32::Graphics::Gdi::HDC;
-use windows::Win32::Graphics::Gdi::HMONITOR;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
-use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
-use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
-use windows::Win32::Graphics::Gdi::MONITORINFOEXW;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::RoundRect;
+use windows::Win32::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::HPOWERNOTIFY;
 use windows::Win32::System::Power::RegisterPowerSettingNotification;
+use windows::Win32::System::Power::HPOWERNOTIFY;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
 use windows::Win32::System::RemoteDesktop::WTSRegisterSessionNotification;
 use windows::Win32::System::Threading::GetCurrentProcessId;
 use windows::Win32::System::Threading::OpenProcess;
+use windows::Win32::System::Threading::QueryFullProcessImageNameW;
 use windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS;
 use windows::Win32::System::Threading::PROCESS_NAME_WIN32;
 use windows::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
-use windows::Win32::System::Threading::QueryFullProcessImageNameW;
-use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::HiDpi::GetDpiForMonitor;
-use windows::Win32::UI::HiDpi::MDT_EFFECTIVE_DPI;
 use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
+use windows::Win32::UI::HiDpi::MDT_EFFECTIVE_DPI;
 use windows::Win32::UI::Input::KeyboardAndMouse::GetKeyState;
+use windows::Win32::UI::Input::KeyboardAndMouse::SendInput;
 use windows::Win32::UI::Input::KeyboardAndMouse::INPUT;
 use windows::Win32::UI::Input::KeyboardAndMouse::INPUT_0;
 use windows::Win32::UI::Input::KeyboardAndMouse::INPUT_MOUSE;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEEVENTF_LEFTDOWN;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEEVENTF_LEFTUP;
 use windows::Win32::UI::Input::KeyboardAndMouse::MOUSEINPUT;
-use windows::Win32::UI::Input::KeyboardAndMouse::SendInput;
 use windows::Win32::UI::Input::KeyboardAndMouse::VK_LBUTTON;
 use windows::Win32::UI::Input::KeyboardAndMouse::VK_MENU;
 use windows::Win32::UI::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;
@@ -88,37 +86,15 @@ use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowRect;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowTextW;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
-use windows::Win32::UI::WindowsAndMessaging::HDEVNOTIFY;
-use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
-use windows::Win32::UI::WindowsAndMessaging::HWND_TOP;
 use windows::Win32::UI::WindowsAndMessaging::IsIconic;
 use windows::Win32::UI::WindowsAndMessaging::IsWindow;
 use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
 use windows::Win32::UI::WindowsAndMessaging::IsZoomed;
-use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
 use windows::Win32::UI::WindowsAndMessaging::MoveWindow;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
-use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterDeviceNotificationW;
-use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
-use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
-use windows::Win32::UI::WindowsAndMessaging::SPI_GETACTIVEWINDOWTRACKING;
-use windows::Win32::UI::WindowsAndMessaging::SPI_GETFOREGROUNDLOCKTIMEOUT;
-use windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
-use windows::Win32::UI::WindowsAndMessaging::SPI_SETFOREGROUNDLOCKTIMEOUT;
-use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
-use windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
-use windows::Win32::UI::WindowsAndMessaging::SW_MINIMIZE;
-use windows::Win32::UI::WindowsAndMessaging::SW_NORMAL;
-use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNOACTIVATE;
-use windows::Win32::UI::WindowsAndMessaging::SWP_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;
@@ -126,6 +102,34 @@ 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;
@@ -136,27 +140,23 @@ 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_2021) => {
+    ($value:expr) => {
         $value as *mut core::ffi::c_void
     };
 }
@@ -1037,9 +1037,7 @@ impl WindowsApi {
         tracing::info!("current value of ForegroundLockTimeout is {value}");
 
         if value != 0 {
-            tracing::info!(
-                "updating value of ForegroundLockTimeout to {value} in order to enable keyboard-driven focus updating"
-            );
+            tracing::info!("updating value of ForegroundLockTimeout to {value} in order to enable keyboard-driven focus updating");
 
             Self::system_parameters_info_w(
                 SPI_SETFOREGROUNDLOCKTIMEOUT,

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,6 +1,5 @@
 #![allow(clippy::use_self)]
 
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -89,7 +88,8 @@ 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, JsonSchema)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Display)]
+#[cfg_attr(feature = "schemars", derive(schemars::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,13 +4,12 @@ use std::fmt::Formatter;
 use std::num::NonZeroUsize;
 use std::sync::atomic::Ordering;
 
-use color_eyre::Result;
 use color_eyre::eyre::anyhow;
+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;
 
@@ -22,13 +21,6 @@ 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;
@@ -40,20 +32,19 @@ 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,
-    JsonSchema,
-    PartialEq,
+    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, PartialEq,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
     pub name: Option<String>,
@@ -103,7 +94,8 @@ pub struct Workspace {
     pub workspace_config: Option<WorkspaceConfig>,
 }
 
-#[derive(Debug, Default, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
+#[derive(Debug, Default, Copy, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum WorkspaceLayer {
     #[default]
     Tiling,
@@ -169,9 +161,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::WindowManager;
 use crate::border_manager;
+use crate::WindowManager;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
@@ -51,18 +51,16 @@ 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 = "2024"
+edition = "2021"
 
 # 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 = "2024"
+edition = "2021"
 
 # 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 }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 shadow-rs = { workspace = true }
@@ -34,5 +34,9 @@ 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,31 +17,28 @@ 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;
@@ -1541,9 +1538,7 @@ 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) => {
@@ -1589,12 +1584,8 @@ 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 => {
@@ -1658,23 +1649,16 @@ 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());
                             }
                         }
                     }
@@ -1692,14 +1676,9 @@ 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");
@@ -1709,17 +1688,13 @@ 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();
@@ -1741,9 +1716,7 @@ 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}");
                     }
                 }
             }
@@ -2058,45 +2031,38 @@ 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 = 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")
-                            })?)
-                        }
+            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")
+                        })?)
                     }
                 }
-                _ => None,
+            } else {
+                None
             };
 
             let mut flags = vec![];
@@ -2298,28 +2264,18 @@ if (!(Get-Process masir -ErrorAction SilentlyContinue))
 
             println!("\nThank you for using komorebi!\n");
             println!("# Commercial Use License");
-            println!(
-                "* View licensing options https://lgug2z.com/software/komorebi - A commercial use license is required to use komorebi at work"
-            );
+            println!("* View licensing options https://lgug2z.com/software/komorebi - A commercial use license is required to use komorebi at work");
             println!("\n# Personal Use Sponsorship");
-            println!(
-                "* Become a sponsor https://github.com/sponsors/LGUG2Z - $5/month makes a big difference"
-            );
+            println!("* Become a sponsor https://github.com/sponsors/LGUG2Z - $5/month makes a big difference");
             println!("* Leave a tip https://ko-fi.com/lgug2z - An alternative to GitHub Sponsors");
             println!("\n# Community");
-            println!(
-                "* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops"
-            );
+            println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
             println!(
                 "* Subscribe to https://youtube.com/@LGUG2Z - Development videos, feature previews and release overviews"
             );
-            println!(
-                "* Explore the Awesome Komorebi list https://github.com/LGUG2Z/awesome-komorebi - Projects in the komorebi ecosystem"
-            );
+            println!("* Explore the Awesome Komorebi list https://github.com/LGUG2Z/awesome-komorebi - Projects in the komorebi ecosystem");
             println!("\n# Documentation");
-            println!(
-                "* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands"
-            );
+            println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");
 
             let bar_config = arg.config.map_or_else(
                 || {
@@ -2366,9 +2322,7 @@ if (!(Get-Process masir -ErrorAction SilentlyContinue))
                 {
                     let trimmed = release.tag_name.trim_start_matches("v");
                     if trimmed > version {
-                        println!(
-                            "An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}"
-                        );
+                        println!("An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}");
                     }
                 }
             }
@@ -2993,9 +2947,7 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
 
             file.write_all(formatted_content.as_bytes())?;
 
-            println!(
-                "File successfully formatted for PRs to https://github.com/LGUG2Z/komorebi-application-specific-configuration"
-            );
+            println!("File successfully formatted for PRs to https://github.com/LGUG2Z/komorebi-application-specific-configuration");
         }
         SubCommand::FetchAppSpecificConfiguration => {
             let content = reqwest::blocking::get("https://raw.githubusercontent.com/LGUG2Z/komorebi-application-specific-configuration/master/applications.json")?
@@ -3011,40 +2963,50 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
 
             file.write_all(content.as_bytes())?;
 
+            println!("Latest version of applications.json from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n");
             println!(
-                "Latest version of applications.json from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n"
-            );
-            println!(
-                "You can add this to your komorebi.json static configuration file like this: \n\n\"app_specific_configuration_path\": \"{}\"",
-                output_file.display().to_string().replace("\\", "/")
+               "You can add this to your komorebi.json static configuration file like this: \n\n\"app_specific_configuration_path\": \"{}\"",
+               output_file.display().to_string().replace("\\", "/")
             );
         }
         SubCommand::ApplicationSpecificConfigurationSchema => {
-            let asc = schema_for!(ApplicationSpecificConfiguration);
-            let schema = serde_json::to_string_pretty(&asc)?;
-            println!("{schema}");
+            #[cfg(feature = "schemars")]
+            {
+                let asc = schemars::schema_for!(ApplicationSpecificConfiguration);
+                let schema = serde_json::to_string_pretty(&asc)?;
+                println!("{schema}");
+            }
         }
         SubCommand::NotificationSchema => {
-            let notification = schema_for!(Notification);
-            let schema = serde_json::to_string_pretty(&notification)?;
-            println!("{schema}");
+            #[cfg(feature = "schemars")]
+            {
+                let notification = schemars::schema_for!(komorebi_client::Notification);
+                let schema = serde_json::to_string_pretty(&notification)?;
+                println!("{schema}");
+            }
         }
         SubCommand::SocketSchema => {
-            let socket_message = schema_for!(SocketMessage);
-            let schema = serde_json::to_string_pretty(&socket_message)?;
-            println!("{schema}");
+            #[cfg(feature = "schemars")]
+            {
+                let socket_message = schemars::schema_for!(SocketMessage);
+                let schema = serde_json::to_string_pretty(&socket_message)?;
+                println!("{schema}");
+            }
         }
         SubCommand::StaticConfigSchema => {
-            let settings = SchemaSettings::default().with(|s| {
-                s.option_nullable = false;
-                s.option_add_null_type = false;
-                s.inline_subschemas = true;
-            });
+            #[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 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}");
+                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}");
+            }
         }
         SubCommand::GenerateStaticConfig => {
             print_query(&SocketMessage::GenerateStaticConfig);

schema.bar.json

@@ -511,9 +511,53 @@
                       "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"
                       }
                     }
                   },
@@ -1865,9 +1909,53 @@
                       "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"
                       }
                     }
                   },
@@ -3152,9 +3240,53 @@
                       "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"
                       }
                     }
                   },