wip

.github/workflows/feature-check.yaml

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

.github/workflows/windows.yaml

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

Cargo.toml

@@ -9,7 +9,7 @@ members = [
     "komorebic-no-console",
     "komorebi-bar",
     "komorebi-themes",
-    "komorebi-shortcuts",
+    "komorebi-shortcuts"
 ]
 
 [workspace.dependencies]
@@ -52,7 +52,7 @@ features = [
     "Win32_Devices",
     "Win32_Devices_Display",
     "Win32_System_Com",
-    "Win32_UI_Shell_Common",           # for IObjectArray
+    "Win32_UI_Shell_Common", # for IObjectArray
     "Win32_Foundation",
     "Win32_Globalization",
     "Win32_Graphics_Dwm",
@@ -73,12 +73,5 @@ features = [
     "Win32_System_SystemServices",
     "Win32_System_WindowsProgramming",
     "Media",
-    "Media_Control",
+    "Media_Control"
 ]
-
-[profile.release-opt]
-inherits = "release"
-lto = true
-panic = "abort"
-codegen-units = 1
-strip = true

README.md

@@ -394,7 +394,7 @@ every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust c
 Below is a simple example of how to use `komorebi-client` in a basic Rust application.
 
 ```rust
-// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.38"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.37"}
 
 use anyhow::Result;
 use komorebi_client::Notification;

deny.toml

@@ -14,8 +14,7 @@ feature-depth = 1
 ignore = [
     { id = "RUSTSEC-2020-0016", reason = "local tcp connectivity is an opt-in feature, and there is no upgrade path for TcpStreamExt" },
     { id = "RUSTSEC-2024-0436", reason = "paste being unmaintained is not an issue in our use" },
-    { id = "RUSTSEC-2024-0320", reason = "not using any yaml features from this library" },
-    { id = "RUSTSEC-2025-0056", reason = "only used for colour palette generation" }
+    { id = "RUSTSEC-2024-0320", reason = "not using any yaml features from this library" }
 ]
 
 [licenses]

docs/cli/change-layout.md

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

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

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

docs/cli/named-workspace-layout.md

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

docs/cli/scrolling-layout-columns.md

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

docs/cli/toggle-pause.md

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

docs/cli/workspace-layout-rule.md

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

docs/cli/workspace-layout.md

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

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

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

docs/komorebi.bar.example.json

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

docs/komorebi.example.json

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

komorebi-bar/Cargo.toml

@@ -22,7 +22,7 @@ font-loader = "0.11"
 hotwatch = { workspace = true }
 image = "0.25"
 lazy_static = { workspace = true }
-netdev = "0.36"
+netdev = "0.34"
 num = "0.4"
 num-derive = "0.4"
 num-traits = "0.2"

komorebi-bar/src/bar.rs

@@ -10,7 +10,7 @@ use crate::render::Grouping;
 use crate::render::RenderConfig;
 use crate::render::RenderExt;
 use crate::widgets::komorebi::Komorebi;
-use crate::widgets::komorebi::MonitorInfo;
+use crate::widgets::komorebi::KomorebiNotificationState;
 use crate::widgets::widget::BarWidget;
 use crate::widgets::widget::WidgetConfig;
 use crate::KomorebiEvent;
@@ -47,14 +47,17 @@ use eframe::egui::Visuals;
 use font_loader::system_fonts;
 use font_loader::system_fonts::FontPropertyBuilder;
 use komorebi_client::Colour;
+use komorebi_client::KomorebiTheme;
 use komorebi_client::MonitorNotification;
 use komorebi_client::NotificationEvent;
 use komorebi_client::PathExt;
 use komorebi_client::SocketMessage;
 use komorebi_client::VirtualDesktopNotification;
 use komorebi_themes::catppuccin_egui;
+use komorebi_themes::Base16Value;
 use komorebi_themes::Base16Wrapper;
 use komorebi_themes::Catppuccin;
+use komorebi_themes::CatppuccinValue;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use std::cell::RefCell;
@@ -125,7 +128,7 @@ fn stop_powershell() -> Result<()> {
 
 pub fn exec_powershell(cmd: &str) -> Result<()> {
     if let Some(session_stdin) = SESSION_STDIN.lock().as_mut() {
-        if let Err(e) = writeln!(session_stdin, "{cmd}") {
+        if let Err(e) = writeln!(session_stdin, "{}", cmd) {
             tracing::error!(error = %e, cmd = cmd, "failed to write command to PowerShell stdin");
             return Err(e);
         }
@@ -150,7 +153,7 @@ pub struct Komobar {
     pub disabled: bool,
     pub config: KomobarConfig,
     pub render_config: Rc<RefCell<RenderConfig>>,
-    pub monitor_info: Option<Rc<RefCell<MonitorInfo>>>,
+    pub komorebi_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     pub left_widgets: Vec<Box<dyn BarWidget>>,
     pub center_widgets: Vec<Box<dyn BarWidget>>,
     pub right_widgets: Vec<Box<dyn BarWidget>>,
@@ -342,7 +345,7 @@ impl Komobar {
     pub fn apply_config(
         &mut self,
         ctx: &Context,
-        previous_monitor_info: Option<Rc<RefCell<MonitorInfo>>>,
+        previous_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     ) {
         MAX_LABEL_WIDTH.store(
             self.config.max_label_width.unwrap_or(400.0) as i32,
@@ -371,7 +374,7 @@ impl Komobar {
             self.config.icon_scale,
         ));
 
-        let mut monitor_info = previous_monitor_info;
+        let mut komorebi_notification_state = previous_notification_state;
         let mut komorebi_widgets = Vec::new();
 
         for (idx, widget_config) in self.config.left_widgets.iter().enumerate() {
@@ -423,18 +426,19 @@ impl Komobar {
             komorebi_widgets
                 .into_iter()
                 .for_each(|(mut widget, idx, side)| {
-                    match monitor_info {
+                    match komorebi_notification_state {
                         None => {
-                            monitor_info = Some(widget.monitor_info.clone());
+                            komorebi_notification_state =
+                                Some(widget.komorebi_notification_state.clone());
                         }
                         Some(ref previous) => {
-                            if widget.workspaces.is_some() {
-                                previous
-                                    .borrow_mut()
-                                    .update_from_self(&widget.monitor_info.borrow());
+                            if widget.workspaces.is_some_and(|w| w.enable) {
+                                previous.borrow_mut().update_from_config(
+                                    &widget.komorebi_notification_state.borrow(),
+                                );
                             }
 
-                            widget.monitor_info = previous.clone();
+                            widget.komorebi_notification_state = previous.clone();
                         }
                     }
 
@@ -460,17 +464,17 @@ impl Komobar {
             MonitorConfigOrIndex::Index(idx) => (*idx, None),
         };
 
-        let mapped_info = self.monitor_info.as_ref().map(|info| {
-            let monitor = info.borrow();
+        let mapped_state = self.komorebi_notification_state.as_ref().map(|state| {
+            let state = state.borrow();
             (
-                monitor.monitor_usr_idx_map.get(&usr_monitor_index).copied(),
-                monitor.mouse_follows_focus,
+                state.monitor_usr_idx_map.get(&usr_monitor_index).copied(),
+                state.mouse_follows_focus,
             )
         });
 
-        if let Some(info) = mapped_info {
-            self.monitor_index = info.0;
-            self.mouse_follows_focus = info.1;
+        if let Some(state) = mapped_state {
+            self.monitor_index = state.0;
+            self.mouse_follows_focus = state.1;
         }
 
         if let Some(monitor_index) = self.monitor_index {
@@ -522,7 +526,7 @@ impl Komobar {
                     }
                 }
             }
-        } else if self.monitor_info.is_some() && !self.disabled {
+        } else if self.komorebi_notification_state.is_some() && !self.disabled {
             tracing::warn!("couldn't find the monitor index of this bar! Disabling the bar until the monitor connects...");
             self.disabled = true;
         } else {
@@ -562,7 +566,7 @@ impl Komobar {
 
         tracing::info!("widget configuration options applied");
 
-        self.monitor_info = monitor_info;
+        self.komorebi_notification_state = komorebi_notification_state;
     }
 
     /// Updates the `size_rect` field. Returns a bool indicating if the field was changed or not
@@ -631,7 +635,8 @@ impl Komobar {
 
                         assert!(
                             home.is_dir(),
-                            "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                            "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                            home_path
                         );
 
                         home
@@ -645,6 +650,26 @@ impl Komobar {
                 match komorebi_client::StaticConfig::read(&config) {
                     Ok(config) => {
                         if let Some(theme) = config.theme {
+                            let stack_accent = match theme {
+                                KomorebiTheme::Catppuccin {
+                                    name, stack_border, ..
+                                } => stack_border
+                                    .unwrap_or(CatppuccinValue::Green)
+                                    .color32(name.as_theme()),
+                                KomorebiTheme::Base16 {
+                                    name, stack_border, ..
+                                } => stack_border
+                                    .unwrap_or(Base16Value::Base0B)
+                                    .color32(Base16Wrapper::Base16(name)),
+                                KomorebiTheme::Custom {
+                                    ref colours,
+                                    stack_border,
+                                    ..
+                                } => stack_border
+                                    .unwrap_or(Base16Value::Base0B)
+                                    .color32(Base16Wrapper::Custom(colours.clone())),
+                            };
+
                             apply_theme(
                                 ctx,
                                 KomobarTheme::from(theme),
@@ -654,6 +679,10 @@ impl Komobar {
                                 bar_grouping,
                                 self.render_config.clone(),
                             );
+
+                            if let Some(state) = &self.komorebi_notification_state {
+                                state.borrow_mut().stack_accent = Some(stack_accent);
+                            }
                         }
                     }
                     Err(_) => {
@@ -696,7 +725,7 @@ impl Komobar {
             disabled: false,
             config,
             render_config: Rc::new(RefCell::new(RenderConfig::new())),
-            monitor_info: None,
+            komorebi_notification_state: None,
             left_widgets: vec![],
             center_widgets: vec![],
             right_widgets: vec![],
@@ -842,12 +871,12 @@ impl eframe::App for Komobar {
 
         if self.scale_factor != ctx.native_pixels_per_point().unwrap_or(1.0) {
             self.scale_factor = ctx.native_pixels_per_point().unwrap_or(1.0);
-            self.apply_config(ctx, self.monitor_info.clone());
+            self.apply_config(ctx, self.komorebi_notification_state.clone());
         }
 
         if let Ok(updated_config) = self.rx_config.try_recv() {
             self.config = updated_config;
-            self.apply_config(ctx, self.monitor_info.clone());
+            self.apply_config(ctx, self.komorebi_notification_state.clone());
         }
 
         match self.rx_gui.try_recv() {
@@ -972,26 +1001,24 @@ impl eframe::App for Komobar {
                     }
                 }
 
-                if let Some(monitor_info) = &self.monitor_info {
-                    monitor_info.borrow_mut().update(
-                        self.monitor_index,
-                        notification.state,
-                        self.render_config.borrow().show_all_icons,
-                    );
-                    handle_notification(
-                        ctx,
-                        notification.event,
-                        self.bg_color.clone(),
-                        self.bg_color_with_alpha.clone(),
-                        self.config.transparency_alpha,
-                        self.config.grouping,
-                        self.config.theme.clone(),
-                        self.render_config.clone(),
-                    );
+                if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
+                    komorebi_notification_state
+                        .borrow_mut()
+                        .handle_notification(
+                            ctx,
+                            self.monitor_index,
+                            notification,
+                            self.bg_color.clone(),
+                            self.bg_color_with_alpha.clone(),
+                            self.config.transparency_alpha,
+                            self.config.grouping,
+                            self.config.theme.clone(),
+                            self.render_config.clone(),
+                        );
                 }
 
                 if should_apply_config {
-                    self.apply_config(ctx, self.monitor_info.clone());
+                    self.apply_config(ctx, self.komorebi_notification_state.clone());
 
                     // Reposition the Bar
                     self.position_bar();
@@ -1317,64 +1344,3 @@ pub enum Alignment {
     Center,
     Right,
 }
-
-#[allow(clippy::too_many_arguments)]
-fn handle_notification(
-    ctx: &Context,
-    event: komorebi_client::NotificationEvent,
-    bg_color: Rc<RefCell<Color32>>,
-    bg_color_with_alpha: Rc<RefCell<Color32>>,
-    transparency_alpha: Option<u8>,
-    grouping: Option<Grouping>,
-    default_theme: Option<KomobarTheme>,
-    render_config: Rc<RefCell<RenderConfig>>,
-) {
-    if let NotificationEvent::Socket(message) = event {
-        match message {
-            SocketMessage::ReloadStaticConfiguration(path) => {
-                if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
-                    if let Some(theme) = config.theme {
-                        apply_theme(
-                            ctx,
-                            KomobarTheme::from(theme),
-                            bg_color.clone(),
-                            bg_color_with_alpha.clone(),
-                            transparency_alpha,
-                            grouping,
-                            render_config,
-                        );
-                        tracing::info!("applied theme from updated komorebi.json");
-                    } else if let Some(default_theme) = default_theme {
-                        apply_theme(
-                            ctx,
-                            default_theme,
-                            bg_color.clone(),
-                            bg_color_with_alpha.clone(),
-                            transparency_alpha,
-                            grouping,
-                            render_config,
-                        );
-                        tracing::info!(
-                            "removed theme from updated komorebi.json and applied default theme"
-                        );
-                    } else {
-                        tracing::warn!("theme was removed from updated komorebi.json but there was no default theme to apply");
-                    }
-                }
-            }
-            SocketMessage::Theme(theme) => {
-                apply_theme(
-                    ctx,
-                    KomobarTheme::from(*theme),
-                    bg_color,
-                    bg_color_with_alpha.clone(),
-                    transparency_alpha,
-                    grouping,
-                    render_config,
-                );
-                tracing::info!("applied theme from komorebi socket message");
-            }
-            _ => {}
-        }
-    }
-}

komorebi-bar/src/config.rs

@@ -332,7 +332,6 @@ pub fn get_individual_spacing(
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-#[serde(untagged)]
 pub enum MouseMessage {
     /// Send a message to the komorebi client.
     /// By default, a batch of messages are sent in the following order:
@@ -368,10 +367,12 @@ pub enum MouseMessage {
     ///   }
     /// }
     /// ```
+    #[serde(untagged)]
     Komorebi(KomorebiMouseMessage),
     /// Execute a custom command.
     /// CMD (%variable%), Bash ($variable) and PowerShell ($Env:variable) variables will be resolved.
     /// Example: `komorebic toggle-pause`
+    #[serde(untagged)]
     Command(String),
 }
 

komorebi-bar/src/main.rs

@@ -159,7 +159,8 @@ fn main() -> color_eyre::Result<()> {
 
             assert!(
                 home.is_dir(),
-                "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                home_path
             );
 
             home

komorebi-bar/src/widgets/battery.rs

@@ -181,7 +181,7 @@ impl BarWidget for Battery {
                             .args(["/C", "start", "ms-settings:batterysaver"])
                             .spawn()
                         {
-                            eprintln!("{error}")
+                            eprintln!("{}", error)
                         }
                     }
                 });

komorebi-bar/src/widgets/cpu.rs

@@ -76,8 +76,8 @@ impl Cpu {
 
         CpuOutput {
             label: match self.label_prefix {
-                LabelPrefix::Text | LabelPrefix::IconAndText => format!("CPU: {used}%"),
-                LabelPrefix::None | LabelPrefix::Icon => format!("{used}%"),
+                LabelPrefix::Text | LabelPrefix::IconAndText => format!("CPU: {}%", used),
+                LabelPrefix::None | LabelPrefix::Icon => format!("{}%", used),
             },
             selected,
         }
@@ -124,7 +124,7 @@ impl BarWidget for Cpu {
                         if let Err(error) =
                             Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
                         {
-                            eprintln!("{error}")
+                            eprintln!("{}", error)
                         }
                     }
                 });

komorebi-bar/src/widgets/date.rs

@@ -166,7 +166,7 @@ impl Date {
                         .to_string()
                         .trim()
                         .to_string(),
-                    Err(_) => format!("Invalid timezone: {timezone}"),
+                    Err(_) => format!("Invalid timezone: {}", timezone),
                 },
                 None => Local::now()
                     .format(&self.format.fmt_string())

komorebi-bar/src/widgets/komorebi_layout.rs

@@ -41,7 +41,8 @@ impl<'de> Deserialize<'de> for KomorebiLayout {
         let s: String = String::deserialize(deserializer)?;
 
         // Attempt to deserialize the string as a DefaultLayout
-        if let Ok(default_layout) = from_str::<komorebi_client::DefaultLayout>(&format!("\"{s}\""))
+        if let Ok(default_layout) =
+            from_str::<komorebi_client::DefaultLayout>(&format!("\"{}\"", s))
         {
             return Ok(KomorebiLayout::Default(default_layout));
         }
@@ -52,7 +53,7 @@ impl<'de> Deserialize<'de> for KomorebiLayout {
             "Floating" => Ok(KomorebiLayout::Floating),
             "Paused" => Ok(KomorebiLayout::Paused),
             "Custom" => Ok(KomorebiLayout::Custom),
-            _ => Err(Error::custom(format!("Invalid layout: {s}"))),
+            _ => Err(Error::custom(format!("Invalid layout: {}", s))),
         }
     }
 }

komorebi-bar/src/widgets/memory.rs

@@ -79,9 +79,9 @@ impl Memory {
         MemoryOutput {
             label: match self.label_prefix {
                 LabelPrefix::Text | LabelPrefix::IconAndText => {
-                    format!("RAM: {usage}%")
+                    format!("RAM: {}%", usage)
                 }
-                LabelPrefix::None | LabelPrefix::Icon => format!("{usage}%"),
+                LabelPrefix::None | LabelPrefix::Icon => format!("{}%", usage),
             },
             selected,
         }
@@ -128,7 +128,7 @@ impl BarWidget for Memory {
                         if let Err(error) =
                             Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
                         {
-                            eprintln!("{error}")
+                            eprintln!("{}", error)
                         }
                     }
                 });

komorebi-bar/src/widgets/network.rs

@@ -314,7 +314,7 @@ impl Network {
             .clicked()
         {
             if let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn() {
-                eprintln!("{error}");
+                eprintln!("{}", error);
             }
         }
     }
@@ -535,6 +535,6 @@ enum DataUnit {
 
 impl fmt::Display for DataUnit {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{self:?}")
+        write!(f, "{:?}", self)
     }
 }

komorebi-bar/src/widgets/storage.rs

@@ -25,10 +25,6 @@ pub struct StorageConfig {
     pub data_refresh_interval: Option<u64>,
     /// Display label prefix
     pub label_prefix: Option<LabelPrefix>,
-    /// Show disks that are read only. (default: false)
-    pub show_read_only_disks: Option<bool>,
-    /// Show removable disks. (default: true)
-    pub show_removable_disks: Option<bool>,
     /// Select when the current percentage is over this value [[1-100]]
     pub auto_select_over: Option<u8>,
     /// Hide when the current percentage is under this value [[1-100]]
@@ -42,8 +38,6 @@ impl From<StorageConfig> for Storage {
             disks: Disks::new_with_refreshed_list(),
             data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
-            show_read_only_disks: value.show_read_only_disks.unwrap_or(false),
-            show_removable_disks: value.show_removable_disks.unwrap_or(true),
             auto_select_over: value.auto_select_over.map(|o| o.clamp(1, 100)),
             auto_hide_under: value.auto_hide_under.map(|o| o.clamp(1, 100)),
             last_updated: Instant::now(),
@@ -61,8 +55,6 @@ pub struct Storage {
     disks: Disks,
     data_refresh_interval: u64,
     label_prefix: LabelPrefix,
-    show_read_only_disks: bool,
-    show_removable_disks: bool,
     auto_select_over: Option<u8>,
     auto_hide_under: Option<u8>,
     last_updated: Instant,
@@ -79,12 +71,6 @@ impl Storage {
         let mut disks = vec![];
 
         for disk in &self.disks {
-            if disk.is_read_only() && !self.show_read_only_disks {
-                continue;
-            }
-            if disk.is_removable() && !self.show_removable_disks {
-                continue;
-            }
             let mount = disk.mount_point();
             let total = disk.total_space();
             let available = disk.available_space();
@@ -101,7 +87,7 @@ impl Storage {
                         LabelPrefix::Text | LabelPrefix::IconAndText => {
                             format!("{} {}%", mount.to_string_lossy(), percentage)
                         }
-                        LabelPrefix::None | LabelPrefix::Icon => format!("{percentage}%"),
+                        LabelPrefix::None | LabelPrefix::Icon => format!("{}%", percentage),
                     },
                     selected,
                 })
@@ -165,7 +151,7 @@ impl BarWidget for Storage {
                             ])
                             .spawn()
                         {
-                            eprintln!("{error}")
+                            eprintln!("{}", error)
                         }
                     }
                 });

komorebi-bar/src/widgets/time.rs

@@ -209,7 +209,7 @@ impl Time {
                             Some(dt.time()),
                         )
                     }
-                    Err(_) => (format!("Invalid timezone: {timezone:?}"), None),
+                    Err(_) => (format!("Invalid timezone: {:?}", timezone), None),
                 },
                 None => {
                     let dt = Local::now();

komorebi-bar/src/widgets/update.rs

@@ -148,7 +148,7 @@ impl BarWidget for Update {
                             )])
                             .spawn()
                         {
-                            eprintln!("{error}")
+                            eprintln!("{}", error)
                         }
                     }
                 });

komorebi-client/src/lib.rs

@@ -77,7 +77,6 @@ pub use komorebi::WorkspaceConfig;
 
 use komorebi::DATA_DIR;
 
-use std::borrow::Borrow;
 use std::io::BufReader;
 use std::io::Read;
 use std::io::Write;
@@ -95,15 +94,12 @@ pub fn send_message(message: &SocketMessage) -> std::io::Result<()> {
     stream.write_all(serde_json::to_string(message)?.as_bytes())
 }
 
-pub fn send_batch<Q>(messages: impl IntoIterator<Item = Q>) -> std::io::Result<()>
-where
-    Q: Borrow<SocketMessage>,
-{
+pub fn send_batch(messages: impl IntoIterator<Item = SocketMessage>) -> std::io::Result<()> {
     let socket = DATA_DIR.join(KOMOREBI);
     let mut stream = UnixStream::connect(socket)?;
     stream.set_write_timeout(Some(Duration::from_secs(1)))?;
     let msgs = messages.into_iter().fold(String::new(), |mut s, m| {
-        if let Ok(m_str) = serde_json::to_string(m.borrow()) {
+        if let Ok(m_str) = serde_json::to_string(&m) {
             s.push_str(&m_str);
             s.push('\n');
         }

komorebi-shortcuts/src/main.rs

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

komorebi/src/animation/prefix.rs

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

komorebi/src/border_manager/mod.rs

@@ -255,7 +255,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let window_kind = if idx != ws.focused_container_idx()
                                 || monitor_idx != focused_monitor_idx
                             {
-                                if c.locked() {
+                                if ws.locked_containers().contains(&idx) {
                                     WindowKind::UnfocusedLocked
                                 } else {
                                     WindowKind::Unfocused
@@ -563,7 +563,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 || monitor_idx != focused_monitor_idx
                                 || focused_window_hwnd != foreground_window
                             {
-                                if c.locked() {
+                                if ws.locked_containers().contains(&idx) {
                                     WindowKind::UnfocusedLocked
                                 } else {
                                     WindowKind::Unfocused

komorebi/src/container.rs

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

komorebi/src/core/mod.rs

@@ -202,7 +202,6 @@ pub enum SocketMessage {
     StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
-    WorkspaceWorkAreaOffset(usize, usize, Rect),
     ToggleWindowBasedWorkAreaOffset,
     ResizeDelta(i32),
     InitialWorkspaceRule(ApplicationIdentifier, String, usize, usize),

komorebi/src/lib.rs

@@ -8,7 +8,7 @@ pub mod ring;
 pub mod container;
 pub mod core;
 pub mod focus_manager;
-pub mod lockable_sequence;
+pub mod locked_deque;
 pub mod monitor;
 pub mod monitor_reconciliator;
 pub mod process_command;
@@ -200,7 +200,8 @@ lazy_static! {
 
             assert!(
                 home.is_dir(),
-                "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                home_path
             );
 
 
@@ -254,14 +255,6 @@ pub static WINDOW_HANDLING_BEHAVIOUR: AtomicCell<WindowHandlingBehaviour> =
 
 shadow_rs::shadow!(build);
 
-/// A trait for types that can be marked as locked or unlocked.
-pub trait Lockable {
-    /// Returns `true` if the item is locked.
-    fn locked(&self) -> bool;
-    /// Sets the locked state of the item.
-    fn set_locked(&mut self, locked: bool) -> &mut Self;
-}
-
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     let hkcu = RegKey::predef(HKEY_CURRENT_USER);
@@ -306,7 +299,7 @@ pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     current
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum NotificationEvent {
@@ -323,7 +316,7 @@ pub enum VirtualDesktopNotification {
     LeftAssociatedVirtualDesktop,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Notification {
     pub event: NotificationEvent,

komorebi/src/lockable_sequence.rs

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

komorebi/src/locked_deque.rs

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

komorebi/src/monitor.rs

@@ -500,7 +500,7 @@ impl Monitor {
             if workspaces.get(idx).is_none() {
                 workspaces.resize(idx + 1, Workspace::default());
             }
-            self.set_last_focused_workspace(Some(self.workspaces.focused_idx()));
+
             self.workspaces.focus(idx);
         }
 

komorebi/src/monitor_reconciliator/mod.rs

@@ -801,7 +801,7 @@ mod tests {
         let wm = match WindowManager::new(receiver, Some(socket_path.clone())) {
             Ok(manager) => manager,
             Err(e) => {
-                panic!("Failed to create WindowManager: {e}");
+                panic!("Failed to create WindowManager: {}", e);
             }
         };
 
@@ -829,7 +829,7 @@ mod tests {
             Ok(notification) => {
                 assert_eq!(notification, MonitorNotification::ResolutionScalingChanged);
             }
-            Err(e) => panic!("Failed to receive MonitorNotification: {e}"),
+            Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
         }
     }
 
@@ -849,7 +849,7 @@ mod tests {
         for _ in 0..20 {
             let notification = match receiver.try_recv() {
                 Ok(notification) => notification,
-                Err(e) => panic!("Failed to receive MonitorNotification: {e}"),
+                Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
             };
             assert_eq!(
                 notification,
@@ -960,7 +960,7 @@ mod tests {
             Ok(notification) => {
                 assert_eq!(notification, MonitorNotification::DisplayConnectionChange);
             }
-            Err(e) => panic!("Failed to receive MonitorNotification: {e}"),
+            Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
         }
     }
 

komorebi/src/process_command.rs

@@ -209,6 +209,25 @@ impl WindowManager {
         // We don't have From implemented for &mut WindowManager
         let initial_state = State::from(self.as_ref());
 
+        match message {
+            SocketMessage::CycleFocusEmptyWorkspace(_)
+            | SocketMessage::CycleFocusWorkspace(_)
+            | SocketMessage::FocusWorkspaceNumber(_) => {
+                if let Some(monitor) = self.focused_monitor_mut() {
+                    let idx = monitor.focused_workspace_idx();
+                    monitor.set_last_focused_workspace(Option::from(idx));
+                }
+            }
+            SocketMessage::FocusMonitorWorkspaceNumber(target_monitor_idx, _) => {
+                let idx = self.focused_workspace_idx_for_monitor_idx(target_monitor_idx)?;
+                if let Some(monitor) = self.monitors_mut().get_mut(target_monitor_idx) {
+                    monitor.set_last_focused_workspace(Option::from(idx));
+                }
+            }
+
+            _ => {}
+        };
+
         let mut force_update_borders = false;
         match message {
             SocketMessage::Promote => self.promote_container_to_front()?,
@@ -330,7 +349,7 @@ impl WindowManager {
             SocketMessage::StackWindow(direction) => self.add_window_to_container(direction)?,
             SocketMessage::UnstackWindow => self.remove_window_from_container()?,
             SocketMessage::StackAll => self.stack_all()?,
-            SocketMessage::UnstackAll => self.unstack_all(true)?,
+            SocketMessage::UnstackAll => self.unstack_all()?,
             SocketMessage::CycleStack(direction) => {
                 self.cycle_container_window_in_direction(direction)?;
             }
@@ -374,9 +393,7 @@ impl WindowManager {
                     .get_mut(workspace_idx)
                     .ok_or_eyre("no workspace at the given index")?;
 
-                if let Some(container) = workspace.containers_mut().get_mut(container_idx) {
-                    container.set_locked(true);
-                }
+                workspace.locked_containers.insert(container_idx);
             }
             SocketMessage::UnlockMonitorWorkspaceContainer(
                 monitor_idx,
@@ -393,9 +410,7 @@ impl WindowManager {
                     .get_mut(workspace_idx)
                     .ok_or_eyre("no workspace at the given index")?;
 
-                if let Some(container) = workspace.containers_mut().get_mut(container_idx) {
-                    container.set_locked(false);
-                }
+                workspace.locked_containers.remove(&container_idx);
             }
             SocketMessage::ToggleLock => self.toggle_lock()?,
             SocketMessage::ToggleFloat => self.toggle_float(false)?,
@@ -1886,14 +1901,6 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
                     self.retile_all(false)?;
                 }
             }
-            SocketMessage::WorkspaceWorkAreaOffset(monitor_idx, workspace_idx, rect) => {
-                if let Some(monitor) = self.monitors_mut().get_mut(monitor_idx) {
-                    if let Some(workspace) = monitor.workspaces_mut().get_mut(workspace_idx) {
-                        workspace.set_work_area_offset(Option::from(rect));
-                        self.retile_all(false)?
-                    }
-                }
-            }
             SocketMessage::ToggleWindowBasedWorkAreaOffset => {
                 let workspace = self.focused_workspace_mut()?;
                 workspace.set_apply_window_based_work_area_offset(

komorebi/src/ring.rs

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

komorebi/src/stackbar_manager/mod.rs

@@ -28,7 +28,7 @@ pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947);
 pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
 pub static STACKBAR_TAB_HEIGHT: AtomicI32 = AtomicI32::new(40);
 pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
-pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Title);
+pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
 pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::Never);
 
 pub static STACKBAR_TEMPORARILY_DISABLED: AtomicBool = AtomicBool::new(false);

komorebi/src/stackbar_manager/stackbar.rs

@@ -58,19 +58,15 @@ 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::LoadCursorW;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
-use windows::Win32::UI::WindowsAndMessaging::SetCursor;
 use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
 use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::IDC_ARROW;
 use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_LBUTTONDOWN;
-use windows::Win32::UI::WindowsAndMessaging::WM_SETCURSOR;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
@@ -316,16 +312,6 @@ impl Stackbar {
     ) -> LRESULT {
         unsafe {
             match msg {
-                WM_SETCURSOR => match LoadCursorW(None, IDC_ARROW) {
-                    Ok(cursor) => {
-                        SetCursor(Some(cursor));
-                        LRESULT(0)
-                    }
-                    Err(error) => {
-                        tracing::error!("{error}");
-                        LRESULT(1)
-                    }
-                },
                 WM_LBUTTONDOWN => {
                     let stackbars_containers = STACKBARS_CONTAINERS.lock();
                     if let Some(container) = stackbars_containers.get(&(hwnd.0 as isize)) {

komorebi/src/static_config.rs

@@ -192,7 +192,7 @@ pub struct WorkspaceConfig {
     /// Layout (default: BSP)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout: Option<DefaultLayout>,
-    /// Layout-specific options (default: None)
+    /// Layout-specific options(default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout_options: Option<LayoutOptions>,
     /// END OF LIFE FEATURE: Custom Layout (default: None)
@@ -218,9 +218,6 @@ pub struct WorkspaceConfig {
     /// Permanent workspace application rules
     #[serde(skip_serializing_if = "Option::is_none")]
     pub workspace_rules: Option<Vec<MatchingRule>>,
-    /// Workspace specific work area offset (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub work_area_offset: Option<Rect>,
     /// Apply this monitor's window-based work area offset (default: true)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub apply_window_based_work_area_offset: Option<bool>,
@@ -233,9 +230,6 @@ pub struct WorkspaceConfig {
     /// Enable or disable float override, which makes it so every new window opens in floating mode (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub float_override: Option<bool>,
-    /// Enable or disable tiling for the workspace (default: true)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tile: Option<bool>,
     /// Specify an axis on which to flip the selected layout (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout_flip: Option<Axis>,
@@ -284,8 +278,6 @@ impl From<&Workspace> for WorkspaceConfig {
             }
         });
 
-        let tile = if *value.tile() { None } else { Some(false) };
-
         Self {
             name: value
                 .name()
@@ -318,12 +310,10 @@ impl From<&Workspace> for WorkspaceConfig {
                 .workspace_config()
                 .as_ref()
                 .and_then(|c| c.workspace_rules.clone()),
-            work_area_offset: value.work_area_offset(),
             apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
             window_container_behaviour: *value.window_container_behaviour(),
             window_container_behaviour_rules: Option::from(window_container_behaviour_rules),
             float_override: *value.float_override(),
-            tile,
             layout_flip: value.layout_flip(),
             floating_layer_behaviour: value.floating_layer_behaviour(),
             wallpaper: None,
@@ -1942,7 +1932,7 @@ mod tests {
         let docs = vec![
             "0.1.20", "0.1.21", "0.1.22", "0.1.23", "0.1.24", "0.1.25", "0.1.26", "0.1.27",
             "0.1.28", "0.1.29", "0.1.30", "0.1.31", "0.1.32", "0.1.33", "0.1.34", "0.1.35",
-            "0.1.36", "0.1.37",
+            "0.1.36",
         ];
 
         let mut versions = vec![];

komorebi/src/window_manager.rs

@@ -126,7 +126,7 @@ pub struct WindowManager {
 }
 
 #[allow(clippy::struct_excessive_bools)]
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct State {
     pub monitors: Ring<Monitor>,
@@ -337,7 +337,6 @@ impl From<&WindowManager> for State {
                             latest_layout: workspace.latest_layout.clone(),
                             resize_dimensions: workspace.resize_dimensions.clone(),
                             tile: workspace.tile,
-                            work_area_offset: workspace.work_area_offset,
                             apply_window_based_work_area_offset: workspace
                                 .apply_window_based_work_area_offset,
                             window_container_behaviour: workspace.window_container_behaviour,
@@ -348,6 +347,7 @@ impl From<&WindowManager> for State {
                             layer: workspace.layer,
                             floating_layer_behaviour: workspace.floating_layer_behaviour,
                             globals: workspace.globals,
+                            locked_containers: workspace.locked_containers.clone(),
                             wallpaper: workspace.wallpaper.clone(),
                             workspace_config: None,
                         })
@@ -822,7 +822,7 @@ impl WindowManager {
         target_workspace_idx: usize,
         floating: bool,
         to_move: &mut Vec<EnforceWorkspaceRuleOp>,
-    ) {
+    ) -> () {
         tracing::trace!(
             "{} should be on monitor {}, workspace {}",
             window_title,
@@ -2960,8 +2960,6 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn stack_all(&mut self) -> Result<()> {
-        self.unstack_all(false)?;
-
         self.handle_unmanaged_window_behaviour()?;
         tracing::info!("stacking all windows on workspace");
 
@@ -2988,7 +2986,7 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn unstack_all(&mut self, update_workspace: bool) -> Result<()> {
+    pub fn unstack_all(&mut self) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
         tracing::info!("unstacking all windows in container");
 
@@ -3018,11 +3016,7 @@ impl WindowManager {
             workspace.focus_container_by_window(hwnd)?;
         }
 
-        if update_workspace {
-            self.update_focused_workspace(self.mouse_follows_focus, true)?;
-        }
-
-        Ok(())
+        self.update_focused_workspace(self.mouse_follows_focus, true)
     }
 
     #[tracing::instrument(skip(self))]
@@ -3192,10 +3186,14 @@ impl WindowManager {
     #[tracing::instrument(skip(self))]
     pub fn toggle_lock(&mut self) -> Result<()> {
         let workspace = self.focused_workspace_mut()?;
-        if let Some(container) = workspace.focused_container_mut() {
-            // Toggle the locked flag
-            container.set_locked(!container.locked());
+        let index = workspace.focused_container_idx();
+
+        if workspace.locked_containers().contains(&index) {
+            workspace.locked_containers_mut().remove(&index);
+        } else {
+            workspace.locked_containers_mut().insert(index);
         }
+
         Ok(())
     }
 
@@ -4773,44 +4771,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_remove_nonexistent_window_from_container() {
-        let (mut wm, _context) = setup_window_manager();
-
-        {
-            // Create a first monitor
-            let mut m = monitor::new(
-                0,
-                Rect::default(),
-                Rect::default(),
-                "TestMonitor1".to_string(),
-                "TestDevice1".to_string(),
-                "TestDeviceID1".to_string(),
-                Some("TestMonitorID1".to_string()),
-            );
-
-            // Create a container
-            let container = Container::default();
-
-            // Should have 3 windows in the container
-            assert_eq!(container.windows().len(), 0);
-
-            // Add the container to a workspace
-            let workspace = m.focused_workspace_mut().unwrap();
-            workspace.add_container_to_back(container);
-
-            // Add monitor to the window manager
-            wm.monitors_mut().push_back(m);
-        }
-
-        // Should receive an error when trying to remove a window from an empty container
-        let result = wm.remove_window_from_container();
-        assert!(
-            result.is_err(),
-            "Expected an error when trying to remove a window from an empty container"
-        );
-    }
-
     #[test]
     fn cycle_container_window_in_direction() {
         let (mut wm, _context) = setup_window_manager();
@@ -4880,44 +4840,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_cycle_nonexistent_windows() {
-        let (mut wm, _context) = setup_window_manager();
-
-        {
-            // Create a first monitor
-            let mut m = monitor::new(
-                0,
-                Rect::default(),
-                Rect::default(),
-                "TestMonitor1".to_string(),
-                "TestDevice1".to_string(),
-                "TestDeviceID1".to_string(),
-                Some("TestMonitorID1".to_string()),
-            );
-
-            // Create a container
-            let container = Container::default();
-
-            // Should have 3 windows in the container
-            assert_eq!(container.windows().len(), 0);
-
-            // Add the container to a workspace
-            let workspace = m.focused_workspace_mut().unwrap();
-            workspace.add_container_to_back(container);
-
-            // Add monitor to the window manager
-            wm.monitors_mut().push_back(m);
-        }
-
-        // Should return an error when trying to cycle through windows in an empty container
-        let result = wm.cycle_container_window_in_direction(CycleDirection::Next);
-        assert!(
-            result.is_err(),
-            "Expected an error when cycling through windows in an empty container"
-        );
-    }
-
     #[test]
     fn test_cycle_container_window_index_in_direction() {
         let (mut wm, _context) = setup_window_manager();
@@ -5447,8 +5369,7 @@ mod tests {
         {
             // Ensure container 2 is not locked
             let workspace = wm.focused_workspace_mut().unwrap();
-            assert_eq!(workspace.focused_container_idx(), 2);
-            assert!(!workspace.focused_container().unwrap().locked());
+            assert!(!workspace.locked_containers().contains(&2));
         }
 
         // Toggle lock on focused container
@@ -5457,7 +5378,7 @@ mod tests {
         {
             // Ensure container 2 is locked
             let workspace = wm.focused_workspace_mut().unwrap();
-            assert!(workspace.focused_container().unwrap().locked());
+            assert!(workspace.locked_containers().contains(&2));
         }
 
         // Toggle lock on focused container
@@ -5466,7 +5387,7 @@ mod tests {
         {
             // Ensure container 2 is not locked
             let workspace = wm.focused_workspace_mut().unwrap();
-            assert!(!workspace.focused_container().unwrap().locked());
+            assert!(!workspace.locked_containers().contains(&2));
         }
     }
 
@@ -5548,40 +5469,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_float_nonexistent_window() {
-        let (mut wm, _context) = setup_window_manager();
-
-        {
-            let mut m = monitor::new(
-                0,
-                Rect::default(),
-                Rect::default(),
-                "TestMonitor".to_string(),
-                "TestDevice".to_string(),
-                "TestDeviceID".to_string(),
-                Some("TestMonitorID".to_string()),
-            );
-
-            // Add another workspace
-            let new_workspace_index = m.new_workspace_idx();
-            m.focus_workspace(new_workspace_index).unwrap();
-
-            // Should have 2 workspaces
-            assert_eq!(m.workspaces().len(), 2);
-
-            // Add monitor to window manager
-            wm.monitors_mut().push_back(m);
-        }
-
-        // Should return an error when trying to float a non-existent window
-        let result = wm.float_window();
-        assert!(
-            result.is_err(),
-            "Expected an error when trying to float a non-existent window"
-        );
-    }
-
     #[test]
     fn test_maximize_and_unmaximize_window() {
         let (mut wm, _context) = setup_window_manager();
@@ -5728,41 +5615,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_toggle_maximize_nonexistent_window() {
-        let (mut wm, _context) = setup_window_manager();
-
-        {
-            // Create a monitor
-            let mut m = monitor::new(
-                0,
-                Rect::default(),
-                Rect::default(),
-                "TestMonitor".to_string(),
-                "TestDevice".to_string(),
-                "TestDeviceID".to_string(),
-                Some("TestMonitorID".to_string()),
-            );
-
-            // Create a container
-            let container = Container::default();
-
-            // Add the container to the workspace
-            let workspace = m.focused_workspace_mut().unwrap();
-            workspace.add_container_to_back(container);
-
-            // Add monitor to the window manager
-            wm.monitors_mut().push_back(m);
-        }
-
-        // Should return an error when trying to toggle maximize on a non-existent window
-        let result = wm.toggle_maximize();
-        assert!(
-            result.is_err(),
-            "Expected an error when trying to toggle maximize on a non-existent window"
-        );
-    }
-
     #[test]
     fn test_monocle_on_and_monocle_off() {
         let (mut wm, _context) = setup_window_manager();
@@ -5834,41 +5686,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_monocle_on_and_off_nonexistent_container() {
-        let (mut wm, _context) = setup_window_manager();
-
-        {
-            // Create a monitor
-            let m = monitor::new(
-                0,
-                Rect::default(),
-                Rect::default(),
-                "TestMonitor".to_string(),
-                "TestDevice".to_string(),
-                "TestDeviceID".to_string(),
-                Some("TestMonitorID".to_string()),
-            );
-
-            // Add monitor to the window manager
-            wm.monitors_mut().push_back(m);
-        }
-
-        // Should return an error when trying to move a non-existent container to monocle
-        let result = wm.monocle_on();
-        assert!(
-            result.is_err(),
-            "Expected an error when trying to move a non-existent container to monocle"
-        );
-
-        // Should return an error when trying to restore a non-existent container from monocle
-        let result = wm.monocle_off();
-        assert!(
-            result.is_err(),
-            "Expected an error when trying to restore a non-existent container from monocle"
-        );
-    }
-
     #[test]
     fn test_toggle_monocle() {
         let (mut wm, _context) = setup_window_manager();
@@ -5940,34 +5757,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_toggle_monocle_nonexistent_container() {
-        let (mut wm, _context) = setup_window_manager();
-
-        {
-            // Create a monitor
-            let m = monitor::new(
-                0,
-                Rect::default(),
-                Rect::default(),
-                "TestMonitor".to_string(),
-                "TestDevice".to_string(),
-                "TestDeviceID".to_string(),
-                Some("TestMonitorID".to_string()),
-            );
-
-            // Add monitor to the window manager
-            wm.monitors_mut().push_back(m);
-        }
-
-        // Should return an error when trying to toggle monocle on a non-existent container
-        let result = wm.toggle_monocle();
-        assert!(
-            result.is_err(),
-            "Expected an error when trying to toggle monocle on a non-existent container"
-        );
-    }
-
     #[test]
     fn test_ensure_named_workspace_for_monitor() {
         let (mut wm, _context) = setup_window_manager();

komorebi/src/windows_api.rs

@@ -1180,7 +1180,6 @@ impl WindowsApi {
 
     #[allow(dead_code)]
     pub fn enable_focus_follows_mouse() -> Result<()> {
-        #[allow(clippy::manual_dangling_ptr)]
         Self::system_parameters_info_w(
             SPI_SETACTIVEWINDOWTRACKING,
             0,

komorebi/src/workspace.rs

@@ -1,3 +1,4 @@
+use std::collections::BTreeSet;
 use std::collections::VecDeque;
 use std::ffi::OsStr;
 use std::fmt::Display;
@@ -16,7 +17,7 @@ use crate::core::Layout;
 use crate::core::OperationDirection;
 use crate::core::Rect;
 use crate::default_layout::LayoutOptions;
-use crate::lockable_sequence::LockableSequence;
+use crate::locked_deque::LockedDeque;
 use crate::ring::Ring;
 use crate::should_act;
 use crate::stackbar_manager;
@@ -87,8 +88,6 @@ pub struct Workspace {
     #[getset(get = "pub", set = "pub")]
     pub tile: bool,
     #[getset(get_copy = "pub", set = "pub")]
-    pub work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
     pub apply_window_based_work_area_offset: bool,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
     pub window_container_behaviour: Option<WindowContainerBehaviour>,
@@ -104,6 +103,8 @@ pub struct Workspace {
     #[getset(get_copy = "pub", get_mut = "pub", set = "pub")]
     pub floating_layer_behaviour: Option<FloatingLayerBehaviour>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    pub locked_containers: BTreeSet<usize>,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
     pub wallpaper: Option<Wallpaper>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get = "pub", set = "pub")]
@@ -149,7 +150,6 @@ impl Default for Workspace {
             latest_layout: vec![],
             resize_dimensions: vec![],
             tile: true,
-            work_area_offset: None,
             apply_window_based_work_area_offset: true,
             window_container_behaviour: None,
             window_container_behaviour_rules: None,
@@ -158,6 +158,7 @@ impl Default for Workspace {
             floating_layer_behaviour: Default::default(),
             globals: Default::default(),
             workspace_config: None,
+            locked_containers: Default::default(),
             wallpaper: None,
         }
     }
@@ -208,16 +209,18 @@ impl Workspace {
 
         if let Some(layout) = &config.layout {
             self.layout = Layout::Default(*layout);
+            self.tile = true;
         }
 
         if let Some(pathbuf) = &config.custom_layout {
             let layout = CustomLayout::from_path(pathbuf)?;
             self.layout = Layout::Custom(layout);
+            self.tile = true;
         }
 
-        self.tile =
-            !(config.custom_layout.is_none() && config.layout.is_none() && config.tile.is_none()
-                || config.tile.is_some_and(|tile| !tile));
+        if config.custom_layout.is_none() && config.layout.is_none() {
+            self.tile = false;
+        }
 
         let mut all_layout_rules = vec![];
         if let Some(layout_rules) = &config.layout_rules {
@@ -242,8 +245,6 @@ impl Workspace {
             self.set_layout_rules(all_layout_rules);
         }
 
-        self.set_work_area_offset(config.work_area_offset);
-
         self.set_apply_window_based_work_area_offset(
             config.apply_window_based_work_area_offset.unwrap_or(true),
         );
@@ -499,7 +500,7 @@ impl Workspace {
         let border_width = self.globals().border_width;
         let border_offset = self.globals().border_offset;
         let work_area = self.globals().work_area;
-        let work_area_offset = self.work_area_offset().or(self.globals().work_area_offset);
+        let work_area_offset = self.globals().work_area_offset;
         let window_based_work_area_offset = self.globals().window_based_work_area_offset;
         let window_based_work_area_offset_limit =
             self.globals().window_based_work_area_offset_limit;
@@ -897,9 +898,10 @@ impl Workspace {
     // this fn respects locked container indexes - we should use it for pretty much everything
     // except monocle and maximize toggles
     pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) -> usize {
-        let insertion_idx = self
-            .containers_mut()
-            .insert_respecting_locks(idx, container);
+        let mut locked_containers = self.locked_containers().clone();
+        let mut ld = LockedDeque::new(self.containers_mut(), &mut locked_containers);
+        let insertion_idx = ld.insert(idx, container);
+        self.locked_containers = locked_containers;
 
         if insertion_idx > self.resize_dimensions().len() {
             self.resize_dimensions_mut().push(None);
@@ -915,7 +917,10 @@ impl Workspace {
     // this fn respects locked container indexes - we should use it for pretty much everything
     // except monocle and maximize toggles
     pub fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
-        let container = self.containers_mut().remove_respecting_locks(idx);
+        let mut locked_containers = self.locked_containers().clone();
+        let mut ld = LockedDeque::new(self.containers_mut(), &mut locked_containers);
+        let container = ld.remove(idx);
+        self.locked_containers = locked_containers;
 
         if idx < self.resize_dimensions().len() {
             self.resize_dimensions_mut().remove(idx);
@@ -1629,7 +1634,7 @@ impl Workspace {
     }
 
     pub fn swap_containers(&mut self, i: usize, j: usize) {
-        self.containers.elements_mut().swap_respecting_locks(i, j);
+        self.containers.swap(i, j);
         self.focus_container(j);
     }
 
@@ -1728,6 +1733,7 @@ mod tests {
     use super::*;
     use crate::container::Container;
     use crate::Window;
+    use std::collections::BTreeSet;
     use std::collections::HashMap;
 
     #[test]
@@ -1735,18 +1741,20 @@ mod tests {
         let mut ws = Workspace::default();
 
         let mut state = HashMap::new();
+        let mut locked = BTreeSet::new();
 
-        // add 4 containers
+        // add 3 containers
         for i in 0..4 {
-            let mut container = Container::default();
-            if i == 3 {
-                container.set_locked(true); // set index 3 locked
-            }
+            let container = Container::default();
             state.insert(i, container.id().to_string());
             ws.add_container_to_back(container);
         }
         assert_eq!(ws.containers().len(), 4);
 
+        // set index 3 locked
+        locked.insert(3);
+        ws.locked_containers = locked;
+
         // focus container at index 2
         ws.focus_container(2);
 
@@ -1778,17 +1786,20 @@ mod tests {
     fn test_locked_containers_remove_window() {
         let mut ws = Workspace::default();
 
+        let mut locked = BTreeSet::new();
+
         // add 4 containers
         for i in 0..4 {
             let mut container = Container::default();
             container.windows_mut().push_back(Window::from(i));
-            if i == 1 {
-                container.set_locked(true);
-            }
             ws.add_container_to_back(container);
         }
         assert_eq!(ws.containers().len(), 4);
 
+        // set index 1 locked
+        locked.insert(1);
+        ws.locked_containers = locked;
+
         ws.remove_window(0).unwrap();
         assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 2);
         // index 1 should still be the same
@@ -1800,17 +1811,20 @@ mod tests {
     fn test_locked_containers_toggle_float() {
         let mut ws = Workspace::default();
 
+        let mut locked = BTreeSet::new();
+
         // add 4 containers
         for i in 0..4 {
             let mut container = Container::default();
             container.windows_mut().push_back(Window::from(i));
-            if i == 1 {
-                container.set_locked(true);
-            }
             ws.add_container_to_back(container);
         }
         assert_eq!(ws.containers().len(), 4);
 
+        // set index 1 locked
+        locked.insert(1);
+        ws.locked_containers = locked;
+
         // set index 0 focused
         ws.focus_container(0);
 
@@ -1842,17 +1856,20 @@ mod tests {
     fn test_locked_containers_stack() {
         let mut ws = Workspace::default();
 
+        let mut locked = BTreeSet::new();
+
         // add 6 containers
         for i in 0..6 {
             let mut container = Container::default();
             container.windows_mut().push_back(Window::from(i));
-            if i == 4 {
-                container.set_locked(true);
-            }
             ws.add_container_to_back(container);
         }
         assert_eq!(ws.containers().len(), 6);
 
+        // set index 4 locked
+        locked.insert(4);
+        ws.locked_containers = locked;
+
         // set index 3 focused
         ws.focus_container(3);
 

komorebic.lib.ahk

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

komorebic/src/main.rs

@@ -6,7 +6,6 @@ use komorebi_client::replace_env_in_path;
 use komorebi_client::PathExt;
 use std::fs::File;
 use std::fs::OpenOptions;
-use std::io;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Write;
@@ -93,7 +92,8 @@ lazy_static! {
 
                 assert!(
                     whkd_config_home.is_dir(),
-                    "$Env:WHKD_CONFIG_HOME is set to '{home_path}', which is not a valid directory"
+                    "$Env:WHKD_CONFIG_HOME is set to '{}', which is not a valid directory",
+                    home_path
                 );
 
                 whkd_config_home
@@ -429,22 +429,6 @@ struct MonitorWorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Parser)]
-struct WorkspaceWorkAreaOffset {
-    /// Monitor index (zero-indexed)
-    monitor: usize,
-    /// Workspace index (zero-indexed)
-    workspace: usize,
-    /// Size of the left work area offset (set right to left * 2 to maintain right padding)
-    left: i32,
-    /// Size of the top work area offset (set bottom to the same value to maintain bottom padding)
-    top: i32,
-    /// Size of the right work area offset
-    right: i32,
-    /// Size of the bottom work area offset
-    bottom: i32,
-}
-
 #[derive(Parser)]
 struct MonitorIndexPreference {
     /// Preferred monitor index (zero-indexed)
@@ -1205,9 +1189,6 @@ enum SubCommand {
     /// Set offsets for a monitor to exclude parts of the work area from tiling
     #[clap(arg_required_else_help = true)]
     MonitorWorkAreaOffset(MonitorWorkAreaOffset),
-    /// Set offsets for a workspace to exclude parts of the work area from tiling
-    #[clap(arg_required_else_help = true)]
-    WorkspaceWorkAreaOffset(WorkspaceWorkAreaOffset),
     /// Toggle application of the window-based work area offset for the focused workspace
     ToggleWindowBasedWorkAreaOffset,
     /// Set container padding on the focused workspace
@@ -1327,7 +1308,7 @@ enum SubCommand {
     ToggleWorkspaceFloatOverride,
     /// Toggle between the Tiling and Floating layers on the focused workspace
     ToggleWorkspaceLayer,
-    /// Toggle the paused state for all window tiling
+    /// Toggle window tiling on the focused workspace
     TogglePause,
     /// Toggle window tiling on the focused workspace
     ToggleTiling,
@@ -1581,33 +1562,6 @@ fn main() -> Result<()> {
             }
         }
         SubCommand::Quickstart => {
-            fn write_file_with_prompt(
-                path: &PathBuf,
-                content: &str,
-                created_files: &mut Vec<String>,
-            ) -> Result<()> {
-                if path.exists() {
-                    print!(
-                        "{} will be overwritten, do you want to continue? (y/N): ",
-                        path.display()
-                    );
-                    io::stdout().flush()?;
-                    let mut input = String::new();
-                    io::stdin().read_line(&mut input)?;
-                    let trimmed = input.trim().to_lowercase();
-                    if trimmed == "y" || trimmed == "yes" {
-                        std::fs::write(path, content)?;
-                        created_files.push(path.display().to_string());
-                    } else {
-                        println!("Skipping {}", path.display());
-                    }
-                } else {
-                    std::fs::write(path, content)?;
-                    created_files.push(path.display().to_string());
-                }
-                Ok(())
-            }
-
             let local_appdata_dir = data_local_dir().expect("could not find localdata dir");
             let data_dir = local_appdata_dir.join("komorebi");
             std::fs::create_dir_all(&*WHKD_CONFIG_DIR)?;
@@ -1623,30 +1577,17 @@ fn main() -> Result<()> {
                     komorebi_json.replace("Env:USERPROFILE", "Env:KOMOREBI_CONFIG_HOME");
             }
 
-            let komorebi_path = HOME_DIR.join("komorebi.json");
-            let bar_path = HOME_DIR.join("komorebi.bar.json");
-            let applications_path = HOME_DIR.join("applications.json");
-            let whkdrc_path = WHKD_CONFIG_DIR.join("whkdrc");
-
-            let mut written_files = Vec::new();
-
-            write_file_with_prompt(&komorebi_path, &komorebi_json, &mut written_files)?;
-            write_file_with_prompt(&bar_path, &komorebi_bar_json, &mut written_files)?;
+            std::fs::write(HOME_DIR.join("komorebi.json"), komorebi_json)?;
+            std::fs::write(HOME_DIR.join("komorebi.bar.json"), komorebi_bar_json)?;
 
             let applications_json = include_str!("../applications.json");
-            write_file_with_prompt(&applications_path, applications_json, &mut written_files)?;
+            std::fs::write(HOME_DIR.join("applications.json"), applications_json)?;
 
             let whkdrc = include_str!("../../docs/whkdrc.sample");
-            write_file_with_prompt(&whkdrc_path, whkdrc, &mut written_files)?;
-            if written_files.is_empty() {
-                println!("\nNo files were written.")
-            } else {
-                println!(
-                    "\nThe following example files were written:\n{}",
-                    written_files.join("\n")
-                );
-            }
-            println!("\nYou can now run komorebic start --whkd --bar");
+            std::fs::write(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;
+
+            println!("Example komorebi.json, komorebi.bar.json, whkdrc and latest applications.json files created");
+            println!("You can now run komorebic start --whkd --bar");
         }
         SubCommand::EnableAutostart(args) => {
             let mut current_exe = std::env::current_exe().expect("unable to get exec path");
@@ -1998,20 +1939,6 @@ fn main() -> Result<()> {
                 bottom: arg.bottom,
             }))?;
         }
-
-        SubCommand::WorkspaceWorkAreaOffset(arg) => {
-            send_message(&SocketMessage::WorkspaceWorkAreaOffset(
-                arg.monitor,
-                arg.workspace,
-                Rect {
-                    left: arg.left,
-                    top: arg.top,
-                    right: arg.right,
-                    bottom: arg.bottom,
-                },
-            ))?;
-        }
-
         SubCommand::ToggleWindowBasedWorkAreaOffset => {
             send_message(&SocketMessage::ToggleWindowBasedWorkAreaOffset)?;
         }

mkdocs.yml

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

schema.json

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