chore(release): v0.1.19

This commit ensures that when a layout or a custom layout is not defined
for a workspace in the static configuration file, Workspace.tile will be
set to false. Thanks to M. Kichel on Discord for pointing out the need
for this!

.czrc

@@ -0,0 +1,3 @@
+{
+  "path": "cz-conventional-changelog"
+}

.github/ISSUE_TEMPLATE/bug_report.md

@@ -32,6 +32,20 @@ OS Name:                   Microsoft Windows 11 Pro
 OS Version:                10.0.22000 N/A Build 22000
 ```
 
+**`komorebic check` Output**
+Provide the output of `komorebic check`
+
+For example:
+```
+No KOMOREBI_CONFIG_HOME detected, defaulting to C:\Users\LGUG2Z
+
+Looking for configuration files in C:\Users\LGUG2Z
+
+No komorebi configuration found in C:\Users\LGUG2Z
+
+If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration
+```
+
 **Additional context**
 Add any other context about the problem here.
 

.github/workflows/windows.yaml

@@ -28,7 +28,7 @@ jobs:
         target:
           - x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Prep cargo dirs
@@ -104,7 +104,7 @@ jobs:
         if: startsWith(github.ref, 'refs/tags/v')
         with:
           version: latest
-          args: release --skip-validate --rm-dist --release-notes=CHANGELOG.md
+          args: release --skip-validate --clean --release-notes=CHANGELOG.md
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SCOOP_TOKEN: ${{ secrets.SCOOP_TOKEN }}
@@ -116,7 +116,7 @@ jobs:
 
   winget:
     name: Publish to WinGet
-    runs-on: windows-latest
+    runs-on: ubuntu-latest
     needs: build
     if: startsWith(github.ref, 'refs/tags/v')
 

.goreleaser.yml

@@ -28,11 +28,8 @@ builds:
         - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64_v1\komorebic.exe"
 
 archives:
-  - replacements:
-      windows: pc-windows-msvc
-      amd64: x86_64
+  - name_template: "{{ .ProjectName }}-{{ .Version }}-x86_64-pc-windows-msvc"
     format: zip
-    name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Arch }}-{{ .Os }}"
     files:
       - LICENSE
       - CHANGELOG.md

Cargo.toml

@@ -1,8 +1,34 @@
 [workspace]
 
+resolver = "2"
 members = [
     "derive-ahk",
     "komorebi",
     "komorebi-core",
     "komorebic",
 ]
+
+[workspace.dependencies]
+windows-interface = { version = "0.51" }
+windows-implement = { version = "0.51" }
+
+[workspace.dependencies.windows]
+version = "0.51"
+features = [
+    "implement",
+    "Win32_System_Com",
+    "Win32_UI_Shell_Common", # for IObjectArray
+    "Win32_Foundation",
+    "Win32_Graphics_Dwm",
+    "Win32_Graphics_Gdi",
+    "Win32_System_LibraryLoader",
+    "Win32_System_RemoteDesktop",
+    "Win32_System_Threading",
+    "Win32_UI_Accessibility",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Shell",
+    "Win32_UI_Shell_Common",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_System_SystemServices"
+]

README.md

@@ -3,6 +3,9 @@
 Tiling Window Management for Windows.
 
 <p>
+  <a href="https://bdsmovement.net">
+    <img alt="Stand With Palestine" src="https://img.shields.io/badge/Stand_With_Palestine-%F0%9F%87%B5%F0%9F%87%B8-white">
+  </a>
   <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/LGUG2Z/komorebi/.github/workflows/windows.yaml">
   <img alt="GitHub" src="https://img.shields.io/github/license/LGUG2Z/komorebi">
   <img alt="GitHub all releases" src="https://img.shields.io/github/downloads/LGUG2Z/komorebi/total">
@@ -16,11 +19,8 @@ Tiling Window Management for Windows.
   <a href="https://notado.app/feeds/jado/software-development">
     <img alt="Notado Feed" src="https://img.shields.io/badge/Notado-Subscribe-informational">
   </a>
-  <a href="https://jeezy.substack.com">
-    <img alt="Substack Read" src="https://img.shields.io/badge/Substack-Read-orange">
-  </a>
   <a href="https://twitter.com/LGUG2Z">
-    <img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/LGUG2Z">
+    <img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/LGUG2Z?style=flat">
   </a>
 </p>
 
@@ -160,8 +160,21 @@ This means that:
 
 ### Quickstart
 
+It highly recommended that you enable support for long paths in Windows by running the following command in an
+Administrator Terminal before starting with this quickstart guide:
+
+```powershell
+Set-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem' -Name 'LongPathsEnabled' -Value 1
+```
+
 Make sure that you have either the [Scoop Package Manager](https://scoop.sh) or WinGet installed, then run the following
-commands at a PowerShell prompt.
+commands at a PowerShell prompt. If you are using WinGet, make sure that you open a new terminal window or reload your
+profile after running the installation steps. Since this is not required when using `scoop`, I personally recommend that
+you use `scoop` for this process.
+
+As of v0.1.17, the quickstart recommends the use of a static configuration file. If you would like to see older versions
+of this quickstart which recommend the use of dynamic configuration scripts, please refer to
+the [README file of v0.1.16](https://github.com/LGUG2Z/komorebi/tree/v0.1.16).
 
 ```powershell
 # if using scoop
@@ -173,25 +186,52 @@ scoop install komorebi
 winget install LGUG2Z.whkd
 winget install LGUG2Z.komorebi
 
-# save the latest generated app-specific config tweaks and fixes to ~/komorebi.generated.ps1
-iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/master/komorebi.generated.ps1 -OutFile $Env:USERPROFILE\komorebi.generated.ps1
+# save the example configuration to ~/komorebi.json
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.19/komorebi.example.json -OutFile "$Env:USERPROFILE\komorebi.json"
 
-# save the sample komorebi configuration file to ~/komorebi.ps1
-iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/master/komorebi.sample.ps1 -OutFile $Env:USERPROFILE\komorebi.ps1
+# save the latest generated app-specific config tweaks and fixes
+komorebic fetch-app-specific-configuration
 
 # ensure the ~/.config folder exists
-mkdir $Env:USERPROFILE\.config -ea 0
+mkdir "$Env:USERPROFILE\.config" -ea 0
 
 # save the sample whkdrc file with key bindings to ~/.config/whkdrc
-iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/master/whkdrc -OutFile $Env:USERPROFILE\whkdrc
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.19/whkdrc.sample -OutFile "$Env:USERPROFILE\.config\whkdrc"
 
-# start komorebi
-komorebic start --await-configuration
+# start komorebi and whkd
+komorebic start -c "$Env:USERPROFILE\komorebi.json" --whkd
 ```
 
 Thanks to [@sitiom](https://github.com/sitiom) for getting _komorebi_ added to both the popular Scoop Extras bucket and
 to WinGet.
 
+You can watch a walkthrough video of this quickstart below on YouTube.
+
+[![Watch the quickstart walkthrough video](https://img.youtube.com/vi/hDDxtvpjpHs/hqdefault.jpg)](https://www.youtube.com/watch?v=hDDxtvpjpHs)
+
+#### Using Autohotkey
+
+If you would like to use Autohotkey, please make sure you have AutoHotKey v2 installed.
+
+Generally, users who opt for AHK will have specific needs that can only be addressed by the advanced functionality of AHK,
+and so they are assumed to be able to craft their own configuration files.
+
+If you would like to try out AHK, a simple sample configuration powered by `komorebic.lib.ahk` is provided as a starting
+point. This sample configuration does not take into account the use of a static configuration file; if you choose to use
+a static configuration file alongside AHK, you can remove all the configuration options from your `komorebi.ahk` and use
+it solely to handle hotkey bindings.
+
+```powershell
+# save the latest generated komorebic library to ~/komorebic.lib.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.19/komorebic.lib.ahk -OutFile $Env:USERPROFILE\komorebic.lib.ahk
+
+# save the latest generated app-specific config tweaks and fixes to ~/komorebi.generated.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.19/komorebi.generated.ahk -OutFile $Env:USERPROFILE\komorebi.generated.ahk
+
+# save the sample komorebi configuration file to ~/komorebi.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.19/komorebi.sample.ahk -OutFile $Env:USERPROFILE\komorebi.ahk
+```
+
 ### GitHub Releases
 
 Prebuilt binaries are available on the [releases page](https://github.com/LGUG2Z/komorebi/releases) in a `zip` archive.
@@ -214,7 +254,12 @@ cargo install --path komorebic --locked
 
 ### Running
 
-Run `komorebic start --await-configuration` at a Powershell prompt, and you will see the following output:
+`komorebi` can be run in two ways, using either a static configuration file or a dynamic configuration script.
+
+The quickstart covers running with a static configuration file.
+
+If you would like to use a dynamic configuration script, ensure that you have a `komorebi.ps1` or `komorebi.ahk` file
+present, run `komorebic start --await-configuration` at a Powershell prompt, and you will see the following output:
 
 ```
 Start-Process komorebi.exe -ArgumentList '--await-configuration' -WindowStyle hidden
@@ -224,15 +269,39 @@ Waiting for komorebi.exe to start...Started!
 This means that `komorebi` is now running in the background, tiling all your windows, and listening for commands sent to
 it by `komorebic`. You can similarly stop the process by running `komorebic stop`.
 
+For further information on running with a dynamic configuration script, please refer to
+the quickstart section in the [README file of v0.1.16](https://github.com/LGUG2Z/komorebi/tree/v0.1.16)
+
 ### Configuring
 
-If you followed the quickstart, `komorebi` will find the sample `komorebi.ps1` file in your `$Env:USERPROFILE` directory
-and automatically load it. This file also starts `whkd` using the sample `whkrc` file in your `$Env:USERPROFILE\.config`
-directory.
+If you followed the quickstart, `komorebi.json` will be the single place where you declaratively configure the behaviour
+of the window manager. There is a [complete JSON Schema for this configuration file](schema.json) available to provide
+users with auto-completions in their editors.
+
+If you are running with a dynamic configuration script as recommended in v0.1.16 and earlier, `komorebi` will find the
+sample `komorebi.ps1` file in your `$Env:USERPROFILE` directory and automatically load it. This file also starts `whkd` using the sample `whkdrc` file
+in your `$Env:USERPROFILE\.config` directory.
 
 Alternatively, if you have AutoHotKey installed and a `komorebi.ahk` file in `$Env:UserProfile` directory, `komorebi`
 will automatically try to load it when starting.
 
+#### Migrating to a Static Configuration File
+
+If you have been using `komorebi` with a dynamic configuration script and wish to migrate to using a static
+configuration file, once you have `komorebi` running in the desired configuration state, you can
+run `komorebic generate-static-config`.
+
+This will print a static configuration that mostly represents your current configuration to the terminal.
+
+There are four configuration options that you may need to set yourself, if you make use of them:
+
+- Custom layouts paths for workspaces
+- Custom layout rules for workspaces
+- The applications.yaml path
+- Any individual application rules you have that are not in applications.yaml
+
+[![Watch the tutorial video](https://img.youtube.com/vi/yqCAOJgL3C0/hqdefault.jpg)](https://www.youtube.com/watch?v=yqCAOJgL3C0)
+
 #### Configuration with `komorebic`
 
 As previously mentioned, this project does not handle anything related to keybindings and shortcuts directly. I
@@ -255,6 +324,9 @@ key combinations in the `whkdrc` file.
 Additionally, you may run `komorebic.exe ahk-library` to generate a helper library for AutoHotKey which wraps
 every `komorebic` command in a native AHK function.
 
+The output of this command is in AHKv1 syntax. It must be manually converted to AHKv2 syntax
+using [this tool](https://github.com/mmikeww/AHK-v2-script-converter) or something similar.
+
 If you include the generated library at the top of your `~/komorebi.ahk` configuration file, you will be able to call
 any of the functions that it contains.
 
@@ -262,13 +334,11 @@ any of the functions that it contains.
 
 ❗️**NOTE**: This section is only relevant for people who wish to use AutoHotKey instead of [`whkd`](https://github.com/LGUG2Z/whkd).
 
-The generated helper library for AutoHotKey currently only supports AutoHotKey v1.1.
-
 The preferred way to install AutoHotKey for use with `komorebi` is to install it via `scoop`:
 
 ```powershell
 scoop bucket add versions
-scoop install autohotkey1.1
+scoop install autohotkey
 ```
 
 If you install AutoHotKey using a different method, the name of the executable file may differ from the name given by
@@ -310,6 +380,8 @@ exist in this folder.
 
 #### Generating Common Application-Specific Configurations
 
+❗️**NOTE**: This section is only relevant for people who use dynamic configuration scripts.
+
 A curated selection of application-specific configurations can be generated to
 help ease the setup for first-time users.
 [`komorebi-application-specific-configuration`](https://github.com/LGUG2Z/komorebi-application-specific-configuration)
@@ -359,10 +431,15 @@ komorebic.exe active-window-border-colour [R G B] --window-kind single
 
 # optionally, if you want a different colour for stacks of windows
 komorebic.exe active-window-border-colour [R G B] --window-kind stack
+
+# optionally, if you want a different colour for windows in monocle mode
+komorebic.exe active-window-border-colour [R G B] --window-kind monocle
 ```
 
 It is important to note that the active window border will only apply to windows managed by `komorebi`.
 
+[![Watch the tutorial video](https://img.youtube.com/vi/ywiAvoMV_gE/hqdefault.jpg)](https://www.youtube.com/watch?v=ywiAvoMV_gE)
+
 #### Removing Gaps
 
 If you would like to remove all gaps from a given workspace, both between windows themselves, and between the monitor edges and the windows, you can set the following two configuration options to `0` for the desired monitors and workspaces:
@@ -372,9 +449,11 @@ komorebic.exe container-padding <MONITOR_INDEX> <WORKSPACE_INDEX> 0
 komorebic.exe workspace-padding <MONITOR_INDEX> <WORKSPACE_INDEX> 0
 ```
 
+[![Watch the tutorial video](https://img.youtube.com/vi/eGr07mymgWE/hqdefault.jpg)](https://www.youtube.com/watch?v=eGr07mymgWE)
+
 #### Multiple Layout Changes on Startup
 
-❗️**NOTE**: If you followed the quickstart and are using the sample configurations, this is already the default behaviour.
+❗️**NOTE**: This section is only relevant for people who use dynamic configuration scripts.
 
 Depending on what is in your configuration, when `komorebi` is started, you may experience the layout rapidly being adjusted
 with many retile events.
@@ -478,10 +557,12 @@ By default, the mouse will move to the center of the window when the focus is ch
 behaviour is know is 'mouse follows focus'. To disable this behaviour across all workspaces, add the following command
 to your configuration file:
 
-```ahk
-Run, komorebic.exe toggle-mouse-follows-focus, , Hide
+```powershell
+komorebic.exe mouse-follows-focus disable
 ```
 
+[![Watch the tutorial video](https://img.youtube.com/vi/LBoyXQiNINc/hqdefault.jpg)](https://www.youtube.com/watch?v=LBoyXQiNINc)
+
 #### Saving and Loading Resized Layouts
 
 If you create a BSP layout through various resize adjustments that you want to be able to restore easily in the future,
@@ -553,6 +634,8 @@ YAML
   configuration: Horizontal
 ```
 
+[![Watch the tutorial video](https://img.youtube.com/vi/SgmBHKEOcQ4/hqdefault.jpg)](https://www.youtube.com/watch?v=SgmBHKEOcQ4)
+
 #### Dynamically Changing Layouts Based on Number of Visible Window Containers
 
 With `komorebi` it is possible to define rules to automatically change the layout on a specified workspace when a

justfile

@@ -22,7 +22,11 @@ install-komorebi:
 install:
     just install-komorebic
     just install-komorebi
-    cat '~/.config/komorebi/komorebi.generated.ps1' > komorebi.generated.ps1
+    komorebic ahk-asc '~/komorebi-application-specific-configuration/applications.yaml'
+    komorebic pwsh-asc '~/komorebi-application-specific-configuration/applications.yaml'
+    cat '~/.config/komorebi/komorebi.generated.ps1' >komorebi.generated.ps1
+    cat '~/.config/komorebi/komorebi.generated.ahk' >komorebi.generated.ahk
+    cat '~/.config/komorebi/komorebic.lib_newV2.ahk' >komorebic.lib.ahk
 
 run:
     just install-komorebic

komorebi-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.15"
+version = "0.1.19"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -11,11 +11,6 @@ color-eyre = "0.6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
-strum = { version = "0.24", features = ["derive"] }
+strum = { version = "0.25", features = ["derive"] }
 schemars = "0.8"
-
-[dependencies.windows]
-version = "0.44"
-features = [
-    "Win32_Foundation",
-]
+windows = { workspace = true }

komorebi-core/src/arrangement.rs

@@ -130,85 +130,7 @@ impl Arrangement for DefaultLayout {
 
                 layouts
             }
-            Self::UltrawideVerticalStack => {
-                let mut layouts: Vec<Rect> = vec![];
-
-                let primary_right = match len {
-                    1 => area.right,
-                    _ => area.right / 2,
-                };
-
-                let secondary_right = match len {
-                    1 => 0,
-                    2 => area.right - primary_right,
-                    _ => (area.right - primary_right) / 2,
-                };
-
-                let (primary_left, secondary_left, stack_left) = match len {
-                    1 => (area.left, 0, 0),
-                    2 => {
-                        let mut primary = area.left + secondary_right;
-                        let mut secondary = area.left;
-
-                        match layout_flip {
-                            Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
-                                primary = area.left;
-                                secondary = area.left + primary_right;
-                            }
-                            _ => {}
-                        }
-
-                        (primary, secondary, 0)
-                    }
-                    _ => {
-                        let primary = area.left + secondary_right;
-                        let mut secondary = area.left;
-                        let mut stack = area.left + primary_right + secondary_right;
-
-                        match layout_flip {
-                            Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
-                                secondary = area.left + primary_right + secondary_right;
-                                stack = area.left;
-                            }
-                            _ => {}
-                        }
-
-                        (primary, secondary, stack)
-                    }
-                };
-
-                if len >= 1 {
-                    layouts.push(Rect {
-                        left: primary_left,
-                        top: area.top,
-                        right: primary_right,
-                        bottom: area.bottom,
-                    });
-
-                    if len >= 2 {
-                        layouts.push(Rect {
-                            left: secondary_left,
-                            top: area.top,
-                            right: secondary_right,
-                            bottom: area.bottom,
-                        });
-
-                        if len > 2 {
-                            layouts.append(&mut rows(
-                                &Rect {
-                                    left: stack_left,
-                                    top: area.top,
-                                    right: secondary_right,
-                                    bottom: area.bottom,
-                                },
-                                len - 2,
-                            ));
-                        }
-                    }
-                }
-
-                layouts
-            }
+            Self::UltrawideVerticalStack => ultrawide(area, len, layout_flip, resize_dimensions),
         };
 
         dimensions
@@ -231,7 +153,7 @@ impl Arrangement for CustomLayout {
         let mut dimensions = vec![];
         let container_count = len.get();
 
-        if container_count <= self.len() {
+        if container_count < self.len() {
             let mut layouts = columns(area, container_count);
             dimensions.append(&mut layouts);
         } else {
@@ -586,3 +508,190 @@ fn recursive_fibonacci(
         res
     }
 }
+
+fn calculate_ultrawide_adjustment(resize_dimensions: &[Option<Rect>]) -> Vec<Rect> {
+    let len = resize_dimensions.len();
+    let mut result = vec![Rect::default(); len];
+    match len {
+        // One container can't be resized
+        0 | 1 => (),
+        2 => {
+            let (primary, secondary) = result.split_at_mut(1);
+            let primary = &mut primary[0];
+            let secondary = &mut secondary[0];
+            // With two containers on screen container 0 is on the right
+            if let Some(resize_primary) = resize_dimensions[0] {
+                resize_left(primary, resize_primary.left);
+                resize_right(secondary, resize_primary.left);
+            }
+
+            if let Some(resize_secondary) = resize_dimensions[1] {
+                resize_left(primary, resize_secondary.right);
+                resize_right(secondary, resize_secondary.right);
+            }
+        }
+        _ => {
+            let (primary, rest) = result.split_at_mut(1);
+            let (secondary, tertiary) = rest.split_at_mut(1);
+            let primary = &mut primary[0];
+            let secondary = &mut secondary[0];
+            // With three or more containers container 0 is in the center
+            if let Some(resize_primary) = resize_dimensions[0] {
+                resize_left(primary, resize_primary.left);
+                resize_right(primary, resize_primary.right);
+
+                resize_right(secondary, resize_primary.left);
+
+                for vertical_element in &mut *tertiary {
+                    resize_left(vertical_element, resize_primary.right);
+                }
+            }
+
+            // Container 1 is on the left
+            if let Some(resize_secondary) = resize_dimensions[1] {
+                resize_left(primary, resize_secondary.right);
+                resize_right(secondary, resize_secondary.right);
+            }
+
+            // Handle stack on the right
+            for (i, rect) in resize_dimensions[2..].iter().enumerate() {
+                if let Some(rect) = rect {
+                    resize_right(primary, rect.left);
+                    tertiary
+                        .iter_mut()
+                        .for_each(|vertical_element| resize_left(vertical_element, rect.left));
+
+                    // Containers in stack except first can be resized up displacing container
+                    // above them
+                    if i != 0 {
+                        resize_bottom(&mut tertiary[i - 1], rect.top);
+                        resize_top(&mut tertiary[i], rect.top);
+                    }
+
+                    // Containers in stack except last can be resized down displacing container
+                    // below them
+                    if i != tertiary.len() - 1 {
+                        resize_bottom(&mut tertiary[i], rect.bottom);
+                        resize_top(&mut tertiary[i + 1], rect.bottom);
+                    }
+                }
+            }
+        }
+    };
+
+    result
+}
+
+fn resize_left(rect: &mut Rect, resize: i32) {
+    rect.left += resize / 2;
+    rect.right += -resize / 2;
+}
+
+fn resize_right(rect: &mut Rect, resize: i32) {
+    rect.right += resize / 2;
+}
+
+fn resize_top(rect: &mut Rect, resize: i32) {
+    rect.top += resize / 2;
+    rect.bottom += -resize / 2;
+}
+
+fn resize_bottom(rect: &mut Rect, resize: i32) {
+    rect.bottom += resize / 2;
+}
+
+fn ultrawide(
+    area: &Rect,
+    len: usize,
+    layout_flip: Option<Axis>,
+    resize_dimensions: &[Option<Rect>],
+) -> Vec<Rect> {
+    let mut layouts: Vec<Rect> = vec![];
+
+    let primary_right = match len {
+        1 => area.right,
+        _ => area.right / 2,
+    };
+
+    let secondary_right = match len {
+        1 => 0,
+        2 => area.right - primary_right,
+        _ => (area.right - primary_right) / 2,
+    };
+
+    let (primary_left, secondary_left, stack_left) = match len {
+        1 => (area.left, 0, 0),
+        2 => {
+            let mut primary = area.left + secondary_right;
+            let mut secondary = area.left;
+
+            match layout_flip {
+                Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
+                    primary = area.left;
+                    secondary = area.left + primary_right;
+                }
+                _ => {}
+            }
+
+            (primary, secondary, 0)
+        }
+        _ => {
+            let primary = area.left + secondary_right;
+            let mut secondary = area.left;
+            let mut stack = area.left + primary_right + secondary_right;
+
+            match layout_flip {
+                Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
+                    secondary = area.left + primary_right + secondary_right;
+                    stack = area.left;
+                }
+                _ => {}
+            }
+
+            (primary, secondary, stack)
+        }
+    };
+
+    if len >= 1 {
+        layouts.push(Rect {
+            left: primary_left,
+            top: area.top,
+            right: primary_right,
+            bottom: area.bottom,
+        });
+
+        if len >= 2 {
+            layouts.push(Rect {
+                left: secondary_left,
+                top: area.top,
+                right: secondary_right,
+                bottom: area.bottom,
+            });
+
+            if len > 2 {
+                layouts.append(&mut rows(
+                    &Rect {
+                        left: stack_left,
+                        top: area.top,
+                        right: secondary_right,
+                        bottom: area.bottom,
+                    },
+                    len - 2,
+                ));
+            }
+        }
+    }
+
+    let adjustment = calculate_ultrawide_adjustment(resize_dimensions);
+    layouts
+        .iter_mut()
+        .zip(adjustment.iter())
+        .for_each(|(layout, adjustment)| {
+            layout.top += adjustment.top;
+            layout.bottom += adjustment.bottom;
+            layout.left += adjustment.left;
+            layout.right += adjustment.right;
+        });
+
+    layouts
+}

komorebi-core/src/config_generation.rs

@@ -24,31 +24,19 @@ impl ApplicationOptions {
     pub fn raw_cfgen(&self, kind: &ApplicationIdentifier, id: &str) -> String {
         match self {
             ApplicationOptions::ObjectNameChange => {
-                format!(
-                    "komorebic.exe identify-object-name-change-application {} \"{}\"",
-                    kind, id
-                )
+                format!("komorebic.exe identify-object-name-change-application {kind} \"{id}\"",)
             }
             ApplicationOptions::Layered => {
-                format!(
-                    "komorebic.exe identify-layered-application {} \"{}\"",
-                    kind, id
-                )
+                format!("komorebic.exe identify-layered-application {kind} \"{id}\"",)
             }
             ApplicationOptions::BorderOverflow => {
-                format!(
-                    "komorebic.exe identify-border-overflow-application {} \"{}\"",
-                    kind, id
-                )
+                format!("komorebic.exe identify-border-overflow-application {kind} \"{id}\"",)
             }
             ApplicationOptions::TrayAndMultiWindow => {
-                format!(
-                    "komorebic.exe identify-tray-application {} \"{}\"",
-                    kind, id
-                )
+                format!("komorebic.exe identify-tray-application {kind} \"{id}\"",)
             }
             ApplicationOptions::Force => {
-                format!("komorebic.exe manage-rule {} \"{}\"", kind, id)
+                format!("komorebic.exe manage-rule {kind} \"{id}\"")
             }
         }
     }
@@ -56,16 +44,28 @@ impl ApplicationOptions {
     #[must_use]
     pub fn cfgen(&self, kind: &ApplicationIdentifier, id: &str) -> String {
         format!(
-            "Run, {}, , Hide",
+            "RunWait('{}', , \"Hide\")",
             ApplicationOptions::raw_cfgen(self, kind, id)
         )
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct IdWithIdentifier {
     pub kind: ApplicationIdentifier,
     pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub matching_strategy: Option<MatchingStrategy>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub enum MatchingStrategy {
+    Legacy,
+    Equals,
+    StartsWith,
+    EndsWith,
+    Contains,
+    Regex,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
@@ -74,6 +74,18 @@ pub struct IdWithIdentifierAndComment {
     pub id: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub matching_strategy: Option<MatchingStrategy>,
+}
+
+impl From<IdWithIdentifierAndComment> for IdWithIdentifier {
+    fn from(value: IdWithIdentifierAndComment) -> Self {
+        Self {
+            kind: value.kind,
+            id: value.id.clone(),
+            matching_strategy: value.matching_strategy,
+        }
+    }
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
@@ -90,7 +102,7 @@ pub struct ApplicationConfiguration {
 pub struct ApplicationConfigurationGenerator;
 
 impl ApplicationConfigurationGenerator {
-    fn load(content: &str) -> Result<Vec<ApplicationConfiguration>> {
+    pub fn load(content: &str) -> Result<Vec<ApplicationConfiguration>> {
         Ok(serde_yaml::from_str(content)?)
     }
 
@@ -143,7 +155,7 @@ impl ApplicationConfigurationGenerator {
             lines.push(format!("# {}", app.name));
             if let Some(options) = app.options {
                 for opt in options {
-                    if let ApplicationOptions::TrayAndMultiWindow = opt {
+                    if matches!(opt, ApplicationOptions::TrayAndMultiWindow) {
                         lines.push(String::from("# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line"));
                     }
 
@@ -161,7 +173,7 @@ impl ApplicationConfigurationGenerator {
                         float_rules.push(float_rule.clone());
 
                         if let Some(comment) = float.comment {
-                            lines.push(format!("# {}", comment));
+                            lines.push(format!("# {comment}"));
                         };
 
                         lines.push(float_rule);
@@ -184,12 +196,7 @@ impl ApplicationConfigurationGenerator {
 
         cfgen.sort_by(|a, b| a.name.cmp(&b.name));
 
-        let mut lines = vec![
-            String::from("; Generated by komorebic.exe"),
-            String::from("; To use this file, add the line below to the top of your komorebi.ahk configuration file"),
-            String::from("; #Include %A_ScriptDir%\\komorebi.generated.ahk"),
-            String::new()
-        ];
+        let mut lines = vec![String::from("; Generated by komorebic.exe"), String::new()];
 
         let mut float_rules = vec![];
 
@@ -197,7 +204,7 @@ impl ApplicationConfigurationGenerator {
             lines.push(format!("; {}", app.name));
             if let Some(options) = app.options {
                 for opt in options {
-                    if let ApplicationOptions::TrayAndMultiWindow = opt {
+                    if matches!(opt, ApplicationOptions::TrayAndMultiWindow) {
                         lines.push(String::from("; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line"));
                     }
 
@@ -208,7 +215,7 @@ impl ApplicationConfigurationGenerator {
             if let Some(float_identifiers) = app.float_identifiers {
                 for float in float_identifiers {
                     let float_rule = format!(
-                        "Run, komorebic.exe float-rule {} \"{}\", , Hide",
+                        "RunWait('komorebic.exe float-rule {} \"{}\"', , \"Hide\")",
                         float.kind, float.id
                     );
 
@@ -217,7 +224,7 @@ impl ApplicationConfigurationGenerator {
                         float_rules.push(float_rule.clone());
 
                         if let Some(comment) = float.comment {
-                            lines.push(format!("; {}", comment));
+                            lines.push(format!("; {comment}"));
                         };
 
                         lines.push(float_rule);

komorebi-core/src/custom_layout.rs

@@ -72,7 +72,7 @@ impl CustomLayout {
     }
 
     #[must_use]
-    pub fn primary_width_percentage(&self) -> Option<usize> {
+    pub fn primary_width_percentage(&self) -> Option<f32> {
         for column in self.iter() {
             if let Column::Primary(Option::Some(ColumnWidth::WidthPercentage(percentage))) = column
             {
@@ -83,7 +83,7 @@ impl CustomLayout {
         None
     }
 
-    pub fn set_primary_width_percentage(&mut self, percentage: usize) {
+    pub fn set_primary_width_percentage(&mut self, percentage: f32) {
         for column in self.iter_mut() {
             if let Column::Primary(Option::Some(ColumnWidth::WidthPercentage(current))) = column {
                 *current = percentage;
@@ -262,7 +262,7 @@ pub enum Column {
 
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnWidth {
-    WidthPercentage(usize),
+    WidthPercentage(f32),
 }
 
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]

komorebi-core/src/default_layout.rs

@@ -20,6 +20,7 @@ pub enum DefaultLayout {
     VerticalStack,
     HorizontalStack,
     UltrawideVerticalStack,
+    // NOTE: If any new layout is added, please make sure to register the same in `DefaultLayout::cycle`
 }
 
 impl DefaultLayout {
@@ -33,7 +34,7 @@ impl DefaultLayout {
         sizing: Sizing,
         delta: i32,
     ) -> Option<Rect> {
-        if !matches!(self, Self::BSP) {
+        if !matches!(self, Self::BSP) && !matches!(self, Self::UltrawideVerticalStack) {
             return None;
         };
 
@@ -125,4 +126,28 @@ impl DefaultLayout {
             Option::from(r)
         }
     }
+
+    #[must_use]
+    pub const fn cycle_next(self) -> Self {
+        match self {
+            Self::BSP => Self::Columns,
+            Self::Columns => Self::Rows,
+            Self::Rows => Self::VerticalStack,
+            Self::VerticalStack => Self::HorizontalStack,
+            Self::HorizontalStack => Self::UltrawideVerticalStack,
+            Self::UltrawideVerticalStack => Self::BSP,
+        }
+    }
+
+    #[must_use]
+    pub const fn cycle_previous(self) -> Self {
+        match self {
+            Self::BSP => Self::UltrawideVerticalStack,
+            Self::UltrawideVerticalStack => Self::HorizontalStack,
+            Self::HorizontalStack => Self::VerticalStack,
+            Self::VerticalStack => Self::Rows,
+            Self::Rows => Self::Columns,
+            Self::Columns => Self::BSP,
+        }
+    }
 }

komorebi-core/src/lib.rs

@@ -46,15 +46,18 @@ pub enum SocketMessage {
     UnstackWindow,
     CycleStack(CycleDirection),
     MoveContainerToMonitorNumber(usize),
+    CycleMoveContainerToMonitor(CycleDirection),
     MoveContainerToWorkspaceNumber(usize),
     MoveContainerToNamedWorkspace(String),
     CycleMoveContainerToWorkspace(CycleDirection),
     SendContainerToMonitorNumber(usize),
+    CycleSendContainerToMonitor(CycleDirection),
     SendContainerToWorkspaceNumber(usize),
     CycleSendContainerToWorkspace(CycleDirection),
     SendContainerToMonitorWorkspaceNumber(usize, usize),
     SendContainerToNamedWorkspace(String),
     MoveWorkspaceToMonitorNumber(usize),
+    SwapWorkspacesToMonitorNumber(usize),
     ForceFocus,
     Close,
     Minimize,
@@ -74,6 +77,7 @@ pub enum SocketMessage {
     AdjustContainerPadding(Sizing, i32),
     AdjustWorkspacePadding(Sizing, i32),
     ChangeLayout(DefaultLayout),
+    CycleLayout(CycleDirection),
     ChangeLayoutCustom(PathBuf),
     FlipLayout(Axis),
     // Monitor and Workspace Commands
@@ -93,6 +97,7 @@ pub enum SocketMessage {
     CycleFocusWorkspace(CycleDirection),
     FocusMonitorNumber(usize),
     FocusWorkspaceNumber(usize),
+    FocusWorkspaceNumbers(usize),
     FocusMonitorWorkspaceNumber(usize, usize),
     FocusNamedWorkspace(String),
     ContainerPadding(usize, usize, i32),
@@ -114,6 +119,7 @@ pub enum SocketMessage {
     ClearNamedWorkspaceLayoutRules(String),
     // Configuration
     ReloadConfiguration,
+    ReloadStaticConfiguration(PathBuf),
     WatchConfiguration(bool),
     CompleteConfiguration,
     AltFocusHack(bool),
@@ -125,6 +131,8 @@ pub enum SocketMessage {
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
     ResizeDelta(i32),
+    InitialWorkspaceRule(ApplicationIdentifier, String, usize, usize),
+    InitialNamedWorkspaceRule(ApplicationIdentifier, String, String),
     WorkspaceRule(ApplicationIdentifier, String, usize, usize),
     NamedWorkspaceRule(ApplicationIdentifier, String, String),
     FloatRule(ApplicationIdentifier, String),
@@ -139,10 +147,14 @@ pub enum SocketMessage {
     ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
     MouseFollowsFocus(bool),
     ToggleMouseFollowsFocus,
+    RemoveTitleBar(ApplicationIdentifier, String),
+    ToggleTitleBars,
     AddSubscriber(String),
     RemoveSubscriber(String),
     NotificationSchema,
     SocketSchema,
+    StaticConfigSchema,
+    GenerateStaticConfig,
 }
 
 impl SocketMessage {
@@ -166,6 +178,7 @@ impl FromStr for SocketMessage {
 pub enum WindowKind {
     Single,
     Stack,
+    Monocle,
 }
 
 #[derive(
@@ -180,13 +193,25 @@ pub enum StateQuery {
 }
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Copy,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
 #[strum(serialize_all = "snake_case")]
-#[serde(rename_all = "snake_case")]
 pub enum ApplicationIdentifier {
+    #[serde(alias = "exe")]
     Exe,
+    #[serde(alias = "class")]
     Class,
+    #[serde(alias = "title")]
     Title,
 }
 
@@ -195,7 +220,9 @@ pub enum ApplicationIdentifier {
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum FocusFollowsMouseImplementation {
+    /// A custom FFM implementation (slightly more CPU-intensive)
     Komorebi,
+    /// The native (legacy) Windows FFM implementation
     Windows,
 }
 
@@ -204,7 +231,9 @@ pub enum FocusFollowsMouseImplementation {
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum WindowContainerBehaviour {
+    /// Create a new container for each new window
     Create,
+    /// Append new windows to the focused window container
     Append,
 }
 
@@ -213,7 +242,9 @@ pub enum WindowContainerBehaviour {
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum MoveBehaviour {
+    /// Swap the window container with the window container at the edge of the adjacent monitor
     Swap,
+    /// Insert the window container into the focused workspace on the adjacent monitor
     Insert,
 }
 
@@ -222,8 +253,11 @@ pub enum MoveBehaviour {
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum HidingBehaviour {
+    /// Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)
     Hide,
+    /// Use the SW_MINIMIZE flag to hide windows when switching workspaces (has issues with frequent workspace switching)
     Minimize,
+    /// Use the undocumented SetCloak Win32 function to hide windows when switching workspaces (has foregrounding issues)
     Cloak,
 }
 
@@ -232,7 +266,9 @@ pub enum HidingBehaviour {
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum OperationBehaviour {
+    /// Process komorebic commands on temporarily unmanaged/floated windows
     Op,
+    /// Ignore komorebic commands on temporarily unmanaged/floated windows
     NoOp,
 }
 

komorebi-core/src/rect.rs

@@ -5,9 +5,13 @@ use windows::Win32::Foundation::RECT;
 
 #[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq, JsonSchema)]
 pub struct Rect {
+    /// The left point in a Win32 Rect
     pub left: i32,
+    /// The top point in a Win32 Rect
     pub top: i32,
+    /// The right point in a Win32 Rect
     pub right: i32,
+    /// The bottom point in a Win32 Rect
     pub bottom: i32,
 }
 

komorebi.example.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/master/schema.json",
+  "app_specific_configuration_path": "$Env:USERPROFILE/applications.yaml",
+  "window_hiding_behaviour": "Cloak",
+  "cross_monitor_move_behaviour": "Insert",
+  "alt_focus_hack": true,
+  "default_workspace_padding": 20,
+  "default_container_padding": 20,
+  "active_window_border": false,
+  "active_window_border_colours": {
+    "single": { "r": 66, "g": 165, "b": 245 },
+    "stack": { "r": 256, "g": 165, "b": 66 },
+    "monocle": { "r": 255, "g": 51, "b": 153 }
+  },
+  "monitors": [
+    {
+      "workspaces": [
+        { "name": "I", "layout": "BSP" },
+        { "name": "II", "layout": "VerticalStack" },
+        { "name": "III", "layout": "HorizontalStack" },
+        { "name": "IV", "layout": "UltrawideVerticalStack" },
+        { "name": "V", "layout": "Rows" }
+      ]
+    }
+  ]
+}

komorebi.generated.ahk

@@ -0,0 +1,594 @@
+; Generated by komorebic.exe
+
+; 1Password
+RunWait('komorebic.exe float-rule exe "1Password.exe"', , "Hide")
+
+; Ableton Live
+; Targets VST2 windows
+RunWait('komorebic.exe float-rule class "AbletonVstPlugClass"', , "Hide")
+; Targets VST3 windows
+RunWait('komorebic.exe float-rule class "Vst3PlugWindow"', , "Hide")
+
+; Adobe Creative Cloud
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application class "CreativeCloudDesktopWindowClass"', , "Hide")
+
+; Adobe Photoshop
+RunWait('komorebic.exe identify-border-overflow-application class "Photoshop"', , "Hide")
+
+; Affinity Photo 2
+RunWait('komorebic.exe manage-rule title "Affinity Photo 2"', , "Hide")
+RunWait('komorebic.exe float-rule exe "Photo.exe"', , "Hide")
+
+; Akiflow
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Akiflow.exe"', , "Hide")
+
+; Android Studio
+RunWait('komorebic.exe identify-object-name-change-application exe "studio64.exe"', , "Hide")
+
+; Anki
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "anki.exe"', , "Hide")
+
+; ArmCord
+RunWait('komorebic.exe identify-border-overflow-application exe "ArmCord.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ArmCord.exe"', , "Hide")
+
+; AutoHotkey
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "AutoHotkeyU64.exe"', , "Hide")
+RunWait('komorebic.exe float-rule title "Window Spy"', , "Hide")
+RunWait('komorebic.exe float-rule exe "AutoHotkeyUX.exe"', , "Hide")
+
+; Beeper
+RunWait('komorebic.exe identify-border-overflow-application exe "Beeper.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Beeper.exe"', , "Hide")
+
+; Bitwarden
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Bitwarden.exe"', , "Hide")
+
+; Bloxstrap
+RunWait('komorebic.exe float-rule exe "Bloxstrap.exe"', , "Hide")
+
+; Calculator
+RunWait('komorebic.exe float-rule title "Calculator"', , "Hide")
+
+; Clash Verge
+RunWait('komorebic.exe identify-border-overflow-application exe "Clash Verge.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Clash Verge.exe"', , "Hide")
+
+; Clementine
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "clementine.exe"', , "Hide")
+
+; CopyQ
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "copyq.exe"', , "Hide")
+
+; Credential Manager UI Host
+; Targets the Windows popup prompting you for a PIN instead of a password on 1Password etc.
+RunWait('komorebic.exe float-rule exe "CredentialUIBroker.exe"', , "Hide")
+
+; Cron
+RunWait('komorebic.exe identify-border-overflow-application exe "Cron.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Cron.exe"', , "Hide")
+
+; DS4Windows
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "DS4Windows.exe"', , "Hide")
+
+; Delphi applications
+; Target hidden window spawned by Delphi applications
+RunWait('komorebic.exe float-rule class "TApplication"', , "Hide")
+; Target Inno Setup installers
+RunWait('komorebic.exe float-rule class "TWizardForm"', , "Hide")
+
+; Discord
+RunWait('komorebic.exe identify-border-overflow-application exe "Discord.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Discord.exe"', , "Hide")
+
+; DiscordCanary
+RunWait('komorebic.exe identify-border-overflow-application exe "DiscordCanary.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "DiscordCanary.exe"', , "Hide")
+
+; DiscordDevelopment
+RunWait('komorebic.exe identify-border-overflow-application exe "DiscordDevelopment.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "DiscordDevelopment.exe"', , "Hide")
+
+; DiscordPTB
+RunWait('komorebic.exe identify-border-overflow-application exe "DiscordPTB.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "DiscordPTB.exe"', , "Hide")
+
+; Docker Desktop
+RunWait('komorebic.exe identify-border-overflow-application exe "Docker Desktop.exe"', , "Hide")
+
+; Dropbox
+RunWait('komorebic.exe float-rule exe "Dropbox.exe"', , "Hide")
+
+; ElectronMail
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ElectronMail.exe"', , "Hide")
+
+; Element
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Element.exe"', , "Hide")
+
+; Elephicon
+RunWait('komorebic.exe float-rule exe "Elephicon.exe"', , "Hide")
+
+; ElevenClock
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ElevenClock.exe"', , "Hide")
+
+; Elgato Camera Hub
+RunWait('komorebic.exe float-rule exe "Camera Hub.exe"', , "Hide")
+
+; Elgato Control Center
+RunWait('komorebic.exe float-rule exe "ControlCenter.exe"', , "Hide")
+
+; Elgato Wave Link
+RunWait('komorebic.exe float-rule exe "WaveLink.exe"', , "Hide")
+
+; Epic Games Launcher
+RunWait('komorebic.exe identify-border-overflow-application exe "EpicGamesLauncher.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "EpicGamesLauncher.exe"', , "Hide")
+
+; Everything
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Everything.exe"', , "Hide")
+
+; Figma
+RunWait('komorebic.exe identify-border-overflow-application exe "Figma.exe"', , "Hide")
+
+; Flow Launcher
+RunWait('komorebic.exe identify-border-overflow-application exe "Flow.Launcher.exe"', , "Hide")
+
+; GOG Galaxy
+RunWait('komorebic.exe identify-border-overflow-application exe "GalaxyClient.exe"', , "Hide")
+RunWait('komorebic.exe manage-rule exe "GalaxyClient.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "GalaxyClient.exe"', , "Hide")
+; Targets a hidden window spawned by GOG Galaxy
+RunWait('komorebic.exe float-rule class "Chrome_RenderWidgetHostHWND"', , "Hide")
+
+; GoPro Webcam
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application class "GoPro Webcam"', , "Hide")
+
+; Godot Manager
+RunWait('komorebic.exe identify-border-overflow-application exe "GodotManager.exe"', , "Hide")
+RunWait('komorebic.exe manage-rule exe "GodotManager.exe"', , "Hide")
+RunWait('komorebic.exe identify-object-name-change-application exe "GodotManager.exe"', , "Hide")
+
+; Golden Dict
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "GoldenDict.exe"', , "Hide")
+
+; Google Chrome
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "chrome.exe"', , "Hide")
+
+; Google Drive
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "GoogleDriveFS.exe"', , "Hide")
+RunWait('komorebic.exe float-rule exe "GoogleDriveFS.exe"', , "Hide")
+
+; Houdoku
+RunWait('komorebic.exe identify-border-overflow-application exe "Houdoku.exe"', , "Hide")
+
+; IntelliJ IDEA
+RunWait('komorebic.exe identify-object-name-change-application exe "idea64.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "idea64.exe"', , "Hide")
+; Targets JetBrains IDE popups and floating windows
+RunWait('komorebic.exe float-rule class "SunAwtDialog"', , "Hide")
+
+; Itch.io
+RunWait('komorebic.exe identify-border-overflow-application exe "itch.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "itch.exe"', , "Hide")
+
+; Keyviz
+RunWait('komorebic.exe float-rule exe "keyviz.exe"', , "Hide")
+
+; Kleopatra
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "kleopatra.exe"', , "Hide")
+
+; Kotatogram
+RunWait('komorebic.exe identify-border-overflow-application exe "Kotatogram.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Kotatogram.exe"', , "Hide")
+
+; LocalSend
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "localsend_app.exe"', , "Hide")
+
+; Logi Bolt
+RunWait('komorebic.exe float-rule exe "LogiBolt.exe"', , "Hide")
+
+; LogiTune
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "LogiTune.exe"', , "Hide")
+RunWait('komorebic.exe float-rule exe "LogiTune.exe"', , "Hide")
+
+; Logitech G HUB
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "lghub.exe"', , "Hide")
+RunWait('komorebic.exe identify-border-overflow-application exe "lghub.exe"', , "Hide")
+
+; Logitech Options
+RunWait('komorebic.exe float-rule exe "LogiOptionsUI.exe"', , "Hide")
+
+; Mailspring
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "mailspring.exe"', , "Hide")
+
+; ManyCam
+RunWait('komorebic.exe identify-border-overflow-application exe "ManyCam.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ManyCam.exe"', , "Hide")
+
+; Mica For Everyone
+
+; Microsoft Excel
+RunWait('komorebic.exe identify-border-overflow-application exe "EXCEL.EXE"', , "Hide")
+RunWait('komorebic.exe identify-layered-application exe "EXCEL.EXE"', , "Hide")
+; Targets a hidden window spawned by Microsoft Office applications
+RunWait('komorebic.exe float-rule class "_WwB"', , "Hide")
+
+; Microsoft Outlook
+RunWait('komorebic.exe identify-border-overflow-application exe "OUTLOOK.EXE"', , "Hide")
+RunWait('komorebic.exe identify-layered-application exe "OUTLOOK.EXE"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "OUTLOOK.EXE"', , "Hide")
+
+; Microsoft PC Manager
+RunWait('komorebic.exe float-rule exe "MSPCManager.exe"', , "Hide")
+
+; Microsoft PowerPoint
+RunWait('komorebic.exe identify-border-overflow-application exe "POWERPNT.EXE"', , "Hide")
+RunWait('komorebic.exe identify-layered-application exe "POWERPNT.EXE"', , "Hide")
+
+; Microsoft Teams
+RunWait('komorebic.exe identify-border-overflow-application exe "Teams.exe"', , "Hide")
+; Target Teams pop-up notification windows
+RunWait('komorebic.exe float-rule title "Microsoft Teams Notification"', , "Hide")
+; Target Teams call in progress windows
+RunWait('komorebic.exe float-rule title "Microsoft Teams Call"', , "Hide")
+
+; Microsoft Word
+RunWait('komorebic.exe identify-border-overflow-application exe "WINWORD.EXE"', , "Hide")
+RunWait('komorebic.exe identify-layered-application exe "WINWORD.EXE"', , "Hide")
+
+; Modern Flyouts
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ModernFlyoutsHost.exe"', , "Hide")
+
+; Mozilla Firefox
+RunWait('komorebic.exe identify-object-name-change-application exe "firefox.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "firefox.exe"', , "Hide")
+; Targets invisible windows spawned by Firefox to show tab previews in the taskbar
+RunWait('komorebic.exe float-rule class "MozillaTaskbarPreviewClass"', , "Hide")
+
+; NVIDIA GeForce Experience
+RunWait('komorebic.exe identify-border-overflow-application exe "NVIDIA GeForce Experience.exe"', , "Hide")
+
+; NZXT CAM
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "NZXT CAM.exe"', , "Hide")
+
+; NetEase Cloud Music
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "cloudmusic.exe"', , "Hide")
+
+; NiceHash Miner
+RunWait('komorebic.exe identify-border-overflow-application exe "nhm_app.exe"', , "Hide")
+RunWait('komorebic.exe manage-rule exe "nhm_app.exe"', , "Hide")
+
+; NohBoard
+RunWait('komorebic.exe float-rule exe "NohBoard.exe"', , "Hide")
+
+; Notion Enhanced
+RunWait('komorebic.exe identify-border-overflow-application exe "Notion Enhanced.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Notion Enhanced.exe"', , "Hide")
+
+; OBS Studio (32-bit)
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "obs32.exe"', , "Hide")
+
+; OBS Studio (64-bit)
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "obs64.exe"', , "Hide")
+
+; ONLYOFFICE Editors
+RunWait('komorebic.exe identify-border-overflow-application class "DocEditorsWindowClass"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application class "DocEditorsWindowClass"', , "Hide")
+
+; Obsidian
+RunWait('komorebic.exe identify-border-overflow-application exe "Obsidian.exe"', , "Hide")
+RunWait('komorebic.exe manage-rule exe "Obsidian.exe"', , "Hide")
+
+; OneDrive
+RunWait('komorebic.exe float-rule class "OneDriveReactNativeWin32WindowClass"', , "Hide")
+
+; OneQuick
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "OneQuick.exe"', , "Hide")
+
+; OpenRGB
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "OpenRGB.exe"', , "Hide")
+
+; Paradox Launcher
+RunWait('komorebic.exe float-rule exe "Paradox Launcher.exe"', , "Hide")
+
+; Playnite
+RunWait('komorebic.exe identify-border-overflow-application exe "Playnite.DesktopApp.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Playnite.DesktopApp.exe"', , "Hide")
+; Target fullscreen app
+RunWait('komorebic.exe float-rule exe "Playnite.FullscreenApp.exe"', , "Hide")
+
+; Plexamp
+RunWait('komorebic.exe identify-border-overflow-application exe "Plexamp.exe"', , "Hide")
+
+; PowerToys
+; Target color picker dialog
+RunWait('komorebic.exe float-rule exe "PowerToys.ColorPickerUI.exe"', , "Hide")
+; Target image resizer dialog
+RunWait('komorebic.exe float-rule exe "PowerToys.ImageResizer.exe"', , "Hide")
+; Target Peek popup
+RunWait('komorebic.exe float-rule exe "PowerToys.Peek.UI.exe"', , "Hide")
+
+; Process Hacker
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ProcessHacker.exe"', , "Hide")
+RunWait('komorebic.exe float-rule exe "ProcessHacker.exe"', , "Hide")
+
+; ProtonVPN
+RunWait('komorebic.exe identify-border-overflow-application exe "ProtonVPN.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ProtonVPN.exe"', , "Hide")
+
+; PyCharm
+RunWait('komorebic.exe identify-object-name-change-application exe "pycharm64.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "pycharm64.exe"', , "Hide")
+
+; QQ
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "QQ.exe"', , "Hide")
+RunWait('komorebic.exe float-rule title "图片查看器"', , "Hide")
+RunWait('komorebic.exe float-rule title "群聊的聊天记录"', , "Hide")
+RunWait('komorebic.exe float-rule title "语音通话"', , "Hide")
+
+; QtScrcpy
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "QtScrcpy.exe"', , "Hide")
+
+; QuickLook
+RunWait('komorebic.exe float-rule exe "QuickLook.exe"', , "Hide")
+
+; RepoZ
+RunWait('komorebic.exe float-rule exe "RepoZ.exe"', , "Hide")
+
+; Rider
+RunWait('komorebic.exe identify-object-name-change-application exe "rider64.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "rider64.exe"', , "Hide")
+
+; Roblox FPS Unlocker
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "rbxfpsunlocker.exe"', , "Hide")
+
+; RoundedTB
+RunWait('komorebic.exe float-rule exe "RoundedTB.exe"', , "Hide")
+
+; RoundedTB
+RunWait('komorebic.exe identify-border-overflow-application exe "RoundedTB.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "RoundedTB.exe"', , "Hide")
+
+; RustRover
+RunWait('komorebic.exe identify-object-name-change-application exe "rustrover64.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "rustrover64.exe"', , "Hide")
+
+; Sandboxie Plus
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "SandMan.exe"', , "Hide")
+
+; ShareX
+RunWait('komorebic.exe identify-border-overflow-application exe "ShareX.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ShareX.exe"', , "Hide")
+
+; Sideloadly
+RunWait('komorebic.exe float-rule exe "sideloadly.exe"', , "Hide")
+
+; Signal
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Signal.exe"', , "Hide")
+
+; SiriKali
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "sirikali.exe"', , "Hide")
+
+; Slack
+RunWait('komorebic.exe identify-border-overflow-application exe "Slack.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Slack.exe"', , "Hide")
+
+; Slack
+RunWait('komorebic.exe identify-border-overflow-application exe "slack.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "slack.exe"', , "Hide")
+
+; Smart Install Maker
+; Target hidden window spawned by installer
+RunWait('komorebic.exe float-rule class "obj_App"', , "Hide")
+; Target installer
+RunWait('komorebic.exe float-rule class "obj_Form"', , "Hide")
+
+; SoulseekQt
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "SoulseekQt.exe"', , "Hide")
+
+; Spotify
+RunWait('komorebic.exe identify-border-overflow-application exe "Spotify.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Spotify.exe"', , "Hide")
+
+; Steam
+RunWait('komorebic.exe identify-border-overflow-application class "vguiPopupWindow"', , "Hide")
+
+; Steam Beta
+RunWait('komorebic.exe identify-border-overflow-application class "SDL_app"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application class "SDL_app"', , "Hide")
+; Target notification toast popups
+RunWait('komorebic.exe float-rule title "notificationtoasts_"', , "Hide")
+
+; Stremio
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "stremio.exe"', , "Hide")
+
+; System Informer
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "SystemInformer.exe"', , "Hide")
+RunWait('komorebic.exe float-rule exe "SystemInformer.exe"', , "Hide")
+
+; SystemSettings
+RunWait('komorebic.exe float-rule class "Shell_Dialog"', , "Hide")
+
+; Task Manager
+RunWait('komorebic.exe float-rule class "TaskManagerWindow"', , "Hide")
+
+; Telegram
+RunWait('komorebic.exe identify-border-overflow-application exe "Telegram.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Telegram.exe"', , "Hide")
+
+; TickTick
+RunWait('komorebic.exe identify-border-overflow-application exe "TickTick.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "TickTick.exe"', , "Hide")
+
+; TouchCursor
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "tcconfig.exe"', , "Hide")
+RunWait('komorebic.exe float-rule exe "tcconfig.exe"', , "Hide")
+
+; TranslucentTB
+RunWait('komorebic.exe float-rule exe "TranslucentTB.exe"', , "Hide")
+
+; TranslucentTB
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "TranslucentTB.exe"', , "Hide")
+
+; Unity Hub
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "Unity Hub.exe"', , "Hide")
+
+; Unreal Editor
+RunWait('komorebic.exe identify-border-overflow-application exe "UnrealEditor.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "UnrealEditor.exe"', , "Hide")
+
+; VRCX
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "VRCX.exe"', , "Hide")
+
+; Visual Studio
+RunWait('komorebic.exe identify-object-name-change-application exe "devenv.exe"', , "Hide")
+
+; Visual Studio Code
+RunWait('komorebic.exe identify-border-overflow-application exe "Code.exe"', , "Hide")
+
+; Visual Studio Code - Insiders
+RunWait('komorebic.exe identify-border-overflow-application exe "Code - Insiders.exe"', , "Hide")
+
+; Voice.ai
+RunWait('komorebic.exe identify-border-overflow-application exe "VoiceAI.exe"', , "Hide")
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "VoiceAI.exe"', , "Hide")
+
+; WebTorrent Desktop
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "WebTorrent.exe"', , "Hide")
+
+; WinZip (32-bit)
+RunWait('komorebic.exe float-rule exe "winzip32.exe"', , "Hide")
+
+; WinZip (64-bit)
+RunWait('komorebic.exe float-rule exe "winzip64.exe"', , "Hide")
+
+; Windows Console (conhost.exe)
+RunWait('komorebic.exe manage-rule class "ConsoleWindowClass"', , "Hide")
+
+; Windows Explorer
+; Targets copy/move operation windows
+RunWait('komorebic.exe float-rule class "OperationStatusWindow"', , "Hide")
+RunWait('komorebic.exe float-rule title "Control Panel"', , "Hide")
+
+; Windows Installer
+RunWait('komorebic.exe float-rule exe "msiexec.exe"', , "Hide")
+
+; Windows Subsystem for Android
+; Targets splash/startup screen
+RunWait('komorebic.exe float-rule class "android(splash)"', , "Hide")
+
+; WingetUI
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "WingetUI.exe"', , "Hide")
+
+; WingetUI
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "wingetui.exe"', , "Hide")
+
+; Wox
+; Targets a hidden window spawned by Wox
+RunWait('komorebic.exe float-rule title "Hotkey sink"', , "Hide")
+
+; XAMPP Control Panel
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "xampp-control.exe"', , "Hide")
+
+; Zoom
+RunWait('komorebic.exe float-rule exe "Zoom.exe"', , "Hide")
+
+; mpv
+RunWait('komorebic.exe identify-object-name-change-application class "mpv"', , "Hide")
+
+; mpv.net
+RunWait('komorebic.exe identify-object-name-change-application exe "mpvnet.exe"', , "Hide")
+
+; paint.net
+RunWait('komorebic.exe float-rule exe "paintdotnet.exe"', , "Hide")
+
+; pinentry
+RunWait('komorebic.exe float-rule exe "pinentry.exe"', , "Hide")
+
+; qBittorrent
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "qbittorrent.exe"', , "Hide")
+
+; ueli
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+RunWait('komorebic.exe identify-tray-application exe "ueli.exe"', , "Hide")
+RunWait('komorebic.exe float-rule exe "ueli.exe"', , "Hide")

komorebi.generated.ps1

@@ -16,6 +16,21 @@ komorebic.exe identify-tray-application class "CreativeCloudDesktopWindowClass"
 # Adobe Photoshop
 komorebic.exe identify-border-overflow-application class "Photoshop"
 
+# Affinity Photo 2
+komorebic.exe manage-rule title "Affinity Photo 2"
+komorebic.exe float-rule exe "Photo.exe"
+
+# Akiflow
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "Akiflow.exe"
+
+# Android Studio
+komorebic.exe identify-object-name-change-application exe "studio64.exe"
+
+# Anki
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "anki.exe"
+
 # ArmCord
 komorebic.exe identify-border-overflow-application exe "ArmCord.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
@@ -25,6 +40,7 @@ komorebic.exe identify-tray-application exe "ArmCord.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "AutoHotkeyU64.exe"
 komorebic.exe float-rule title "Window Spy"
+komorebic.exe float-rule exe "AutoHotkeyUX.exe"
 
 # Beeper
 komorebic.exe identify-border-overflow-application exe "Beeper.exe"
@@ -41,6 +57,19 @@ komorebic.exe float-rule exe "Bloxstrap.exe"
 # Calculator
 komorebic.exe float-rule title "Calculator"
 
+# Clash Verge
+komorebic.exe identify-border-overflow-application exe "Clash Verge.exe"
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "Clash Verge.exe"
+
+# Clementine
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "clementine.exe"
+
+# CopyQ
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "copyq.exe"
+
 # Credential Manager UI Host
 # Targets the Windows popup prompting you for a PIN instead of a password on 1Password etc.
 komorebic.exe float-rule exe "CredentialUIBroker.exe"
@@ -50,6 +79,10 @@ komorebic.exe identify-border-overflow-application exe "Cron.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "Cron.exe"
 
+# DS4Windows
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "DS4Windows.exe"
+
 # Delphi applications
 # Target hidden window spawned by Delphi applications
 komorebic.exe float-rule class "TApplication"
@@ -76,6 +109,12 @@ komorebic.exe identify-border-overflow-application exe "DiscordPTB.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "DiscordPTB.exe"
 
+# Docker Desktop
+komorebic.exe identify-border-overflow-application exe "Docker Desktop.exe"
+
+# Dropbox
+komorebic.exe float-rule exe "Dropbox.exe"
+
 # ElectronMail
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "ElectronMail.exe"
@@ -84,6 +123,9 @@ komorebic.exe identify-tray-application exe "ElectronMail.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "Element.exe"
 
+# Elephicon
+komorebic.exe float-rule exe "Elephicon.exe"
+
 # ElevenClock
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "ElevenClock.exe"
@@ -102,6 +144,13 @@ komorebic.exe identify-border-overflow-application exe "EpicGamesLauncher.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "EpicGamesLauncher.exe"
 
+# Everything
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "Everything.exe"
+
+# Figma
+komorebic.exe identify-border-overflow-application exe "Figma.exe"
+
 # Flow Launcher
 komorebic.exe identify-border-overflow-application exe "Flow.Launcher.exe"
 
@@ -122,6 +171,10 @@ komorebic.exe identify-border-overflow-application exe "GodotManager.exe"
 komorebic.exe manage-rule exe "GodotManager.exe"
 komorebic.exe identify-object-name-change-application exe "GodotManager.exe"
 
+# Golden Dict
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "GoldenDict.exe"
+
 # Google Chrome
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "chrome.exe"
@@ -129,6 +182,7 @@ komorebic.exe identify-tray-application exe "chrome.exe"
 # Google Drive
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "GoogleDriveFS.exe"
+komorebic.exe float-rule exe "GoogleDriveFS.exe"
 
 # Houdoku
 komorebic.exe identify-border-overflow-application exe "Houdoku.exe"
@@ -232,6 +286,14 @@ komorebic.exe float-rule class "MozillaTaskbarPreviewClass"
 # NVIDIA GeForce Experience
 komorebic.exe identify-border-overflow-application exe "NVIDIA GeForce Experience.exe"
 
+# NZXT CAM
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "NZXT CAM.exe"
+
+# NetEase Cloud Music
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "cloudmusic.exe"
+
 # NiceHash Miner
 komorebic.exe identify-border-overflow-application exe "nhm_app.exe"
 komorebic.exe manage-rule exe "nhm_app.exe"
@@ -261,6 +323,13 @@ komorebic.exe identify-tray-application class "DocEditorsWindowClass"
 komorebic.exe identify-border-overflow-application exe "Obsidian.exe"
 komorebic.exe manage-rule exe "Obsidian.exe"
 
+# OneDrive
+komorebic.exe float-rule class "OneDriveReactNativeWin32WindowClass"
+
+# OneQuick
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "OneQuick.exe"
+
 # OpenRGB
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "OpenRGB.exe"
@@ -268,6 +337,13 @@ komorebic.exe identify-tray-application exe "OpenRGB.exe"
 # Paradox Launcher
 komorebic.exe float-rule exe "Paradox Launcher.exe"
 
+# Playnite
+komorebic.exe identify-border-overflow-application exe "Playnite.DesktopApp.exe"
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "Playnite.DesktopApp.exe"
+# Target fullscreen app
+komorebic.exe float-rule exe "Playnite.FullscreenApp.exe"
+
 # Plexamp
 komorebic.exe identify-border-overflow-application exe "Plexamp.exe"
 
@@ -276,6 +352,8 @@ komorebic.exe identify-border-overflow-application exe "Plexamp.exe"
 komorebic.exe float-rule exe "PowerToys.ColorPickerUI.exe"
 # Target image resizer dialog
 komorebic.exe float-rule exe "PowerToys.ImageResizer.exe"
+# Target Peek popup
+komorebic.exe float-rule exe "PowerToys.Peek.UI.exe"
 
 # Process Hacker
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
@@ -292,6 +370,13 @@ komorebic.exe identify-object-name-change-application exe "pycharm64.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "pycharm64.exe"
 
+# QQ
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "QQ.exe"
+komorebic.exe float-rule title "图片查看器"
+komorebic.exe float-rule title "群聊的聊天记录"
+komorebic.exe float-rule title "语音通话"
+
 # QtScrcpy
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "QtScrcpy.exe"
@@ -319,6 +404,15 @@ komorebic.exe identify-border-overflow-application exe "RoundedTB.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "RoundedTB.exe"
 
+# RustRover
+komorebic.exe identify-object-name-change-application exe "rustrover64.exe"
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "rustrover64.exe"
+
+# Sandboxie Plus
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "SandMan.exe"
+
 # ShareX
 komorebic.exe identify-border-overflow-application exe "ShareX.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
@@ -329,7 +423,7 @@ komorebic.exe float-rule exe "sideloadly.exe"
 
 # Signal
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
-komorebic.exe identify-tray-application exe "signal.exe"
+komorebic.exe identify-tray-application exe "Signal.exe"
 
 # SiriKali
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
@@ -337,13 +431,11 @@ komorebic.exe identify-tray-application exe "sirikali.exe"
 
 # Slack
 komorebic.exe identify-border-overflow-application exe "Slack.exe"
-komorebic.exe manage-rule exe "Slack.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "Slack.exe"
 
 # Slack
 komorebic.exe identify-border-overflow-application exe "slack.exe"
-komorebic.exe manage-rule exe "slack.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "slack.exe"
 
@@ -365,6 +457,13 @@ komorebic.exe identify-tray-application exe "Spotify.exe"
 # Steam
 komorebic.exe identify-border-overflow-application class "vguiPopupWindow"
 
+# Steam Beta
+komorebic.exe identify-border-overflow-application class "SDL_app"
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application class "SDL_app"
+# Target notification toast popups
+komorebic.exe float-rule title "notificationtoasts_"
+
 # Stremio
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "stremio.exe"
@@ -385,6 +484,11 @@ komorebic.exe identify-border-overflow-application exe "Telegram.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "Telegram.exe"
 
+# TickTick
+komorebic.exe identify-border-overflow-application exe "TickTick.exe"
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "TickTick.exe"
+
 # TouchCursor
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "tcconfig.exe"
@@ -397,6 +501,10 @@ komorebic.exe float-rule exe "TranslucentTB.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "TranslucentTB.exe"
 
+# Unity Hub
+# If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+komorebic.exe identify-tray-application exe "Unity Hub.exe"
+
 # Unreal Editor
 komorebic.exe identify-border-overflow-application exe "UnrealEditor.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
@@ -412,6 +520,9 @@ komorebic.exe identify-object-name-change-application exe "devenv.exe"
 # Visual Studio Code
 komorebic.exe identify-border-overflow-application exe "Code.exe"
 
+# Visual Studio Code - Insiders
+komorebic.exe identify-border-overflow-application exe "Code - Insiders.exe"
+
 # Voice.ai
 komorebic.exe identify-border-overflow-application exe "VoiceAI.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
@@ -421,6 +532,12 @@ komorebic.exe identify-tray-application exe "VoiceAI.exe"
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "WebTorrent.exe"
 
+# WinZip (32-bit)
+komorebic.exe float-rule exe "winzip32.exe"
+
+# WinZip (64-bit)
+komorebic.exe float-rule exe "winzip64.exe"
+
 # Windows Console (conhost.exe)
 komorebic.exe manage-rule class "ConsoleWindowClass"
 
@@ -432,6 +549,10 @@ komorebic.exe float-rule title "Control Panel"
 # Windows Installer
 komorebic.exe float-rule exe "msiexec.exe"
 
+# Windows Subsystem for Android
+# Targets splash/startup screen
+komorebic.exe float-rule class "android(splash)"
+
 # WingetUI
 # If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
 komorebic.exe identify-tray-application exe "WingetUI.exe"
@@ -451,6 +572,9 @@ komorebic.exe identify-tray-application exe "xampp-control.exe"
 # Zoom
 komorebic.exe float-rule exe "Zoom.exe"
 
+# mpv
+komorebic.exe identify-object-name-change-application class "mpv"
+
 # mpv.net
 komorebic.exe identify-object-name-change-application exe "mpvnet.exe"
 

komorebi.sample.ahk

@@ -0,0 +1,93 @@
+#SingleInstance Force
+
+; Load library
+#Include komorebic.lib.ahk
+; Load configuration
+#Include komorebi.generated.ahk
+
+; Send the ALT key whenever changing focus to force focus changes
+AltFocusHack("enable")
+; Default to cloaking windows when switching workspaces
+WindowHidingBehaviour("cloak")
+; Set cross-monitor move behaviour to insert instead of swap
+CrossMonitorMoveBehaviour("Insert")
+; Enable hot reloading of changes to this file
+WatchConfiguration("enable")
+
+; Create named workspaces I-V on monitor 0
+EnsureNamedWorkspaces(0, "I II III IV V")
+; You can do the same thing for secondary monitors too
+; EnsureNamedWorkspaces(1, "A B C D E F")
+
+; Assign layouts to workspaces, possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack
+NamedWorkspaceLayout("I", "bsp")
+
+; Set the gaps around the edge of the screen for a workspace
+NamedWorkspacePadding("I", 20)
+; Set the gaps between the containers for a workspace
+NamedWorkspaceContainerPadding("I", 20)
+
+; You can assign specific apps to named workspaces
+; NamedWorkspaceRule("exe", "Firefox.exe", "III")
+
+; Configure the invisible border dimensions
+InvisibleBorders(7, 0, 14, 7)
+
+; Uncomment the next lines if you want a visual border around the active window
+; ActiveWindowBorderColour(66, 165, 245, "single")
+; ActiveWindowBorderColour(256, 165, 66, "stack")
+; ActiveWindowBorderColour(255, 51, 153, "monocle")
+
+CompleteConfiguration()
+
+; Focus windows
+!h::Focus("left")
+!j::Focus("down")
+!k::Focus("up")
+!l::Focus("right")
+!+[::CycleFocus("previous")
+!+]::CycleFocus("next")
+
+; Move windows
+!+h::Move("left")
+!+j::Move("down")
+!+k::Move("up")
+!+l::Move("right")
+!+Enter::Promote()
+
+; Stack windows
+!Left::Stack("left")
+!Right::Stack("right")
+!Up::Stack("up")
+!Down::Stack("down")
+!;::Unstack()
+![::CycleStack("previous")
+!]::CycleStack("next")
+
+; Resize
+!=::ResizeAxis("horizontal", "increase")
+!-::ResizeAxis("horizontal", "decrease")
+!+=::ResizeAxis("vertical", "increase")
+!+-::ResizeAxis("vertical", "decrease")
+
+; Manipulate windows
+!t::ToggleFloat()
+!+f::ToggleMonocle()
+
+; Window manager options
+!+r::Retile()
+!p::TogglePause()
+
+; Layouts
+!x::FlipLayout("horizontal")
+!y::FlipLayout("vertical")
+
+; Workspaces
+!1::FocusWorkspace(0)
+!2::FocusWorkspace(1)
+!3::FocusWorkspace(2)
+
+; Move windows across workspaces
+!+1::MoveToWorkspace(0)
+!+2::MoveToWorkspace(1)
+!+3::MoveToWorkspace(2)

komorebi.sample.ps1

@@ -7,28 +7,27 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
 
 # Send the ALT key whenever changing focus to force focus changes
 komorebic alt-focus-hack enable
-# Default to minimizing windows when switching workspaces
+# Default to cloaking windows when switching workspaces
 komorebic window-hiding-behaviour cloak
 # Set cross-monitor move behaviour to insert instead of swap
 komorebic cross-monitor-move-behaviour insert
 # Enable hot reloading of changes to this file
 komorebic watch-configuration enable
 
-# create named workspaces I-V on monitor 0
+# Create named workspaces I-V on monitor 0
 komorebic ensure-named-workspaces 0 I II III IV V
-# you can do the same thing for secondary monitors too
+# You can do the same thing for secondary monitors too
 # komorebic ensure-named-workspaces 1 A B C D E F
 
-# assign layouts to workspaces, possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack
+# Assign layouts to workspaces, possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack
 komorebic named-workspace-layout I bsp
 
-# set the gaps around the edge of the screen for a workspace
+# Set the gaps around the edge of the screen for a workspace
 komorebic named-workspace-padding I 20
-
-# set the gaps between the containers for a workspace
+# Set the gaps between the containers for a workspace
 komorebic named-workspace-container-padding I 20
 
-# you can assign specific apps to named workspaces
+# You can assign specific apps to named workspaces
 # komorebic named-workspace-rule exe "Firefox.exe" III
 
 # Configure the invisible border dimensions
@@ -37,6 +36,7 @@ komorebic invisible-borders 7 0 14 7
 # Uncomment the next lines if you want a visual border around the active window
 # komorebic active-window-border-colour 66 165 245 --window-kind single
 # komorebic active-window-border-colour 256 165 66 --window-kind stack
+# komorebic active-window-border-colour 255 51 153 --window-kind monocle
 # komorebic active-window-border enable
 
 komorebic complete-configuration

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.15"
+version = "0.1.19"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -13,56 +13,38 @@ edition = "2021"
 [dependencies]
 komorebi-core = { path = "../komorebi-core" }
 
-bitflags = "1"
+bitflags = "2"
 clap = { version = "4", features = ["derive"] }
 color-eyre = "0.6"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 ctrlc = "3"
-dirs = "4"
+dirs = "5"
 getset = "0.1"
 hotwatch = "0.4"
 lazy_static = "1"
 miow = "0.5"
 nanoid = "0.4"
 net2 = "0.2"
-os_info = "3.6"
+os_info = "3.7"
 parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 paste = "1"
+regex = "1"
 schemars = "0.8"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-strum = { version = "0.24", features = ["derive"] }
-sysinfo = "0.27"
+strum = { version = "0.25", features = ["derive"] }
+sysinfo = "0.29"
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uds_windows = "1"
-which = "4"
+which = "5"
 winput = "0.2"
-winreg = "0.10"
-windows-interface = { version = "0.44" }
-windows-implement = { version = "0.44" }
-[dependencies.windows]
-version = "0.44"
-features = [
-    "implement",
-    "Win32_System_Com",
-    "Win32_UI_Shell_Common", # for IObjectArray
-    "Win32_Foundation",
-    "Win32_Graphics_Dwm",
-    "Win32_Graphics_Gdi",
-    "Win32_System_LibraryLoader",
-    "Win32_System_RemoteDesktop",
-    "Win32_System_Threading",
-    "Win32_UI_Accessibility",
-    "Win32_UI_HiDpi",
-    "Win32_UI_Input_KeyboardAndMouse",
-    "Win32_UI_Shell",
-    "Win32_UI_Shell_Common",
-    "Win32_UI_WindowsAndMessaging",
-    "Win32_System_SystemServices"
-]
+winreg = "0.51"
+windows-interface = { workspace = true }
+windows-implement = { workspace = true }
+windows = { workspace = true }
 
 [features]
 deadlock_detection = []

komorebi/src/border.rs

@@ -14,6 +14,7 @@ use windows::Win32::UI::WindowsAndMessaging::WNDCLASSA;
 
 use komorebi_core::Rect;
 
+use crate::window::should_act;
 use crate::window::Window;
 use crate::windows_callbacks;
 use crate::WindowsApi;
@@ -21,6 +22,7 @@ use crate::BORDER_HWND;
 use crate::BORDER_OFFSET;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::BORDER_RECT;
+use crate::REGEX_IDENTIFIERS;
 use crate::TRANSPARENCY_COLOUR;
 use crate::WINDOWS_11;
 
@@ -46,7 +48,7 @@ impl Border {
         let class_name = PCSTR(name.as_ptr());
         let brush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
         let window_class = WNDCLASSA {
-            hInstance: instance,
+            hInstance: instance.into(),
             lpszClassName: class_name,
             style: CS_HREDRAW | CS_VREDRAW,
             lpfnWndProc: Some(windows_callbacks::border_window),
@@ -108,19 +110,24 @@ impl Border {
                 Self::create("komorebi-border-window")?;
             }
 
-            let mut should_expand_border = false;
-
             let mut rect = WindowsApi::window_rect(window.hwnd())?;
             rect.top -= invisible_borders.bottom;
             rect.bottom += invisible_borders.bottom;
 
             let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
-            if border_overflows.contains(&window.title()?)
-                || border_overflows.contains(&window.exe()?)
-                || border_overflows.contains(&window.class()?)
-            {
-                should_expand_border = true;
-            }
+            let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
+            let title = &window.title()?;
+            let exe_name = &window.exe()?;
+            let class = &window.class()?;
+
+            let should_expand_border = should_act(
+                title,
+                exe_name,
+                class,
+                &border_overflows,
+                &regex_identifiers,
+            );
 
             if should_expand_border {
                 rect.left -= invisible_borders.left;

komorebi/src/com/mod.rs

@@ -10,8 +10,8 @@ use interfaces::IServiceProvider;
 
 use std::ffi::c_void;
 
+use windows::core::ComInterface;
 use windows::core::Interface;
-use windows::core::Vtable;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::System::Com::CoCreateInstance;
 use windows::Win32::System::Com::CoInitializeEx;

komorebi/src/hidden.rs

@@ -39,7 +39,7 @@ impl Hidden {
         let class_name = PCSTR(name.as_ptr());
         let brush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
         let window_class = WNDCLASSA {
-            hInstance: instance,
+            hInstance: instance.into(),
             lpszClassName: class_name,
             style: CS_HREDRAW | CS_VREDRAW,
             lpfnWndProc: Some(windows_callbacks::hidden_window),

komorebi/src/main.rs

@@ -1,5 +1,10 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc, clippy::redundant_pub_crate)]
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::redundant_pub_crate,
+    clippy::significant_drop_tightening,
+    clippy::significant_drop_in_scrutinee
+)]
 
 use std::collections::HashMap;
 use std::fs::File;
@@ -27,6 +32,7 @@ use os_info::Version;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
+use regex::Regex;
 use schemars::JsonSchema;
 use serde::Serialize;
 use sysinfo::Process;
@@ -40,6 +46,9 @@ use winreg::enums::HKEY_CURRENT_USER;
 use winreg::RegKey;
 
 use crate::hidden::Hidden;
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::config_generation::MatchingStrategy;
+use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 use komorebi_core::SocketMessage;
@@ -48,6 +57,7 @@ use crate::process_command::listen_for_commands;
 use crate::process_command::listen_for_commands_tcp;
 use crate::process_event::listen_for_events;
 use crate::process_movement::listen_for_movements;
+use crate::static_config::StaticConfig;
 use crate::window_manager::State;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
@@ -65,6 +75,7 @@ mod process_command;
 mod process_event;
 mod process_movement;
 mod set_window_position;
+mod static_config;
 mod styles;
 mod window;
 mod window_manager;
@@ -75,35 +86,87 @@ mod winevent;
 mod winevent_listener;
 mod workspace;
 
+type WorkspaceRule = (usize, usize, bool);
+
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
-    static ref LAYERED_WHITELIST: Arc<Mutex<Vec<String>>> =
-        Arc::new(Mutex::new(vec!["steam.exe".to_string()]));
-    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<String>>> =
+    static ref LAYERED_WHITELIST: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Exe,
+            id: String::from("steam.exe"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+    ]));
+    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> =
         Arc::new(Mutex::new(vec![
-            "explorer.exe".to_string(),
-            "firefox.exe".to_string(),
-            "chrome.exe".to_string(),
-            "idea64.exe".to_string(),
-            "ApplicationFrameHost.exe".to_string(),
-            "steam.exe".to_string(),
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("explorer.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("firefox.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("chrome.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("idea64.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("ApplicationFrameHost.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            },
+            IdWithIdentifier {
+                kind: ApplicationIdentifier::Exe,
+                id: String::from("steam.exe"),
+                matching_strategy: Option::from(MatchingStrategy::Equals),
+            }
         ]));
-    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
-        "firefox.exe".to_string(),
-        "idea64.exe".to_string(),
+    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Exe,
+            id: String::from("firefox.exe"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Exe,
+            id: String::from("idea64.exe"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
     ]));
     static ref MONITOR_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, Rect>>> =
         Arc::new(Mutex::new(HashMap::new()));
-    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, (usize, usize)>>> =
+    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, WorkspaceRule>>> =
         Arc::new(Mutex::new(HashMap::new()));
-    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
-    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
+    static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
+    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
         // mstsc.exe creates these on Windows 11 when a WSL process is launched
         // https://github.com/LGUG2Z/komorebi/issues/74
-        "OPContainerClass".to_string(),
-        "IHWindowClass".to_string()
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Class,
+            id: String::from("OPContainerClass"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        },
+        IdWithIdentifier {
+            kind: ApplicationIdentifier::Class,
+            id: String::from("IHWindowClass"),
+            matching_strategy: Option::from(MatchingStrategy::Equals),
+        }
     ]));
-    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
+    static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
+        "Chrome_RenderWidgetHostHWND".to_string(),
+    ]));
+    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
     static ref WSL2_UI_PROCESSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "X410.exe".to_string(),
         "vcxsrv.exe".to_string(),
@@ -122,8 +185,7 @@ lazy_static! {
                 home
             } else {
                 panic!(
-                    "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
-                    home_path
+                    "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory",
                 );
             }
         })
@@ -152,8 +214,15 @@ lazy_static! {
 
     static ref BORDER_OFFSET: Arc<Mutex<Option<Rect>>> =
         Arc::new(Mutex::new(None));
+
+    // Use app-specific titlebar removal options where possible
+    // eg. Windows Terminal, IntelliJ IDEA, Firefox
+    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
 }
 
+pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
+pub static DEFAULT_CONTAINER_PADDING: AtomicI32 = AtomicI32::new(10);
+
 pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
@@ -163,10 +232,12 @@ pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
 pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);
 pub static BORDER_COLOUR_SINGLE: AtomicU32 = AtomicU32::new(0);
 pub static BORDER_COLOUR_STACK: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_COLOUR_MONOCLE: AtomicU32 = AtomicU32::new(0);
 pub static BORDER_COLOUR_CURRENT: AtomicU32 = AtomicU32::new(0);
 pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(20);
 // 0 0 0 aka pure black, I doubt anyone will want this as a border colour
 pub const TRANSPARENCY_COLOUR: u32 = 0;
+pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
 
 pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);
 
@@ -239,7 +310,7 @@ pub fn load_configuration() -> Result<()> {
     let mut config_pwsh = home.clone();
     config_pwsh.push("komorebi.ps1");
 
-    let mut config_ahk = home.clone();
+    let mut config_ahk = home;
     config_ahk.push("komorebi.ahk");
 
     if config_pwsh.exists() {
@@ -269,7 +340,7 @@ pub fn load_configuration() -> Result<()> {
                 .ok_or_else(|| anyhow!("cannot convert path to string"))?
         );
 
-        Command::new("autohotkey.exe")
+        Command::new(&*AHK_EXE)
             .arg(config_ahk.as_os_str())
             .output()?;
     }
@@ -277,6 +348,7 @@ pub fn load_configuration() -> Result<()> {
     Ok(())
 }
 
+#[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     let hkcu = RegKey::predef(HKEY_CURRENT_USER);
 
@@ -297,7 +369,7 @@ pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     // This is the path on Windows 11
     if current.is_none() {
         current = hkcu
-            .open_subkey(r#"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VirtualDesktops"#)
+            .open_subkey(r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VirtualDesktops")
             .ok()
             .and_then(
                 |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
@@ -336,8 +408,8 @@ pub struct Notification {
 pub fn notify_subscribers(notification: &str) -> Result<()> {
     let mut stale_subscriptions = vec![];
     let mut subscriptions = SUBSCRIPTION_PIPES.lock();
-    for (subscriber, pipe) in subscriptions.iter_mut() {
-        match writeln!(pipe, "{}", notification) {
+    for (subscriber, pipe) in &mut *subscriptions {
+        match writeln!(pipe, "{notification}") {
             Ok(_) => {
                 tracing::debug!("pushed notification to subscriber: {}", subscriber);
             }
@@ -402,81 +474,89 @@ struct Opts {
     /// Start a TCP server on the given port to allow the direct sending of SocketMessages
     #[clap(action, short, long)]
     tcp_port: Option<usize>,
+    /// Path to a static configuration JSON file
+    #[clap(action, short, long)]
+    config: Option<PathBuf>,
 }
 
 #[tracing::instrument]
-#[allow(clippy::nonminimal_bool)]
+#[allow(clippy::cognitive_complexity)]
 fn main() -> Result<()> {
     let opts: Opts = Opts::parse();
     CUSTOM_FFM.store(opts.focus_follows_mouse, Ordering::SeqCst);
 
-    let arg_count = std::env::args().count();
+    let process_id = WindowsApi::current_process_id();
+    WindowsApi::allow_set_foreground_window(process_id)?;
+    WindowsApi::set_process_dpi_awareness_context()?;
 
-    let has_valid_args = arg_count == 1
-        || (arg_count == 2
-            && (opts.await_configuration || opts.focus_follows_mouse || opts.tcp_port.is_some()))
-        || (arg_count == 3 && opts.await_configuration && opts.focus_follows_mouse)
-        || (arg_count == 3 && opts.tcp_port.is_some() && opts.focus_follows_mouse)
-        || (arg_count == 3 && opts.tcp_port.is_some() && opts.await_configuration)
-        || (arg_count == 4
-            && (opts.focus_follows_mouse && opts.await_configuration && opts.tcp_port.is_some()));
+    let session_id = WindowsApi::process_id_to_session_id()?;
+    SESSION_ID.store(session_id, Ordering::SeqCst);
 
-    if has_valid_args {
-        let process_id = WindowsApi::current_process_id();
-        WindowsApi::allow_set_foreground_window(process_id)?;
-        WindowsApi::set_process_dpi_awareness_context()?;
+    let mut system = sysinfo::System::new_all();
+    system.refresh_processes();
 
-        let session_id = WindowsApi::process_id_to_session_id()?;
-        SESSION_ID.store(session_id, Ordering::SeqCst);
+    let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
 
-        let mut system = sysinfo::System::new_all();
-        system.refresh_processes();
-
-        let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
-
-        if matched_procs.len() > 1 {
-            let mut len = matched_procs.len();
-            for proc in matched_procs {
-                if proc.root().ends_with("shims") {
-                    len -= 1;
-                }
-            }
-
-            if len > 1 {
-                tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
-                std::process::exit(1);
+    if matched_procs.len() > 1 {
+        let mut len = matched_procs.len();
+        for proc in matched_procs {
+            if proc.root().ends_with("shims") {
+                len -= 1;
             }
         }
 
-        // File logging worker guard has to have an assignment in the main fn to work
-        let (_guard, _color_guard) = setup()?;
+        if len > 1 {
+            tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
+            std::process::exit(1);
+        }
+    }
 
-        #[cfg(feature = "deadlock_detection")]
-        detect_deadlocks();
+    // File logging worker guard has to have an assignment in the main fn to work
+    let (_guard, _color_guard) = setup()?;
 
-        let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
-            crossbeam_channel::unbounded();
+    #[cfg(feature = "deadlock_detection")]
+    detect_deadlocks();
 
-        let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
-        winevent_listener.start();
+    let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
+        crossbeam_channel::unbounded();
 
-        Hidden::create("komorebi-hidden")?;
+    let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
+    winevent_listener.start();
 
-        let wm = Arc::new(Mutex::new(WindowManager::new(Arc::new(Mutex::new(
+    Hidden::create("komorebi-hidden")?;
+
+    let wm = if let Some(config) = &opts.config {
+        tracing::info!(
+            "creating window manager from static configuration file: {}",
+            config.as_os_str().to_str().unwrap()
+        );
+
+        Arc::new(Mutex::new(StaticConfig::preload(
+            config,
+            Arc::new(Mutex::new(incoming)),
+        )?))
+    } else {
+        Arc::new(Mutex::new(WindowManager::new(Arc::new(Mutex::new(
             incoming,
-        )))?));
+        )))?))
+    };
 
-        wm.lock().init()?;
-        listen_for_commands(wm.clone());
+    wm.lock().init()?;
+    if let Some(config) = &opts.config {
+        StaticConfig::postload(config, &wm)?;
+    }
 
-        if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
-            INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
-        };
+    listen_for_commands(wm.clone());
 
-        if let Some(port) = opts.tcp_port {
-            listen_for_commands_tcp(wm.clone(), port);
-        }
+    if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+        INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
+    };
 
+    if let Some(port) = opts.tcp_port {
+        listen_for_commands_tcp(wm.clone(), port);
+    }
+
+    if opts.config.is_none() {
         std::thread::spawn(|| {
             load_configuration().expect("could not load configuration");
         });
@@ -487,36 +567,34 @@ fn main() -> Result<()> {
                 backoff.snooze();
             }
         }
-
-        wm.lock().retile_all(false)?;
-
-        listen_for_events(wm.clone());
-
-        if CUSTOM_FFM.load(Ordering::SeqCst) {
-            listen_for_movements(wm.clone());
-        }
-
-        let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
-        ctrlc::set_handler(move || {
-            ctrlc_sender
-                .send(())
-                .expect("could not send signal on ctrl-c channel");
-        })?;
-
-        ctrlc_receiver
-            .recv()
-            .expect("could not receive signal on ctrl-c channel");
-
-        tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
-
-        wm.lock().restore_all_windows();
-
-        if WindowsApi::focus_follows_mouse()? {
-            WindowsApi::disable_focus_follows_mouse()?;
-        }
-
-        std::process::exit(130);
     }
 
-    Ok(())
+    wm.lock().retile_all(false)?;
+
+    listen_for_events(wm.clone());
+
+    if CUSTOM_FFM.load(Ordering::SeqCst) {
+        listen_for_movements(wm.clone());
+    }
+
+    let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
+    ctrlc::set_handler(move || {
+        ctrlc_sender
+            .send(())
+            .expect("could not send signal on ctrl-c channel");
+    })?;
+
+    ctrlc_receiver
+        .recv()
+        .expect("could not receive signal on ctrl-c channel");
+
+    tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
+
+    wm.lock().restore_all_windows()?;
+
+    if WindowsApi::focus_follows_mouse()? {
+        WindowsApi::disable_focus_follows_mouse()?;
+    }
+
+    std::process::exit(130);
 }

komorebi/src/monitor.rs

@@ -105,6 +105,10 @@ impl Monitor {
         }
     }
 
+    pub fn remove_workspaces(&mut self) -> VecDeque<Workspace> {
+        self.workspaces_mut().drain(..).collect()
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn move_container_to_workspace(
         &mut self,

komorebi/src/process_command.rs

@@ -20,6 +20,8 @@ use parking_lot::Mutex;
 use schemars::schema_for;
 use uds_windows::UnixStream;
 
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
 use komorebi_core::FocusFollowsMouseImplementation;
@@ -36,6 +38,7 @@ use komorebi_core::WindowKind;
 use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
+use crate::static_config::StaticConfig;
 use crate::window::Window;
 use crate::window_manager;
 use crate::window_manager::WindowManager;
@@ -44,6 +47,7 @@ use crate::Notification;
 use crate::NotificationEvent;
 use crate::ALT_FOCUS_HACK;
 use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_COLOUR_MONOCLE;
 use crate::BORDER_COLOUR_SINGLE;
 use crate::BORDER_COLOUR_STACK;
 use crate::BORDER_ENABLED;
@@ -60,7 +64,9 @@ use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
+use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::REMOVE_TITLEBARS;
 use crate::SUBSCRIPTION_PIPES;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
@@ -94,7 +100,7 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
 #[tracing::instrument]
 pub fn listen_for_commands_tcp(wm: Arc<Mutex<WindowManager>>, port: usize) {
     let listener =
-        TcpListener::bind(format!("0.0.0.0:{}", port)).expect("could not start tcp server");
+        TcpListener::bind(format!("0.0.0.0:{port}")).expect("could not start tcp server");
 
     std::thread::spawn(move || {
         tracing::info!("listening on 0.0.0.0:43663");
@@ -214,36 +220,60 @@ impl WindowManager {
                     self.set_workspace_padding(monitor_idx, workspace_idx, size)?;
                 }
             }
-            SocketMessage::WorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
+            SocketMessage::InitialWorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
+                self.handle_initial_workspace_rules(id, monitor_idx, workspace_idx)?;
+            }
+            SocketMessage::InitialNamedWorkspaceRule(_, ref id, ref workspace) => {
+                if let Some((monitor_idx, workspace_idx)) =
+                    self.monitor_workspace_index_by_name(workspace)
                 {
-                    let mut workspace_rules = WORKSPACE_RULES.lock();
-                    workspace_rules.insert(id.to_string(), (monitor_idx, workspace_idx));
+                    self.handle_initial_workspace_rules(id, monitor_idx, workspace_idx)?;
                 }
-
-                self.enforce_workspace_rules()?;
+            }
+            SocketMessage::WorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
+                self.handle_definitive_workspace_rules(id, monitor_idx, workspace_idx)?;
             }
             SocketMessage::NamedWorkspaceRule(_, ref id, ref workspace) => {
                 if let Some((monitor_idx, workspace_idx)) =
                     self.monitor_workspace_index_by_name(workspace)
                 {
-                    {
-                        let mut workspace_rules = WORKSPACE_RULES.lock();
-                        workspace_rules.insert(id.to_string(), (monitor_idx, workspace_idx));
-                    }
-
-                    self.enforce_workspace_rules()?;
+                    self.handle_definitive_workspace_rules(id, monitor_idx, workspace_idx)?;
                 }
             }
-            SocketMessage::ManageRule(_, ref id) => {
+            SocketMessage::ManageRule(identifier, ref id) => {
                 let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
-                if !manage_identifiers.contains(id) {
-                    manage_identifiers.push(id.to_string());
+
+                let mut should_push = true;
+                for m in &*manage_identifiers {
+                    if m.id.eq(id) {
+                        should_push = false;
+                    }
+                }
+
+                if should_push {
+                    manage_identifiers.push(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    });
                 }
             }
             SocketMessage::FloatRule(identifier, ref id) => {
                 let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
-                if !float_identifiers.contains(id) {
-                    float_identifiers.push(id.to_string());
+
+                let mut should_push = true;
+                for f in &*float_identifiers {
+                    if f.id.eq(id) {
+                        should_push = false;
+                    }
+                }
+
+                if should_push {
+                    float_identifiers.push(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    });
                 }
 
                 let invisible_borders = self.invisible_borders;
@@ -255,9 +285,8 @@ impl WindowManager {
                         .focused_workspace()
                         .ok_or_else(|| anyhow!("there is no workspace"))?
                         .containers()
-                        .iter()
                     {
-                        for window in container.windows().iter() {
+                        for window in container.windows() {
                             match identifier {
                                 ApplicationIdentifier::Exe => {
                                     if window.exe()? == *id {
@@ -321,6 +350,18 @@ impl WindowManager {
             SocketMessage::MoveContainerToMonitorNumber(monitor_idx) => {
                 self.move_container_to_monitor(monitor_idx, None, true)?;
             }
+            SocketMessage::SwapWorkspacesToMonitorNumber(monitor_idx) => {
+                self.swap_focused_monitor(monitor_idx)?;
+            }
+            SocketMessage::CycleMoveContainerToMonitor(direction) => {
+                let monitor_idx = direction.next_idx(
+                    self.focused_monitor_idx(),
+                    NonZeroUsize::new(self.monitors().len())
+                        .ok_or_else(|| anyhow!("there must be at least one monitor"))?,
+                );
+
+                self.move_container_to_monitor(monitor_idx, None, true)?;
+            }
             SocketMessage::SendContainerToWorkspaceNumber(workspace_idx) => {
                 self.move_container_to_workspace(workspace_idx, false)?;
             }
@@ -343,6 +384,15 @@ impl WindowManager {
             SocketMessage::SendContainerToMonitorNumber(monitor_idx) => {
                 self.move_container_to_monitor(monitor_idx, None, false)?;
             }
+            SocketMessage::CycleSendContainerToMonitor(direction) => {
+                let monitor_idx = direction.next_idx(
+                    self.focused_monitor_idx(),
+                    NonZeroUsize::new(self.monitors().len())
+                        .ok_or_else(|| anyhow!("there must be at least one monitor"))?,
+                );
+
+                self.move_container_to_monitor(monitor_idx, None, false)?;
+            }
             SocketMessage::SendContainerToMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
                 self.move_container_to_monitor(monitor_idx, Option::from(workspace_idx), false)?;
             }
@@ -398,6 +448,7 @@ impl WindowManager {
             SocketMessage::Retile => self.retile_all(false)?,
             SocketMessage::FlipLayout(layout_flip) => self.flip_layout(layout_flip)?,
             SocketMessage::ChangeLayout(layout) => self.change_workspace_layout_default(layout)?,
+            SocketMessage::CycleLayout(direction) => self.cycle_layout(direction)?,
             SocketMessage::ChangeLayoutCustom(ref path) => {
                 self.change_workspace_custom_layout(path.clone())?;
             }
@@ -536,6 +587,29 @@ impl WindowManager {
                     self.show_border()?;
                 };
             }
+            SocketMessage::FocusWorkspaceNumbers(workspace_idx) => {
+                // This is to ensure that even on an empty workspace on a secondary monitor, the
+                // secondary monitor where the cursor is focused will be used as the target for
+                // the workspace switch op
+                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
+                    self.focus_monitor(monitor_idx)?;
+                }
+
+                let focused_monitor_idx = self.focused_monitor_idx();
+
+                for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
+                    if i != focused_monitor_idx {
+                        monitor.focus_workspace(workspace_idx)?;
+                        monitor.load_focused_workspace(false)?;
+                    }
+                }
+
+                self.focus_workspace(workspace_idx)?;
+
+                if BORDER_ENABLED.load(Ordering::SeqCst) {
+                    self.show_border()?;
+                };
+            }
             SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
                 self.focus_monitor(monitor_idx)?;
                 self.focus_workspace(workspace_idx)?;
@@ -556,7 +630,7 @@ impl WindowManager {
                 tracing::info!(
                     "received stop command, restoring all hidden windows and terminating process"
                 );
-                self.restore_all_windows();
+                self.restore_all_windows()?;
 
                 if WindowsApi::focus_follows_mouse()? {
                     WindowsApi::disable_focus_follows_mouse()?;
@@ -637,17 +711,18 @@ impl WindowManager {
 
                 if let Layout::Custom(ref mut custom) = workspace.layout_mut() {
                     if matches!(axis, Axis::Horizontal) {
+                        #[allow(clippy::cast_precision_loss)]
                         let percentage = custom
                             .primary_width_percentage()
-                            .unwrap_or(100 / custom.len());
+                            .unwrap_or(100.0 / (custom.len() as f32));
 
                         if no_layout_rules {
                             match sizing {
                                 Sizing::Increase => {
-                                    custom.set_primary_width_percentage(percentage + 5);
+                                    custom.set_primary_width_percentage(percentage + 5.0);
                                 }
                                 Sizing::Decrease => {
-                                    custom.set_primary_width_percentage(percentage - 5);
+                                    custom.set_primary_width_percentage(percentage - 5.0);
                                 }
                             }
                         } else {
@@ -656,10 +731,12 @@ impl WindowManager {
                                     if let Layout::Custom(ref mut custom) = rule.1 {
                                         match sizing {
                                             Sizing::Increase => {
-                                                custom.set_primary_width_percentage(percentage + 5);
+                                                custom
+                                                    .set_primary_width_percentage(percentage + 5.0);
                                             }
                                             Sizing::Decrease => {
-                                                custom.set_primary_width_percentage(percentage - 5);
+                                                custom
+                                                    .set_primary_width_percentage(percentage - 5.0);
                                             }
                                         }
                                     }
@@ -667,8 +744,8 @@ impl WindowManager {
                             }
                         }
                     }
-                // Otherwise proceed with the resizing logic for individual window containers in the
-                // assumed BSP layout
+                    // Otherwise proceed with the resizing logic for individual window containers in the
+                    // assumed BSP layout
                 } else {
                     match axis {
                         Axis::Horizontal => {
@@ -752,9 +829,10 @@ impl WindowManager {
                         }
                     }
                     FocusFollowsMouseImplementation::Windows => {
-                        if let Some(FocusFollowsMouseImplementation::Komorebi) =
-                            self.focus_follows_mouse
-                        {
+                        if matches!(
+                            self.focus_follows_mouse,
+                            Some(FocusFollowsMouseImplementation::Komorebi)
+                        ) {
                             tracing::warn!(
                                 "the windows implementation of focus follows mouse cannot be enabled while the komorebi implementation is enabled"
                             );
@@ -799,9 +877,10 @@ impl WindowManager {
                         }
                     }
                     FocusFollowsMouseImplementation::Windows => {
-                        if let Some(FocusFollowsMouseImplementation::Komorebi) =
-                            self.focus_follows_mouse
-                        {
+                        if matches!(
+                            self.focus_follows_mouse,
+                            Some(FocusFollowsMouseImplementation::Komorebi)
+                        ) {
                             tracing::warn!(
                                 "the windows implementation of focus follows mouse cannot be toggled while the komorebi implementation is enabled"
                             );
@@ -826,6 +905,9 @@ impl WindowManager {
             SocketMessage::ReloadConfiguration => {
                 Self::reload_configuration();
             }
+            SocketMessage::ReloadStaticConfiguration(ref pathbuf) => {
+                self.reload_static_configuration(pathbuf)?;
+            }
             SocketMessage::CompleteConfiguration => {
                 if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
                     INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
@@ -835,28 +917,75 @@ impl WindowManager {
             SocketMessage::WatchConfiguration(enable) => {
                 self.watch_configuration(enable)?;
             }
-            SocketMessage::IdentifyBorderOverflowApplication(_, ref id) => {
+            SocketMessage::IdentifyBorderOverflowApplication(identifier, ref id) => {
                 let mut identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
-                if !identifiers.contains(id) {
-                    identifiers.push(id.to_string());
+
+                let mut should_push = true;
+                for i in &*identifiers {
+                    if i.id.eq(id) {
+                        should_push = false;
+                    }
+                }
+
+                if should_push {
+                    identifiers.push(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    });
                 }
             }
-            SocketMessage::IdentifyObjectNameChangeApplication(_, ref id) => {
+            SocketMessage::IdentifyObjectNameChangeApplication(identifier, ref id) => {
                 let mut identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
-                if !identifiers.contains(id) {
-                    identifiers.push(id.to_string());
+
+                let mut should_push = true;
+                for i in &*identifiers {
+                    if i.id.eq(id) {
+                        should_push = false;
+                    }
+                }
+
+                if should_push {
+                    identifiers.push(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    });
                 }
             }
-            SocketMessage::IdentifyTrayApplication(_, ref id) => {
+            SocketMessage::IdentifyTrayApplication(identifier, ref id) => {
                 let mut identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
-                if !identifiers.contains(id) {
-                    identifiers.push(id.to_string());
+                let mut should_push = true;
+                for i in &*identifiers {
+                    if i.id.eq(id) {
+                        should_push = false;
+                    }
+                }
+
+                if should_push {
+                    identifiers.push(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    });
                 }
             }
-            SocketMessage::IdentifyLayeredApplication(_, ref id) => {
+            SocketMessage::IdentifyLayeredApplication(identifier, ref id) => {
                 let mut identifiers = LAYERED_WHITELIST.lock();
-                if !identifiers.contains(id) {
-                    identifiers.push(id.to_string());
+
+                let mut should_push = true;
+                for i in &*identifiers {
+                    if i.id.eq(id) {
+                        should_push = false;
+                    }
+                }
+
+                if should_push {
+                    identifiers.push(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    });
                 }
             }
             SocketMessage::ManageFocusedWindow => {
@@ -937,7 +1066,7 @@ impl WindowManager {
             }
             SocketMessage::AddSubscriber(ref subscriber) => {
                 let mut pipes = SUBSCRIPTION_PIPES.lock();
-                let pipe_path = format!(r"\\.\pipe\{}", subscriber);
+                let pipe_path = format!(r"\\.\pipe\{subscriber}");
                 let pipe = connect(&pipe_path).map_err(|_| {
                     anyhow!("the named pipe '{}' has not yet been created; please create it before running this command", pipe_path)
                 })?;
@@ -1009,6 +1138,9 @@ impl WindowManager {
                     WindowKind::Stack => {
                         BORDER_COLOUR_STACK.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
                     }
+                    WindowKind::Monocle => {
+                        BORDER_COLOUR_MONOCLE.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
+                    }
                 }
 
                 WindowsApi::invalidate_border_rect()?;
@@ -1054,10 +1186,76 @@ impl WindowManager {
                 let mut stream = UnixStream::connect(socket)?;
                 stream.write_all(schema.as_bytes())?;
             }
+            SocketMessage::StaticConfigSchema => {
+                let socket_message = schema_for!(StaticConfig);
+                let schema = serde_json::to_string_pretty(&socket_message)?;
+                let mut socket = DATA_DIR.clone();
+                socket.push("komorebic.sock");
+                let socket = socket.as_path();
+
+                let mut stream = UnixStream::connect(socket)?;
+                stream.write_all(schema.as_bytes())?;
+            }
+            SocketMessage::GenerateStaticConfig => {
+                let config = serde_json::to_string_pretty(&StaticConfig::from(&*self))?;
+                let mut socket = DATA_DIR.clone();
+                socket.push("komorebic.sock");
+                let socket = socket.as_path();
+
+                let mut stream = UnixStream::connect(socket)?;
+                stream.write_all(config.as_bytes())?;
+            }
+            SocketMessage::RemoveTitleBar(_, ref id) => {
+                let mut identifiers = NO_TITLEBAR.lock();
+                if !identifiers.contains(id) {
+                    identifiers.push(id.clone());
+                }
+            }
+            SocketMessage::ToggleTitleBars => {
+                let current = REMOVE_TITLEBARS.load(Ordering::SeqCst);
+                REMOVE_TITLEBARS.store(!current, Ordering::SeqCst);
+                self.update_focused_workspace(false)?;
+            }
         };
 
+        match message {
+            SocketMessage::ToggleMonocle => {
+                let current = BORDER_COLOUR_CURRENT.load(Ordering::SeqCst);
+                let monocle = BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst);
+
+                if monocle != 0 {
+                    if current == monocle {
+                        BORDER_COLOUR_CURRENT.store(
+                            BORDER_COLOUR_SINGLE.load(Ordering::SeqCst),
+                            Ordering::SeqCst,
+                        );
+                    } else {
+                        BORDER_COLOUR_CURRENT.store(
+                            BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst),
+                            Ordering::SeqCst,
+                        );
+                    }
+                }
+            }
+            SocketMessage::StackWindow(_) => {
+                let stack = BORDER_COLOUR_STACK.load(Ordering::SeqCst);
+                if stack != 0 {
+                    BORDER_COLOUR_CURRENT
+                        .store(BORDER_COLOUR_STACK.load(Ordering::SeqCst), Ordering::SeqCst);
+                }
+            }
+            SocketMessage::UnstackWindow => {
+                BORDER_COLOUR_CURRENT.store(
+                    BORDER_COLOUR_SINGLE.load(Ordering::SeqCst),
+                    Ordering::SeqCst,
+                );
+            }
+            _ => {}
+        }
+
         match message {
             SocketMessage::ChangeLayout(_)
+            | SocketMessage::CycleLayout(_)
             | SocketMessage::ChangeLayoutCustom(_)
             | SocketMessage::FlipLayout(_)
             | SocketMessage::ManageFocusedWindow
@@ -1071,6 +1269,8 @@ impl WindowManager {
             | SocketMessage::ToggleMaximize
             | SocketMessage::Promote
             | SocketMessage::PromoteFocus
+            | SocketMessage::StackWindow(_)
+            | SocketMessage::UnstackWindow
             | SocketMessage::Retile
             // Adding this one so that changes can be seen instantly after
             // modifying the active window border offset
@@ -1081,6 +1281,7 @@ impl WindowManager {
             | SocketMessage::FocusWindow(_)
             | SocketMessage::InvisibleBorders(_)
             | SocketMessage::WorkAreaOffset(_)
+            | SocketMessage::CycleMoveWindow(_)
             | SocketMessage::MoveWindow(_) => {
                 let foreground = WindowsApi::foreground_window()?;
                 let foreground_window = Window { hwnd: foreground };
@@ -1121,6 +1322,51 @@ impl WindowManager {
         tracing::info!("processed");
         Ok(())
     }
+
+    #[tracing::instrument(skip(self))]
+    fn handle_initial_workspace_rules(
+        &mut self,
+        id: &String,
+        monitor_idx: usize,
+        workspace_idx: usize,
+    ) -> Result<()> {
+        self.handle_workspace_rules(id, monitor_idx, workspace_idx, true)?;
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self))]
+    fn handle_definitive_workspace_rules(
+        &mut self,
+        id: &String,
+        monitor_idx: usize,
+        workspace_idx: usize,
+    ) -> Result<()> {
+        self.handle_workspace_rules(id, monitor_idx, workspace_idx, false)?;
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn handle_workspace_rules(
+        &mut self,
+        id: &String,
+        monitor_idx: usize,
+        workspace_idx: usize,
+        initial_workspace_rule: bool,
+    ) -> Result<()> {
+        {
+            let mut workspace_rules = WORKSPACE_RULES.lock();
+            workspace_rules.insert(
+                id.to_string(),
+                (monitor_idx, workspace_idx, initial_workspace_rule),
+            );
+        }
+
+        self.enforce_workspace_rules()?;
+
+        Ok(())
+    }
 }
 
 pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, stream: UnixStream) -> Result<()> {
@@ -1169,11 +1415,8 @@ pub fn read_commands_tcp(
                 break;
             }
             Ok(size) => {
-                let message = if let Ok(message) =
-                    SocketMessage::from_str(&String::from_utf8_lossy(&buf[..size]))
-                {
-                    message
-                } else {
+                let Ok(message) = SocketMessage::from_str(&String::from_utf8_lossy(&buf[..size]))
+                else {
                     tracing::warn!("client sent an invalid message, disconnecting: {addr}");
                     let mut connections = TCP_CONNECTIONS.lock();
                     connections.remove(addr);

komorebi/src/process_event.rs

@@ -15,12 +15,14 @@ use komorebi_core::WindowContainerBehaviour;
 use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
+use crate::window::should_act;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_COLOUR_MONOCLE;
 use crate::BORDER_COLOUR_SINGLE;
 use crate::BORDER_COLOUR_STACK;
 use crate::BORDER_ENABLED;
@@ -28,6 +30,7 @@ use crate::BORDER_HIDDEN;
 use crate::BORDER_HWND;
 use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
+use crate::REGEX_IDENTIFIERS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
@@ -149,6 +152,10 @@ impl WindowManager {
             WindowManagerEvent::Destroy(_, window) | WindowManagerEvent::Unmanage(window) => {
                 self.focused_workspace_mut()?.remove_window(window.hwnd)?;
                 self.update_focused_workspace(false)?;
+
+                let mut already_moved_window_handles = self.already_moved_window_handles.lock();
+
+                already_moved_window_handles.remove(&window.hwnd);
             }
             WindowManagerEvent::Minimize(_, window) => {
                 let mut hide = false;
@@ -174,15 +181,26 @@ impl WindowManager {
                 {
                     let tray_and_multi_window_identifiers =
                         TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
+                    let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
+                    let title = &window.title()?;
+                    let exe_name = &window.exe()?;
+                    let class = &window.class()?;
 
                     // We don't want to purge windows that have been deliberately hidden by us, eg. when
                     // they are not on the top of a container stack.
                     let programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
+                    let should_act = should_act(
+                        title,
+                        exe_name,
+                        class,
+                        &tray_and_multi_window_identifiers,
+                        &regex_identifiers,
+                    );
 
-                    if ((!window.is_window()
-                        || tray_and_multi_window_identifiers.contains(&window.exe()?))
-                        || tray_and_multi_window_identifiers.contains(&window.class()?))
-                        && !programmatically_hidden_hwnds.contains(&window.hwnd)
+                    if !window.is_window()
+                        || should_act
+                        || !programmatically_hidden_hwnds.contains(&window.hwnd)
                     {
                         hide = true;
                     }
@@ -192,6 +210,10 @@ impl WindowManager {
                     self.focused_workspace_mut()?.remove_window(window.hwnd)?;
                     self.update_focused_workspace(false)?;
                 }
+
+                let mut already_moved_window_handles = self.already_moved_window_handles.lock();
+
+                already_moved_window_handles.remove(&window.hwnd);
             }
             WindowManagerEvent::FocusChange(_, window) => {
                 let workspace = self.focused_workspace_mut()?;
@@ -510,6 +532,7 @@ impl WindowManager {
                 | WindowManagerEvent::Minimize(_, window) => {
                     let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
                     let mut target_window = None;
+                    let mut target_window_is_monocle = false;
                     if self
                         .focused_workspace()?
                         .floating_windows()
@@ -523,6 +546,7 @@ impl WindowManager {
                     if let Some(monocle_container) = self.focused_workspace()?.monocle_container() {
                         if let Some(window) = monocle_container.focused_window() {
                             target_window = Option::from(*window);
+                            target_window_is_monocle = true;
                         }
                     }
 
@@ -539,7 +563,12 @@ impl WindowManager {
                                     let container_size = self.focused_container()?.windows().len();
                                     target_window = Option::from(*self.focused_window()?);
 
-                                    if container_size > 1 {
+                                    if target_window_is_monocle {
+                                        BORDER_COLOUR_CURRENT.store(
+                                            BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst),
+                                            Ordering::SeqCst,
+                                        );
+                                    } else if container_size > 1 {
                                         BORDER_COLOUR_CURRENT.store(
                                             BORDER_COLOUR_STACK.load(Ordering::SeqCst),
                                             Ordering::SeqCst,

komorebi/src/process_movement.rs

@@ -18,7 +18,10 @@ pub fn listen_for_movements(wm: Arc<Mutex<WindowManager>>) {
 
         loop {
             let focus_follows_mouse = wm.lock().focus_follows_mouse;
-            if let Some(FocusFollowsMouseImplementation::Komorebi) = focus_follows_mouse {
+            if matches!(
+                focus_follows_mouse,
+                Some(FocusFollowsMouseImplementation::Komorebi)
+            ) {
                 match receiver.next_event() {
                     // Don't want to send any raise events while we are dragging or resizing
                     Event::MouseButton { action, .. } => match action {

komorebi/src/static_config.rs

@@ -0,0 +1,956 @@
+use crate::border::Border;
+use crate::current_virtual_desktop;
+use crate::monitor::Monitor;
+use crate::ring::Ring;
+use crate::window_manager::WindowManager;
+use crate::window_manager_event::WindowManagerEvent;
+use crate::workspace::Workspace;
+use crate::ALT_FOCUS_HACK;
+use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_COLOUR_MONOCLE;
+use crate::BORDER_COLOUR_SINGLE;
+use crate::BORDER_COLOUR_STACK;
+use crate::BORDER_ENABLED;
+use crate::BORDER_HWND;
+use crate::BORDER_OFFSET;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::BORDER_WIDTH;
+use crate::DATA_DIR;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
+use crate::FLOAT_IDENTIFIERS;
+use crate::HIDING_BEHAVIOUR;
+use crate::LAYERED_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;
+use crate::MONITOR_INDEX_PREFERENCES;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::REGEX_IDENTIFIERS;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WORKSPACE_RULES;
+use color_eyre::Result;
+use crossbeam_channel::Receiver;
+use dirs::home_dir;
+use hotwatch::notify::DebouncedEvent;
+use hotwatch::Hotwatch;
+use komorebi_core::config_generation::ApplicationConfigurationGenerator;
+use komorebi_core::config_generation::ApplicationOptions;
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::config_generation::MatchingStrategy;
+use komorebi_core::ApplicationIdentifier;
+use komorebi_core::DefaultLayout;
+use komorebi_core::FocusFollowsMouseImplementation;
+use komorebi_core::HidingBehaviour;
+use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
+use komorebi_core::OperationBehaviour;
+use komorebi_core::Rect;
+use komorebi_core::SocketMessage;
+use komorebi_core::WindowContainerBehaviour;
+use parking_lot::Mutex;
+use regex::Regex;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::io::ErrorKind;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use uds_windows::UnixListener;
+use uds_windows::UnixStream;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct Rgb {
+    /// Red
+    pub r: u32,
+    /// Green
+    pub g: u32,
+    /// Blue
+    pub b: u32,
+}
+
+impl From<u32> for Rgb {
+    fn from(value: u32) -> Self {
+        Self {
+            r: value & 0xff,
+            g: value >> 8 & 0xff,
+            b: value >> 16 & 0xff,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct ActiveWindowBorderColours {
+    /// Border colour when the container contains a single window
+    pub single: Rgb,
+    /// Border colour when the container contains multiple windows
+    pub stack: Rgb,
+    /// Border colour when the container is in monocle mode
+    pub monocle: Rgb,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct WorkspaceConfig {
+    /// Name
+    pub name: String,
+    /// Layout (default: BSP)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layout: Option<DefaultLayout>,
+    /// Custom Layout (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub custom_layout: Option<PathBuf>,
+    /// Layout rules (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layout_rules: Option<HashMap<usize, DefaultLayout>>,
+    /// Layout rules (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub custom_layout_rules: Option<HashMap<usize, PathBuf>>,
+    /// Container padding (default: global)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub container_padding: Option<i32>,
+    /// Container padding (default: global)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_padding: Option<i32>,
+    /// Initial workspace application rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub initial_workspace_rules: Option<Vec<IdWithIdentifier>>,
+    /// Permanent workspace application rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_rules: Option<Vec<IdWithIdentifier>>,
+}
+
+impl From<&Workspace> for WorkspaceConfig {
+    fn from(value: &Workspace) -> Self {
+        let mut layout_rules = HashMap::new();
+        for (threshold, layout) in value.layout_rules() {
+            match layout {
+                Layout::Default(value) => {
+                    layout_rules.insert(*threshold, *value);
+                }
+                Layout::Custom(_) => {}
+            }
+        }
+
+        let workspace_rules = WORKSPACE_RULES.lock();
+        let mut initial_ws_rules = vec![];
+        let mut ws_rules = vec![];
+
+        for (identifier, (_, _, is_initial)) in &*workspace_rules {
+            if identifier.ends_with("exe") {
+                let rule = IdWithIdentifier {
+                    kind: ApplicationIdentifier::Exe,
+                    id: identifier.clone(),
+                    matching_strategy: None,
+                };
+
+                if *is_initial {
+                    initial_ws_rules.push(rule);
+                } else {
+                    ws_rules.push(rule);
+                }
+            }
+        }
+
+        let initial_ws_rules = if initial_ws_rules.is_empty() {
+            None
+        } else {
+            Option::from(initial_ws_rules)
+        };
+        let ws_rules = if ws_rules.is_empty() {
+            None
+        } else {
+            Option::from(ws_rules)
+        };
+
+        let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
+        let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
+
+        let container_padding = value.container_padding().and_then(|container_padding| {
+            if container_padding == default_container_padding {
+                None
+            } else {
+                Option::from(container_padding)
+            }
+        });
+
+        let workspace_padding = value.workspace_padding().and_then(|workspace_padding| {
+            if workspace_padding == default_workspace_padding {
+                None
+            } else {
+                Option::from(workspace_padding)
+            }
+        });
+
+        Self {
+            name: value
+                .name()
+                .clone()
+                .unwrap_or_else(|| String::from("unnamed")),
+            layout: match value.layout() {
+                Layout::Default(layout) => Option::from(*layout),
+                // TODO: figure out how we might resolve file references in the future
+                Layout::Custom(_) => None,
+            },
+            custom_layout: None,
+            layout_rules: Option::from(layout_rules),
+            // TODO: figure out how we might resolve file references in the future
+            custom_layout_rules: None,
+            container_padding,
+            workspace_padding,
+            initial_workspace_rules: initial_ws_rules,
+            workspace_rules: ws_rules,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct MonitorConfig {
+    /// Workspace configurations
+    pub workspaces: Vec<WorkspaceConfig>,
+    /// Monitor-specific work area offset (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub work_area_offset: Option<Rect>,
+}
+
+impl From<&Monitor> for MonitorConfig {
+    fn from(value: &Monitor) -> Self {
+        let mut workspaces = vec![];
+        for w in value.workspaces() {
+            workspaces.push(WorkspaceConfig::from(w));
+        }
+
+        Self {
+            workspaces,
+            work_area_offset: value.work_area_offset(),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct StaticConfig {
+    /// Dimensions of Windows' own invisible borders; don't set these yourself unless you are told to
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub invisible_borders: Option<Rect>,
+    /// Delta to resize windows by (default 50)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resize_delta: Option<i32>,
+    /// Determine what happens when a new window is opened (default: Create)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_container_behaviour: Option<WindowContainerBehaviour>,
+    /// Determine what happens when a window is moved across a monitor boundary (default: Swap)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cross_monitor_move_behaviour: Option<MoveBehaviour>,
+    /// Determine what happens when commands are sent while an unmanaged window is in the foreground (default: Op)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub unmanaged_window_operation_behaviour: Option<OperationBehaviour>,
+    /// Determine focus follows mouse implementation (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
+    /// Enable or disable mouse follows focus (default: true)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mouse_follows_focus: Option<bool>,
+    /// Path to applications.yaml from komorebi-application-specific-configurations (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub app_specific_configuration_path: Option<PathBuf>,
+    /// DEPRECATED from v0.1.19: use active_window_border_width instead
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_width: Option<i32>,
+    /// DEPRECATED from v0.1.19: use active_window_border_offset instead
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_offset: Option<Rect>,
+    /// Width of the active window border (default: 20)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border_width: Option<i32>,
+    /// Offset of the active window border (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border_offset: Option<i32>,
+    /// Display an active window border (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border: Option<bool>,
+    /// Active window border colours for different container types
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_window_border_colours: Option<ActiveWindowBorderColours>,
+    /// Global default workspace padding (default: 10)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub default_workspace_padding: Option<i32>,
+    /// Global default container padding (default: 10)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub default_container_padding: Option<i32>,
+    /// Monitor and workspace configurations
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub monitors: Option<Vec<MonitorConfig>>,
+    /// Always send the ALT key when using focus commands (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub alt_focus_hack: Option<bool>,
+    /// Which Windows signal to use when hiding windows (default: minimize)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_hiding_behaviour: Option<HidingBehaviour>,
+    /// Global work area (space used for tiling) offset (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub global_work_area_offset: Option<Rect>,
+    /// Individual window floating rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub float_rules: Option<Vec<IdWithIdentifier>>,
+    /// Individual window force-manage rules
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub manage_rules: Option<Vec<IdWithIdentifier>>,
+    /// Identify border overflow applications
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_overflow_applications: Option<Vec<IdWithIdentifier>>,
+    /// Identify tray and multi-window applications
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tray_and_multi_window_applications: Option<Vec<IdWithIdentifier>>,
+    /// Identify applications that have the WS_EX_LAYERED extended window style
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layered_applications: Option<Vec<IdWithIdentifier>>,
+    /// Identify applications that send EVENT_OBJECT_NAMECHANGE on launch (very rare)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub object_name_change_applications: Option<Vec<IdWithIdentifier>>,
+    /// Set monitor index preferences
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub monitor_index_preferences: Option<HashMap<usize, Rect>>,
+}
+
+impl From<&WindowManager> for StaticConfig {
+    #[allow(clippy::too_many_lines)]
+    fn from(value: &WindowManager) -> Self {
+        let default_invisible_borders = Rect {
+            left: 7,
+            top: 0,
+            right: 14,
+            bottom: 7,
+        };
+
+        let mut monitors = vec![];
+        for m in value.monitors() {
+            monitors.push(MonitorConfig::from(m));
+        }
+
+        let mut to_remove = vec![];
+
+        let workspace_rules = WORKSPACE_RULES.lock();
+        for (m_idx, m) in monitors.iter().enumerate() {
+            for (w_idx, w) in m.workspaces.iter().enumerate() {
+                if let Some(rules) = &w.initial_workspace_rules {
+                    for iwsr in rules {
+                        for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
+                            if iwsr.id.eq(identifier)
+                                && (*monitor_idx != m_idx || *workspace_idx != w_idx)
+                            {
+                                to_remove.push((m_idx, w_idx, iwsr.id.clone()));
+                            }
+                        }
+                    }
+                }
+
+                if let Some(rules) = &w.workspace_rules {
+                    for wsr in rules {
+                        for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
+                            if wsr.id.eq(identifier)
+                                && (*monitor_idx != m_idx || *workspace_idx != w_idx)
+                            {
+                                to_remove.push((m_idx, w_idx, wsr.id.clone()));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        for (m_idx, w_idx, id) in to_remove {
+            if let Some(monitor) = monitors.get_mut(m_idx) {
+                if let Some(workspace) = monitor.workspaces.get_mut(w_idx) {
+                    if let Some(rules) = &mut workspace.workspace_rules {
+                        rules.retain(|r| r.id != id);
+                    }
+
+                    if let Some(rules) = &mut workspace.initial_workspace_rules {
+                        rules.retain(|r| r.id != id);
+                    }
+                }
+            }
+        }
+
+        let border_colours = if BORDER_COLOUR_SINGLE.load(Ordering::SeqCst) == 0 {
+            None
+        } else {
+            Option::from(ActiveWindowBorderColours {
+                single: Rgb::from(BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)),
+                stack: Rgb::from(if BORDER_COLOUR_STACK.load(Ordering::SeqCst) == 0 {
+                    BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)
+                } else {
+                    BORDER_COLOUR_STACK.load(Ordering::SeqCst)
+                }),
+                monocle: Rgb::from(if BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst) == 0 {
+                    BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)
+                } else {
+                    BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst)
+                }),
+            })
+        };
+
+        Self {
+            invisible_borders: if value.invisible_borders == default_invisible_borders {
+                None
+            } else {
+                Option::from(value.invisible_borders)
+            },
+            resize_delta: Option::from(value.resize_delta),
+            window_container_behaviour: Option::from(value.window_container_behaviour),
+            cross_monitor_move_behaviour: Option::from(value.cross_monitor_move_behaviour),
+            unmanaged_window_operation_behaviour: Option::from(
+                value.unmanaged_window_operation_behaviour,
+            ),
+            focus_follows_mouse: value.focus_follows_mouse,
+            mouse_follows_focus: Option::from(value.mouse_follows_focus),
+            app_specific_configuration_path: None,
+            active_window_border_width: Option::from(BORDER_WIDTH.load(Ordering::SeqCst)),
+            active_window_border_offset: BORDER_OFFSET
+                .lock()
+                .map_or(None, |offset| Option::from(offset.left)),
+            border_width: None,
+            border_offset: None,
+            active_window_border: Option::from(BORDER_ENABLED.load(Ordering::SeqCst)),
+            active_window_border_colours: border_colours,
+            default_workspace_padding: Option::from(
+                DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
+            ),
+            default_container_padding: Option::from(
+                DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst),
+            ),
+            monitors: Option::from(monitors),
+            alt_focus_hack: Option::from(ALT_FOCUS_HACK.load(Ordering::SeqCst)),
+            window_hiding_behaviour: Option::from(*HIDING_BEHAVIOUR.lock()),
+            global_work_area_offset: value.work_area_offset,
+            float_rules: None,
+            manage_rules: None,
+            border_overflow_applications: None,
+            tray_and_multi_window_applications: None,
+            layered_applications: None,
+            object_name_change_applications: None,
+            monitor_index_preferences: Option::from(MONITOR_INDEX_PREFERENCES.lock().clone()),
+        }
+    }
+}
+
+impl StaticConfig {
+    #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
+    fn apply_globals(&mut self) -> Result<()> {
+        if let Some(monitor_index_preferences) = &self.monitor_index_preferences {
+            let mut preferences = MONITOR_INDEX_PREFERENCES.lock();
+            *preferences = monitor_index_preferences.clone();
+        }
+
+        if let Some(behaviour) = self.window_hiding_behaviour {
+            let mut window_hiding_behaviour = HIDING_BEHAVIOUR.lock();
+            *window_hiding_behaviour = behaviour;
+        }
+
+        if let Some(hack) = self.alt_focus_hack {
+            ALT_FOCUS_HACK.store(hack, Ordering::SeqCst);
+        }
+
+        if let Some(container) = self.default_container_padding {
+            DEFAULT_CONTAINER_PADDING.store(container, Ordering::SeqCst);
+        }
+
+        if let Some(workspace) = self.default_workspace_padding {
+            DEFAULT_WORKSPACE_PADDING.store(workspace, Ordering::SeqCst);
+        }
+
+        self.active_window_border_width.map_or_else(
+            || {
+                BORDER_WIDTH.store(20, Ordering::SeqCst);
+            },
+            |width| {
+                BORDER_WIDTH.store(width, Ordering::SeqCst);
+            },
+        );
+        self.active_window_border_offset.map_or_else(
+            || {
+                let mut border_offset = BORDER_OFFSET.lock();
+                *border_offset = None;
+            },
+            |offset| {
+                let new_border_offset = Rect {
+                    left: offset,
+                    top: offset,
+                    right: offset * 2,
+                    bottom: offset * 2,
+                };
+
+                let mut border_offset = BORDER_OFFSET.lock();
+                *border_offset = Some(new_border_offset);
+            },
+        );
+
+        if let Some(colours) = &self.active_window_border_colours {
+            BORDER_COLOUR_SINGLE.store(
+                colours.single.r | (colours.single.g << 8) | (colours.single.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_CURRENT.store(
+                colours.single.r | (colours.single.g << 8) | (colours.single.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_STACK.store(
+                colours.stack.r | (colours.stack.g << 8) | (colours.stack.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_MONOCLE.store(
+                colours.monocle.r | (colours.monocle.g << 8) | (colours.monocle.b << 16),
+                Ordering::SeqCst,
+            );
+        }
+
+        let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
+        let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
+        let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
+        let mut tray_and_multi_window_identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
+        let mut border_overflow_identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
+        let mut object_name_change_identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+        let mut layered_identifiers = LAYERED_WHITELIST.lock();
+
+        if let Some(float) = &mut self.float_rules {
+            for identifier in float {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !float_identifiers.contains(identifier) {
+                    float_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
+        }
+
+        if let Some(manage) = &mut self.manage_rules {
+            for identifier in manage {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !manage_identifiers.contains(identifier) {
+                    manage_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
+        }
+
+        if let Some(identifiers) = &mut self.object_name_change_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !object_name_change_identifiers.contains(identifier) {
+                    object_name_change_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
+        }
+
+        if let Some(identifiers) = &mut self.layered_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !layered_identifiers.contains(identifier) {
+                    layered_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
+        }
+
+        if let Some(identifiers) = &mut self.border_overflow_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !border_overflow_identifiers.contains(identifier) {
+                    border_overflow_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
+        }
+
+        if let Some(identifiers) = &mut self.tray_and_multi_window_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !tray_and_multi_window_identifiers.contains(identifier) {
+                    tray_and_multi_window_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
+        }
+
+        if let Some(path) = &self.app_specific_configuration_path {
+            let stringified = path.to_string_lossy();
+            let stringified = stringified.replace(
+                "$Env:USERPROFILE",
+                &home_dir().expect("no home dir").to_string_lossy(),
+            );
+
+            let content = std::fs::read_to_string(stringified)?;
+            let asc = ApplicationConfigurationGenerator::load(&content)?;
+
+            for mut entry in asc {
+                if let Some(float) = entry.float_identifiers {
+                    for f in float {
+                        let mut without_comment: IdWithIdentifier = f.into();
+                        if without_comment.matching_strategy.is_none() {
+                            without_comment.matching_strategy =
+                                Option::from(MatchingStrategy::Legacy);
+                        }
+
+                        if !float_identifiers.contains(&without_comment) {
+                            float_identifiers.push(without_comment.clone());
+
+                            if matches!(
+                                without_comment.matching_strategy,
+                                Some(MatchingStrategy::Regex)
+                            ) {
+                                let re = Regex::new(&without_comment.id)?;
+                                regex_identifiers.insert(without_comment.id.clone(), re);
+                            }
+                        }
+                    }
+                }
+                if let Some(options) = entry.options {
+                    for o in options {
+                        match o {
+                            ApplicationOptions::ObjectNameChange => {
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !object_name_change_identifiers.contains(&entry.identifier) {
+                                    object_name_change_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
+                            }
+                            ApplicationOptions::Layered => {
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !layered_identifiers.contains(&entry.identifier) {
+                                    layered_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
+                            }
+                            ApplicationOptions::BorderOverflow => {
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !border_overflow_identifiers.contains(&entry.identifier) {
+                                    border_overflow_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
+                            }
+                            ApplicationOptions::TrayAndMultiWindow => {
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !tray_and_multi_window_identifiers.contains(&entry.identifier) {
+                                    tray_and_multi_window_identifiers
+                                        .push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
+                            }
+                            ApplicationOptions::Force => {
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !manage_identifiers.contains(&entry.identifier) {
+                                    manage_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_lines)]
+    pub fn preload(
+        path: &PathBuf,
+        incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>,
+    ) -> Result<WindowManager> {
+        let content = std::fs::read_to_string(path)?;
+        let mut value: Self = serde_json::from_str(&content)?;
+        value.apply_globals()?;
+
+        let socket = DATA_DIR.join("komorebi.sock");
+
+        match std::fs::remove_file(&socket) {
+            Ok(_) => {}
+            Err(error) => match error.kind() {
+                // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
+                ErrorKind::NotFound => {}
+                _ => {
+                    return Err(error.into());
+                }
+            },
+        };
+
+        let listener = UnixListener::bind(&socket)?;
+
+        let mut wm = WindowManager {
+            monitors: Ring::default(),
+            monitor_cache: HashMap::new(),
+            incoming_events: incoming,
+            command_listener: listener,
+            is_paused: false,
+            invisible_borders: value.invisible_borders.unwrap_or(Rect {
+                left: 7,
+                top: 0,
+                right: 14,
+                bottom: 7,
+            }),
+            virtual_desktop_id: current_virtual_desktop(),
+            work_area_offset: value.global_work_area_offset,
+            window_container_behaviour: value
+                .window_container_behaviour
+                .unwrap_or(WindowContainerBehaviour::Create),
+            cross_monitor_move_behaviour: value
+                .cross_monitor_move_behaviour
+                .unwrap_or(MoveBehaviour::Swap),
+            unmanaged_window_operation_behaviour: value
+                .unmanaged_window_operation_behaviour
+                .unwrap_or(OperationBehaviour::Op),
+            resize_delta: value.resize_delta.unwrap_or(50),
+            focus_follows_mouse: value.focus_follows_mouse,
+            mouse_follows_focus: value.mouse_follows_focus.unwrap_or(true),
+            hotwatch: Hotwatch::new()?,
+            has_pending_raise_op: false,
+            pending_move_op: None,
+            already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
+        };
+
+        let bytes = SocketMessage::ReloadStaticConfiguration(path.clone()).as_bytes()?;
+
+        wm.hotwatch.watch(path, move |event| match event {
+            // Editing in Notepad sends a NoticeWrite while editing in (Neo)Vim sends
+            // a NoticeRemove, presumably because of the use of swap files?
+            DebouncedEvent::NoticeWrite(_) | DebouncedEvent::NoticeRemove(_) => {
+                let socket = DATA_DIR.join("komorebi.sock");
+                let mut stream =
+                    UnixStream::connect(socket).expect("could not connect to komorebi.sock");
+                stream
+                    .write_all(&bytes)
+                    .expect("could not write to komorebi.sock");
+            }
+            _ => {}
+        })?;
+
+        Ok(wm)
+    }
+
+    pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> Result<()> {
+        let content = std::fs::read_to_string(path)?;
+        let value: Self = serde_json::from_str(&content)?;
+        let mut wm = wm.lock();
+
+        if let Some(monitors) = value.monitors {
+            for (i, monitor) in monitors.iter().enumerate() {
+                if let Some(m) = wm.monitors_mut().get_mut(i) {
+                    m.ensure_workspace_count(monitor.workspaces.len());
+                    m.set_work_area_offset(monitor.work_area_offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        ws.load_static_config(
+                            monitor
+                                .workspaces
+                                .get(j)
+                                .expect("no static workspace config"),
+                        )?;
+                    }
+                }
+
+                for (j, ws) in monitor.workspaces.iter().enumerate() {
+                    if let Some(rules) = &ws.workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, false)?;
+                        }
+                    }
+
+                    if let Some(rules) = &ws.initial_workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, true)?;
+                        }
+                    }
+                }
+            }
+        }
+
+        if value.active_window_border == Some(true) {
+            if BORDER_HWND.load(Ordering::SeqCst) == 0 {
+                Border::create("komorebi-border-window")?;
+            }
+
+            BORDER_ENABLED.store(true, Ordering::SeqCst);
+            wm.show_border()?;
+        }
+
+        Ok(())
+    }
+
+    pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> Result<()> {
+        let content = std::fs::read_to_string(path)?;
+        let mut value: Self = serde_json::from_str(&content)?;
+
+        value.apply_globals()?;
+
+        if let Some(monitors) = value.monitors {
+            for (i, monitor) in monitors.iter().enumerate() {
+                if let Some(m) = wm.monitors_mut().get_mut(i) {
+                    m.ensure_workspace_count(monitor.workspaces.len());
+                    m.set_work_area_offset(monitor.work_area_offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        ws.load_static_config(
+                            monitor
+                                .workspaces
+                                .get(j)
+                                .expect("no static workspace config"),
+                        )?;
+                    }
+                }
+
+                for (j, ws) in monitor.workspaces.iter().enumerate() {
+                    if let Some(rules) = &ws.workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, false)?;
+                        }
+                    }
+
+                    if let Some(rules) = &ws.initial_workspace_rules {
+                        for r in rules {
+                            wm.handle_workspace_rules(&r.id, i, j, true)?;
+                        }
+                    }
+                }
+            }
+        }
+
+        if value.active_window_border == Some(true) {
+            if BORDER_HWND.load(Ordering::SeqCst) == 0 {
+                Border::create("komorebi-border-window")?;
+            }
+
+            BORDER_ENABLED.store(true, Ordering::SeqCst);
+            wm.show_border()?;
+        } else {
+            BORDER_ENABLED.store(false, Ordering::SeqCst);
+            wm.hide_border()?;
+        }
+
+        if let Some(val) = value.invisible_borders {
+            wm.invisible_borders = val;
+        }
+
+        if let Some(val) = value.window_container_behaviour {
+            wm.window_container_behaviour = val;
+        }
+
+        if let Some(val) = value.cross_monitor_move_behaviour {
+            wm.cross_monitor_move_behaviour = val;
+        }
+
+        if let Some(val) = value.unmanaged_window_operation_behaviour {
+            wm.unmanaged_window_operation_behaviour = val;
+        }
+
+        if let Some(val) = value.resize_delta {
+            wm.resize_delta = val;
+        }
+
+        if let Some(val) = value.mouse_follows_focus {
+            wm.mouse_follows_focus = val;
+        }
+
+        wm.work_area_offset = value.global_work_area_offset;
+        wm.focus_follows_mouse = value.focus_follows_mouse;
+
+        Ok(())
+    }
+}

komorebi/src/window.rs

@@ -1,4 +1,5 @@
 use crate::com::SetCloak;
+use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;
@@ -7,6 +8,9 @@ use std::sync::atomic::Ordering;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use komorebi_core::config_generation::IdWithIdentifier;
+use komorebi_core::config_generation::MatchingStrategy;
+use regex::Regex;
 use schemars::JsonSchema;
 use serde::ser::Error;
 use serde::ser::SerializeStruct;
@@ -32,6 +36,9 @@ use crate::HIDDEN_HWNDS;
 use crate::HIDING_BEHAVIOUR;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
+use crate::NO_TITLEBAR;
+use crate::PERMAIGNORE_CLASSES;
+use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
 #[derive(Debug, Clone, Copy, JsonSchema)]
@@ -44,20 +51,20 @@ impl Display for Window {
         let mut display = format!("(hwnd: {}", self.hwnd);
 
         if let Ok(title) = self.title() {
-            write!(display, ", title: {}", title)?;
+            write!(display, ", title: {title}")?;
         }
 
         if let Ok(exe) = self.exe() {
-            write!(display, ", exe: {}", exe)?;
+            write!(display, ", exe: {exe}")?;
         }
 
         if let Ok(class) = self.class() {
-            write!(display, ", class: {}", class)?;
+            write!(display, ", class: {class}")?;
         }
 
         write!(display, ")")?;
 
-        write!(f, "{}", display)
+        write!(f, "{display}")
     }
 }
 
@@ -123,15 +130,21 @@ impl Window {
         top: bool,
     ) -> Result<()> {
         let mut rect = *layout;
-        let mut should_remove_border = true;
 
         let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
-        if border_overflows.contains(&self.title()?)
-            || border_overflows.contains(&self.exe()?)
-            || border_overflows.contains(&self.class()?)
-        {
-            should_remove_border = false;
-        }
+        let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
+        let title = &self.title()?;
+        let class = &self.class()?;
+        let exe_name = &self.exe()?;
+
+        let should_remove_border = !should_act(
+            title,
+            exe_name,
+            class,
+            &border_overflows,
+            &regex_identifiers,
+        );
 
         if should_remove_border {
             // Remove the invisible borders
@@ -346,23 +359,22 @@ impl Window {
     pub fn transparent(self) -> Result<()> {
         let mut ex_style = self.ex_style()?;
         ex_style.insert(ExtendedWindowStyle::LAYERED);
-        self.update_ex_style(ex_style)?;
-        WindowsApi::set_transparent(self.hwnd());
-        Ok(())
+        self.update_ex_style(&ex_style)?;
+        WindowsApi::set_transparent(self.hwnd())
     }
 
     pub fn opaque(self) -> Result<()> {
         let mut ex_style = self.ex_style()?;
         ex_style.remove(ExtendedWindowStyle::LAYERED);
-        self.update_ex_style(ex_style)
+        self.update_ex_style(&ex_style)
     }
 
     #[allow(dead_code)]
-    pub fn update_style(self, style: WindowStyle) -> Result<()> {
+    pub fn update_style(self, style: &WindowStyle) -> Result<()> {
         WindowsApi::update_style(self.hwnd(), isize::try_from(style.bits())?)
     }
 
-    pub fn update_ex_style(self, style: ExtendedWindowStyle) -> Result<()> {
+    pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> Result<()> {
         WindowsApi::update_ex_style(self.hwnd(), isize::try_from(style.bits())?)
     }
 
@@ -382,7 +394,10 @@ impl Window {
 
     pub fn exe(self) -> Result<String> {
         let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd());
-        WindowsApi::exe(WindowsApi::process_handle(process_id)?)
+        let handle = WindowsApi::process_handle(process_id)?;
+        let exe = WindowsApi::exe(handle);
+        WindowsApi::close_process(handle)?;
+        exe
     }
 
     pub fn class(self) -> Result<String> {
@@ -397,6 +412,20 @@ impl Window {
         WindowsApi::is_window(self.hwnd())
     }
 
+    pub fn remove_title_bar(self) -> Result<()> {
+        let mut style = self.style()?;
+        style.remove(WindowStyle::CAPTION);
+        style.remove(WindowStyle::THICKFRAME);
+        self.update_style(&style)
+    }
+
+    pub fn add_title_bar(self) -> Result<()> {
+        let mut style = self.style()?;
+        style.insert(WindowStyle::CAPTION);
+        style.insert(WindowStyle::THICKFRAME);
+        self.update_style(&style)
+    }
+
     #[tracing::instrument(fields(exe, title))]
     pub fn should_manage(self, event: Option<WindowManagerEvent>) -> Result<bool> {
         if let Some(WindowManagerEvent::DisplayChange(_)) = event {
@@ -427,7 +456,7 @@ impl Window {
             // If not allowing cloaked windows, we need to ensure the window is not cloaked
             (false, false) => {
                 if let (Ok(title), Ok(exe_name), Ok(class)) = (self.title(), self.exe(), self.class()) {
-                    return Ok(window_is_eligible(&title, &exe_name, &class, self.style()?, self.ex_style()?, event));
+                    return Ok(window_is_eligible(&title, &exe_name, &class, &self.style()?, &self.ex_style()?, event));
                 }
             }
             _ => {}
@@ -441,59 +470,49 @@ fn window_is_eligible(
     title: &String,
     exe_name: &String,
     class: &String,
-    style: WindowStyle,
-    ex_style: ExtendedWindowStyle,
+    style: &WindowStyle,
+    ex_style: &ExtendedWindowStyle,
     event: Option<WindowManagerEvent>,
 ) -> bool {
-    let mut should_float = false;
-    let mut matched_identifier = None;
-
     {
-        let float_identifiers = FLOAT_IDENTIFIERS.lock();
-        for identifier in float_identifiers.iter() {
-            if title.starts_with(identifier) || title.ends_with(identifier) {
-                should_float = true;
-                matched_identifier = Option::from(ApplicationIdentifier::Title);
-            }
-
-            if class.starts_with(identifier) || class.ends_with(identifier) {
-                should_float = true;
-                matched_identifier = Option::from(ApplicationIdentifier::Class);
-            }
-
-            if identifier == exe_name {
-                should_float = true;
-                matched_identifier = Option::from(ApplicationIdentifier::Exe);
-            }
+        let permaignore_classes = PERMAIGNORE_CLASSES.lock();
+        if permaignore_classes.contains(class) {
+            return false;
         }
-    };
+    }
 
-    let managed_override = {
-        let manage_identifiers = MANAGE_IDENTIFIERS.lock();
-        matched_identifier.map_or_else(
-            || {
-                manage_identifiers.contains(exe_name)
-                    || manage_identifiers.contains(class)
-                    || manage_identifiers.contains(title)
-            },
-            |matched_identifier| match matched_identifier {
-                ApplicationIdentifier::Exe => manage_identifiers.contains(exe_name),
-                ApplicationIdentifier::Class => manage_identifiers.contains(class),
-                ApplicationIdentifier::Title => manage_identifiers.contains(title),
-            },
-        )
-    };
+    let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
+    let float_identifiers = FLOAT_IDENTIFIERS.lock();
+    let should_float = should_act(
+        title,
+        exe_name,
+        class,
+        &float_identifiers,
+        &regex_identifiers,
+    );
+
+    let manage_identifiers = MANAGE_IDENTIFIERS.lock();
+    let managed_override = should_act(
+        title,
+        exe_name,
+        class,
+        &manage_identifiers,
+        &regex_identifiers,
+    );
 
     if should_float && !managed_override {
         return false;
     }
 
-    let allow_layered = {
-        let layered_whitelist = LAYERED_WHITELIST.lock();
-        layered_whitelist.contains(exe_name)
-            || layered_whitelist.contains(class)
-            || layered_whitelist.contains(title)
-    };
+    let layered_whitelist = LAYERED_WHITELIST.lock();
+    let allow_layered = should_act(
+        title,
+        exe_name,
+        class,
+        &layered_whitelist,
+        &regex_identifiers,
+    );
 
     // TODO: might need this for transparency
     // let allow_layered = true;
@@ -503,7 +522,12 @@ fn window_is_eligible(
         wsl2_ui_processes.contains(exe_name)
     };
 
-    if (allow_wsl2_gui || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))
+    let allow_titlebar_removed = {
+        let titlebars_removed = NO_TITLEBAR.lock();
+        titlebars_removed.contains(exe_name)
+    };
+
+    if (allow_wsl2_gui || allow_titlebar_removed || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))
                         && !ex_style.contains(ExtendedWindowStyle::DLGMODALFRAME)
                         // Get a lot of dupe events coming through that make the redrawing go crazy
                         // on FocusChange events if I don't filter out this one. But, if we are
@@ -519,3 +543,131 @@ fn window_is_eligible(
 
     false
 }
+
+#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
+pub fn should_act(
+    title: &str,
+    exe_name: &str,
+    class: &str,
+    identifiers: &[IdWithIdentifier],
+    regex_identifiers: &HashMap<String, Regex>,
+) -> bool {
+    let mut should_act = false;
+    for identifier in identifiers {
+        match identifier.matching_strategy {
+            None => {
+                panic!("there is no matching strategy identified for this rule");
+            }
+            Some(MatchingStrategy::Legacy) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.starts_with(&identifier.id) || title.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.starts_with(&identifier.id) || class.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::Equals) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::StartsWith) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.starts_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.starts_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.starts_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::EndsWith) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::Contains) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.contains(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.contains(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.contains(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::Regex) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if let Some(re) = regex_identifiers.get(&identifier.id) {
+                        if re.is_match(title) {
+                            should_act = true;
+                        }
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if let Some(re) = regex_identifiers.get(&identifier.id) {
+                        if re.is_match(class) {
+                            should_act = true;
+                        }
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if let Some(re) = regex_identifiers.get(&identifier.id) {
+                        if re.is_match(exe_name) {
+                            should_act = true;
+                        }
+                    }
+                }
+            },
+        }
+    }
+
+    should_act
+}

komorebi/src/window_manager.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::collections::VecDeque;
 use std::io::ErrorKind;
 use std::num::NonZeroUsize;
@@ -16,6 +17,7 @@ use schemars::JsonSchema;
 use serde::Serialize;
 use uds_windows::UnixListener;
 
+use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::custom_layout::CustomLayout;
 use komorebi_core::Arrangement;
 use komorebi_core::Axis;
@@ -36,6 +38,7 @@ use crate::current_virtual_desktop;
 use crate::load_configuration;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
+use crate::static_config::StaticConfig;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
@@ -48,7 +51,10 @@ use crate::FLOAT_IDENTIFIERS;
 use crate::HOME_DIR;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
+use crate::MONITOR_INDEX_PREFERENCES;
+use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::REMOVE_TITLEBARS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
 
@@ -71,8 +77,10 @@ pub struct WindowManager {
     pub virtual_desktop_id: Option<Vec<u8>>,
     pub has_pending_raise_op: bool,
     pub pending_move_op: Option<(usize, usize, usize)>,
+    pub already_moved_window_handles: Arc<Mutex<HashSet<isize>>>,
 }
 
+#[allow(clippy::struct_excessive_bools)]
 #[derive(Debug, Serialize, JsonSchema)]
 pub struct State {
     pub monitors: Ring<Monitor>,
@@ -85,12 +93,14 @@ pub struct State {
     pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
     pub mouse_follows_focus: bool,
     pub has_pending_raise_op: bool,
-    pub float_identifiers: Vec<String>,
-    pub manage_identifiers: Vec<String>,
-    pub layered_whitelist: Vec<String>,
-    pub tray_and_multi_window_identifiers: Vec<String>,
-    pub border_overflow_identifiers: Vec<String>,
-    pub name_change_on_launch_identifiers: Vec<String>,
+    pub remove_titlebars: bool,
+    pub float_identifiers: Vec<IdWithIdentifier>,
+    pub manage_identifiers: Vec<IdWithIdentifier>,
+    pub layered_whitelist: Vec<IdWithIdentifier>,
+    pub tray_and_multi_window_identifiers: Vec<IdWithIdentifier>,
+    pub border_overflow_identifiers: Vec<IdWithIdentifier>,
+    pub name_change_on_launch_identifiers: Vec<IdWithIdentifier>,
+    pub monitor_index_preferences: HashMap<usize, Rect>,
 }
 
 impl AsRef<Self> for WindowManager {
@@ -112,12 +122,14 @@ impl From<&WindowManager> for State {
             focus_follows_mouse: wm.focus_follows_mouse,
             mouse_follows_focus: wm.mouse_follows_focus,
             has_pending_raise_op: wm.has_pending_raise_op,
+            remove_titlebars: REMOVE_TITLEBARS.load(Ordering::SeqCst),
             float_identifiers: FLOAT_IDENTIFIERS.lock().clone(),
             manage_identifiers: MANAGE_IDENTIFIERS.lock().clone(),
             layered_whitelist: LAYERED_WHITELIST.lock().clone(),
             tray_and_multi_window_identifiers: TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock().clone(),
             border_overflow_identifiers: BORDER_OVERFLOW_IDENTIFIERS.lock().clone(),
             name_change_on_launch_identifiers: OBJECT_NAME_CHANGE_ON_LAUNCH.lock().clone(),
+            monitor_index_preferences: MONITOR_INDEX_PREFERENCES.lock().clone(),
         }
     }
 }
@@ -189,6 +201,7 @@ impl WindowManager {
             hotwatch: Hotwatch::new()?,
             has_pending_raise_op: false,
             pending_move_op: None,
+            already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
         })
     }
 
@@ -226,6 +239,12 @@ impl WindowManager {
         std::thread::spawn(|| load_configuration().expect("could not load configuration"));
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn reload_static_configuration(&mut self, pathbuf: &PathBuf) -> Result<()> {
+        tracing::info!("reloading static configuration");
+        StaticConfig::reload(pathbuf, self)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn watch_configuration(&mut self, enable: bool) -> Result<()> {
         let home = HOME_DIR.clone();
@@ -233,7 +252,7 @@ impl WindowManager {
         let mut config_pwsh = home.clone();
         config_pwsh.push("komorebi.ps1");
 
-        let mut config_ahk = home.clone();
+        let mut config_ahk = home;
         config_ahk.push("komorebi.ahk");
 
         if config_pwsh.exists() {
@@ -477,6 +496,35 @@ impl WindowManager {
         Ok(())
     }
 
+    #[allow(clippy::too_many_arguments)]
+    #[tracing::instrument(skip(self))]
+    fn add_window_handle_to_move_based_on_workspace_rule(
+        &self,
+        window_title: &String,
+        hwnd: isize,
+        origin_monitor_idx: usize,
+        origin_workspace_idx: usize,
+        target_monitor_idx: usize,
+        target_workspace_idx: usize,
+        to_move: &mut Vec<EnforceWorkspaceRuleOp>,
+    ) -> () {
+        tracing::info!(
+            "{} should be on monitor {}, workspace {}",
+            window_title,
+            target_monitor_idx,
+            target_workspace_idx
+        );
+
+        // Create an operation outline and save it for later in the fn
+        to_move.push(EnforceWorkspaceRuleOp {
+            hwnd,
+            origin_monitor_idx,
+            origin_workspace_idx,
+            target_monitor_idx,
+            target_workspace_idx,
+        });
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn enforce_workspace_rules(&mut self) -> Result<()> {
         let mut to_move = vec![];
@@ -494,41 +542,43 @@ impl WindowManager {
             for (j, workspace) in monitor.workspaces().iter().enumerate() {
                 // And all the visible windows (at the top of a container)
                 for window in workspace.visible_windows().into_iter().flatten() {
+                    let mut already_moved_window_handles = self.already_moved_window_handles.lock();
+
+                    let mut found_workspace_rule = workspace_rules.get(&window.exe()?);
+
+                    if found_workspace_rule.is_none() {
+                        found_workspace_rule = workspace_rules.get(&window.title()?);
+                    }
+
                     // If the executable names or titles of any of those windows are in our rules map
-                    if let Some((monitor_idx, workspace_idx)) = workspace_rules.get(&window.exe()?)
+                    if let Some((monitor_idx, workspace_idx, apply_on_first_show_only)) =
+                        found_workspace_rule
                     {
-                        tracing::info!(
-                            "{} should be on monitor {}, workspace {}",
-                            window.title()?,
-                            *monitor_idx,
-                            *workspace_idx
-                        );
+                        if *apply_on_first_show_only {
+                            if !already_moved_window_handles.contains(&window.hwnd) {
+                                already_moved_window_handles.insert(window.hwnd);
 
-                        // Create an operation outline and save it for later in the fn
-                        to_move.push(EnforceWorkspaceRuleOp {
-                            hwnd: window.hwnd,
-                            origin_monitor_idx: i,
-                            origin_workspace_idx: j,
-                            target_monitor_idx: *monitor_idx,
-                            target_workspace_idx: *workspace_idx,
-                        });
-                    } else if let Some((monitor_idx, workspace_idx)) =
-                        workspace_rules.get(&window.title()?)
-                    {
-                        tracing::info!(
-                            "{} should be on monitor {}, workspace {}",
-                            window.title()?,
-                            *monitor_idx,
-                            *workspace_idx
-                        );
-
-                        to_move.push(EnforceWorkspaceRuleOp {
-                            hwnd: window.hwnd,
-                            origin_monitor_idx: i,
-                            origin_workspace_idx: j,
-                            target_monitor_idx: *monitor_idx,
-                            target_workspace_idx: *workspace_idx,
-                        });
+                                self.add_window_handle_to_move_based_on_workspace_rule(
+                                    &window.title()?,
+                                    window.hwnd,
+                                    i,
+                                    j,
+                                    *monitor_idx,
+                                    *workspace_idx,
+                                    &mut to_move,
+                                );
+                            }
+                        } else {
+                            self.add_window_handle_to_move_based_on_workspace_rule(
+                                &window.title()?,
+                                window.hwnd,
+                                i,
+                                j,
+                                *monitor_idx,
+                                *workspace_idx,
+                                &mut to_move,
+                            );
+                        }
                     }
                 }
             }
@@ -921,23 +971,34 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn restore_all_windows(&mut self) {
+    pub fn restore_all_windows(&mut self) -> Result<()> {
         tracing::info!("restoring all hidden windows");
 
+        let no_titlebar = NO_TITLEBAR.lock();
+
         for monitor in self.monitors_mut() {
             for workspace in monitor.workspaces_mut() {
                 for containers in workspace.containers_mut() {
                     for window in containers.windows_mut() {
+                        if no_titlebar.contains(&window.exe()?) {
+                            window.add_title_bar()?;
+                        }
+
                         window.restore();
                     }
                 }
             }
         }
+
+        Ok(())
     }
 
     #[tracing::instrument(skip(self))]
     fn handle_unmanaged_window_behaviour(&self) -> Result<()> {
-        if let OperationBehaviour::NoOp = self.unmanaged_window_operation_behaviour {
+        if matches!(
+            self.unmanaged_window_operation_behaviour,
+            OperationBehaviour::NoOp
+        ) {
             let workspace = self.focused_workspace()?;
             let focused_hwnd = WindowsApi::foreground_window()?;
             if !workspace.contains_managed_window(focused_hwnd) {
@@ -950,6 +1011,92 @@ impl WindowManager {
         Ok(())
     }
 
+    pub fn update_focused_workspace_by_monitor_idx(&mut self, idx: usize) -> Result<()> {
+        let invisible_borders = self.invisible_borders;
+        let offset = self.work_area_offset;
+
+        self.monitors_mut()
+            .get_mut(idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?
+            .update_focused_workspace(offset, &invisible_borders)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn swap_monitor_workspaces(&mut self, first_idx: usize, second_idx: usize) -> Result<()> {
+        tracing::info!("swaping monitors");
+        if first_idx == second_idx {
+            return Ok(());
+        }
+        let mouse_follows_focus = self.mouse_follows_focus;
+        let first_focused_workspace = {
+            let first_monitor = self
+                .monitors()
+                .get(first_idx)
+                .ok_or_else(|| anyhow!("There is no monitor"))?;
+            first_monitor.focused_workspace_idx()
+        };
+
+        let second_focused_workspace = {
+            let second_monitor = self
+                .monitors()
+                .get(second_idx)
+                .ok_or_else(|| anyhow!("There is no monitor"))?;
+            second_monitor.focused_workspace_idx()
+        };
+
+        // Swap workspaces between the first and second monitors
+
+        let first_workspaces = self
+            .monitors_mut()
+            .get_mut(first_idx)
+            .ok_or_else(|| anyhow!("There is no monitor"))?
+            .remove_workspaces();
+
+        let second_workspaces = self
+            .monitors_mut()
+            .get_mut(second_idx)
+            .ok_or_else(|| anyhow!("There is no monitor"))?
+            .remove_workspaces();
+
+        self.monitors_mut()
+            .get_mut(first_idx)
+            .ok_or_else(|| anyhow!("There is no monitor"))?
+            .workspaces_mut()
+            .extend(second_workspaces);
+
+        self.monitors_mut()
+            .get_mut(second_idx)
+            .ok_or_else(|| anyhow!("There is no monitor"))?
+            .workspaces_mut()
+            .extend(first_workspaces);
+
+        // Set the focused workspaces for the first and second monitors
+        if let Some(first_monitor) = self.monitors_mut().get_mut(first_idx) {
+            first_monitor.focus_workspace(second_focused_workspace)?;
+            first_monitor.load_focused_workspace(mouse_follows_focus)?;
+        }
+
+        if let Some(second_monitor) = self.monitors_mut().get_mut(second_idx) {
+            second_monitor.focus_workspace(first_focused_workspace)?;
+            second_monitor.load_focused_workspace(mouse_follows_focus)?;
+        }
+
+        self.update_focused_workspace_by_monitor_idx(second_idx)?;
+        self.update_focused_workspace_by_monitor_idx(first_idx)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn swap_focused_monitor(&mut self, idx: usize) -> Result<()> {
+        tracing::info!("swapping focused monitor");
+
+        let focused_monitor_idx = self.focused_monitor_idx();
+        let mouse_follows_focus = self.mouse_follows_focus;
+
+        self.swap_monitor_workspaces(focused_monitor_idx, idx)?;
+
+        self.update_focused_workspace(mouse_follows_focus)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn move_container_to_monitor(
         &mut self,
@@ -1558,6 +1705,29 @@ impl WindowManager {
         self.update_focused_workspace(self.mouse_follows_focus)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn cycle_layout(&mut self, direction: CycleDirection) -> Result<()> {
+        tracing::info!("cycling layout");
+
+        let workspace = self.focused_workspace_mut()?;
+        let current_layout = workspace.layout();
+
+        match current_layout {
+            Layout::Default(current) => {
+                let new_layout = match direction {
+                    CycleDirection::Previous => current.cycle_previous(),
+                    CycleDirection::Next => current.cycle_next(),
+                };
+
+                tracing::info!("next layout: {new_layout}");
+                workspace.set_layout(Layout::Default(new_layout));
+            }
+            Layout::Custom(_) => {}
+        }
+
+        self.update_focused_workspace(self.mouse_follows_focus)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn change_workspace_custom_layout(&mut self, path: PathBuf) -> Result<()> {
         tracing::info!("changing layout");

komorebi/src/window_manager_event.rs

@@ -4,9 +4,11 @@ use std::fmt::Formatter;
 use schemars::JsonSchema;
 use serde::Serialize;
 
+use crate::window::should_act;
 use crate::window::Window;
 use crate::winevent::WinEvent;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::REGEX_IDENTIFIERS;
 
 #[derive(Debug, Copy, Clone, Serialize, JsonSchema)]
 #[serde(tag = "type", content = "content")]
@@ -31,62 +33,49 @@ impl Display for WindowManagerEvent {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Manage(window) => {
-                write!(f, "Manage (Window: {})", window)
+                write!(f, "Manage (Window: {window})")
             }
             Self::Unmanage(window) => {
-                write!(f, "Unmanage (Window: {})", window)
+                write!(f, "Unmanage (Window: {window})")
             }
             Self::Destroy(winevent, window) => {
-                write!(f, "Destroy (WinEvent: {}, Window: {})", winevent, window)
+                write!(f, "Destroy (WinEvent: {winevent}, Window: {window})")
             }
             Self::FocusChange(winevent, window) => {
-                write!(
-                    f,
-                    "FocusChange (WinEvent: {}, Window: {})",
-                    winevent, window
-                )
+                write!(f, "FocusChange (WinEvent: {winevent}, Window: {window})",)
             }
             Self::Hide(winevent, window) => {
-                write!(f, "Hide (WinEvent: {}, Window: {})", winevent, window)
+                write!(f, "Hide (WinEvent: {winevent}, Window: {window})")
             }
             Self::Cloak(winevent, window) => {
-                write!(f, "Cloak (WinEvent: {}, Window: {})", winevent, window)
+                write!(f, "Cloak (WinEvent: {winevent}, Window: {window})")
             }
             Self::Minimize(winevent, window) => {
-                write!(f, "Minimize (WinEvent: {}, Window: {})", winevent, window)
+                write!(f, "Minimize (WinEvent: {winevent}, Window: {window})")
             }
             Self::Show(winevent, window) => {
-                write!(f, "Show (WinEvent: {}, Window: {})", winevent, window)
+                write!(f, "Show (WinEvent: {winevent}, Window: {window})")
             }
             Self::Uncloak(winevent, window) => {
-                write!(f, "Uncloak (WinEvent: {}, Window: {})", winevent, window)
+                write!(f, "Uncloak (WinEvent: {winevent}, Window: {window})")
             }
             Self::MoveResizeStart(winevent, window) => {
                 write!(
                     f,
-                    "MoveResizeStart (WinEvent: {}, Window: {})",
-                    winevent, window
+                    "MoveResizeStart (WinEvent: {winevent}, Window: {window})",
                 )
             }
             Self::MoveResizeEnd(winevent, window) => {
-                write!(
-                    f,
-                    "MoveResizeEnd (WinEvent: {}, Window: {})",
-                    winevent, window
-                )
+                write!(f, "MoveResizeEnd (WinEvent: {winevent}, Window: {window})",)
             }
             Self::MouseCapture(winevent, window) => {
-                write!(
-                    f,
-                    "MouseCapture (WinEvent: {}, Window: {})",
-                    winevent, window
-                )
+                write!(f, "MouseCapture (WinEvent: {winevent}, Window: {window})",)
             }
             Self::Raise(window) => {
-                write!(f, "Raise (Window: {})", window)
+                write!(f, "Raise (Window: {window})")
             }
             Self::DisplayChange(window) => {
-                write!(f, "DisplayChange (Window: {})", window)
+                write!(f, "DisplayChange (Window: {window})")
             }
         }
     }
@@ -144,11 +133,21 @@ impl WindowManagerEvent {
                 // [yatta\src\windows_event.rs:110] event = 32779 ObjectLocationChange
 
                 let object_name_change_on_launch = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+                let regex_identifiers = REGEX_IDENTIFIERS.lock();
 
-                if object_name_change_on_launch.contains(&window.exe().ok()?)
-                    || object_name_change_on_launch.contains(&window.class().ok()?)
-                    || object_name_change_on_launch.contains(&window.title().ok()?)
-                {
+                let title = &window.title().ok()?;
+                let exe_name = &window.exe().ok()?;
+                let class = &window.class().ok()?;
+
+                let should_trigger = should_act(
+                    title,
+                    exe_name,
+                    class,
+                    &object_name_change_on_launch,
+                    &regex_identifiers,
+                );
+
+                if should_trigger {
                     Option::from(Self::Show(winevent, window))
                 } else {
                     None

komorebi/src/windows_api.rs

@@ -11,10 +11,11 @@ use color_eyre::Result;
 use windows::core::Result as WindowsCrateResult;
 use windows::core::PCSTR;
 use windows::core::PWSTR;
+use windows::Win32::Foundation::CloseHandle;
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HANDLE;
-use windows::Win32::Foundation::HINSTANCE;
+use windows::Win32::Foundation::HMODULE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
@@ -233,9 +234,7 @@ impl WindowsApi {
     }
 
     pub fn enum_windows(callback: WNDENUMPROC, callback_data_address: isize) -> Result<()> {
-        unsafe { EnumWindows(callback, LPARAM(callback_data_address)) }
-            .ok()
-            .process()
+        unsafe { EnumWindows(callback, LPARAM(callback_data_address)) }.process()
     }
 
     pub fn load_workspace_information(monitors: &mut Ring<Monitor>) -> Result<()> {
@@ -274,9 +273,7 @@ impl WindowsApi {
     }
 
     pub fn allow_set_foreground_window(process_id: u32) -> Result<()> {
-        unsafe { AllowSetForegroundWindow(process_id) }
-            .ok()
-            .process()
+        unsafe { AllowSetForegroundWindow(process_id) }.process()
     }
 
     pub fn monitor_from_window(hwnd: HWND) -> isize {
@@ -302,14 +299,17 @@ impl WindowsApi {
     }
 
     pub fn position_window(hwnd: HWND, layout: &Rect, top: bool) -> Result<()> {
-        let flags = SetWindowPosition::NO_ACTIVATE;
+        let flags = SetWindowPosition::NO_ACTIVATE
+            | SetWindowPosition::NO_SEND_CHANGING
+            | SetWindowPosition::NO_COPY_BITS
+            | SetWindowPosition::FRAME_CHANGED;
 
         let position = if top { HWND_TOPMOST } else { HWND_BOTTOM };
         Self::set_window_pos(hwnd, layout, position, flags.bits())
     }
 
     pub fn bring_window_to_top(hwnd: HWND) -> Result<()> {
-        unsafe { BringWindowToTop(hwnd) }.ok().process()
+        unsafe { BringWindowToTop(hwnd) }.process()
     }
 
     pub fn raise_window(hwnd: HWND) -> Result<()> {
@@ -349,7 +349,6 @@ impl WindowsApi {
                 SET_WINDOW_POS_FLAGS(flags),
             )
         }
-        .ok()
         .process()
     }
 
@@ -364,9 +363,7 @@ impl WindowsApi {
     }
 
     fn post_message(hwnd: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> Result<()> {
-        unsafe { PostMessageW(hwnd, message, wparam, lparam) }
-            .ok()
-            .process()
+        unsafe { PostMessageW(hwnd, message, wparam, lparam) }.process()
     }
 
     pub fn close_window(hwnd: HWND) -> Result<()> {
@@ -432,18 +429,18 @@ impl WindowsApi {
 
     pub fn window_rect(hwnd: HWND) -> Result<Rect> {
         let mut rect = unsafe { std::mem::zeroed() };
-        unsafe { GetWindowRect(hwnd, &mut rect) }.ok().process()?;
+        unsafe { GetWindowRect(hwnd, &mut rect) }.process()?;
 
         Ok(Rect::from(rect))
     }
 
     fn set_cursor_pos(x: i32, y: i32) -> Result<()> {
-        unsafe { SetCursorPos(x, y) }.ok().process()
+        unsafe { SetCursorPos(x, y) }.process()
     }
 
     pub fn cursor_pos() -> Result<POINT> {
         let mut cursor_pos = POINT::default();
-        unsafe { GetCursorPos(&mut cursor_pos) }.ok().process()?;
+        unsafe { GetCursorPos(&mut cursor_pos) }.process()?;
 
         Ok(cursor_pos)
     }
@@ -485,7 +482,7 @@ impl WindowsApi {
         let mut session_id = 0;
 
         unsafe {
-            if ProcessIdToSessionId(process_id, &mut session_id).as_bool() {
+            if ProcessIdToSessionId(process_id, &mut session_id).is_ok() {
                 Ok(session_id)
             } else {
                 Err(anyhow!("could not determine current session id"))
@@ -524,6 +521,8 @@ impl WindowsApi {
     }
 
     fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> Result<isize> {
+        // Can return 0, which does not always mean that an error has occurred
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowlongptrw
         Result::from(WindowsResult::from(unsafe {
             GetWindowLongPtrW(hwnd, index)
         }))
@@ -558,6 +557,10 @@ impl WindowsApi {
         unsafe { OpenProcess(access_rights, inherit_handle, process_id) }.process()
     }
 
+    pub fn close_process(handle: HANDLE) -> Result<()> {
+        unsafe { CloseHandle(handle) }.process()
+    }
+
     pub fn process_handle(process_id: u32) -> Result<HANDLE> {
         Self::open_process(PROCESS_QUERY_INFORMATION, false, process_id)
     }
@@ -570,7 +573,6 @@ impl WindowsApi {
         unsafe {
             QueryFullProcessImageNameW(handle, PROCESS_NAME_WIN32, PWSTR(text_ptr), &mut len)
         }
-        .ok()
         .process()?;
 
         Ok(String::from_utf16(&path[..len as usize])?)
@@ -663,7 +665,6 @@ impl WindowsApi {
 
     pub fn set_process_dpi_awareness_context() -> Result<()> {
         unsafe { SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) }
-            .ok()
             .process()
     }
 
@@ -671,22 +672,21 @@ impl WindowsApi {
     pub fn system_parameters_info_w(
         action: SYSTEM_PARAMETERS_INFO_ACTION,
         ui_param: u32,
-        pv_param: *const c_void,
+        pv_param: *mut c_void,
         update_flags: SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS,
     ) -> Result<()> {
         unsafe { SystemParametersInfoW(action, ui_param, Option::from(pv_param), update_flags) }
-            .ok()
             .process()
     }
 
     #[allow(dead_code)]
     pub fn focus_follows_mouse() -> Result<bool> {
-        let is_enabled: BOOL = unsafe { std::mem::zeroed() };
+        let mut is_enabled: BOOL = unsafe { std::mem::zeroed() };
 
         Self::system_parameters_info_w(
             SPI_GETACTIVEWINDOWTRACKING,
             0,
-            std::ptr::addr_of!(is_enabled).cast(),
+            std::ptr::addr_of_mut!(is_enabled).cast(),
             SPIF_SENDCHANGE,
         )?;
 
@@ -698,7 +698,7 @@ impl WindowsApi {
         Self::system_parameters_info_w(
             SPI_SETACTIVEWINDOWTRACKING,
             0,
-            1 as *const c_void,
+            1 as *mut c_void,
             SPIF_SENDCHANGE,
         )
     }
@@ -708,12 +708,12 @@ impl WindowsApi {
         Self::system_parameters_info_w(
             SPI_SETACTIVEWINDOWTRACKING,
             0,
-            std::ptr::null::<c_void>(),
+            std::ptr::null_mut::<c_void>(),
             SPIF_SENDCHANGE,
         )
     }
 
-    pub fn module_handle_w() -> Result<HINSTANCE> {
+    pub fn module_handle_w() -> Result<HMODULE> {
         unsafe { GetModuleHandleW(None) }.process()
     }
 
@@ -750,7 +750,7 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn create_border_window(name: PCSTR, instance: HINSTANCE) -> Result<isize> {
+    pub fn create_border_window(name: PCSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             let hwnd = CreateWindowExA(
                 WS_EX_TOOLWINDOW | WS_EX_LAYERED,
@@ -767,22 +767,24 @@ impl WindowsApi {
                 None,
             );
 
-            SetLayeredWindowAttributes(hwnd, COLORREF(TRANSPARENCY_COLOUR), 0, LWA_COLORKEY);
+            SetLayeredWindowAttributes(hwnd, COLORREF(TRANSPARENCY_COLOUR), 0, LWA_COLORKEY)?;
 
             hwnd
         }
         .process()
     }
 
-    pub fn set_transparent(hwnd: HWND) {
+    pub fn set_transparent(hwnd: HWND) -> Result<()> {
         unsafe {
             #[allow(clippy::cast_sign_loss)]
             // TODO: alpha should be configurable
-            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), 150, LWA_ALPHA);
+            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), 150, LWA_ALPHA)?;
         }
+
+        Ok(())
     }
 
-    pub fn create_hidden_window(name: PCSTR, instance: HINSTANCE) -> Result<isize> {
+    pub fn create_hidden_window(name: PCSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             CreateWindowExA(
                 WS_EX_NOACTIVATE,

komorebi/src/windows_callbacks.rs

@@ -18,10 +18,10 @@ use windows::Win32::Graphics::Gdi::HDC;
 use windows::Win32::Graphics::Gdi::HMONITOR;
 use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
 use windows::Win32::Graphics::Gdi::PS_SOLID;
-use windows::Win32::System::SystemServices::DBT_DEVNODES_CHANGED;
 use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
+use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
 use windows::Win32::UI::WindowsAndMessaging::SPI_ICONVERTICALSPACING;
 use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
@@ -158,7 +158,7 @@ pub extern "system" fn border_window(
     lparam: LPARAM,
 ) -> LRESULT {
     unsafe {
-        match message as u32 {
+        match message {
             WM_PAINT => {
                 let border_rect = *BORDER_RECT.lock();
                 let mut ps = PAINTSTRUCT::default();
@@ -194,7 +194,7 @@ pub extern "system" fn hidden_window(
     lparam: LPARAM,
 ) -> LRESULT {
     unsafe {
-        match message as u32 {
+        match message {
             WM_DISPLAYCHANGE => {
                 let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
                 WINEVENT_CALLBACK_CHANNEL

komorebi/src/workspace.rs

@@ -12,6 +12,7 @@ use schemars::JsonSchema;
 use serde::Serialize;
 
 use komorebi_core::Axis;
+use komorebi_core::CustomLayout;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::Layout;
@@ -20,9 +21,14 @@ use komorebi_core::Rect;
 
 use crate::container::Container;
 use crate::ring::Ring;
+use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::windows_api::WindowsApi;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::INITIAL_CONFIGURATION_LOADED;
+use crate::NO_TITLEBAR;
+use crate::REMOVE_TITLEBARS;
 
 #[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
 pub struct Workspace {
@@ -75,8 +81,8 @@ impl Default for Workspace {
             layout: Layout::Default(DefaultLayout::BSP),
             layout_rules: vec![],
             layout_flip: None,
-            workspace_padding: Option::from(10),
-            container_padding: Option::from(10),
+            workspace_padding: Option::from(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)),
+            container_padding: Option::from(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)),
             latest_layout: vec![],
             resize_dimensions: vec![],
             tile: true,
@@ -85,6 +91,52 @@ impl Default for Workspace {
 }
 
 impl Workspace {
+    pub fn load_static_config(&mut self, config: &WorkspaceConfig) -> Result<()> {
+        self.name = Option::from(config.name.clone());
+
+        if config.container_padding.is_some() {
+            self.set_container_padding(config.container_padding);
+        }
+
+        if config.workspace_padding.is_some() {
+            self.set_workspace_padding(config.workspace_padding);
+        }
+
+        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_buf(pathbuf.clone())?;
+            self.layout = Layout::Custom(layout);
+            self.tile = true;
+        }
+
+        if config.custom_layout.is_none() && config.layout.is_none() {
+            self.tile = false;
+        }
+
+        if let Some(layout_rules) = &config.layout_rules {
+            let mut all_rules = vec![];
+            for (count, rule) in layout_rules {
+                all_rules.push((*count, Layout::Default(*rule)));
+            }
+
+            self.set_layout_rules(all_rules);
+        }
+
+        if let Some(layout_rules) = &config.custom_layout_rules {
+            let rules = self.layout_rules_mut();
+            for (count, pathbuf) in layout_rules {
+                let rule = CustomLayout::from_path_buf(pathbuf.clone())?;
+                rules.push((*count, Layout::Custom(rule)));
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn hide(&mut self) {
         for container in self.containers_mut() {
             for window in container.windows_mut() {
@@ -212,9 +264,18 @@ impl Workspace {
                     self.resize_dimensions(),
                 );
 
+                let should_remove_titlebars = REMOVE_TITLEBARS.load(Ordering::SeqCst);
+                let no_titlebar = NO_TITLEBAR.lock().clone();
+
                 let windows = self.visible_windows_mut();
                 for (i, window) in windows.into_iter().enumerate() {
                     if let (Some(window), Some(layout)) = (window, layouts.get(i)) {
+                        if should_remove_titlebars && no_titlebar.contains(&window.exe()?) {
+                            window.remove_title_bar()?;
+                        } else if no_titlebar.contains(&window.exe()?) {
+                            window.add_title_bar()?;
+                        }
+
                         window.set_position(layout, invisible_borders, false)?;
                     }
                 }
@@ -720,6 +781,16 @@ impl Workspace {
     }
 
     fn enforce_resize_constraints(&mut self) {
+        match self.layout {
+            Layout::Default(DefaultLayout::BSP) => self.enforce_resize_constraints_for_bsp(),
+            Layout::Default(DefaultLayout::UltrawideVerticalStack) => {
+                self.enforce_resize_for_ultrawide();
+            }
+            _ => self.enforce_no_resize(),
+        }
+    }
+
+    fn enforce_resize_constraints_for_bsp(&mut self) {
         for (i, rect) in self.resize_dimensions_mut().iter_mut().enumerate() {
             if let Some(rect) = rect {
                 // Even containers can't be resized to the bottom
@@ -745,6 +816,72 @@ impl Workspace {
         }
     }
 
+    fn enforce_resize_for_ultrawide(&mut self) {
+        let resize_dimensions = self.resize_dimensions_mut();
+        match resize_dimensions.len() {
+            // Single window can not be resized at all
+            0 | 1 => self.enforce_no_resize(),
+            // Two windows can only be resized in the middle
+            2 => {
+                // Zero is actually on the right
+                if let Some(mut right) = resize_dimensions[0] {
+                    right.top = 0;
+                    right.bottom = 0;
+                    right.right = 0;
+                }
+
+                // One is on the left
+                if let Some(mut left) = resize_dimensions[1] {
+                    left.top = 0;
+                    left.bottom = 0;
+                    left.left = 0;
+                }
+            }
+            // Three or more windows means 0 is in center, 1 is at the left, 2.. are a vertical
+            // stack on the right
+            _ => {
+                // Central can be resized left or right
+                if let Some(mut right) = resize_dimensions[0] {
+                    right.top = 0;
+                    right.bottom = 0;
+                }
+
+                // Left one can only be resized to the right
+                if let Some(mut left) = resize_dimensions[1] {
+                    left.top = 0;
+                    left.bottom = 0;
+                    left.left = 0;
+                }
+
+                // Handle stack on the right
+                let stack_size = resize_dimensions[2..].len();
+                for (i, rect) in resize_dimensions[2..].iter_mut().enumerate() {
+                    if let Some(rect) = rect {
+                        // No containers can resize to the right
+                        rect.right = 0;
+
+                        // First container in stack cant resize up
+                        if i == 0 {
+                            rect.top = 0;
+                        } else if i == stack_size - 1 {
+                            // Last cant be resized to the bottom
+                            rect.bottom = 0;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn enforce_no_resize(&mut self) {
+        for rect in self.resize_dimensions_mut().iter_mut().flatten() {
+            rect.left = 0;
+            rect.right = 0;
+            rect.top = 0;
+            rect.bottom = 0;
+        }
+    }
+
     pub fn new_monocle_container(&mut self) -> Result<()> {
         let focused_idx = self.focused_container_idx();
         let container = self

komorebic.lib.ahk

@@ -0,0 +1,457 @@
+; Generated by komorebic.exe
+
+Start(ffm, await_configuration, tcp_port) {
+    RunWait("komorebic.exe start " ffm " --await-configuration " await_configuration " --tcp-port " tcp_port, , "Hide")
+}
+
+Stop() {
+    RunWait("komorebic.exe stop", , "Hide")
+}
+
+State() {
+    RunWait("komorebic.exe state", , "Hide")
+}
+
+Query(state_query) {
+    RunWait("komorebic.exe query " state_query, , "Hide")
+}
+
+Subscribe(named_pipe) {
+    RunWait("komorebic.exe subscribe " named_pipe, , "Hide")
+}
+
+Unsubscribe(named_pipe) {
+    RunWait("komorebic.exe unsubscribe " named_pipe, , "Hide")
+}
+
+Log() {
+    RunWait("komorebic.exe log", , "Hide")
+}
+
+QuickSaveResize() {
+    RunWait("komorebic.exe quick-save-resize", , "Hide")
+}
+
+QuickLoadResize() {
+    RunWait("komorebic.exe quick-load-resize", , "Hide")
+}
+
+SaveResize(path) {
+    RunWait("komorebic.exe save-resize " path, , "Hide")
+}
+
+LoadResize(path) {
+    RunWait("komorebic.exe load-resize " path, , "Hide")
+}
+
+Focus(operation_direction) {
+    RunWait("komorebic.exe focus " operation_direction, , "Hide")
+}
+
+Move(operation_direction) {
+    RunWait("komorebic.exe move " operation_direction, , "Hide")
+}
+
+Minimize() {
+    RunWait("komorebic.exe minimize", , "Hide")
+}
+
+Close() {
+    RunWait("komorebic.exe close", , "Hide")
+}
+
+ForceFocus() {
+    RunWait("komorebic.exe force-focus", , "Hide")
+}
+
+CycleFocus(cycle_direction) {
+    RunWait("komorebic.exe cycle-focus " cycle_direction, , "Hide")
+}
+
+CycleMove(cycle_direction) {
+    RunWait("komorebic.exe cycle-move " cycle_direction, , "Hide")
+}
+
+Stack(operation_direction) {
+    RunWait("komorebic.exe stack " operation_direction, , "Hide")
+}
+
+Resize(edge, sizing) {
+    RunWait("komorebic.exe resize " edge " " sizing, , "Hide")
+}
+
+ResizeAxis(axis, sizing) {
+    RunWait("komorebic.exe resize-axis " axis " " sizing, , "Hide")
+}
+
+Unstack() {
+    RunWait("komorebic.exe unstack", , "Hide")
+}
+
+CycleStack(cycle_direction) {
+    RunWait("komorebic.exe cycle-stack " cycle_direction, , "Hide")
+}
+
+MoveToMonitor(target) {
+    RunWait("komorebic.exe move-to-monitor " target, , "Hide")
+}
+
+CycleMoveToMonitor(cycle_direction) {
+    RunWait("komorebic.exe cycle-move-to-monitor " cycle_direction, , "Hide")
+}
+
+MoveToWorkspace(target) {
+    RunWait("komorebic.exe move-to-workspace " target, , "Hide")
+}
+
+MoveToNamedWorkspace(workspace) {
+    RunWait("komorebic.exe move-to-named-workspace " workspace, , "Hide")
+}
+
+CycleMoveToWorkspace(cycle_direction) {
+    RunWait("komorebic.exe cycle-move-to-workspace " cycle_direction, , "Hide")
+}
+
+SendToMonitor(target) {
+    RunWait("komorebic.exe send-to-monitor " target, , "Hide")
+}
+
+CycleSendToMonitor(cycle_direction) {
+    RunWait("komorebic.exe cycle-send-to-monitor " cycle_direction, , "Hide")
+}
+
+SendToWorkspace(target) {
+    RunWait("komorebic.exe send-to-workspace " target, , "Hide")
+}
+
+SendToNamedWorkspace(workspace) {
+    RunWait("komorebic.exe send-to-named-workspace " workspace, , "Hide")
+}
+
+CycleSendToWorkspace(cycle_direction) {
+    RunWait("komorebic.exe cycle-send-to-workspace " cycle_direction, , "Hide")
+}
+
+SendToMonitorWorkspace(target_monitor, target_workspace) {
+    RunWait("komorebic.exe send-to-monitor-workspace " target_monitor " " target_workspace, , "Hide")
+}
+
+FocusMonitor(target) {
+    RunWait("komorebic.exe focus-monitor " target, , "Hide")
+}
+
+FocusWorkspace(target) {
+    RunWait("komorebic.exe focus-workspace " target, , "Hide")
+}
+
+FocusMonitorWorkspace(target_monitor, target_workspace) {
+    RunWait("komorebic.exe focus-monitor-workspace " target_monitor " " target_workspace, , "Hide")
+}
+
+FocusNamedWorkspace(workspace) {
+    RunWait("komorebic.exe focus-named-workspace " workspace, , "Hide")
+}
+
+CycleMonitor(cycle_direction) {
+    RunWait("komorebic.exe cycle-monitor " cycle_direction, , "Hide")
+}
+
+CycleWorkspace(cycle_direction) {
+    RunWait("komorebic.exe cycle-workspace " cycle_direction, , "Hide")
+}
+
+MoveWorkspaceToMonitor(target) {
+    RunWait("komorebic.exe move-workspace-to-monitor " target, , "Hide")
+}
+
+NewWorkspace() {
+    RunWait("komorebic.exe new-workspace", , "Hide")
+}
+
+ResizeDelta(pixels) {
+    RunWait("komorebic.exe resize-delta " pixels, , "Hide")
+}
+
+InvisibleBorders(left, top, right, bottom) {
+    RunWait("komorebic.exe invisible-borders " left " " top " " right " " bottom, , "Hide")
+}
+
+GlobalWorkAreaOffset(left, top, right, bottom) {
+    RunWait("komorebic.exe global-work-area-offset " left " " top " " right " " bottom, , "Hide")
+}
+
+MonitorWorkAreaOffset(monitor, left, top, right, bottom) {
+    RunWait("komorebic.exe monitor-work-area-offset " monitor " " left " " top " " right " " bottom, , "Hide")
+}
+
+AdjustContainerPadding(sizing, adjustment) {
+    RunWait("komorebic.exe adjust-container-padding " sizing " " adjustment, , "Hide")
+}
+
+AdjustWorkspacePadding(sizing, adjustment) {
+    RunWait("komorebic.exe adjust-workspace-padding " sizing " " adjustment, , "Hide")
+}
+
+ChangeLayout(default_layout) {
+    RunWait("komorebic.exe change-layout " default_layout, , "Hide")
+}
+
+CycleLayout(operation_direction) {
+    RunWait("komorebic.exe cycle-layout " operation_direction, , "Hide")
+}
+
+LoadCustomLayout(path) {
+    RunWait("komorebic.exe load-custom-layout " path, , "Hide")
+}
+
+FlipLayout(axis) {
+    RunWait("komorebic.exe flip-layout " axis, , "Hide")
+}
+
+Promote() {
+    RunWait("komorebic.exe promote", , "Hide")
+}
+
+PromoteFocus() {
+    RunWait("komorebic.exe promote-focus", , "Hide")
+}
+
+Retile() {
+    RunWait("komorebic.exe retile", , "Hide")
+}
+
+MonitorIndexPreference(index_preference, left, top, right, bottom) {
+    RunWait("komorebic.exe monitor-index-preference " index_preference " " left " " top " " right " " bottom, , "Hide")
+}
+
+EnsureWorkspaces(monitor, workspace_count) {
+    RunWait("komorebic.exe ensure-workspaces " monitor " " workspace_count, , "Hide")
+}
+
+EnsureNamedWorkspaces(monitor, names) {
+    RunWait("komorebic.exe ensure-named-workspaces " monitor " " names, , "Hide")
+}
+
+ContainerPadding(monitor, workspace, size) {
+    RunWait("komorebic.exe container-padding " monitor " " workspace " " size, , "Hide")
+}
+
+NamedWorkspaceContainerPadding(workspace, size) {
+    RunWait("komorebic.exe named-workspace-container-padding " workspace " " size, , "Hide")
+}
+
+WorkspacePadding(monitor, workspace, size) {
+    RunWait("komorebic.exe workspace-padding " monitor " " workspace " " size, , "Hide")
+}
+
+NamedWorkspacePadding(workspace, size) {
+    RunWait("komorebic.exe named-workspace-padding " workspace " " size, , "Hide")
+}
+
+WorkspaceLayout(monitor, workspace, value) {
+    RunWait("komorebic.exe workspace-layout " monitor " " workspace " " value, , "Hide")
+}
+
+NamedWorkspaceLayout(workspace, value) {
+    RunWait("komorebic.exe named-workspace-layout " workspace " " value, , "Hide")
+}
+
+WorkspaceCustomLayout(monitor, workspace, path) {
+    RunWait("komorebic.exe workspace-custom-layout " monitor " " workspace " " path, , "Hide")
+}
+
+NamedWorkspaceCustomLayout(workspace, path) {
+    RunWait("komorebic.exe named-workspace-custom-layout " workspace " " path, , "Hide")
+}
+
+WorkspaceLayoutRule(monitor, workspace, at_container_count, layout) {
+    RunWait("komorebic.exe workspace-layout-rule " monitor " " workspace " " at_container_count " " layout, , "Hide")
+}
+
+NamedWorkspaceLayoutRule(workspace, at_container_count, layout) {
+    RunWait("komorebic.exe named-workspace-layout-rule " workspace " " at_container_count " " layout, , "Hide")
+}
+
+WorkspaceCustomLayoutRule(monitor, workspace, at_container_count, path) {
+    RunWait("komorebic.exe workspace-custom-layout-rule " monitor " " workspace " " at_container_count " " path, , "Hide")
+}
+
+NamedWorkspaceCustomLayoutRule(workspace, at_container_count, path) {
+    RunWait("komorebic.exe named-workspace-custom-layout-rule " workspace " " at_container_count " " path, , "Hide")
+}
+
+ClearWorkspaceLayoutRules(monitor, workspace) {
+    RunWait("komorebic.exe clear-workspace-layout-rules " monitor " " workspace, , "Hide")
+}
+
+ClearNamedWorkspaceLayoutRules(workspace) {
+    RunWait("komorebic.exe clear-named-workspace-layout-rules " workspace, , "Hide")
+}
+
+WorkspaceTiling(monitor, workspace, value) {
+    RunWait("komorebic.exe workspace-tiling " monitor " " workspace " " value, , "Hide")
+}
+
+NamedWorkspaceTiling(workspace, value) {
+    RunWait("komorebic.exe named-workspace-tiling " workspace " " value, , "Hide")
+}
+
+WorkspaceName(monitor, workspace, value) {
+    RunWait("komorebic.exe workspace-name " monitor " " workspace " " value, , "Hide")
+}
+
+ToggleWindowContainerBehaviour() {
+    RunWait("komorebic.exe toggle-window-container-behaviour", , "Hide")
+}
+
+TogglePause() {
+    RunWait("komorebic.exe toggle-pause", , "Hide")
+}
+
+ToggleTiling() {
+    RunWait("komorebic.exe toggle-tiling", , "Hide")
+}
+
+ToggleFloat() {
+    RunWait("komorebic.exe toggle-float", , "Hide")
+}
+
+ToggleMonocle() {
+    RunWait("komorebic.exe toggle-monocle", , "Hide")
+}
+
+ToggleMaximize() {
+    RunWait("komorebic.exe toggle-maximize", , "Hide")
+}
+
+RestoreWindows() {
+    RunWait("komorebic.exe restore-windows", , "Hide")
+}
+
+Manage() {
+    RunWait("komorebic.exe manage", , "Hide")
+}
+
+Unmanage() {
+    RunWait("komorebic.exe unmanage", , "Hide")
+}
+
+ReloadConfiguration() {
+    RunWait("komorebic.exe reload-configuration", , "Hide")
+}
+
+WatchConfiguration(boolean_state) {
+    RunWait("komorebic.exe watch-configuration " boolean_state, , "Hide")
+}
+
+CompleteConfiguration() {
+    RunWait("komorebic.exe complete-configuration", , "Hide")
+}
+
+AltFocusHack(boolean_state) {
+    RunWait("komorebic.exe alt-focus-hack " boolean_state, , "Hide")
+}
+
+WindowHidingBehaviour(hiding_behaviour) {
+    RunWait("komorebic.exe window-hiding-behaviour " hiding_behaviour, , "Hide")
+}
+
+CrossMonitorMoveBehaviour(move_behaviour) {
+    RunWait("komorebic.exe cross-monitor-move-behaviour " move_behaviour, , "Hide")
+}
+
+ToggleCrossMonitorMoveBehaviour() {
+    RunWait("komorebic.exe toggle-cross-monitor-move-behaviour", , "Hide")
+}
+
+UnmanagedWindowOperationBehaviour(operation_behaviour) {
+    RunWait("komorebic.exe unmanaged-window-operation-behaviour " operation_behaviour, , "Hide")
+}
+
+FloatRule(identifier, id) {
+    RunWait("komorebic.exe float-rule " identifier " `"" id "`"", , "Hide")
+}
+
+ManageRule(identifier, id) {
+    RunWait("komorebic.exe manage-rule " identifier " `"" id "`"", , "Hide")
+}
+
+WorkspaceRule(identifier, id, monitor, workspace) {
+    RunWait("komorebic.exe workspace-rule " identifier " `"" id "`" " monitor " " workspace, , "Hide")
+}
+
+NamedWorkspaceRule(identifier, id, workspace) {
+    RunWait("komorebic.exe named-workspace-rule " identifier " `"" id "`" " workspace, , "Hide")
+}
+
+IdentifyObjectNameChangeApplication(identifier, id) {
+    RunWait("komorebic.exe identify-object-name-change-application " identifier " `"" id "`"", , "Hide")
+}
+
+IdentifyTrayApplication(identifier, id) {
+    RunWait("komorebic.exe identify-tray-application " identifier " `"" id "`"", , "Hide")
+}
+
+IdentifyLayeredApplication(identifier, id) {
+    RunWait("komorebic.exe identify-layered-application " identifier " `"" id "`"", , "Hide")
+}
+
+IdentifyBorderOverflowApplication(identifier, id) {
+    RunWait("komorebic.exe identify-border-overflow-application " identifier " `"" id "`"", , "Hide")
+}
+
+ActiveWindowBorder(boolean_state) {
+    RunWait("komorebic.exe active-window-border " boolean_state, , "Hide")
+}
+
+ActiveWindowBorderColour(r, g, b, window_kind) {
+    RunWait("komorebic.exe active-window-border-colour " r " " g " " b " --window-kind " window_kind, , "Hide")
+}
+
+ActiveWindowBorderWidth(width) {
+    RunWait("komorebic.exe active-window-border-width " width, , "Hide")
+}
+
+ActiveWindowBorderOffset(offset) {
+    RunWait("komorebic.exe active-window-border-offset " offset, , "Hide")
+}
+
+FocusFollowsMouse(boolean_state, implementation) {
+    RunWait("komorebic.exe focus-follows-mouse " boolean_state " --implementation " implementation, , "Hide")
+}
+
+ToggleFocusFollowsMouse(implementation) {
+    RunWait("komorebic.exe toggle-focus-follows-mouse  --implementation " implementation, , "Hide")
+}
+
+MouseFollowsFocus(boolean_state) {
+    RunWait("komorebic.exe mouse-follows-focus " boolean_state, , "Hide")
+}
+
+ToggleMouseFollowsFocus() {
+    RunWait("komorebic.exe toggle-mouse-follows-focus", , "Hide")
+}
+
+AhkLibrary() {
+    RunWait("komorebic.exe ahk-library", , "Hide")
+}
+
+AhkAppSpecificConfiguration(path, override_path) {
+    RunWait("komorebic.exe ahk-app-specific-configuration " path " " override_path, , "Hide")
+}
+
+PwshAppSpecificConfiguration(path, override_path) {
+    RunWait("komorebic.exe pwsh-app-specific-configuration " path " " override_path, , "Hide")
+}
+
+FormatAppSpecificConfiguration(path) {
+    RunWait("komorebic.exe format-app-specific-configuration " path, , "Hide")
+}
+
+NotificationSchema() {
+    RunWait("komorebic.exe notification-schema", , "Hide")
+}
+
+SocketSchema() {
+    RunWait("komorebic.exe socket-schema", , "Hide")
+}

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.15"
+version = "0.1.19"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
@@ -16,21 +16,17 @@ komorebi-core = { path = "../komorebi-core" }
 
 clap = { version = "4", features = ["derive", "wrap_help"] }
 color-eyre = "0.6"
-dirs = "4"
+dirs = "5"
 fs-tail = "0.1"
 heck = "0.4"
 lazy_static = "1"
 paste = "1"
 powershell_script = "1.0"
+reqwest = { version = "0.11", features = ["blocking"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"
-sysinfo = "0.27"
+sysinfo = "0.29"
 uds_windows = "1"
-
-[dependencies.windows]
-version = "0.44"
-features = [
-    "Win32_Foundation",
-    "Win32_UI_WindowsAndMessaging"
-]
+which = "5"
+windows = { workspace = true }

komorebic/src/main.rs

@@ -9,6 +9,8 @@ use std::io::ErrorKind;
 use std::io::Write;
 use std::path::PathBuf;
 use std::process::Command;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 
 use clap::Parser;
@@ -22,6 +24,7 @@ use paste::paste;
 use sysinfo::SystemExt;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
+use which::which;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
@@ -46,6 +49,7 @@ use komorebi_core::StateQuery;
 use komorebi_core::WindowKind;
 
 lazy_static! {
+    static ref HAS_CUSTOM_CONFIG_HOME: AtomicBool = AtomicBool::new(false);
     static ref HOME_DIR: PathBuf = {
         std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(
             |_| dirs::home_dir().expect("there is no home directory"),
@@ -53,11 +57,11 @@ lazy_static! {
                 let home = PathBuf::from(&home_path);
 
                 if home.as_path().is_dir() {
+                    HAS_CUSTOM_CONFIG_HOME.store(true, Ordering::SeqCst);
                     home
                 } else {
                     panic!(
-                        "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
-                        home_path
+                        "$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory",
                     );
                 }
             },
@@ -113,12 +117,15 @@ gen_enum_subcommand_args! {
     CycleMove: CycleDirection,
     CycleMoveToWorkspace: CycleDirection,
     CycleSendToWorkspace: CycleDirection,
+    CycleSendToMonitor: CycleDirection,
+    CycleMoveToMonitor: CycleDirection,
     CycleMonitor: CycleDirection,
     CycleWorkspace: CycleDirection,
     Stack: OperationDirection,
     CycleStack: CycleDirection,
     FlipLayout: Axis,
     ChangeLayout: DefaultLayout,
+    CycleLayout: CycleDirection,
     WatchConfiguration: BooleanState,
     MouseFollowsFocus: BooleanState,
     Query: StateQuery,
@@ -147,7 +154,9 @@ gen_target_subcommand_args! {
     SendToWorkspace,
     FocusMonitor,
     FocusWorkspace,
+    FocusWorkspaces,
     MoveWorkspaceToMonitor,
+    SwapWorkspacesWithMonitor,
 }
 
 macro_rules! gen_named_target_subcommand_args {
@@ -507,6 +516,29 @@ gen_application_target_subcommand_args! {
     IdentifyLayeredApplication,
     IdentifyObjectNameChangeApplication,
     IdentifyBorderOverflowApplication,
+    RemoveTitleBar,
+}
+
+#[derive(Parser, AhkFunction)]
+struct InitialWorkspaceRule {
+    #[clap(value_enum)]
+    identifier: ApplicationIdentifier,
+    /// Identifier as a string
+    id: String,
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+}
+
+#[derive(Parser, AhkFunction)]
+struct InitialNamedWorkspaceRule {
+    #[clap(value_enum)]
+    identifier: ApplicationIdentifier,
+    /// Identifier as a string
+    id: String,
+    /// Name of a workspace
+    workspace: String,
 }
 
 #[derive(Parser, AhkFunction)]
@@ -576,16 +608,33 @@ struct ActiveWindowBorderOffset {
 }
 
 #[derive(Parser, AhkFunction)]
+#[allow(clippy::struct_excessive_bools)]
 struct Start {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
     #[clap(action, short, long = "ffm")]
     ffm: bool,
+    /// Path to a static configuration JSON file
+    #[clap(action, short, long)]
+    config: Option<PathBuf>,
     /// Wait for 'komorebic complete-configuration' to be sent before processing events
     #[clap(action, short, long)]
     await_configuration: bool,
     /// Start a TCP server on the given port to allow the direct sending of SocketMessages
     #[clap(action, short, long)]
     tcp_port: Option<usize>,
+    /// Start whkd in a background process
+    #[clap(action, long)]
+    whkd: bool,
+    /// Start autohotkey configuration file
+    #[clap(action, long)]
+    ahk: bool,
+}
+
+#[derive(Parser, AhkFunction)]
+struct Stop {
+    /// Stop whkd if it is running as a background process
+    #[clap(action, long)]
+    whkd: bool,
 }
 
 #[derive(Parser, AhkFunction)]
@@ -646,6 +695,19 @@ struct AltFocusHack {
     boolean_state: BooleanState,
 }
 
+#[derive(Parser, AhkFunction)]
+struct EnableAutostart {
+    /// Path to a static configuration JSON file
+    #[clap(action, short, long)]
+    config: String,
+    /// Enable autostart of whkd
+    #[clap(action, long)]
+    whkd: bool,
+    /// Enable autostart of ahk
+    #[clap(action, long)]
+    ahk: bool,
+}
+
 #[derive(Parser)]
 #[clap(author, about, version)]
 struct Opts {
@@ -658,7 +720,9 @@ enum SubCommand {
     /// Start komorebi.exe as a background process
     Start(Start),
     /// Stop the komorebi.exe process and restore all hidden windows
-    Stop,
+    Stop(Stop),
+    /// Output various important komorebi-related environment values
+    Check,
     /// Show a JSON representation of the current window manager state
     State,
     /// Query the current window manager state
@@ -722,6 +786,9 @@ enum SubCommand {
     /// Move the focused window to the specified monitor
     #[clap(arg_required_else_help = true)]
     MoveToMonitor(MoveToMonitor),
+    /// Move the focused window to the monitor in the given cycle direction
+    #[clap(arg_required_else_help = true)]
+    CycleMoveToMonitor(CycleMoveToMonitor),
     /// Move the focused window to the specified workspace
     #[clap(arg_required_else_help = true)]
     MoveToWorkspace(MoveToWorkspace),
@@ -734,6 +801,9 @@ enum SubCommand {
     /// Send the focused window to the specified monitor
     #[clap(arg_required_else_help = true)]
     SendToMonitor(SendToMonitor),
+    /// Send the focused window to the monitor in the given cycle direction
+    #[clap(arg_required_else_help = true)]
+    CycleSendToMonitor(CycleSendToMonitor),
     /// Send the focused window to the specified workspace
     #[clap(arg_required_else_help = true)]
     SendToWorkspace(SendToWorkspace),
@@ -752,6 +822,9 @@ enum SubCommand {
     /// Focus the specified workspace on the focused monitor
     #[clap(arg_required_else_help = true)]
     FocusWorkspace(FocusWorkspace),
+    /// Focus the specified workspace on all monitors
+    #[clap(arg_required_else_help = true)]
+    FocusWorkspaces(FocusWorkspaces),
     /// Focus the specified workspace on the target monitor
     #[clap(arg_required_else_help = true)]
     FocusMonitorWorkspace(FocusMonitorWorkspace),
@@ -767,6 +840,9 @@ enum SubCommand {
     /// Move the focused workspace to the specified monitor
     #[clap(arg_required_else_help = true)]
     MoveWorkspaceToMonitor(MoveWorkspaceToMonitor),
+    /// Swap focused monitor workspaces with specified monitor
+    #[clap(arg_required_else_help = true)]
+    SwapWorkspacesWithMonitor(SwapWorkspacesWithMonitor),
     /// Create and append a new workspace on the focused monitor
     NewWorkspace,
     /// Set the resize delta (used by resize-edge and resize-axis)
@@ -777,7 +853,6 @@ enum SubCommand {
     InvisibleBorders(InvisibleBorders),
     /// Set offsets to exclude parts of the work area from tiling
     #[clap(arg_required_else_help = true)]
-    #[clap(alias = "global-work-area-offset")]
     GlobalWorkAreaOffset(GlobalWorkAreaOffset),
     /// Set offsets for a monitor to exclude parts of the work area from tiling
     #[clap(arg_required_else_help = true)]
@@ -791,6 +866,9 @@ enum SubCommand {
     /// Set the layout on the focused workspace
     #[clap(arg_required_else_help = true)]
     ChangeLayout(ChangeLayout),
+    /// Cycle between available layouts
+    #[clap(arg_required_else_help = true)]
+    CycleLayout(CycleLayout),
     /// Load a custom layout from file for the focused workspace
     #[clap(arg_required_else_help = true)]
     LoadCustomLayout(LoadCustomLayout),
@@ -908,6 +986,12 @@ enum SubCommand {
     /// Add a rule to always manage the specified application
     #[clap(arg_required_else_help = true)]
     ManageRule(ManageRule),
+    /// Add a rule to associate an application with a workspace on first show
+    #[clap(arg_required_else_help = true)]
+    InitialWorkspaceRule(InitialWorkspaceRule),
+    /// Add a rule to associate an application with a named workspace on first show
+    #[clap(arg_required_else_help = true)]
+    InitialNamedWorkspaceRule(InitialNamedWorkspaceRule),
     /// Add a rule to associate an application with a workspace
     #[clap(arg_required_else_help = true)]
     WorkspaceRule(WorkspaceRule),
@@ -923,6 +1007,11 @@ enum SubCommand {
     /// Identify an application that has WS_EX_LAYERED, but should still be managed
     #[clap(arg_required_else_help = true)]
     IdentifyLayeredApplication(IdentifyLayeredApplication),
+    /// Whitelist an application for title bar removal
+    #[clap(arg_required_else_help = true)]
+    RemoveTitleBar(RemoveTitleBar),
+    /// Toggle title bars for whitelisted applications
+    ToggleTitleBars,
     /// Identify an application that has overflowing borders
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "identify-border-overflow")]
@@ -964,23 +1053,124 @@ enum SubCommand {
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "fmt-asc")]
     FormatAppSpecificConfiguration(FormatAppSpecificConfiguration),
+    /// Fetch the latest version of applications.yaml from komorebi-application-specific-configuration
+    #[clap(alias = "fetch-asc")]
+    FetchAppSpecificConfiguration,
     /// Generate a JSON Schema of subscription notifications
     NotificationSchema,
     /// Generate a JSON Schema of socket messages
     SocketSchema,
+    /// Generate a JSON Schema of the static configuration file
+    StaticConfigSchema,
+    /// Generates a static configuration JSON file based on the current window manager state
+    GenerateStaticConfig,
+    /// Generates the komorebi.lnk shortcut in shell:startup to autostart komorebi
+    #[clap(arg_required_else_help = true)]
+    EnableAutostart(EnableAutostart),
+    /// Deletes the komorebi.lnk shortcut in shell:startup to disable autostart
+    DisableAutostart,
 }
 
 pub fn send_message(bytes: &[u8]) -> Result<()> {
     let socket = DATA_DIR.join("komorebi.sock");
-    let mut stream = UnixStream::connect(&socket)?;
+    let mut stream = UnixStream::connect(socket)?;
     Ok(stream.write_all(bytes)?)
 }
 
-#[allow(clippy::too_many_lines)]
+fn startup_dir() -> Result<PathBuf> {
+    let home_dir = dirs::home_dir().expect("unable to obtain user's home folder");
+    let app_data = home_dir.join("AppData");
+    let roaming = app_data.join("Roaming");
+    let microsoft = roaming.join("Microsoft");
+    let windows = microsoft.join("Windows");
+    let start_menu = windows.join("Start Menu");
+    let programs = start_menu.join("Programs");
+    let startup = programs.join("Startup");
+
+    if !startup.is_dir() {
+        std::fs::create_dir_all(&startup)?;
+    }
+
+    Ok(startup)
+}
+
+#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
 fn main() -> Result<()> {
     let opts: Opts = Opts::parse();
 
     match opts.subcmd {
+        SubCommand::EnableAutostart(args) => {
+            let mut current_exe = std::env::current_exe().expect("unable to get exec path");
+            current_exe.pop();
+
+            let komorebic_exe = current_exe.join("komorebic.exe");
+
+            let startup_dir = startup_dir()?;
+            let shortcut_file = startup_dir.join("komorebi.lnk");
+
+            let mut arguments = format!("start --config {}", args.config);
+
+            if args.whkd {
+                arguments.push_str(" --whkd");
+            } else if args.ahk {
+                arguments.push_str(" --ahk");
+            }
+
+            Command::new("powershell")
+            .arg("-c")
+            .arg("$WshShell = New-Object -comObject WScript.Shell; $Shortcut = $WshShell.CreateShortcut($env:SHORTCUT_PATH); $Shortcut.TargetPath = $env:TARGET_PATH; $Shortcut.Arguments = $env:TARGET_ARGS; $Shortcut.Save()")
+            .env("SHORTCUT_PATH", shortcut_file.to_string_lossy().to_string())
+            .env("TARGET_PATH", komorebic_exe.to_string_lossy().to_string())
+            .env("TARGET_ARGS", arguments)
+            .output()?;
+        }
+        SubCommand::DisableAutostart => {
+            let startup_dir = startup_dir()?;
+            let shortcut_file = startup_dir.join("komorebi.lnk");
+
+            if shortcut_file.is_file() {
+                std::fs::remove_file(shortcut_file)?;
+            }
+        }
+        SubCommand::Check => {
+            let home = HOME_DIR.clone();
+            let home_lossy_string = home.to_string_lossy();
+            if HAS_CUSTOM_CONFIG_HOME.load(Ordering::SeqCst) {
+                println!("KOMOREBI_CONFIG_HOME detected: {home_lossy_string}\n");
+            } else {
+                println!(
+                    "No KOMOREBI_CONFIG_HOME detected, defaulting to {}\n",
+                    dirs::home_dir()
+                        .expect("could not find home dir")
+                        .to_string_lossy()
+                );
+            }
+
+            println!("Looking for configuration files in {home_lossy_string}\n");
+
+            let mut config_pwsh = home.clone();
+            config_pwsh.push("komorebi.ps1");
+
+            let mut config_ahk = home.clone();
+            config_ahk.push("komorebi.ahk");
+
+            if config_pwsh.exists() {
+                println!("Found komorebi.ps1; this file will be autoloaded by komorebi\n");
+                let mut config_whkd = dirs::home_dir().expect("could not find home dir");
+                config_whkd.push(".config");
+                config_whkd.push("whkdrc");
+                if config_whkd.exists() {
+                    println!("Found ~/.config/whkdrc; key bindings will be loaded from here when whkd is started\n");
+                } else {
+                    println!("No ~/.config/whkdrc found; you may not be able to control komorebi with your keyboard\n");
+                }
+            } else if config_ahk.exists() {
+                println!("Found komorebi.ahk; this file will be autoloaded by komorebi\n");
+            } else {
+                println!("No komorebi configuration found in {home_lossy_string}\n");
+                println!("If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration\n");
+            }
+        }
         SubCommand::AhkLibrary => {
             let mut library = HOME_DIR.clone();
             library.push("komorebic.lib.ahk");
@@ -996,17 +1186,19 @@ fn main() -> Result<()> {
             file.write_all(fixed_output.as_bytes())?;
 
             println!(
-                "\nAHK helper library for komorebic written to {}",
+                "\nAHKv1 helper library for komorebic written to {}",
                 library.to_str().ok_or_else(|| anyhow!(
                     "could not find the path to the generated ahk lib file"
                 ))?
             );
 
+            println!("\nYou can convert this file to AHKv2 syntax using https://github.com/mmikeww/AHK-v2-script-converter");
+
             println!(
-                "\nYou can include the library at the top of your ~/komorebi.ahk config with this line:"
+                "\nYou can include the converted library at the top of your komorebi.ahk config with this line:"
             );
 
-            println!("\n#Include %A_ScriptDir%\\komorebic.lib.ahk");
+            println!("\n#Include komorebic.lib.ahk");
         }
         SubCommand::Log => {
             let mut color_log = std::env::temp_dir();
@@ -1015,7 +1207,7 @@ fn main() -> Result<()> {
             let locked = file.lock();
             #[allow(clippy::significant_drop_in_scrutinee)]
             for line in locked.lines().flatten() {
-                println!("{}", line);
+                println!("{line}");
             }
         }
         SubCommand::Focus(arg) => {
@@ -1054,6 +1246,11 @@ fn main() -> Result<()> {
         SubCommand::MoveToMonitor(arg) => {
             send_message(&SocketMessage::MoveContainerToMonitorNumber(arg.target).as_bytes()?)?;
         }
+        SubCommand::CycleMoveToMonitor(arg) => {
+            send_message(
+                &SocketMessage::CycleMoveContainerToMonitor(arg.cycle_direction).as_bytes()?,
+            )?;
+        }
         SubCommand::MoveToWorkspace(arg) => {
             send_message(&SocketMessage::MoveContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
         }
@@ -1068,6 +1265,11 @@ fn main() -> Result<()> {
         SubCommand::SendToMonitor(arg) => {
             send_message(&SocketMessage::SendContainerToMonitorNumber(arg.target).as_bytes()?)?;
         }
+        SubCommand::CycleSendToMonitor(arg) => {
+            send_message(
+                &SocketMessage::CycleSendContainerToMonitor(arg.cycle_direction).as_bytes()?,
+            )?;
+        }
         SubCommand::SendToWorkspace(arg) => {
             send_message(&SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
         }
@@ -1091,6 +1293,9 @@ fn main() -> Result<()> {
         SubCommand::MoveWorkspaceToMonitor(arg) => {
             send_message(&SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
         }
+        SubCommand::SwapWorkspacesWithMonitor(arg) => {
+            send_message(&SocketMessage::SwapWorkspacesToMonitorNumber(arg.target).as_bytes()?)?;
+        }
         SubCommand::InvisibleBorders(arg) => {
             send_message(
                 &SocketMessage::InvisibleBorders(Rect {
@@ -1269,6 +1474,22 @@ fn main() -> Result<()> {
             )?;
         }
         SubCommand::Start(arg) => {
+            let mut ahk: String = String::from("autohotkey.exe");
+
+            if let Ok(komorebi_ahk_exe) = std::env::var("KOMOREBI_AHK_EXE") {
+                if which(&komorebi_ahk_exe).is_ok() {
+                    ahk = komorebi_ahk_exe;
+                }
+            }
+
+            if arg.whkd && which("whkd").is_err() {
+                return Err(anyhow!("could not find whkd, please make sure it is installed before using the --whkd flag"));
+            }
+
+            if arg.ahk && which(&ahk).is_err() {
+                return Err(anyhow!("could not find autohotkey, please make sure it is installed before using the --ahk flag"));
+            }
+
             let mut buf: PathBuf;
 
             // The komorebi.ps1 shim will only exist in the Path if installed by Scoop
@@ -1292,73 +1513,55 @@ fn main() -> Result<()> {
                 None
             };
 
-            let script = exec.map_or_else(
-                || {
-                    if arg.ffm | arg.await_configuration | arg.tcp_port.is_some() {
-                        format!(
-                            "Start-Process komorebi.exe -ArgumentList {} -WindowStyle hidden",
-                            arg.tcp_port.map_or_else(
-                                || if arg.ffm && arg.await_configuration {
-                                    "'--ffm','--await-configuration'".to_string()
-                                } else if arg.ffm {
-                                    "'--ffm'".to_string()
-                                } else {
-                                    "'--await-configuration'".to_string()
-                                },
-                                |port| if arg.ffm {
-                                    format!("'--ffm','--tcp-port={}'", port)
-                                } else if arg.await_configuration {
-                                    format!("'--await-configuration','--tcp-port={}'", port)
-                                } else if arg.ffm && arg.await_configuration {
-                                    format!("'--ffm','--await-configuration','--tcp-port={}'", port)
-                                } else {
-                                    format!("'--tcp-port={}'", port)
-                                }
-                            )
-                        )
-                    } else {
-                        String::from("Start-Process komorebi.exe -WindowStyle hidden")
-                    }
-                },
-                |exec| {
-                    if arg.ffm | arg.await_configuration {
-                        format!(
-                            "Start-Process '{}' -ArgumentList {} -WindowStyle hidden",
-                            exec,
-                            arg.tcp_port.map_or_else(
-                                || if arg.ffm && arg.await_configuration {
-                                    "'--ffm','--await-configuration'".to_string()
-                                } else if arg.ffm {
-                                    "'--ffm'".to_string()
-                                } else {
-                                    "'--await-configuration'".to_string()
-                                },
-                                |port| if arg.ffm {
-                                    format!("'--ffm','--tcp-port={}'", port)
-                                } else if arg.await_configuration {
-                                    format!("'--await-configuration','--tcp-port={}'", port)
-                                } else if arg.ffm && arg.await_configuration {
-                                    format!("'--ffm','--await-configuration','--tcp-port={}'", port)
-                                } else {
-                                    format!("'--tcp-port={}'", port)
-                                }
-                            )
-                        )
-                    } else {
-                        format!("Start-Process '{}' -WindowStyle hidden", exec)
-                    }
-                },
-            );
+            let mut flags = vec![];
+            if let Some(config) = arg.config {
+                let path = resolve_windows_path(config.as_os_str().to_str().unwrap())?;
+                if !path.is_file() {
+                    return Err(anyhow!("could not find file: {}", path.to_string_lossy()));
+                }
+
+                flags.push(format!(
+                    "'--config=\"{}\"'",
+                    path.as_os_str()
+                        .to_string_lossy()
+                        .trim_start_matches(r"\\?\"),
+                ));
+            }
+
+            if arg.ffm {
+                flags.push("'--ffm'".to_string());
+            }
+
+            if arg.await_configuration {
+                flags.push("'--await-configuration'".to_string());
+            }
+
+            if let Some(port) = arg.tcp_port {
+                flags.push(format!("'--tcp-port={port}'"));
+            }
+
+            let script = if flags.is_empty() {
+                format!(
+                    "Start-Process '{}' -WindowStyle hidden",
+                    exec.unwrap_or("komorebi.exe")
+                )
+            } else {
+                let argument_list = flags.join(",");
+                format!(
+                    "Start-Process '{}' -ArgumentList {argument_list} -WindowStyle hidden",
+                    exec.unwrap_or("komorebi.exe")
+                )
+            };
 
             let mut running = false;
 
             while !running {
                 match powershell_script::run(&script) {
                     Ok(_) => {
-                        println!("{}", script);
+                        println!("{script}");
                     }
                     Err(error) => {
-                        println!("Error: {}", error);
+                        println!("Error: {error}");
                     }
                 }
 
@@ -1375,8 +1578,61 @@ fn main() -> Result<()> {
                     println!("komorebi.exe did not start... Trying again");
                 }
             }
+
+            if arg.whkd {
+                let script = r#"
+if (!(Get-Process whkd -ErrorAction SilentlyContinue))
+{
+  Start-Process whkd -WindowStyle hidden
+}
+                "#;
+                match powershell_script::run(script) {
+                    Ok(_) => {
+                        println!("{script}");
+                    }
+                    Err(error) => {
+                        println!("Error: {error}");
+                    }
+                }
+            }
+
+            if arg.ahk {
+                let home = HOME_DIR.clone();
+                let mut config_ahk = home;
+                config_ahk.push("komorebi.ahk");
+
+                let script = format!(
+                    r#"
+  Start-Process {ahk} {config} -WindowStyle hidden
+                "#,
+                    config = config_ahk.as_os_str().to_string_lossy()
+                );
+
+                match powershell_script::run(&script) {
+                    Ok(_) => {
+                        println!("{script}");
+                    }
+                    Err(error) => {
+                        println!("Error: {error}");
+                    }
+                }
+            }
         }
-        SubCommand::Stop => {
+        SubCommand::Stop(arg) => {
+            if arg.whkd {
+                let script = r#"
+Stop-Process -Name:whkd -ErrorAction SilentlyContinue
+                "#;
+                match powershell_script::run(script) {
+                    Ok(_) => {
+                        println!("{script}");
+                    }
+                    Err(error) => {
+                        println!("Error: {error}");
+                    }
+                }
+            }
+
             send_message(&SocketMessage::Stop.as_bytes()?)?;
         }
         SubCommand::FloatRule(arg) => {
@@ -1385,6 +1641,23 @@ fn main() -> Result<()> {
         SubCommand::ManageRule(arg) => {
             send_message(&SocketMessage::ManageRule(arg.identifier, arg.id).as_bytes()?)?;
         }
+        SubCommand::InitialWorkspaceRule(arg) => {
+            send_message(
+                &SocketMessage::InitialWorkspaceRule(
+                    arg.identifier,
+                    arg.id,
+                    arg.monitor,
+                    arg.workspace,
+                )
+                .as_bytes()?,
+            )?;
+        }
+        SubCommand::InitialNamedWorkspaceRule(arg) => {
+            send_message(
+                &SocketMessage::InitialNamedWorkspaceRule(arg.identifier, arg.id, arg.workspace)
+                    .as_bytes()?,
+            )?;
+        }
         SubCommand::WorkspaceRule(arg) => {
             send_message(
                 &SocketMessage::WorkspaceRule(arg.identifier, arg.id, arg.monitor, arg.workspace)
@@ -1409,6 +1682,9 @@ fn main() -> Result<()> {
         SubCommand::ChangeLayout(arg) => {
             send_message(&SocketMessage::ChangeLayout(arg.default_layout).as_bytes()?)?;
         }
+        SubCommand::CycleLayout(arg) => {
+            send_message(&SocketMessage::CycleLayout(arg.cycle_direction).as_bytes()?)?;
+        }
         SubCommand::LoadCustomLayout(arg) => {
             send_message(
                 &SocketMessage::ChangeLayoutCustom(resolve_windows_path(&arg.path)?).as_bytes()?,
@@ -1423,6 +1699,9 @@ fn main() -> Result<()> {
         SubCommand::FocusWorkspace(arg) => {
             send_message(&SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
         }
+        SubCommand::FocusWorkspaces(arg) => {
+            send_message(&SocketMessage::FocusWorkspaceNumbers(arg.target).as_bytes()?)?;
+        }
         SubCommand::FocusMonitorWorkspace(arg) => {
             send_message(
                 &SocketMessage::FocusMonitorWorkspaceNumber(
@@ -1601,6 +1880,21 @@ fn main() -> Result<()> {
                     .as_bytes()?,
             )?;
         }
+        SubCommand::RemoveTitleBar(target) => {
+            match target.identifier {
+                ApplicationIdentifier::Exe => {}
+                _ => {
+                    return Err(anyhow!(
+                        "this command requires applications to be identified by their exe"
+                    ));
+                }
+            }
+
+            send_message(&SocketMessage::RemoveTitleBar(target.identifier, target.id).as_bytes()?)?;
+        }
+        SubCommand::ToggleTitleBars => {
+            send_message(&SocketMessage::ToggleTitleBars.as_bytes()?)?;
+        }
         SubCommand::Manage => {
             send_message(&SocketMessage::ManageFocusedWindow.as_bytes()?)?;
         }
@@ -1699,12 +1993,6 @@ fn main() -> Result<()> {
                     "could not find the path to the generated configuration file"
                 ))?
             );
-
-            println!(
-                "\nYou can include the generated configuration at the top of your komorebi.ahk config with this line:"
-            );
-
-            println!("\n#Include %A_ScriptDir%\\komorebi.generated.ahk");
         }
         SubCommand::PwshAppSpecificConfiguration(arg) => {
             let content = std::fs::read_to_string(resolve_windows_path(&arg.path)?)?;
@@ -1752,6 +2040,29 @@ fn main() -> Result<()> {
 
             println!("File successfully formatted for PRs to https://github.com/LGUG2Z/komorebi-application-specific-configuration");
         }
+        SubCommand::FetchAppSpecificConfiguration => {
+            let content = reqwest::blocking::get("https://raw.githubusercontent.com/LGUG2Z/komorebi-application-specific-configuration/master/applications.yaml")?
+                .text()?;
+
+            let mut output_file = HOME_DIR.clone();
+            output_file.push("applications.yaml");
+
+            let mut file = OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(&output_file)?;
+
+            file.write_all(content.as_bytes())?;
+
+            let output_path = output_file.to_str().unwrap().to_string();
+            let output_path = output_path.replace('\\', "/");
+
+            println!("Latest version of applications.yaml from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n");
+            println!(
+               "You can add this to your komorebi.json static configuration file like this: \n\n\"app_specific_configuration_path\": \"{output_path}\"",
+            );
+        }
         SubCommand::NotificationSchema => {
             let home = DATA_DIR.clone();
             let mut socket = home;
@@ -1805,6 +2116,74 @@ fn main() -> Result<()> {
 
             send_message(&SocketMessage::SocketSchema.as_bytes()?)?;
 
+            let listener = UnixListener::bind(socket)?;
+            match listener.accept() {
+                Ok(incoming) => {
+                    let stream = BufReader::new(incoming.0);
+                    for line in stream.lines() {
+                        println!("{}", line?);
+                    }
+
+                    return Ok(());
+                }
+                Err(error) => {
+                    panic!("{}", error);
+                }
+            }
+        }
+        SubCommand::StaticConfigSchema => {
+            let home = DATA_DIR.clone();
+            let mut socket = home;
+            socket.push("komorebic.sock");
+            let socket = socket.as_path();
+
+            match std::fs::remove_file(socket) {
+                Ok(_) => {}
+                Err(error) => match error.kind() {
+                    // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
+                    ErrorKind::NotFound => {}
+                    _ => {
+                        return Err(error.into());
+                    }
+                },
+            };
+
+            send_message(&SocketMessage::StaticConfigSchema.as_bytes()?)?;
+
+            let listener = UnixListener::bind(socket)?;
+            match listener.accept() {
+                Ok(incoming) => {
+                    let stream = BufReader::new(incoming.0);
+                    for line in stream.lines() {
+                        println!("{}", line?);
+                    }
+
+                    return Ok(());
+                }
+                Err(error) => {
+                    panic!("{}", error);
+                }
+            }
+        }
+        SubCommand::GenerateStaticConfig => {
+            let home = DATA_DIR.clone();
+            let mut socket = home;
+            socket.push("komorebic.sock");
+            let socket = socket.as_path();
+
+            match std::fs::remove_file(socket) {
+                Ok(_) => {}
+                Err(error) => match error.kind() {
+                    // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
+                    ErrorKind::NotFound => {}
+                    _ => {
+                        return Err(error.into());
+                    }
+                },
+            };
+
+            send_message(&SocketMessage::GenerateStaticConfig.as_bytes()?)?;
+
             let listener = UnixListener::bind(socket)?;
             match listener.accept() {
                 Ok(incoming) => {

schema.json

@@ -0,0 +1,621 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "StaticConfig",
+  "type": "object",
+  "properties": {
+    "active_window_border": {
+      "description": "Display an active window border (default: false)",
+      "type": [
+        "boolean",
+        "null"
+      ]
+    },
+    "active_window_border_colours": {
+      "description": "Active window border colours for different container types",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/ActiveWindowBorderColours"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "active_window_border_offset": {
+      "description": "Offset of the active window border (default: None)",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int32"
+    },
+    "active_window_border_width": {
+      "description": "Width of the active window border (default: 20)",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int32"
+    },
+    "alt_focus_hack": {
+      "description": "Always send the ALT key when using focus commands (default: false)",
+      "type": [
+        "boolean",
+        "null"
+      ]
+    },
+    "app_specific_configuration_path": {
+      "description": "Path to applications.yaml from komorebi-application-specific-configurations (default: None)",
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "border_offset": {
+      "description": "DEPRECATED from v0.1.19: use active_window_border_offset instead",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/Rect"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "border_overflow_applications": {
+      "description": "Identify border overflow applications",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/IdWithIdentifier"
+      }
+    },
+    "border_width": {
+      "description": "DEPRECATED from v0.1.19: use active_window_border_width instead",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int32"
+    },
+    "cross_monitor_move_behaviour": {
+      "description": "Determine what happens when a window is moved across a monitor boundary (default: Swap)",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/MoveBehaviour"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "default_container_padding": {
+      "description": "Global default container padding (default: 10)",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int32"
+    },
+    "default_workspace_padding": {
+      "description": "Global default workspace padding (default: 10)",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int32"
+    },
+    "float_rules": {
+      "description": "Individual window floating rules",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/IdWithIdentifier"
+      }
+    },
+    "focus_follows_mouse": {
+      "description": "Determine focus follows mouse implementation (default: None)",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/FocusFollowsMouseImplementation"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "global_work_area_offset": {
+      "description": "Global work area (space used for tiling) offset (default: None)",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/Rect"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "invisible_borders": {
+      "description": "Dimensions of Windows' own invisible borders; don't set these yourself unless you are told to",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/Rect"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "layered_applications": {
+      "description": "Identify applications that have the WS_EX_LAYERED extended window style",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/IdWithIdentifier"
+      }
+    },
+    "manage_rules": {
+      "description": "Individual window force-manage rules",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/IdWithIdentifier"
+      }
+    },
+    "monitor_index_preferences": {
+      "description": "Set monitor index preferences",
+      "type": [
+        "object",
+        "null"
+      ],
+      "additionalProperties": {
+        "$ref": "#/definitions/Rect"
+      }
+    },
+    "monitors": {
+      "description": "Monitor and workspace configurations",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/MonitorConfig"
+      }
+    },
+    "mouse_follows_focus": {
+      "description": "Enable or disable mouse follows focus (default: true)",
+      "type": [
+        "boolean",
+        "null"
+      ]
+    },
+    "object_name_change_applications": {
+      "description": "Identify applications that send EVENT_OBJECT_NAMECHANGE on launch (very rare)",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/IdWithIdentifier"
+      }
+    },
+    "resize_delta": {
+      "description": "Delta to resize windows by (default 50)",
+      "type": [
+        "integer",
+        "null"
+      ],
+      "format": "int32"
+    },
+    "tray_and_multi_window_applications": {
+      "description": "Identify tray and multi-window applications",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "$ref": "#/definitions/IdWithIdentifier"
+      }
+    },
+    "unmanaged_window_operation_behaviour": {
+      "description": "Determine what happens when commands are sent while an unmanaged window is in the foreground (default: Op)",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/OperationBehaviour"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "window_container_behaviour": {
+      "description": "Determine what happens when a new window is opened (default: Create)",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/WindowContainerBehaviour"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "window_hiding_behaviour": {
+      "description": "Which Windows signal to use when hiding windows (default: minimize)",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/HidingBehaviour"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "definitions": {
+    "ActiveWindowBorderColours": {
+      "type": "object",
+      "required": [
+        "monocle",
+        "single",
+        "stack"
+      ],
+      "properties": {
+        "monocle": {
+          "description": "Border colour when the container is in monocle mode",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Rgb"
+            }
+          ]
+        },
+        "single": {
+          "description": "Border colour when the container contains a single window",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Rgb"
+            }
+          ]
+        },
+        "stack": {
+          "description": "Border colour when the container contains multiple windows",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Rgb"
+            }
+          ]
+        }
+      }
+    },
+    "ApplicationIdentifier": {
+      "type": "string",
+      "enum": [
+        "Exe",
+        "Class",
+        "Title"
+      ]
+    },
+    "DefaultLayout": {
+      "type": "string",
+      "enum": [
+        "BSP",
+        "Columns",
+        "Rows",
+        "VerticalStack",
+        "HorizontalStack",
+        "UltrawideVerticalStack"
+      ]
+    },
+    "FocusFollowsMouseImplementation": {
+      "oneOf": [
+        {
+          "description": "A custom FFM implementation (slightly more CPU-intensive)",
+          "type": "string",
+          "enum": [
+            "Komorebi"
+          ]
+        },
+        {
+          "description": "The native (legacy) Windows FFM implementation",
+          "type": "string",
+          "enum": [
+            "Windows"
+          ]
+        }
+      ]
+    },
+    "HidingBehaviour": {
+      "oneOf": [
+        {
+          "description": "Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)",
+          "type": "string",
+          "enum": [
+            "Hide"
+          ]
+        },
+        {
+          "description": "Use the SW_MINIMIZE flag to hide windows when switching workspaces (has issues with frequent workspace switching)",
+          "type": "string",
+          "enum": [
+            "Minimize"
+          ]
+        },
+        {
+          "description": "Use the undocumented SetCloak Win32 function to hide windows when switching workspaces (has foregrounding issues)",
+          "type": "string",
+          "enum": [
+            "Cloak"
+          ]
+        }
+      ]
+    },
+    "IdWithIdentifier": {
+      "type": "object",
+      "required": [
+        "id",
+        "kind"
+      ],
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "kind": {
+          "$ref": "#/definitions/ApplicationIdentifier"
+        },
+        "matching_strategy": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/MatchingStrategy"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      }
+    },
+    "MatchingStrategy": {
+      "type": "string",
+      "enum": [
+        "Legacy",
+        "Equals",
+        "StartsWith",
+        "EndsWith",
+        "Contains",
+        "Regex"
+      ]
+    },
+    "MonitorConfig": {
+      "type": "object",
+      "required": [
+        "workspaces"
+      ],
+      "properties": {
+        "work_area_offset": {
+          "description": "Monitor-specific work area offset (default: None)",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/Rect"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "workspaces": {
+          "description": "Workspace configurations",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/WorkspaceConfig"
+          }
+        }
+      }
+    },
+    "MoveBehaviour": {
+      "oneOf": [
+        {
+          "description": "Swap the window container with the window container at the edge of the adjacent monitor",
+          "type": "string",
+          "enum": [
+            "Swap"
+          ]
+        },
+        {
+          "description": "Insert the window container into the focused workspace on the adjacent monitor",
+          "type": "string",
+          "enum": [
+            "Insert"
+          ]
+        }
+      ]
+    },
+    "OperationBehaviour": {
+      "oneOf": [
+        {
+          "description": "Process komorebic commands on temporarily unmanaged/floated windows",
+          "type": "string",
+          "enum": [
+            "Op"
+          ]
+        },
+        {
+          "description": "Ignore komorebic commands on temporarily unmanaged/floated windows",
+          "type": "string",
+          "enum": [
+            "NoOp"
+          ]
+        }
+      ]
+    },
+    "Rect": {
+      "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"
+        }
+      }
+    },
+    "Rgb": {
+      "type": "object",
+      "required": [
+        "b",
+        "g",
+        "r"
+      ],
+      "properties": {
+        "b": {
+          "description": "Blue",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "g": {
+          "description": "Green",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        },
+        "r": {
+          "description": "Red",
+          "type": "integer",
+          "format": "uint32",
+          "minimum": 0.0
+        }
+      }
+    },
+    "WindowContainerBehaviour": {
+      "oneOf": [
+        {
+          "description": "Create a new container for each new window",
+          "type": "string",
+          "enum": [
+            "Create"
+          ]
+        },
+        {
+          "description": "Append new windows to the focused window container",
+          "type": "string",
+          "enum": [
+            "Append"
+          ]
+        }
+      ]
+    },
+    "WorkspaceConfig": {
+      "type": "object",
+      "required": [
+        "name"
+      ],
+      "properties": {
+        "container_padding": {
+          "description": "Container padding (default: global)",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "int32"
+        },
+        "custom_layout": {
+          "description": "Custom Layout (default: None)",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "custom_layout_rules": {
+          "description": "Layout rules (default: None)",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "initial_workspace_rules": {
+          "description": "Initial workspace application rules",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/IdWithIdentifier"
+          }
+        },
+        "layout": {
+          "description": "Layout (default: BSP)",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/DefaultLayout"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "layout_rules": {
+          "description": "Layout rules (default: None)",
+          "type": [
+            "object",
+            "null"
+          ],
+          "additionalProperties": {
+            "$ref": "#/definitions/DefaultLayout"
+          }
+        },
+        "name": {
+          "description": "Name",
+          "type": "string"
+        },
+        "workspace_padding": {
+          "description": "Container padding (default: global)",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "int32"
+        },
+        "workspace_rules": {
+          "description": "Permanent workspace application rules",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/IdWithIdentifier"
+          }
+        }
+      }
+    }
+  }
+}

whkdrc.sample

@@ -1,16 +1,16 @@
-.shell pwsh
+.shell powershell
 
-# reload swhkd configuration
-# alt + o                 : taskkill /f /im swhkd.exe && start /b swhkd # if shell is cmd
-alt + o                 : taskkill /f /im swhkd.exe && Start-Process swhkd -WindowStyle hidden # if shell is pwsh / powershell
+# Reload whkd configuration
+# alt + o                 : taskkill /f /im whkd.exe && start /b whkd # if shell is cmd
+alt + o                 : taskkill /f /im whkd.exe && Start-Process whkd -WindowStyle hidden # if shell is pwsh / powershell
 alt + shift + o         : komorebic reload-configuration
 
-# app shortcuts - these require shell to be pwsh / powershell
-# the apps will be focused if open, or launched if not open
+# App shortcuts - these require shell to be pwsh / powershell
+# The apps will be focused if open, or launched if not open
 # alt + f                 : if ($wshell.AppActivate('Firefox') -eq $False) { start firefox }
 # alt + b                 : if ($wshell.AppActivate('Chrome') -eq $False) { start chrome }
 
-# focus windows
+# Focus windows
 alt + h                 : komorebic focus left
 alt + j                 : komorebic focus down
 alt + k                 : komorebic focus up
@@ -18,14 +18,14 @@ alt + l                 : komorebic focus right
 alt + shift + oem_4     : komorebic cycle-focus previous # oem_4 is [
 alt + shift + oem_6     : komorebic cycle-focus next # oem_6 is ]
 
-# move windows
+# Move windows
 alt + shift + h         : komorebic move left
 alt + shift + j         : komorebic move down
 alt + shift + k         : komorebic move up
 alt + shift + l         : komorebic move right
 alt + shift + return    : komorebic promote
 
-# stack windows
+# Stack windows
 alt + left              : komorebic stack left
 alt + down              : komorebic stack down
 alt + up                : komorebic stack up
@@ -34,31 +34,30 @@ alt + oem_1             : komorebic unstack # oem_1 is ;
 alt + oem_4             : komorebic cycle-stack previous # oem_4 is [
 alt + oem_6             : komorebic cycle-stack next # oem_6 is ]
 
-# resize
+# Resize
 alt + oem_plus          : komorebic resize-axis horizontal increase
 alt + oem_minus         : komorebic resize-axis horizontal decrease
 alt + shift + oem_plus  : komorebic resize-axis vertical increase
 alt + shift + oem_minus : komorebic resize-axis vertical decrease
 
-# manipulate windows
+# Manipulate windows
 alt + t                 : komorebic toggle-float
 alt + shift + f         : komorebic toggle-monocle
 
-# window manager options
+# Window manager options
 alt + shift + r         : komorebic retile
 alt + p                 : komorebic toggle-pause
-alt + 0                 : komorebic toggle-focus-follows-mouse
 
-# layouts
+# Layouts
 alt + x                 : komorebic flip-layout horizontal
 alt + y                 : komorebic flip-layout vertical
 
-# workspaces
+# Workspaces
 alt + 1                 : komorebic focus-workspace 0
 alt + 2                 : komorebic focus-workspace 1
 alt + 3                 : komorebic focus-workspace 2
 
-# move windows across workspaces
+# Move windows across workspaces
 alt + shift + 1         : komorebic move-to-workspace 0
 alt + shift + 2         : komorebic move-to-workspace 1
 alt + shift + 3         : komorebic move-to-workspace 2