fix(wm): ignore com hwnds on monitor polling

This commit adds a new command, 'unmanaged-window-operation-behaviour'
which allows the user to configure their desired behaviour in situations
when sending window container commands which operate on the focused
window container in the workspace state, but having an unmanaged window
as the foreground hwnd.

The default previously was previously Op (and this remains the default
with these new changes), but the user can now select NoOp, which will
return an error when the focused hwnd is unmanaged and not allow any
write operations to take place on the focused workspace state.

resolve #133

.github/workflows/windows.yaml

@@ -28,7 +28,7 @@ jobs:
         target:
           - x86_64-pc-windows-msvc
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
       - name: Prep cargo dirs
@@ -42,7 +42,7 @@ jobs:
           echo "TARGET=${{ matrix.target }}" | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
           echo "SKIP_TESTS=" | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
       - name: Cache cargo registry, git trees and binaries
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: |
             ~/.cargo/registry
@@ -55,7 +55,7 @@ jobs:
           echo "::set-output name=rust_hash::$(rustc -Vv | grep commit-hash | awk '{print $2}')"
         shell: bash
       - name: Cache cargo build
-        uses: actions/cache@v2
+        uses: actions/cache@v3
         with:
           path: target
           key: ${{ github.base_ref }}-${{ github.head_ref }}-${{ matrix.target }}-cargo-target-dir-${{ steps.cargo-target-cache.outputs.rust_hash }}-${{ hashFiles('**/Cargo.lock') }}
@@ -77,12 +77,14 @@ jobs:
         run: |
           cargo build --locked --release --target ${{ matrix.target }}
       - name: Upload the built artifacts
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: komorebi-${{ matrix.target }}
           path: |
             target/${{ matrix.target }}/release/komorebi.exe
             target/${{ matrix.target }}/release/komorebic.exe
+            target/${{ matrix.target }}/release/komorebi.pdb
+            target/${{ matrix.target }}/release/komorebic.pdb
           retention-days: 7
       - name: Generate changelog
         if: startsWith(github.ref, 'refs/tags/')

Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 
 members = [
-    "bindings",
     "derive-ahk",
     "komorebi",
     "komorebi-core",

README.md

@@ -18,10 +18,32 @@ Translations of this document can be found in the project wiki:
 
 - [komorebi 中文用户指南](https://github.com/LGUG2Z/komorebi/wiki/README-zh) (by [@crosstyan](https://github.com/crosstyan))
 
-There is a [Discord server](https://discord.gg/vzBmPm6RkQ) available for _komorebi_-related discussion, help,
+There is a [Discord server](https://discord.gg/mGkn66PHkx) available for _komorebi_-related discussion, help,
 troubleshooting etc. If you have any specific feature requests or bugs to report, please create an issue in this
 repository.
 
+Articles, blog posts, demos, and videos about _komorebi_ can be added to this list by PR:
+
+- [Moving to Windows from Linux Pt 1](https://kvwu.io/posts/moving-to-windows/)
+- [Windows 下的现代化平铺窗口管理器 komorebi](https://zhuanlan.zhihu.com/p/455064481)
+
+## Demonstrations
+
+[@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
+11 with a terminal emulator, a web browser and a code editor. The original
+video can be viewed
+[here](https://twitter.com/haxibami/status/1501560766578659332).
+
+https://user-images.githubusercontent.com/13164844/163496447-20c3ff0a-c5d8-40d1-9cc8-156c4cebf12e.mp4
+
+[@aik2mlj](https://github.com/aik2mlj) showing _komorebi_ running on Windows 11
+with multiple workspaces, terminal emulators, a web browser, and the
+[yasb](https://github.com/DenBot/yasb) status bar with the _komorebi_ workspace
+widget enabled. The original video can be viewed
+[here](https://zhuanlan.zhihu.com/p/455064481).
+
+https://user-images.githubusercontent.com/13164844/163496414-a9cde3d1-b8a7-4a7a-96fb-a8985380bc70.mp4
+
 ## Description
 
 _komorebi_ only responds to [WinEvents](https://docs.microsoft.com/en-us/windows/win32/winauto/event-constants) and the
@@ -83,14 +105,16 @@ PowerShell prompt), and then move the binaries to that directory.
 If you use the [Scoop](https://scoop.sh/) command line installer, you can run the following commands to install the
 binaries from the latest GitHub Release:
 
-```
-scoop bucket add komorebi https://github.com/LGUG2Z/komorebi-bucket
+```powershell
+scoop bucket add extras
 scoop install komorebi
 ```
 
 If you install _komorebi_ using Scoop, the binaries will automatically be added to your `Path` and a command will be
 shown for you to run in order to get started using the sample configuration file.
 
+Thanks to [@sitiom](https://github.com/sitiom) for getting _komorebi_ added to the popular Scoop Extras bucket.
+
 ### Building from Source
 
 If you prefer to compile _komorebi_ from source, you will need
@@ -133,6 +157,68 @@ for _komorebi_ can be found [here](https://gist.github.com/crosstyan/dafacc0778d
 
 ### Common First-Time Tips
 
+#### Generating Common Application-Specific Configurations
+
+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)
+contains YAML definitions of settings that are known to make tricky
+applications behave as expected. These YAML definitions can be used to generate
+an AHK file which you can import at the start of your own `komorebi.ahk` file,
+leaving you to focus primarily on your desired keybindings and workspace
+configurations.
+
+If you have settings for an application that you think should be part of this
+curated selection, please open a PR on the configuration repository.
+
+In the event that your PR is not accepted, or if you find there are any
+settings that you wish to override, this can easily be done using an override
+file.
+
+```powershell
+# Clone and enter the repository
+git clone https://github.com/LGUG2Z/komorebi-application-specific-configuration.git
+cd komorebi-application-specific-configuration
+
+# Use komorebic to generate an AHK file
+komorebic.exe ahk-app-specific-configuration applications.yaml
+
+# Application-specific generated configuration written to C:\Users\LGUG2Z\.config\komorebi\komorebi.generated.ahk
+#
+# You can include the generated configuration at the top of your komorebi.ahk config with this line:
+#
+# #Include %A_ScriptDir%\komorebi.generated.ahk
+
+# Optionally, provide an override file that follows the same schema as the second argument
+komorebic.exe ahk-app-specific-configuration applications.yaml overrides.yaml
+```
+
+#### Setting a Custom KOMOREBI_CONFIG_HOME Directory
+
+If you do not want to keep _komorebi_-related files in your `$Env:UserProfile` directory, you can specify a custom directory
+by setting the `$Env:KOMOREBI_CONFIG_HOME` environment variable.
+
+For example, to use the `~/.config/komorebi` directory:
+
+```powershell
+# Run this command to make sure that the directory has been created
+mkdir -p ~/.config/komorebi
+
+# Run this command to open up your PowerShell profile configuration in Notepad
+notepad $PROFILE
+
+# Add this line (with your login user!) to the bottom of your PowerShell profile configuration
+$Env:KOMOREBI_CONFIG_HOME = 'C:\Users\LGUG2Z\.config\komorebi'
+
+# Save the changes and then reload the PowerShell profile
+. $PROFILE
+```
+
+If you already have configuration files that you wish to keep, move them to the `~/.config/komorebi` directory.
+
+The next time you run `komorebic start`, any files created by or loaded by _komorebi_ will be placed or expected to
+exist in this folder.
+
 #### Floating Windows
 
 Sometimes you will want a specific application to never be tiled, and instead float all the time. You add add rules to
@@ -168,6 +254,24 @@ komorebic.exe identify-tray-application exe Discord.exe
 # komorebic.exe identify-tray-application title [TITLE]
 ```
 
+#### Microsoft Office Applications
+
+Microsoft Office applications such as Word and Excel require certain configuration options to be set in order to be
+managed correctly. Below is an example of configuring Microsoft Word to be managed correctly by _komorebi_.
+
+```powershell
+# This only needs to be added once
+komorebic.exe float-rule class _WwB
+
+# Repeat these for other office applications such as EXCEL.EXE etc
+# Note that the capitalised EXE is important here- double check the
+# exact case for the name and the file extension in Task Manager or
+# the AHK Window Spy
+
+komorebic.exe identify-layered-application exe WINWORD.EXE
+komorebic.exe identify-border-overflow-application exe WINWORD.EXE
+```
+
 #### Focus Follows Mouse
 
 `komorebi` supports two focus-follows-mouse implementations; the native Windows Xmouse implementation, which treats the
@@ -188,6 +292,16 @@ passing it as an argument to the `--implementation` flag:
 komorebic.exe toggle-focus-follows-mouse --implementation komorebi
 ```
 
+#### Mouse Follows Focus
+
+By default, the mouse will move to the center of the window when the focus is changed in a given direction. This
+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
+```
+
 #### 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,
@@ -261,6 +375,31 @@ YAML
   configuration: Horizontal
 ```
 
+#### 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
+threshold of window containers is met.
+
+```powershell
+# On the first workspace of the first monitor (0 0)
+# When there are one or more window containers visible on the screen (1)
+# Use the bsp layout (bsp)
+komorebic workspace-layout-rule 0 0 1 bsp
+
+# On the first workspace of the first monitor (0 0)
+# When there are five or more window containers visible on the screen (five)
+# Use the custom layout stored in the home directory (~/custom.yaml)
+komorebic workspace-custom-layout-rule 0 0 5 ~/custom.yaml
+```
+
+However, if you add workspace layout rules, you will not be able to manually change the layout of a workspace until all
+layout rules for that workspace have been cleared.
+
+```powershell
+# If you decide that workspace layout rules are not for you, you can remove them from that same workspace like this
+komorebic clear-workspace-layout-rules 0 0
+```
+
 ## Configuration with `komorebic`
 
 As previously mentioned, this project does not handle anything related to keybindings and shortcuts directly. I
@@ -272,69 +411,87 @@ keybindings with. You can run `komorebic.exe <COMMAND> --help` to get a full exp
 each command.
 
 ```
-start                         Start komorebi.exe as a background process
-stop                          Stop the komorebi.exe process and restore all hidden windows
-state                         Show a JSON representation of the current window manager state
-query                         Query the current window manager state
-subscribe                     Subscribe to komorebi events
-unsubscribe                   Unsubscribe from komorebi events
-log                           Tail komorebi.exe's process logs (cancel with Ctrl-C)
-quick-save                    Quicksave the current resize layout dimensions
-quick-load                    Load the last quicksaved resize layout dimensions
-save                          Save the current resize layout dimensions to a file
-load                          Load the resize layout dimensions from a file
-focus                         Change focus to the window in the specified direction
-move                          Move the focused window in the specified direction
-cycle-focus                   Change focus to the window in the specified cycle direction
-cycle-move                    Move the focused window in the specified cycle direction
-stack                         Stack the focused window in the specified direction
-resize                        Resize the focused window in the specified direction
-unstack                       Unstack the focused window
-cycle-stack                   Cycle the focused stack in the specified cycle direction
-move-to-monitor               Move the focused window to the specified monitor
-move-to-workspace             Move the focused window to the specified workspace
-send-to-monitor               Send the focused window to the specified monitor
-send-to-workspace             Send the focused window to the specified workspace
-focus-monitor                 Focus the specified monitor
-focus-workspace               Focus the specified workspace on the focused monitor
-cycle-monitor                 Focus the monitor in the given cycle direction
-cycle-workspace               Focus the workspace in the given cycle direction
-new-workspace                 Create and append a new workspace on the focused monitor
-invisible-borders             Set the invisible border dimensions around each window
-work-area-offset              Set offsets to exclude parts of the work area from tiling
-adjust-container-padding      Adjust container padding on the focused workspace
-adjust-workspace-padding      Adjust workspace padding on the focused workspace
-change-layout                 Set the layout on the focused workspace
-load-custom-layout            Load a custom layout from file for the focused workspace
-flip-layout                   Flip the layout on the focused workspace (BSP only)
-promote                       Promote the focused window to the top of the tree
-retile                        Force the retiling of all managed windows
-ensure-workspaces             Create at least this many workspaces for the specified monitor
-container-padding             Set the container padding for the specified workspace
-workspace-padding             Set the workspace padding for the specified workspace
-workspace-layout              Set the layout for the specified workspace
-workspace-custom-layout       Set a custom layout for the specified workspace
-workspace-tiling              Enable or disable window tiling for the specified workspace
-workspace-name                Set the workspace name for the specified workspace
-toggle-pause                  Toggle the window manager on and off across all monitors
-toggle-tiling                 Toggle window tiling on the focused workspace
-toggle-float                  Toggle floating mode for the focused window
-toggle-monocle                Toggle monocle mode for the focused container
-toggle-maximize               Toggle native maximization for the focused window
-restore-windows               Restore all hidden windows (debugging command)
-manage                        Force komorebi to manage the focused window
-unmanage                      Unmanage a window that was forcibly managed
-reload-configuration          Reload ~/komorebi.ahk (if it exists)
-watch-configuration           Enable or disable watching of ~/komorebi.ahk (if it exists)
-float-rule                    Add a rule to always float the specified application
-manage-rule                   Add a rule to always manage the specified application
-workspace-rule                Add a rule to associate an application with a workspace
-identify-tray-application     Identify an application that closes to the system tray
-identify-border-overflow      Identify an application that has overflowing borders
-focus-follows-mouse           Enable or disable focus follows mouse for the operating system
-toggle-focus-follows-mouse    Toggle focus follows mouse for the operating system
-ahk-library                   Generate a library of AutoHotKey helper functions
-help                          Print this message or the help of the given subcommand(s)
+start                                      Start komorebi.exe as a background process
+stop                                       Stop the komorebi.exe process and restore all hidden windows
+state                                      Show a JSON representation of the current window manager state
+query                                      Query the current window manager state
+subscribe                                  Subscribe to komorebi events
+unsubscribe                                Unsubscribe from komorebi events
+log                                        Tail komorebi.exe's process logs (cancel with Ctrl-C)
+quick-save-resize                          Quicksave the current resize layout dimensions
+quick-load-resize                          Load the last quicksaved resize layout dimensions
+save-resize                                Save the current resize layout dimensions to a file
+load-resize                                Load the resize layout dimensions from a file
+focus                                      Change focus to the window in the specified direction
+move                                       Move the focused window in the specified direction
+cycle-focus                                Change focus to the window in the specified cycle direction
+cycle-move                                 Move the focused window in the specified cycle direction
+stack                                      Stack the focused window in the specified direction
+resize-edge                                Resize the focused window in the specified direction
+resize-axis                                Resize the focused window or primary column along the specified axis
+unstack                                    Unstack the focused window
+cycle-stack                                Cycle the focused stack in the specified cycle direction
+move-to-monitor                            Move the focused window to the specified monitor
+move-to-workspace                          Move the focused window to the specified workspace
+send-to-monitor                            Send the focused window to the specified monitor
+send-to-workspace                          Send the focused window to the specified workspace
+send-to-monitor-workspace                  Send the focused window to the specified monitor workspace
+focus-monitor                              Focus the specified monitor
+focus-workspace                            Focus the specified workspace on the focused monitor
+focus-monitor-workspace                    Focus the specified workspace on the target monitor
+cycle-monitor                              Focus the monitor in the given cycle direction
+cycle-workspace                            Focus the workspace in the given cycle direction
+move-workspace-to-monitor                  Move the focused workspace to the specified monitor
+new-workspace                              Create and append a new workspace on the focused monitor
+resize-delta                               Set the resize delta (used by resize-edge and resize-axis)
+invisible-borders                          Set the invisible border dimensions around each window
+work-area-offset                           Set offsets to exclude parts of the work area from tiling
+adjust-container-padding                   Adjust container padding on the focused workspace
+adjust-workspace-padding                   Adjust workspace padding on the focused workspace
+change-layout                              Set the layout on the focused workspace
+load-custom-layout                         Load a custom layout from file for the focused workspace
+flip-layout                                Flip the layout on the focused workspace (BSP only)
+promote                                    Promote the focused window to the top of the tree
+retile                                     Force the retiling of all managed windows
+ensure-workspaces                          Create at least this many workspaces for the specified monitor
+container-padding                          Set the container padding for the specified workspace
+workspace-padding                          Set the workspace padding for the specified workspace
+workspace-layout                           Set the layout for the specified workspace
+workspace-custom-layout                    Set a custom layout for the specified workspace
+workspace-layout-rule                      Add a dynamic layout rule for the specified workspace
+workspace-custom-layout-rule               Add a dynamic custom layout for the specified workspace
+clear-workspace-layout-rules               Clear all dynamic layout rules for the specified workspace
+workspace-tiling                           Enable or disable window tiling for the specified workspace
+workspace-name                             Set the workspace name for the specified workspace
+toggle-window-container-behaviour          Toggle the behaviour for new windows (stacking or dynamic tiling)
+toggle-pause                               Toggle window tiling on the focused workspace
+toggle-tiling                              Toggle window tiling on the focused workspace
+toggle-float                               Toggle floating mode for the focused window
+toggle-monocle                             Toggle monocle mode for the focused container
+toggle-maximize                            Toggle native maximization for the focused window
+restore-windows                            Restore all hidden windows (debugging command)
+manage                                     Force komorebi to manage the focused window
+unmanage                                   Unmanage a window that was forcibly managed
+reload-configuration                       Reload ~/komorebi.ahk (if it exists)
+watch-configuration                        Enable or disable watching of ~/komorebi.ahk (if it exists)
+window-hiding-behaviour                    Set the window behaviour when switching workspaces / cycling stacks
+unmanaged-window-operation-behaviour       Set the operation behaviour when the focused window is not managed
+float-rule                                 Add a rule to always float the specified application
+manage-rule                                Add a rule to always manage the specified application
+workspace-rule                             Add a rule to associate an application with a workspace
+identify-object-name-change-application    Identify an application that sends EVENT_OBJECT_NAMECHANGE on launch
+identify-tray-application                  Identify an application that closes to the system tray
+identify-layered-application               Identify an application that has WS_EX_LAYERED, but should still be managed
+identify-border-overflow-application       Identify an application that has overflowing borders
+focus-follows-mouse                        Enable or disable focus follows mouse for the operating system
+toggle-focus-follows-mouse                 Toggle focus follows mouse for the operating system
+mouse-follows-focus                        Enable or disable mouse follows focus on all workspaces
+toggle-mouse-follows-focus                 Toggle mouse follows focus on all workspaces
+ahk-library                                Generate a library of AutoHotKey helper functions
+ahk-app-specific-configuration             Generate common app-specific configurations and fixes to use in komorebi.ahk
+format-app-specific-configuration          Format a YAML file for use with the 'ahk-app-specific-configuration' command
+notification-schema                        Generate a JSON Schema of subscription notifications
+help                                       Print this message or the help of the given subcommand(s)
 ```
 
 ### AutoHotKey Helper Library for `komorebic`
@@ -359,8 +516,11 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [x] Move focused window container to workspace follow
 - [x] Send focused window container to monitor
 - [x] Send focused window container to workspace
+- [x] Move focused workspace to monitor
 - [x] Mouse follows focused container
 - [x] Resize window container in direction
+- [x] Resize window container on axis
+- [x] Set custom resize delta
 - [ ] Resize child window containers by split ratio
 - [x] Quicksave and quickload layouts with resize dimensions
 - [x] Save and load layouts with resize dimensions to/from specific files
@@ -375,6 +535,7 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [x] Main half-width window with horizontal stack layout (`vertical-stack`)
 - [x] 2x Main window (half and quarter-width) with horizontal stack layout (`ultrawide-vertical-stack`)
 - [x] Load custom layouts from JSON and YAML representations
+- [x] Dynamically select layout based on the number of open windows
 - [x] Floating rules based on exe name, window title and class
 - [x] Workspace rules based on exe name and window class
 - [x] Additional manage rules based on exe name and window class
@@ -385,6 +546,7 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [x] Toggle floating windows
 - [x] Toggle monocle window
 - [x] Toggle native maximization
+- [x] Toggle mouse follows focus
 - [x] Toggle Xmouse/Windows focus follows mouse implementation
 - [x] Toggle Komorebi focus follows mouse implementation (desktop and system tray-aware)
 - [x] Toggle automatic tiling
@@ -470,16 +632,16 @@ Note that you do not have to include the full path of the named pipe, just the n
 If the named pipe exists, `komorebi` will start pushing JSON data of successfully handled events and messages:
 
 ```json lines
-{"event":{"type":"AddSubscriber","content":"yasb"},"state":{...}}
-{"event":{"type":"FocusWindow","content":"Left"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":131444,"title":"komorebi – README.md","exe":"idea64.exe","class":"SunAwtFrame","rect":{"left":13,"top":60,"right":1520,"bottom":1655}}]},"state":{...}}
-{"event":{"type":"MonitorPoll","content":["ObjectCreate",{"hwnd":5572450,"title":"OLEChannelWnd","exe":"explorer.exe","class":"OleMainThreadWndClass","rect":{"left":0,"top":0,"right":0,"bottom":0}}]},"state":{...}}
-{"event":{"type":"FocusWindow","content":"Right"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}...}
-{"event":{"type":"FocusWindow","content":"Down"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":329264,"title":"den — Mozilla Firefox","exe":"firefox.exe","class":"MozillaWindowClass","rect":{"left":1539,"top":894,"right":1520,"bottom":821}}]},"state":{...}}
-{"event":{"type":"FocusWindow","content":"Up"},"state":{...}}
-{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{...}}
+{"event":{"type":"AddSubscriber","content":"yasb"},"state":{}}
+{"event":{"type":"FocusWindow","content":"Left"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":131444,"title":"komorebi – README.md","exe":"idea64.exe","class":"SunAwtFrame","rect":{"left":13,"top":60,"right":1520,"bottom":1655}}]},"state":{}}
+{"event":{"type":"MonitorPoll","content":["ObjectCreate",{"hwnd":5572450,"title":"OLEChannelWnd","exe":"explorer.exe","class":"OleMainThreadWndClass","rect":{"left":0,"top":0,"right":0,"bottom":0}}]},"state":{}}
+{"event":{"type":"FocusWindow","content":"Right"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusWindow","content":"Down"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":329264,"title":"den — Mozilla Firefox","exe":"firefox.exe","class":"MozillaWindowClass","rect":{"left":1539,"top":894,"right":1520,"bottom":821}}]},"state":{}}
+{"event":{"type":"FocusWindow","content":"Up"},"state":{}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}}
 ```
 
 You may then filter on the `type` key to listen to the events that you are interested in. For a full list of possible
@@ -489,3 +651,10 @@ in `komorebi-core`.
 An example of how to create a named pipe and a subscription to `komorebi`'s handled events in Python
 by [@denBot](https://github.com/denBot) can be
 found [here](https://gist.github.com/denBot/4136279812f87819f86d99eba77c1ee0).
+
+### Subscription Event Notification Schema
+
+A [JSON Schema](https://json-schema.org/) of the event notifications emitted to subscribers can be generated with
+the `komorebic notification-schema` command. The output of this command can be redirected to the clipboard or a file,
+which can be used with services such as [Quicktype](https://app.quicktype.io/) to generate type definitions in different
+programming languages.

bindings/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "bindings"
-version = "0.1.0"
-authors = ["Jade Iqbal"]
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-windows = "0.21"
-
-[build-dependencies]
-windows = "0.21"

bindings/build.rs

@@ -1,26 +0,0 @@
-fn main() {
-    windows::build!(
-        Windows::Win32::Foundation::RECT,
-        Windows::Win32::Foundation::POINT,
-        Windows::Win32::Foundation::BOOL,
-        Windows::Win32::Foundation::PWSTR,
-        Windows::Win32::Foundation::HWND,
-        Windows::Win32::Foundation::LPARAM,
-        // error: `Windows.Win32.Graphics.Dwm.DWMWA_CLOAKED` not found in metadata
-        Windows::Win32::Graphics::Dwm::*,
-        // error: `Windows.Win32.Graphics.Gdi.MONITOR_DEFAULTTONEAREST` not found in metadata
-        Windows::Win32::Graphics::Gdi::*,
-        Windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS,
-        Windows::Win32::System::Threading::PROCESS_NAME_FORMAT,
-        Windows::Win32::System::Threading::OpenProcess,
-        Windows::Win32::System::Threading::QueryFullProcessImageNameW,
-        Windows::Win32::System::Threading::GetCurrentThreadId,
-        Windows::Win32::System::Threading::AttachThreadInput,
-        Windows::Win32::System::Threading::GetCurrentProcessId,
-        Windows::Win32::UI::KeyboardAndMouseInput::SetFocus,
-        Windows::Win32::UI::Accessibility::SetWinEventHook,
-        Windows::Win32::UI::Accessibility::HWINEVENTHOOK,
-        // error: `Windows.Win32.UI.WindowsAndMessaging.GWL_EXSTYLE` not found in metadata
-        Windows::Win32::UI::WindowsAndMessaging::*,
-    );
-}

bindings/src/lib.rs

@@ -1,4 +0,0 @@
-pub use windows::Handle;
-pub use windows::Result;
-
-::windows::include_bindings!();

justfile

@@ -0,0 +1,42 @@
+set shell := ["cmd.exe", "/C"]
+export RUST_BACKTRACE := "full"
+
+clean:
+    cargo clean
+
+fmt:
+    cargo +nightly fmt
+    cargo +nightly clippy
+    prettier --write README.md
+
+install-komorebic:
+    cargo +stable install --path komorebic --locked
+
+install-komorebi:
+    cargo +stable install --path komorebi --locked
+
+install:
+    just install-komorebic
+    just install-komorebi
+    komorebic ahk-library
+    cat '%USERPROFILE%\.config\komorebi\komorebic.lib.ahk' > komorebic.lib.sample.ahk
+
+run:
+    just install-komorebic
+    cargo +stable run --bin komorebi --locked
+
+warn $RUST_LOG="warn":
+    just run
+
+info $RUST_LOG="info":
+    just run
+
+debug $RUST_LOG="debug":
+    just run
+
+trace $RUST_LOG="trace":
+    just run
+
+deadlock $RUST_LOG="trace":
+    just install-komorebic
+    cargo +stable run --bin komorebi --locked --features deadlock_detection

komorebi-core/Cargo.toml

@@ -1,16 +1,21 @@
 [package]
 name = "komorebi-core"
-version = "0.1.6"
+version = "0.1.8"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bindings = { package = "bindings", path = "../bindings" }
-
-clap = "3.0.0-beta.4"
-color-eyre = "0.5"
+clap = { version = "3", features = ["derive"] }
+color-eyre = "0.6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.8"
-strum = { version = "0.21", features = ["derive"] }
+strum = { version = "0.24", features = ["derive"] }
+schemars = "0.8"
+
+[dependencies.windows]
+version = "0.35"
+features = [
+    "Win32_Foundation",
+]

komorebi-core/src/arrangement.rs

@@ -1,6 +1,7 @@
 use std::num::NonZeroUsize;
 
 use clap::ArgEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -19,7 +20,7 @@ pub trait Arrangement {
         area: &Rect,
         len: NonZeroUsize,
         container_padding: Option<i32>,
-        layout_flip: Option<Flip>,
+        layout_flip: Option<Axis>,
         resize_dimensions: &[Option<Rect>],
     ) -> Vec<Rect>;
 }
@@ -31,21 +32,21 @@ impl Arrangement for DefaultLayout {
         area: &Rect,
         len: NonZeroUsize,
         container_padding: Option<i32>,
-        layout_flip: Option<Flip>,
+        layout_flip: Option<Axis>,
         resize_dimensions: &[Option<Rect>],
     ) -> Vec<Rect> {
         let len = usize::from(len);
         let mut dimensions = match self {
-            DefaultLayout::BSP => recursive_fibonacci(
+            Self::BSP => recursive_fibonacci(
                 0,
                 len,
                 area,
                 layout_flip,
                 calculate_resize_adjustments(resize_dimensions),
             ),
-            DefaultLayout::Columns => columns(area, len),
-            DefaultLayout::Rows => rows(area, len),
-            DefaultLayout::VerticalStack => {
+            Self::Columns => columns(area, len),
+            Self::Rows => rows(area, len),
+            Self::VerticalStack => {
                 let mut layouts: Vec<Rect> = vec![];
 
                 let primary_right = match len {
@@ -57,7 +58,7 @@ impl Arrangement for DefaultLayout {
                 let mut stack_left = area.left + primary_right;
 
                 match layout_flip {
-                    Some(Flip::Horizontal | Flip::HorizontalAndVertical) if len > 1 => {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
                         main_left = main_left + area.right - primary_right;
                         stack_left = area.left;
                     }
@@ -87,7 +88,7 @@ impl Arrangement for DefaultLayout {
 
                 layouts
             }
-            DefaultLayout::HorizontalStack => {
+            Self::HorizontalStack => {
                 let mut layouts: Vec<Rect> = vec![];
 
                 let bottom = match len {
@@ -99,7 +100,7 @@ impl Arrangement for DefaultLayout {
                 let mut stack_top = area.top + bottom;
 
                 match layout_flip {
-                    Some(Flip::Vertical | Flip::HorizontalAndVertical) if len > 1 => {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) if len > 1 => {
                         main_top = main_top + area.bottom - bottom;
                         stack_top = area.top;
                     }
@@ -129,7 +130,7 @@ impl Arrangement for DefaultLayout {
 
                 layouts
             }
-            DefaultLayout::UltrawideVerticalStack => {
+            Self::UltrawideVerticalStack => {
                 let mut layouts: Vec<Rect> = vec![];
 
                 let primary_right = match len {
@@ -150,7 +151,7 @@ impl Arrangement for DefaultLayout {
                         let mut secondary = area.left;
 
                         match layout_flip {
-                            Some(Flip::Horizontal | Flip::HorizontalAndVertical) if len > 1 => {
+                            Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
                                 primary = area.left;
                                 secondary = area.left + primary_right;
                             }
@@ -165,7 +166,7 @@ impl Arrangement for DefaultLayout {
                         let mut stack = area.left + primary_right + secondary_right;
 
                         match layout_flip {
-                            Some(Flip::Horizontal | Flip::HorizontalAndVertical) if len > 1 => {
+                            Some(Axis::Horizontal | Axis::HorizontalAndVertical) if len > 1 => {
                                 secondary = area.left + primary_right + secondary_right;
                                 stack = area.left;
                             }
@@ -224,7 +225,7 @@ impl Arrangement for CustomLayout {
         area: &Rect,
         len: NonZeroUsize,
         container_padding: Option<i32>,
-        _layout_flip: Option<Flip>,
+        _layout_flip: Option<Axis>,
         _resize_dimensions: &[Option<Rect>],
     ) -> Vec<Rect> {
         let mut dimensions = vec![];
@@ -341,9 +342,9 @@ impl Arrangement for CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
-pub enum Flip {
+pub enum Axis {
     Horizontal,
     Vertical,
     HorizontalAndVertical,
@@ -474,11 +475,12 @@ fn calculate_resize_adjustments(resize_dimensions: &[Option<Rect>]) -> Vec<Optio
     cleaned_resize_adjustments
 }
 
+#[allow(clippy::only_used_in_recursion)]
 fn recursive_fibonacci(
     idx: usize,
     count: usize,
     area: &Rect,
-    layout_flip: Option<Flip>,
+    layout_flip: Option<Axis>,
     resize_adjustments: Vec<Option<Rect>>,
 ) -> Vec<Rect> {
     let mut a = *area;
@@ -502,21 +504,21 @@ fn recursive_fibonacci(
 
     if let Some(flip) = layout_flip {
         match flip {
-            Flip::Horizontal => {
+            Axis::Horizontal => {
                 main_x = resized.left + half_width + (half_width - half_resized_width);
                 alt_x = resized.left;
 
                 alt_y = resized.top + half_resized_height;
                 main_y = resized.top;
             }
-            Flip::Vertical => {
+            Axis::Vertical => {
                 main_y = resized.top + half_height + (half_height - half_resized_height);
                 alt_y = resized.top;
 
                 main_x = resized.left;
                 alt_x = resized.left + half_resized_width;
             }
-            Flip::HorizontalAndVertical => {
+            Axis::HorizontalAndVertical => {
                 main_x = resized.left + half_width + (half_width - half_resized_width);
                 alt_x = resized.left;
                 main_y = resized.top + half_height + (half_height - half_resized_height);

komorebi-core/src/config_generation.rs

@@ -0,0 +1,176 @@
+use clap::ArgEnum;
+use color_eyre::Result;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use strum::Display;
+use strum::EnumString;
+
+use crate::ApplicationIdentifier;
+
+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+#[serde(rename_all = "snake_case")]
+pub enum ApplicationOptions {
+    ObjectNameChange,
+    Layered,
+    BorderOverflow,
+    TrayAndMultiWindow,
+    Force,
+}
+
+impl ApplicationOptions {
+    #[must_use]
+    pub fn cfgen(&self, kind: &ApplicationIdentifier, id: &str) -> String {
+        format!(
+            "Run, {}, , Hide",
+            match self {
+                ApplicationOptions::ObjectNameChange => {
+                    format!(
+                        "komorebic.exe identify-object-name-change-application {} \"{}\"",
+                        kind, id
+                    )
+                }
+                ApplicationOptions::Layered => {
+                    format!(
+                        "komorebic.exe identify-layered-application {} \"{}\"",
+                        kind, id
+                    )
+                }
+                ApplicationOptions::BorderOverflow => {
+                    format!(
+                        "komorebic.exe identify-border-overflow-application {} \"{}\"",
+                        kind, id
+                    )
+                }
+                ApplicationOptions::TrayAndMultiWindow => {
+                    format!(
+                        "komorebic.exe identify-tray-application {} \"{}\"",
+                        kind, id
+                    )
+                }
+                ApplicationOptions::Force => {
+                    format!("komorebic.exe manage-rule {} \"{}\"", kind, id)
+                }
+            }
+        )
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct IdWithIdentifier {
+    kind: ApplicationIdentifier,
+    id: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct IdWithIdentifierAndComment {
+    kind: ApplicationIdentifier,
+    id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    comment: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct ApplicationConfiguration {
+    name: String,
+    identifier: IdWithIdentifier,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    options: Option<Vec<ApplicationOptions>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    float_identifiers: Option<Vec<IdWithIdentifierAndComment>>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct ApplicationConfigurationGenerator;
+
+impl ApplicationConfigurationGenerator {
+    fn load(content: &str) -> Result<Vec<ApplicationConfiguration>> {
+        Ok(serde_yaml::from_str(content)?)
+    }
+
+    pub fn format(content: &str) -> Result<String> {
+        let mut cfgen = Self::load(content)?;
+        cfgen.sort_by(|a, b| a.name.cmp(&b.name));
+        Ok(serde_yaml::to_string(&cfgen)?)
+    }
+
+    fn merge(base_content: &str, override_content: &str) -> Result<Vec<ApplicationConfiguration>> {
+        let base_cfgen = Self::load(base_content)?;
+        let override_cfgen = Self::load(override_content)?;
+
+        let mut final_cfgen = base_cfgen.clone();
+
+        for entry in override_cfgen {
+            let mut replace_idx = None;
+            for (idx, base_entry) in base_cfgen.iter().enumerate() {
+                if base_entry.name == entry.name {
+                    replace_idx = Option::from(idx);
+                }
+            }
+
+            match replace_idx {
+                None => final_cfgen.push(entry),
+                Some(idx) => final_cfgen[idx] = entry,
+            }
+        }
+
+        Ok(final_cfgen)
+    }
+
+    pub fn generate_ahk(base_content: &str, override_content: Option<&str>) -> Result<Vec<String>> {
+        let mut cfgen = if let Some(override_content) = override_content {
+            Self::merge(base_content, override_content)?
+        } else {
+            Self::load(base_content)?
+        };
+
+        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::from("")
+        ];
+
+        let mut float_rules = vec![];
+
+        for app in cfgen {
+            lines.push(format!("; {}", app.name));
+            if let Some(options) = app.options {
+                for opt in options {
+                    if let ApplicationOptions::TrayAndMultiWindow = opt {
+                        lines.push(String::from("; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line"));
+                    }
+
+                    lines.push(opt.cfgen(&app.identifier.kind, &app.identifier.id));
+                }
+            }
+
+            if let Some(float_identifiers) = app.float_identifiers {
+                for float in float_identifiers {
+                    let float_rule = format!(
+                        "Run, komorebic.exe float-rule {} \"{}\", , Hide",
+                        float.kind, float.id
+                    );
+
+                    // Don't want to send duped signals especially as configs get larger
+                    if !float_rules.contains(&float_rule) {
+                        float_rules.push(float_rule.clone());
+
+                        if let Some(comment) = float.comment {
+                            lines.push(format!("; {}", comment));
+                        };
+
+                        lines.push(float_rule);
+                    }
+                }
+            }
+
+            lines.push(String::from(""));
+        }
+
+        Ok(lines)
+    }
+}

komorebi-core/src/custom_layout.rs

@@ -2,16 +2,18 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::io::BufReader;
 use std::ops::Deref;
+use std::ops::DerefMut;
 use std::path::PathBuf;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::Rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub struct CustomLayout(Vec<Column>);
 
 impl Deref for CustomLayout {
@@ -22,6 +24,12 @@ impl Deref for CustomLayout {
     }
 }
 
+impl DerefMut for CustomLayout {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 impl CustomLayout {
     pub fn from_path_buf(path: PathBuf) -> Result<Self> {
         let invalid_filetype = anyhow!("custom layouts must be json or yaml files");
@@ -75,6 +83,14 @@ impl CustomLayout {
         None
     }
 
+    pub fn set_primary_width_percentage(&mut self, percentage: usize) {
+        for column in self.iter_mut() {
+            if let Column::Primary(Option::Some(ColumnWidth::WidthPercentage(current))) = column {
+                *current = percentage;
+            }
+        }
+    }
+
     #[must_use]
     pub fn is_valid(&self) -> bool {
         // A valid layout must have at least one column
@@ -236,7 +252,7 @@ impl CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "column", content = "configuration")]
 pub enum Column {
     Primary(Option<ColumnWidth>),
@@ -244,18 +260,18 @@ pub enum Column {
     Tertiary(ColumnSplit),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnWidth {
     WidthPercentage(usize),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnSplit {
     Horizontal,
     Vertical,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum ColumnSplitWithCapacity {
     Horizontal(usize),
     Vertical(usize),

komorebi-core/src/cycle_direction.rs

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

komorebi-core/src/default_layout.rs

@@ -1,4 +1,5 @@
 use clap::ArgEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -8,7 +9,7 @@ use crate::OperationDirection;
 use crate::Rect;
 use crate::Sizing;
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum DefaultLayout {
     BSP,
@@ -21,14 +22,14 @@ pub enum DefaultLayout {
 
 impl DefaultLayout {
     #[must_use]
-    #[allow(clippy::cast_precision_loss)]
+    #[allow(clippy::cast_precision_loss, clippy::only_used_in_recursion)]
     pub fn resize(
         &self,
         unaltered: &Rect,
         resize: &Option<Rect>,
         edge: OperationDirection,
         sizing: Sizing,
-        step: Option<i32>,
+        delta: i32,
     ) -> Option<Rect> {
         if !matches!(self, Self::BSP) {
             return None;
@@ -37,7 +38,7 @@ impl DefaultLayout {
         let max_divisor = 1.005;
         let mut r = resize.unwrap_or_default();
 
-        let resize_step = step.unwrap_or(50);
+        let resize_delta = delta;
 
         match edge {
             OperationDirection::Left => match sizing {
@@ -52,65 +53,65 @@ impl DefaultLayout {
                     // with index 0. I don't think it's worth trying to defensively program
                     // against this; if people end up in this situation they are better off
                     // just hitting the retile command
-                    let diff = ((r.left + -resize_step) as f32).abs();
+                    let diff = ((r.left + -resize_delta) as f32).abs();
                     let max = unaltered.right as f32 / max_divisor;
                     if diff < max {
-                        r.left += -resize_step;
+                        r.left += -resize_delta;
                     }
                 }
                 Sizing::Decrease => {
-                    let diff = ((r.left - -resize_step) as f32).abs();
+                    let diff = ((r.left - -resize_delta) as f32).abs();
                     let max = unaltered.right as f32 / max_divisor;
                     if diff < max {
-                        r.left -= -resize_step;
+                        r.left -= -resize_delta;
                     }
                 }
             },
             OperationDirection::Up => match sizing {
                 Sizing::Increase => {
-                    let diff = ((r.top + resize_step) as f32).abs();
+                    let diff = ((r.top + resize_delta) as f32).abs();
                     let max = unaltered.bottom as f32 / max_divisor;
                     if diff < max {
-                        r.top += -resize_step;
+                        r.top += -resize_delta;
                     }
                 }
                 Sizing::Decrease => {
-                    let diff = ((r.top - resize_step) as f32).abs();
+                    let diff = ((r.top - resize_delta) as f32).abs();
                     let max = unaltered.bottom as f32 / max_divisor;
                     if diff < max {
-                        r.top -= -resize_step;
+                        r.top -= -resize_delta;
                     }
                 }
             },
             OperationDirection::Right => match sizing {
                 Sizing::Increase => {
-                    let diff = ((r.right + resize_step) as f32).abs();
+                    let diff = ((r.right + resize_delta) as f32).abs();
                     let max = unaltered.right as f32 / max_divisor;
                     if diff < max {
-                        r.right += resize_step;
+                        r.right += resize_delta;
                     }
                 }
                 Sizing::Decrease => {
-                    let diff = ((r.right - resize_step) as f32).abs();
+                    let diff = ((r.right - resize_delta) as f32).abs();
                     let max = unaltered.right as f32 / max_divisor;
                     if diff < max {
-                        r.right -= resize_step;
+                        r.right -= resize_delta;
                     }
                 }
             },
             OperationDirection::Down => match sizing {
                 Sizing::Increase => {
-                    let diff = ((r.bottom + resize_step) as f32).abs();
+                    let diff = ((r.bottom + resize_delta) as f32).abs();
                     let max = unaltered.bottom as f32 / max_divisor;
                     if diff < max {
-                        r.bottom += resize_step;
+                        r.bottom += resize_delta;
                     }
                 }
                 Sizing::Decrease => {
-                    let diff = ((r.bottom - resize_step) as f32).abs();
+                    let diff = ((r.bottom - resize_delta) as f32).abs();
                     let max = unaltered.bottom as f32 / max_divisor;
                     if diff < max {
-                        r.bottom -= resize_step;
+                        r.bottom -= resize_delta;
                     }
                 }
             },

komorebi-core/src/direction.rs

@@ -72,34 +72,34 @@ impl Direction for DefaultLayout {
     ) -> bool {
         match op_direction {
             OperationDirection::Up => match self {
-                DefaultLayout::BSP => count > 2 && idx != 0 && idx != 1,
-                DefaultLayout::Columns => false,
-                DefaultLayout::Rows | DefaultLayout::HorizontalStack => idx != 0,
-                DefaultLayout::VerticalStack => idx != 0 && idx != 1,
-                DefaultLayout::UltrawideVerticalStack => idx > 2,
+                Self::BSP => count > 2 && idx != 0 && idx != 1,
+                Self::Columns => false,
+                Self::Rows | Self::HorizontalStack => idx != 0,
+                Self::VerticalStack => idx != 0 && idx != 1,
+                Self::UltrawideVerticalStack => idx > 2,
             },
             OperationDirection::Down => match self {
-                DefaultLayout::BSP => count > 2 && idx != count - 1 && idx % 2 != 0,
-                DefaultLayout::Columns => false,
-                DefaultLayout::Rows => idx != count - 1,
-                DefaultLayout::VerticalStack => idx != 0 && idx != count - 1,
-                DefaultLayout::HorizontalStack => idx == 0,
-                DefaultLayout::UltrawideVerticalStack => idx > 1 && idx != count - 1,
+                Self::BSP => count > 2 && idx != count - 1 && idx % 2 != 0,
+                Self::Columns => false,
+                Self::Rows => idx != count - 1,
+                Self::VerticalStack => idx != 0 && idx != count - 1,
+                Self::HorizontalStack => idx == 0,
+                Self::UltrawideVerticalStack => idx > 1 && idx != count - 1,
             },
             OperationDirection::Left => match self {
-                DefaultLayout::BSP => count > 1 && idx != 0,
-                DefaultLayout::Columns | DefaultLayout::VerticalStack => idx != 0,
-                DefaultLayout::Rows => false,
-                DefaultLayout::HorizontalStack => idx != 0 && idx != 1,
-                DefaultLayout::UltrawideVerticalStack => count > 1 && idx != 1,
+                Self::BSP => count > 1 && idx != 0,
+                Self::Columns | Self::VerticalStack => idx != 0,
+                Self::Rows => false,
+                Self::HorizontalStack => idx != 0 && idx != 1,
+                Self::UltrawideVerticalStack => count > 1 && idx != 1,
             },
             OperationDirection::Right => match self {
-                DefaultLayout::BSP => count > 1 && idx % 2 == 0 && idx != count - 1,
-                DefaultLayout::Columns => idx != count - 1,
-                DefaultLayout::Rows => false,
-                DefaultLayout::VerticalStack => idx == 0,
-                DefaultLayout::HorizontalStack => idx != 0 && idx != count - 1,
-                DefaultLayout::UltrawideVerticalStack => match count {
+                Self::BSP => count > 1 && idx % 2 == 0 && idx != count - 1,
+                Self::Columns => idx != count - 1,
+                Self::Rows => false,
+                Self::VerticalStack => idx == 0,
+                Self::HorizontalStack => idx != 0 && idx != count - 1,
+                Self::UltrawideVerticalStack => match count {
                     0 | 1 => false,
                     2 => idx != 0,
                     _ => idx < 2,
@@ -110,45 +110,40 @@ impl Direction for DefaultLayout {
 
     fn up_index(&self, idx: usize) -> usize {
         match self {
-            DefaultLayout::BSP => {
+            Self::BSP => {
                 if idx % 2 == 0 {
                     idx - 1
                 } else {
                     idx - 2
                 }
             }
-            DefaultLayout::Columns => unreachable!(),
-            DefaultLayout::Rows
-            | DefaultLayout::VerticalStack
-            | DefaultLayout::UltrawideVerticalStack => idx - 1,
-            DefaultLayout::HorizontalStack => 0,
+            Self::Columns => unreachable!(),
+            Self::Rows | Self::VerticalStack | Self::UltrawideVerticalStack => idx - 1,
+            Self::HorizontalStack => 0,
         }
     }
 
     fn down_index(&self, idx: usize) -> usize {
         match self {
-            DefaultLayout::BSP
-            | DefaultLayout::Rows
-            | DefaultLayout::VerticalStack
-            | DefaultLayout::UltrawideVerticalStack => idx + 1,
-            DefaultLayout::Columns => unreachable!(),
-            DefaultLayout::HorizontalStack => 1,
+            Self::BSP | Self::Rows | Self::VerticalStack | Self::UltrawideVerticalStack => idx + 1,
+            Self::Columns => unreachable!(),
+            Self::HorizontalStack => 1,
         }
     }
 
     fn left_index(&self, idx: usize) -> usize {
         match self {
-            DefaultLayout::BSP => {
+            Self::BSP => {
                 if idx % 2 == 0 {
                     idx - 2
                 } else {
                     idx - 1
                 }
             }
-            DefaultLayout::Columns | DefaultLayout::HorizontalStack => idx - 1,
-            DefaultLayout::Rows => unreachable!(),
-            DefaultLayout::VerticalStack => 0,
-            DefaultLayout::UltrawideVerticalStack => match idx {
+            Self::Columns | Self::HorizontalStack => idx - 1,
+            Self::Rows => unreachable!(),
+            Self::VerticalStack => 0,
+            Self::UltrawideVerticalStack => match idx {
                 0 => 1,
                 1 => unreachable!(),
                 _ => 0,
@@ -158,10 +153,10 @@ impl Direction for DefaultLayout {
 
     fn right_index(&self, idx: usize) -> usize {
         match self {
-            DefaultLayout::BSP | DefaultLayout::Columns | DefaultLayout::HorizontalStack => idx + 1,
-            DefaultLayout::Rows => unreachable!(),
-            DefaultLayout::VerticalStack => 1,
-            DefaultLayout::UltrawideVerticalStack => match idx {
+            Self::BSP | Self::Columns | Self::HorizontalStack => idx + 1,
+            Self::Rows => unreachable!(),
+            Self::VerticalStack => 1,
+            Self::UltrawideVerticalStack => match idx {
                 1 => 0,
                 0 => 2,
                 _ => unreachable!(),

komorebi-core/src/layout.rs

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

komorebi-core/src/lib.rs

@@ -1,18 +1,19 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::missing_errors_doc, clippy::use_self)]
 
 use std::path::PathBuf;
 use std::str::FromStr;
 
 use clap::ArgEnum;
 use color_eyre::Result;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
 pub use arrangement::Arrangement;
-pub use arrangement::Flip;
+pub use arrangement::Axis;
 pub use custom_layout::CustomLayout;
 pub use cycle_direction::CycleDirection;
 pub use default_layout::DefaultLayout;
@@ -22,6 +23,7 @@ pub use operation_direction::OperationDirection;
 pub use rect::Rect;
 
 pub mod arrangement;
+pub mod config_generation;
 pub mod custom_layout;
 pub mod cycle_direction;
 pub mod default_layout;
@@ -30,7 +32,7 @@ pub mod layout;
 pub mod operation_direction;
 pub mod rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display)]
+#[derive(Clone, Debug, Serialize, Deserialize, Display, JsonSchema)]
 #[serde(tag = "type", content = "content")]
 pub enum SocketMessage {
     // Window / Container Commands
@@ -39,17 +41,23 @@ pub enum SocketMessage {
     CycleFocusWindow(CycleDirection),
     CycleMoveWindow(CycleDirection),
     StackWindow(OperationDirection),
-    ResizeWindow(OperationDirection, Sizing),
+    ResizeWindowEdge(OperationDirection, Sizing),
+    ResizeWindowAxis(Axis, Sizing),
     UnstackWindow,
     CycleStack(CycleDirection),
     MoveContainerToMonitorNumber(usize),
     MoveContainerToWorkspaceNumber(usize),
     SendContainerToMonitorNumber(usize),
     SendContainerToWorkspaceNumber(usize),
+    SendContainerToMonitorWorkspaceNumber(usize, usize),
+    MoveWorkspaceToMonitorNumber(usize),
     Promote,
     ToggleFloat,
     ToggleMonocle,
     ToggleMaximize,
+    ToggleWindowContainerBehaviour,
+    WindowHidingBehaviour(HidingBehaviour),
+    UnmanagedWindowOperationBehaviour(OperationBehaviour),
     // Current Workspace Commands
     ManageFocusedWindow,
     UnmanageFocusedWindow,
@@ -57,7 +65,7 @@ pub enum SocketMessage {
     AdjustWorkspacePadding(Sizing, i32),
     ChangeLayout(DefaultLayout),
     ChangeLayoutCustom(PathBuf),
-    FlipLayout(Flip),
+    FlipLayout(Axis),
     // Monitor and Workspace Commands
     EnsureWorkspaces(usize, usize),
     NewWorkspace,
@@ -73,28 +81,38 @@ pub enum SocketMessage {
     CycleFocusWorkspace(CycleDirection),
     FocusMonitorNumber(usize),
     FocusWorkspaceNumber(usize),
+    FocusMonitorWorkspaceNumber(usize, usize),
     ContainerPadding(usize, usize, i32),
     WorkspacePadding(usize, usize, i32),
     WorkspaceTiling(usize, usize, bool),
     WorkspaceName(usize, usize, String),
     WorkspaceLayout(usize, usize, DefaultLayout),
     WorkspaceLayoutCustom(usize, usize, PathBuf),
+    WorkspaceLayoutRule(usize, usize, usize, DefaultLayout),
+    WorkspaceLayoutCustomRule(usize, usize, usize, PathBuf),
+    ClearWorkspaceLayoutRules(usize, usize),
     // Configuration
     ReloadConfiguration,
     WatchConfiguration(bool),
     InvisibleBorders(Rect),
     WorkAreaOffset(Rect),
+    ResizeDelta(i32),
     WorkspaceRule(ApplicationIdentifier, String, usize, usize),
     FloatRule(ApplicationIdentifier, String),
     ManageRule(ApplicationIdentifier, String),
+    IdentifyObjectNameChangeApplication(ApplicationIdentifier, String),
     IdentifyTrayApplication(ApplicationIdentifier, String),
-    IdentifyBorderOverflow(ApplicationIdentifier, String),
+    IdentifyLayeredApplication(ApplicationIdentifier, String),
+    IdentifyBorderOverflowApplication(ApplicationIdentifier, String),
     State,
     Query(StateQuery),
     FocusFollowsMouse(FocusFollowsMouseImplementation, bool),
     ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
+    MouseFollowsFocus(bool),
+    ToggleMouseFollowsFocus,
     AddSubscriber(String),
     RemoveSubscriber(String),
+    NotificationSchema,
 }
 
 impl SocketMessage {
@@ -111,7 +129,7 @@ impl FromStr for SocketMessage {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum StateQuery {
     FocusedMonitorIndex,
@@ -120,22 +138,44 @@ pub enum StateQuery {
     FocusedWindowIndex,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
+#[serde(rename_all = "snake_case")]
 pub enum ApplicationIdentifier {
     Exe,
     Class,
     Title,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum FocusFollowsMouseImplementation {
     Komorebi,
     Windows,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+pub enum WindowContainerBehaviour {
+    Create,
+    Append,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+pub enum HidingBehaviour {
+    Hide,
+    Minimize,
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+pub enum OperationBehaviour {
+    Op,
+    NoOp,
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum Sizing {
     Increase,
@@ -146,8 +186,8 @@ impl Sizing {
     #[must_use]
     pub const fn adjust_by(&self, value: i32, adjustment: i32) -> i32 {
         match self {
-            Sizing::Increase => value + adjustment,
-            Sizing::Decrease => {
+            Self::Increase => value + adjustment,
+            Self::Decrease => {
                 if value > 0 && value - adjustment >= 0 {
                     value - adjustment
                 } else {

komorebi-core/src/operation_direction.rs

@@ -1,15 +1,16 @@
 use std::num::NonZeroUsize;
 
 use clap::ArgEnum;
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
 use crate::direction::Direction;
-use crate::Flip;
+use crate::Axis;
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum OperationDirection {
     Left,
@@ -29,23 +30,23 @@ impl OperationDirection {
         }
     }
 
-    fn flip(self, layout_flip: Option<Flip>) -> Self {
+    fn flip(self, layout_flip: Option<Axis>) -> Self {
         layout_flip.map_or(self, |flip| match self {
             Self::Left => match flip {
-                Flip::Horizontal | Flip::HorizontalAndVertical => Self::Right,
-                Flip::Vertical => self,
+                Axis::Horizontal | Axis::HorizontalAndVertical => Self::Right,
+                Axis::Vertical => self,
             },
             Self::Right => match flip {
-                Flip::Horizontal | Flip::HorizontalAndVertical => Self::Left,
-                Flip::Vertical => self,
+                Axis::Horizontal | Axis::HorizontalAndVertical => Self::Left,
+                Axis::Vertical => self,
             },
             Self::Up => match flip {
-                Flip::Vertical | Flip::HorizontalAndVertical => Self::Down,
-                Flip::Horizontal => self,
+                Axis::Vertical | Axis::HorizontalAndVertical => Self::Down,
+                Axis::Horizontal => self,
             },
             Self::Down => match flip {
-                Flip::Vertical | Flip::HorizontalAndVertical => Self::Up,
-                Flip::Horizontal => self,
+                Axis::Vertical | Axis::HorizontalAndVertical => Self::Up,
+                Axis::Horizontal => self,
             },
         })
     }
@@ -54,7 +55,7 @@ impl OperationDirection {
     pub fn destination(
         self,
         layout: &dyn Direction,
-        layout_flip: Option<Flip>,
+        layout_flip: Option<Axis>,
         idx: usize,
         len: NonZeroUsize,
     ) -> Option<usize> {

komorebi-core/src/rect.rs

@@ -1,9 +1,9 @@
+use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
+use windows::Win32::Foundation::RECT;
 
-use bindings::Windows::Win32::Foundation::RECT;
-
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq, JsonSchema)]
 pub struct Rect {
     pub left: i32,
     pub top: i32,

komorebi.sample.with.lib.ahk

@@ -1,6 +1,9 @@
 #SingleInstance Force
 #Include %A_ScriptDir%\komorebic.lib.ahk
 
+; Default to minimizing windows when switching workspaces
+WindowHidingBehaviour("minimize")
+
 ; Enable hot reloading of changes to this file
 WatchConfiguration("enable")
 
@@ -34,7 +37,7 @@ WorkspaceTiling(0, 4, "disable") ; Everything floats here
 
 ; Configure floating rules
 FloatRule("class", "SunAwtDialog") ; All the IntelliJ popups
-FloatRule("title", "Control Panek")
+FloatRule("title", "Control Panel")
 FloatRule("class", "TaskManagerWindow")
 FloatRule("exe", "Wally.exe")
 FloatRule("exe", "wincompose.exe")

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.6"
+version = "0.1.8"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -11,12 +11,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bindings = { package = "bindings", path = "../bindings" }
 komorebi-core = { path = "../komorebi-core" }
 
 bitflags = "1"
-clap = "3.0.0-beta.4"
-color-eyre = "0.5"
+clap = { version = "3", features = ["derive"] }
+color-eyre = "0.6"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 ctrlc = "3"
@@ -25,20 +24,34 @@ getset = "0.1"
 hotwatch = "0.4"
 lazy_static = "1"
 nanoid = "0.4"
-parking_lot = { version = "0.11", features = ["deadlock_detection"] }
+parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 paste = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-strum = { version = "0.21", features = ["derive"] }
-sysinfo = "0.20"
+strum = { version = "0.24", features = ["derive"] }
+sysinfo = "0.23"
 tracing = "0.1"
-tracing-appender = "0.1"
-tracing-subscriber = "0.2"
+tracing-appender = "0.2"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uds_windows = "1"
 which = "4"
 winput = "0.2"
-winvd = "0.0.20"
-miow = "0.3"
+miow = "0.4"
+winreg = "0.10"
+schemars = "0.8"
+
+[dependencies.windows]
+version = "0.35"
+features = [
+    "Win32_Foundation",
+    "Win32_Graphics_Dwm",
+    "Win32_Graphics_Gdi",
+    "Win32_System_Threading",
+    "Win32_System_RemoteDesktop",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Accessibility",
+    "Win32_UI_WindowsAndMessaging"
+]
 
 [features]
 deadlock_detection = []

komorebi/src/container.rs

@@ -2,12 +2,13 @@ use std::collections::VecDeque;
 
 use getset::Getters;
 use nanoid::nanoid;
+use schemars::JsonSchema;
 use serde::Serialize;
 
 use crate::ring::Ring;
 use crate::window::Window;
 
-#[derive(Debug, Clone, Serialize, Getters)]
+#[derive(Debug, Clone, Serialize, Getters, JsonSchema)]
 pub struct Container {
     #[serde(skip_serializing)]
     #[getset(get = "pub")]
@@ -78,18 +79,18 @@ impl Container {
     }
 
     pub fn remove_window_by_idx(&mut self, idx: usize) -> Option<Window> {
-        self.windows_mut().remove(idx)
+        let window = self.windows_mut().remove(idx);
+
+        if idx != 0 {
+            self.focus_window(idx - 1);
+        };
+
+        window
     }
 
     pub fn remove_focused_window(&mut self) -> Option<Window> {
         let focused_idx = self.focused_window_idx();
-        let window = self.remove_window_by_idx(focused_idx);
-
-        if focused_idx != 0 {
-            self.focus_window(focused_idx - 1);
-        }
-
-        window
+        self.remove_window_by_idx(focused_idx)
     }
 
     pub fn add_window(&mut self, window: Window) {

komorebi/src/main.rs

@@ -4,8 +4,10 @@
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
+use std::path::PathBuf;
 use std::process::Command;
 use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 #[cfg(feature = "deadlock_detection")]
@@ -13,7 +15,7 @@ use std::thread;
 #[cfg(feature = "deadlock_detection")]
 use std::time::Duration;
 
-use clap::Clap;
+use clap::Parser;
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
@@ -22,13 +24,19 @@ use lazy_static::lazy_static;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
+use schemars::JsonSchema;
 use serde::Serialize;
+use sysinfo::Process;
+use sysinfo::ProcessExt;
 use sysinfo::SystemExt;
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
 use which::which;
+use winreg::enums::HKEY_CURRENT_USER;
+use winreg::RegKey;
 
+use komorebi_core::HidingBehaviour;
 use komorebi_core::SocketMessage;
 
 use crate::process_command::listen_for_commands;
@@ -60,7 +68,7 @@ mod workspace;
 
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
-    static ref LAYERED_EXE_WHITELIST: Arc<Mutex<Vec<String>>> =
+    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>>> =
         Arc::new(Mutex::new(vec![
@@ -78,7 +86,12 @@ lazy_static! {
     static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, (usize, usize)>>> =
         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 FLOAT_IDENTIFIERS: Arc<Mutex<Vec<String>>> = 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()
+    ]));
     static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
     static ref WSL2_UI_PROCESSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "X410.exe".to_string(),
@@ -87,9 +100,28 @@ lazy_static! {
     ]));
     static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
         Arc::new(Mutex::new(HashMap::new()));
+    static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
+        Arc::new(Mutex::new(HidingBehaviour::Minimize));
+    static ref HOME_DIR: PathBuf = {
+        if let Ok(home_path) = std::env::var("KOMOREBI_CONFIG_HOME") {
+            let home = PathBuf::from(&home_path);
+
+            if home.as_path().is_dir() {
+                home
+            } else {
+                panic!(
+                    "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                    home_path
+                );
+            }
+        } else {
+            dirs::home_dir().expect("there is no home directory")
+        }
+    };
 }
 
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
+pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
 
 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
@@ -102,7 +134,7 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
         std::env::set_var("RUST_LOG", "info");
     }
 
-    let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+    let home = HOME_DIR.clone();
     let appender = tracing_appender::rolling::never(home, "komorebi.log");
     let color_appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi.log");
     let (non_blocking, guard) = tracing_appender::non_blocking(appender);
@@ -133,27 +165,30 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     // occurred to be recorded.
     std::panic::set_hook(Box::new(|panic| {
         // If the panic has a source location, record it as structured fields.
-        if let Some(location) = panic.location() {
-            // On nightly Rust, where the `PanicInfo` type also exposes a
-            // `message()` method returning just the message, we could record
-            // just the message instead of the entire `fmt::Display`
-            // implementation, avoiding the duplciated location
-            tracing::error!(
-                message = %panic,
-                panic.file = location.file(),
-                panic.line = location.line(),
-                panic.column = location.column(),
-            );
-        } else {
-            tracing::error!(message = %panic);
-        }
+        panic.location().map_or_else(
+            || {
+                tracing::error!(message = %panic);
+            },
+            |location| {
+                // On nightly Rust, where the `PanicInfo` type also exposes a
+                // `message()` method returning just the message, we could record
+                // just the message instead of the entire `fmt::Display`
+                // implementation, avoiding the duplciated location
+                tracing::error!(
+                    message = %panic,
+                    panic.file = location.file(),
+                    panic.line = location.line(),
+                    panic.column = location.column(),
+                );
+            },
+        );
     }));
 
     Ok((guard, color_guard))
 }
 
 pub fn load_configuration() -> Result<()> {
-    let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+    let home = HOME_DIR.clone();
 
     let mut config_v1 = home.clone();
     config_v1.push("komorebi.ahk");
@@ -190,14 +225,57 @@ pub fn load_configuration() -> Result<()> {
     Ok(())
 }
 
-#[derive(Debug, Serialize)]
+pub fn current_virtual_desktop() -> Option<Vec<u8>> {
+    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
+
+    // This is the path on Windows 10
+    let mut current = hkcu
+        .open_subkey(format!(
+            r#"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\SessionInfo\{}\VirtualDesktops"#,
+            SESSION_ID.load(Ordering::SeqCst)
+        ))
+        .ok()
+        .and_then(
+            |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
+                Ok(current) => Option::from(current.bytes),
+                Err(_) => None,
+            },
+        );
+
+    // This is the path on Windows 11
+    if current.is_none() {
+        current = hkcu
+            .open_subkey(r#"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VirtualDesktops"#)
+            .ok()
+            .and_then(
+                |desktops| match desktops.get_raw_value("CurrentVirtualDesktop") {
+                    Ok(current) => Option::from(current.bytes),
+                    Err(_) => None,
+                },
+            );
+    }
+
+    // For Win10 users that do not use virtual desktops, the CurrentVirtualDesktop value will not
+    // exist until one has been created in the task view
+
+    // The registry value will also not exist on user login if virtual desktops have been created
+    // but the task view has not been initiated
+
+    // In both of these cases, we return None, and the virtual desktop validation will never run. In
+    // the latter case, if the user desires this validation after initiating the task view, komorebi
+    // should be restarted, and then when this // fn runs again for the first time, it will pick up
+    // the value of CurrentVirtualDesktop and validate against it accordingly
+    current
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
 #[serde(untagged)]
 pub enum NotificationEvent {
     WindowManager(WindowManagerEvent),
     Socket(SocketMessage),
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, JsonSchema)]
 pub struct Notification {
     pub event: NotificationEvent,
     pub state: State,
@@ -260,7 +338,7 @@ fn detect_deadlocks() {
     });
 }
 
-#[derive(Clap)]
+#[derive(Parser)]
 #[clap(author, about, version)]
 struct Opts {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
@@ -277,12 +355,26 @@ fn main() -> Result<()> {
     let has_valid_args = arg_count == 1 || (arg_count == 2 && CUSTOM_FFM.load(Ordering::SeqCst));
 
     if has_valid_args {
+        let session_id = WindowsApi::process_id_to_session_id()?;
+        SESSION_ID.store(session_id, Ordering::SeqCst);
+
         let mut system = sysinfo::System::new_all();
         system.refresh_processes();
 
-        if system.process_by_name("komorebi.exe").len() > 1 {
-            tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
-            std::process::exit(1);
+        let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
+
+        if matched_procs.len() > 1 {
+            let mut shim_is_active = false;
+            for proc in matched_procs {
+                if proc.root().ends_with("shims") {
+                    shim_is_active = true;
+                }
+            }
+
+            if !shim_is_active {
+                tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
+                std::process::exit(1);
+            }
         }
 
         // File logging worker guard has to have an assignment in the main fn to work
@@ -328,6 +420,11 @@ fn main() -> Result<()> {
         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

@@ -7,6 +7,7 @@ use getset::CopyGetters;
 use getset::Getters;
 use getset::MutGetters;
 use getset::Setters;
+use schemars::JsonSchema;
 use serde::Serialize;
 
 use komorebi_core::Rect;
@@ -15,7 +16,7 @@ use crate::container::Container;
 use crate::ring::Ring;
 use crate::workspace::Workspace;
 
-#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters)]
+#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
 pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
     id: isize,
@@ -45,11 +46,11 @@ pub fn new(id: isize, size: Rect, work_area_size: Rect) -> Monitor {
 }
 
 impl Monitor {
-    pub fn load_focused_workspace(&mut self) -> Result<()> {
+    pub fn load_focused_workspace(&mut self, mouse_follows_focus: bool) -> Result<()> {
         let focused_idx = self.focused_workspace_idx();
         for (i, workspace) in self.workspaces_mut().iter_mut().enumerate() {
             if i == focused_idx {
-                workspace.restore()?;
+                workspace.restore(mouse_follows_focus)?;
             } else {
                 workspace.hide();
             }
@@ -58,16 +59,39 @@ impl Monitor {
         Ok(())
     }
 
-    pub fn add_container(&mut self, container: Container) -> Result<()> {
-        let workspace = self
-            .focused_workspace_mut()
-            .ok_or_else(|| anyhow!("there is no workspace"))?;
+    pub fn add_container(
+        &mut self,
+        container: Container,
+        workspace_idx: Option<usize>,
+    ) -> Result<()> {
+        let workspace = if let Some(idx) = workspace_idx {
+            self.workspaces_mut()
+                .get_mut(idx)
+                .ok_or_else(|| anyhow!("there is no workspace at index {}", idx))?
+        } else {
+            self.focused_workspace_mut()
+                .ok_or_else(|| anyhow!("there is no workspace"))?
+        };
 
         workspace.add_container(container);
 
         Ok(())
     }
 
+    pub fn remove_workspace_by_idx(&mut self, idx: usize) -> Option<Workspace> {
+        if idx < self.workspaces().len() {
+            return self.workspaces_mut().remove(idx);
+        }
+
+        if idx == 0 {
+            self.workspaces_mut().push_back(Workspace::default());
+        } else {
+            self.focus_workspace(idx - 1).ok()?;
+        };
+
+        None
+    }
+
     pub fn ensure_workspace_count(&mut self, ensure_count: usize) {
         if self.workspaces().len() < ensure_count {
             self.workspaces_mut()

komorebi/src/process_command.rs

@@ -13,13 +13,21 @@ use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use miow::pipe::connect;
 use parking_lot::Mutex;
+use schemars::schema_for;
 use uds_windows::UnixStream;
 
+use komorebi_core::ApplicationIdentifier;
+use komorebi_core::Axis;
 use komorebi_core::FocusFollowsMouseImplementation;
+use komorebi_core::Layout;
+use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
+use komorebi_core::Sizing;
 use komorebi_core::SocketMessage;
 use komorebi_core::StateQuery;
+use komorebi_core::WindowContainerBehaviour;
 
+use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::window_manager;
 use crate::window_manager::WindowManager;
@@ -29,7 +37,11 @@ use crate::NotificationEvent;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::CUSTOM_FFM;
 use crate::FLOAT_IDENTIFIERS;
+use crate::HIDING_BEHAVIOUR;
+use crate::HOME_DIR;
+use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::SUBSCRIPTION_PIPES;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
@@ -62,7 +74,17 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
 impl WindowManager {
     #[tracing::instrument(skip(self))]
     pub fn process_command(&mut self, message: SocketMessage) -> Result<()> {
-        self.validate_virtual_desktop_id();
+        if let Some(virtual_desktop_id) = &self.virtual_desktop_id {
+            if let Some(id) = current_virtual_desktop() {
+                if id != *virtual_desktop_id {
+                    tracing::info!(
+                        "ignoring events and commands while not on virtual desktop {:?}",
+                        virtual_desktop_id
+                    );
+                    return Ok(());
+                }
+            }
+        }
 
         match message {
             SocketMessage::Promote => self.promote_container_to_front()?,
@@ -106,10 +128,57 @@ impl WindowManager {
                     manage_identifiers.push(id);
                 }
             }
-            SocketMessage::FloatRule(_, id) => {
+            SocketMessage::FloatRule(identifier, id) => {
                 let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
                 if !float_identifiers.contains(&id) {
-                    float_identifiers.push(id);
+                    float_identifiers.push(id.clone());
+                }
+
+                let invisible_borders = self.invisible_borders;
+                let offset = self.work_area_offset;
+
+                let mut hwnds_to_purge = vec![];
+                for (i, monitor) in self.monitors().iter().enumerate() {
+                    for container in monitor
+                        .focused_workspace()
+                        .ok_or_else(|| anyhow!("there is no workspace"))?
+                        .containers()
+                        .iter()
+                    {
+                        for window in container.windows().iter() {
+                            match identifier {
+                                ApplicationIdentifier::Exe => {
+                                    if window.exe()? == id {
+                                        hwnds_to_purge.push((i, window.hwnd));
+                                    }
+                                }
+                                ApplicationIdentifier::Class => {
+                                    if window.class()? == id {
+                                        hwnds_to_purge.push((i, window.hwnd));
+                                    }
+                                }
+                                ApplicationIdentifier::Title => {
+                                    if window.title()? == id {
+                                        hwnds_to_purge.push((i, window.hwnd));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                for (monitor_idx, hwnd) in hwnds_to_purge {
+                    let monitor = self
+                        .monitors_mut()
+                        .get_mut(monitor_idx)
+                        .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+                    monitor
+                        .focused_workspace_mut()
+                        .ok_or_else(|| anyhow!("there is no focused workspace"))?
+                        .remove_window(hwnd)?;
+
+                    monitor.update_focused_workspace(offset, &invisible_borders)?;
                 }
             }
             SocketMessage::AdjustContainerPadding(sizing, adjustment) => {
@@ -122,13 +191,19 @@ impl WindowManager {
                 self.move_container_to_workspace(workspace_idx, true)?;
             }
             SocketMessage::MoveContainerToMonitorNumber(monitor_idx) => {
-                self.move_container_to_monitor(monitor_idx, true)?;
+                self.move_container_to_monitor(monitor_idx, None, true)?;
             }
             SocketMessage::SendContainerToWorkspaceNumber(workspace_idx) => {
                 self.move_container_to_workspace(workspace_idx, false)?;
             }
             SocketMessage::SendContainerToMonitorNumber(monitor_idx) => {
-                self.move_container_to_monitor(monitor_idx, false)?;
+                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)?;
+            }
+            SocketMessage::MoveWorkspaceToMonitorNumber(monitor_idx) => {
+                self.move_workspace_to_monitor(monitor_idx)?;
             }
             SocketMessage::TogglePause => {
                 if self.is_paused {
@@ -138,6 +213,7 @@ impl WindowManager {
                 }
 
                 self.is_paused = !self.is_paused;
+                self.retile_all(true)?;
             }
             SocketMessage::ToggleTiling => {
                 self.toggle_tiling()?;
@@ -150,13 +226,13 @@ impl WindowManager {
                 );
 
                 self.focus_monitor(monitor_idx)?;
-                self.update_focused_workspace(true)?;
+                self.update_focused_workspace(self.mouse_follows_focus)?;
             }
             SocketMessage::FocusMonitorNumber(monitor_idx) => {
                 self.focus_monitor(monitor_idx)?;
-                self.update_focused_workspace(true)?;
+                self.update_focused_workspace(self.mouse_follows_focus)?;
             }
-            SocketMessage::Retile => self.retile_all()?,
+            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::ChangeLayoutCustom(path) => self.change_workspace_custom_layout(path)?,
@@ -169,6 +245,35 @@ impl WindowManager {
             SocketMessage::WorkspaceLayout(monitor_idx, workspace_idx, layout) => {
                 self.set_workspace_layout_default(monitor_idx, workspace_idx, layout)?;
             }
+            SocketMessage::WorkspaceLayoutRule(
+                monitor_idx,
+                workspace_idx,
+                at_container_count,
+                layout,
+            ) => {
+                self.add_workspace_layout_default_rule(
+                    monitor_idx,
+                    workspace_idx,
+                    at_container_count,
+                    layout,
+                )?;
+            }
+            SocketMessage::WorkspaceLayoutCustomRule(
+                monitor_idx,
+                workspace_idx,
+                at_container_count,
+                path,
+            ) => {
+                self.add_workspace_layout_custom_rule(
+                    monitor_idx,
+                    workspace_idx,
+                    at_container_count,
+                    path,
+                )?;
+            }
+            SocketMessage::ClearWorkspaceLayoutRules(monitor_idx, workspace_idx) => {
+                self.clear_workspace_layout_rules(monitor_idx, workspace_idx)?;
+            }
             SocketMessage::CycleFocusWorkspace(direction) => {
                 // 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
@@ -203,7 +308,10 @@ impl WindowManager {
                 })?;
 
                 self.focus_monitor(monitor_idx)?;
-
+                self.focus_workspace(workspace_idx)?;
+            }
+            SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
+                self.focus_monitor(monitor_idx)?;
                 self.focus_workspace(workspace_idx)?;
             }
             SocketMessage::Stop => {
@@ -211,6 +319,11 @@ impl WindowManager {
                     "received stop command, restoring all hidden windows and terminating process"
                 );
                 self.restore_all_windows();
+
+                if WindowsApi::focus_follows_mouse()? {
+                    WindowsApi::disable_focus_follows_mouse()?;
+                }
+
                 std::process::exit(0)
             }
             SocketMessage::EnsureWorkspaces(monitor_idx, workspace_count) => {
@@ -223,9 +336,13 @@ impl WindowManager {
                 self.set_workspace_name(monitor_idx, workspace_idx, name)?;
             }
             SocketMessage::State => {
-                let state = serde_json::to_string_pretty(&window_manager::State::from(&*self))?;
-                let mut socket =
-                    dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+                let state = match serde_json::to_string_pretty(&window_manager::State::from(&*self))
+                {
+                    Ok(state) => state,
+                    Err(error) => error.to_string(),
+                };
+
+                let mut socket = HOME_DIR.clone();
                 socket.push("komorebic.sock");
                 let socket = socket.as_path();
 
@@ -248,16 +365,92 @@ impl WindowManager {
                 }
                 .to_string();
 
-                let mut socket =
-                    dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+                let mut socket = HOME_DIR.clone();
                 socket.push("komorebic.sock");
                 let socket = socket.as_path();
 
                 let mut stream = UnixStream::connect(&socket)?;
                 stream.write_all(response.as_bytes())?;
             }
-            SocketMessage::ResizeWindow(direction, sizing) => {
-                self.resize_window(direction, sizing, Option::from(50))?;
+            SocketMessage::ResizeWindowEdge(direction, sizing) => {
+                self.resize_window(direction, sizing, self.resize_delta, true)?;
+            }
+            SocketMessage::ResizeWindowAxis(axis, sizing) => {
+                // If the user has a custom layout, allow for the resizing of the primary column
+                // with this signal
+                if let Layout::Custom(ref mut custom) = self.focused_workspace_mut()?.layout_mut() {
+                    if matches!(axis, Axis::Horizontal) {
+                        let percentage = custom
+                            .primary_width_percentage()
+                            .unwrap_or(100 / custom.len());
+
+                        match sizing {
+                            Sizing::Increase => custom.set_primary_width_percentage(percentage + 5),
+                            Sizing::Decrease => custom.set_primary_width_percentage(percentage - 5),
+                        }
+                    }
+                // Otherwise proceed with the resizing logic for individual window containers in the
+                // assumed BSP layout
+                } else {
+                    match axis {
+                        Axis::Horizontal => {
+                            self.resize_window(
+                                OperationDirection::Left,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                            self.resize_window(
+                                OperationDirection::Right,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                        }
+                        Axis::Vertical => {
+                            self.resize_window(
+                                OperationDirection::Up,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                            self.resize_window(
+                                OperationDirection::Down,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                        }
+                        Axis::HorizontalAndVertical => {
+                            self.resize_window(
+                                OperationDirection::Left,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                            self.resize_window(
+                                OperationDirection::Right,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                            self.resize_window(
+                                OperationDirection::Up,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                            self.resize_window(
+                                OperationDirection::Down,
+                                sizing,
+                                self.resize_delta,
+                                false,
+                            )?;
+                        }
+                    }
+                }
+
+                self.update_focused_workspace(false)?;
             }
             SocketMessage::FocusFollowsMouse(mut implementation, enable) => {
                 if !CUSTOM_FFM.load(Ordering::SeqCst) {
@@ -358,18 +551,30 @@ impl WindowManager {
             SocketMessage::WatchConfiguration(enable) => {
                 self.watch_configuration(enable)?;
             }
-            SocketMessage::IdentifyBorderOverflow(_, id) => {
+            SocketMessage::IdentifyBorderOverflowApplication(_, id) => {
                 let mut identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
                 if !identifiers.contains(&id) {
                     identifiers.push(id);
                 }
             }
+            SocketMessage::IdentifyObjectNameChangeApplication(_, id) => {
+                let mut identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+                if !identifiers.contains(&id) {
+                    identifiers.push(id);
+                }
+            }
             SocketMessage::IdentifyTrayApplication(_, id) => {
                 let mut identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
                 if !identifiers.contains(&id) {
                     identifiers.push(id);
                 }
             }
+            SocketMessage::IdentifyLayeredApplication(_, id) => {
+                let mut identifiers = LAYERED_WHITELIST.lock();
+                if !identifiers.contains(&id) {
+                    identifiers.push(id);
+                }
+            }
             SocketMessage::ManageFocusedWindow => {
                 self.manage_focused_window()?;
             }
@@ -378,11 +583,11 @@ impl WindowManager {
             }
             SocketMessage::InvisibleBorders(rect) => {
                 self.invisible_borders = rect;
-                self.retile_all()?;
+                self.retile_all(false)?;
             }
             SocketMessage::WorkAreaOffset(rect) => {
                 self.work_area_offset = Option::from(rect);
-                self.retile_all()?;
+                self.retile_all(false)?;
             }
             SocketMessage::QuickSave => {
                 let workspace = self.focused_workspace()?;
@@ -453,6 +658,42 @@ impl WindowManager {
                 let mut pipes = SUBSCRIPTION_PIPES.lock();
                 pipes.remove(&subscriber);
             }
+            SocketMessage::MouseFollowsFocus(enable) => {
+                self.mouse_follows_focus = enable;
+            }
+            SocketMessage::ToggleMouseFollowsFocus => {
+                self.mouse_follows_focus = !self.mouse_follows_focus;
+            }
+            SocketMessage::ResizeDelta(delta) => {
+                self.resize_delta = delta;
+            }
+            SocketMessage::ToggleWindowContainerBehaviour => {
+                match self.window_container_behaviour {
+                    WindowContainerBehaviour::Create => {
+                        self.window_container_behaviour = WindowContainerBehaviour::Append;
+                    }
+                    WindowContainerBehaviour::Append => {
+                        self.window_container_behaviour = WindowContainerBehaviour::Create;
+                    }
+                }
+            }
+            SocketMessage::WindowHidingBehaviour(behaviour) => {
+                let mut hiding_behaviour = HIDING_BEHAVIOUR.lock();
+                *hiding_behaviour = behaviour;
+            }
+            SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
+                self.unmanaged_window_operation_behaviour = behaviour;
+            }
+            SocketMessage::NotificationSchema => {
+                let notification = schema_for!(Notification);
+                let schema = serde_json::to_string_pretty(&notification)?;
+                let mut socket = HOME_DIR.clone();
+                socket.push("komorebic.sock");
+                let socket = socket.as_path();
+
+                let mut stream = UnixStream::connect(&socket)?;
+                stream.write_all(schema.as_bytes())?;
+            }
         };
 
         tracing::info!("processed");
@@ -480,7 +721,7 @@ impl WindowManager {
             self.process_command(message.clone())?;
             notify_subscribers(&serde_json::to_string(&Notification {
                 event: NotificationEvent::Socket(message.clone()),
-                state: (&*self).into(),
+                state: self.as_ref().into(),
             })?)?;
         }
 

komorebi/src/process_event.rs

@@ -10,7 +10,9 @@ use parking_lot::Mutex;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
+use komorebi_core::WindowContainerBehaviour;
 
+use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
@@ -18,6 +20,7 @@ use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::HIDDEN_HWNDS;
+use crate::HOME_DIR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
@@ -50,7 +53,17 @@ impl WindowManager {
             return Ok(());
         }
 
-        self.validate_virtual_desktop_id();
+        if let Some(virtual_desktop_id) = &self.virtual_desktop_id {
+            if let Some(id) = current_virtual_desktop() {
+                if id != *virtual_desktop_id {
+                    tracing::info!(
+                        "ignoring events and commands while not on virtual desktop {:?}",
+                        virtual_desktop_id
+                    );
+                    return Ok(());
+                }
+            }
+        }
 
         // Make sure we have the most recently focused monitor from any event
         match event {
@@ -63,7 +76,9 @@ impl WindowManager {
                 let monitor_idx = self.monitor_idx_from_window(*window)
                     .ok_or_else(|| anyhow!("there is no monitor associated with this window, it may have already been destroyed"))?;
 
-                self.focus_monitor(monitor_idx)?;
+                if window.class()? != "OleMainThreadWndClass" {
+                    self.focus_monitor(monitor_idx)?;
+                }
             }
             _ => {}
         }
@@ -102,13 +117,25 @@ impl WindowManager {
                 window.raise()?;
                 self.has_pending_raise_op = false;
             }
-            WindowManagerEvent::Minimize(_, window)
-            | WindowManagerEvent::Destroy(_, window)
-            | WindowManagerEvent::Unmanage(window) => {
+            WindowManagerEvent::Destroy(_, window) | WindowManagerEvent::Unmanage(window) => {
                 self.focused_workspace_mut()?.remove_window(window.hwnd)?;
                 self.update_focused_workspace(false)?;
             }
+            WindowManagerEvent::Minimize(_, window) => {
+                let mut hide = false;
 
+                {
+                    let programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
+                    if !programmatically_hidden_hwnds.contains(&window.hwnd) {
+                        hide = true;
+                    }
+                }
+
+                if hide {
+                    self.focused_workspace_mut()?.remove_window(window.hwnd)?;
+                    self.update_focused_workspace(false)?;
+                }
+            }
             WindowManagerEvent::Hide(_, window) => {
                 let mut hide = false;
                 // Some major applications unfortunately send the HIDE signal when they are being
@@ -201,14 +228,53 @@ impl WindowManager {
                     }
                 }
 
+                let behaviour = self.window_container_behaviour;
                 let workspace = self.focused_workspace_mut()?;
 
                 if !workspace.contains_window(window.hwnd) {
-                    workspace.new_container_for_window(*window);
-                    self.update_focused_workspace(false)?;
+                    match behaviour {
+                        WindowContainerBehaviour::Create => {
+                            workspace.new_container_for_window(*window);
+                            self.update_focused_workspace(false)?;
+                        }
+                        WindowContainerBehaviour::Append => {
+                            workspace
+                                .focused_container_mut()
+                                .ok_or_else(|| anyhow!("there is no focused container"))?
+                                .add_window(*window);
+                            self.update_focused_workspace(true)?;
+                        }
+                    }
                 }
             }
+            WindowManagerEvent::MoveResizeStart(_, _) => {
+                let monitor_idx = self.focused_monitor_idx();
+                let workspace_idx = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
+                    .focused_workspace_idx();
+                let container_idx = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
+                    .focused_workspace()
+                    .ok_or_else(|| anyhow!("there is no workspace with this idx"))?
+                    .focused_container_idx();
+
+                self.pending_move_op = Option::from((monitor_idx, workspace_idx, container_idx));
+            }
             WindowManagerEvent::MoveResizeEnd(_, window) => {
+                // We need this because if the event ends on a different monitor,
+                // that monitor will already have been focused and updated in the state
+                let pending = self.pending_move_op;
+                // Always consume the pending move op whenever this event is handled
+                self.pending_move_op = None;
+
+                let target_monitor_idx = self
+                    .monitor_idx_from_current_pos()
+                    .ok_or_else(|| anyhow!("cannot get monitor idx from current position"))?;
+
+                let new_window_behaviour = self.window_container_behaviour;
+
                 let workspace = self.focused_workspace_mut()?;
                 if workspace
                     .floating_windows()
@@ -218,12 +284,32 @@ impl WindowManager {
                     return Ok(());
                 }
 
-                let focused_idx = workspace.focused_container_idx();
+                let focused_container_idx = workspace.focused_container_idx();
+
+                let mut new_position = WindowsApi::window_rect(window.hwnd())?;
+
                 let old_position = *workspace
                     .latest_layout()
-                    .get(focused_idx)
-                    .ok_or_else(|| anyhow!("there is no latest layout"))?;
-                let mut new_position = WindowsApi::window_rect(window.hwnd())?;
+                    .get(focused_container_idx)
+                    // If the move was to another monitor with an empty workspace, the
+                    // workspace here will refer to that empty workspace, which won't
+                    // have any latest layout set. We fall back to a Default for Rect
+                    // which allows us to make a reasonable guess that the drag has taken
+                    // place across a monitor boundary to an empty workspace
+                    .unwrap_or(&Rect::default());
+
+                // This will be true if we have moved to an empty workspace on another monitor
+                let mut moved_across_monitors = old_position == Rect::default();
+
+                if let Some((origin_monitor_idx, _, _)) = pending {
+                    // If we didn't move to another monitor with an empty workspace, it is
+                    // still possible that we moved to another monitor with a populated workspace
+                    if !moved_across_monitors {
+                        // So we'll check if the origin monitor index and the target monitor index
+                        // are different, if they are, we can set the override
+                        moved_across_monitors = origin_monitor_idx != target_monitor_idx;
+                    }
+                }
 
                 // Adjust for the invisible borders
                 new_position.left += invisible_borders.left;
@@ -238,16 +324,90 @@ impl WindowManager {
                     bottom: new_position.bottom - old_position.bottom,
                 };
 
-                let is_move = resize.right == 0 && resize.bottom == 0;
+                // If we have moved across the monitors, use that override, otherwise determine
+                // if a move has taken place by ruling out a resize
+                let is_move = moved_across_monitors || resize.right == 0 && resize.bottom == 0;
 
                 if is_move {
                     tracing::info!("moving with mouse");
-                    match workspace.container_idx_from_current_point() {
-                        Some(target_idx) => {
-                            workspace.swap_containers(focused_idx, target_idx);
+
+                    if moved_across_monitors {
+                        if let Some((
+                            origin_monitor_idx,
+                            origin_workspace_idx,
+                            origin_container_idx,
+                        )) = pending
+                        {
+                            let target_workspace_idx = self
+                                .monitors()
+                                .get(target_monitor_idx)
+                                .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
+                                .focused_workspace_idx();
+
+                            let target_container_idx = self
+                                .monitors()
+                                .get(target_monitor_idx)
+                                .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
+                                .focused_workspace()
+                                .ok_or_else(|| {
+                                    anyhow!("there is no focused workspace for this monitor")
+                                })?
+                                .container_idx_from_current_point()
+                                // Default to 0 in the case of an empty workspace
+                                .unwrap_or(0);
+
+                            self.transfer_container(
+                                (
+                                    origin_monitor_idx,
+                                    origin_workspace_idx,
+                                    origin_container_idx,
+                                ),
+                                (
+                                    target_monitor_idx,
+                                    target_workspace_idx,
+                                    target_container_idx,
+                                ),
+                            )?;
+
+                            // We want to make sure both the origin and target monitors are updated,
+                            // so that we don't have ghost tiles until we force an interaction on
+                            // the origin monitor's focused workspace
+                            self.focus_monitor(origin_monitor_idx)?;
+                            self.focus_workspace(origin_workspace_idx)?;
+                            self.update_focused_workspace(false)?;
+
+                            self.focus_monitor(target_monitor_idx)?;
+                            self.focus_workspace(target_workspace_idx)?;
                             self.update_focused_workspace(false)?;
                         }
-                        None => self.update_focused_workspace(true)?,
+                    // Here we handle a simple move on the same monitor which is treated as
+                    // a container swap
+                    } else {
+                        match new_window_behaviour {
+                            WindowContainerBehaviour::Create => {
+                                match workspace.container_idx_from_current_point() {
+                                    Some(target_idx) => {
+                                        workspace
+                                            .swap_containers(focused_container_idx, target_idx);
+                                        self.update_focused_workspace(false)?;
+                                    }
+                                    None => {
+                                        self.update_focused_workspace(self.mouse_follows_focus)?;
+                                    }
+                                }
+                            }
+                            WindowContainerBehaviour::Append => {
+                                match workspace.container_idx_from_current_point() {
+                                    Some(target_idx) => {
+                                        workspace.move_window_to_container(target_idx)?;
+                                        self.update_focused_workspace(false)?;
+                                    }
+                                    None => {
+                                        self.update_focused_workspace(self.mouse_follows_focus)?;
+                                    }
+                                }
+                            }
+                        }
                     }
                 } else {
                     tracing::info!("resizing with mouse");
@@ -282,8 +442,8 @@ impl WindowManager {
                         ops.push(resize_op!(resize.bottom, <, OperationDirection::Down));
                     }
 
-                    for (edge, sizing, step) in ops {
-                        self.resize_window(edge, sizing, Option::from(step))?;
+                    for (edge, sizing, delta) in ops {
+                        self.resize_window(edge, sizing, delta, true)?;
                     }
 
                     self.update_focused_workspace(false)?;
@@ -309,8 +469,7 @@ impl WindowManager {
             }
         }
 
-        let mut hwnd_json =
-            dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+        let mut hwnd_json = HOME_DIR.clone();
         hwnd_json.push("komorebi.hwnd.json");
         let file = OpenOptions::new()
             .write(true)
@@ -321,7 +480,7 @@ impl WindowManager {
         serde_json::to_writer_pretty(&file, &known_hwnds)?;
         notify_subscribers(&serde_json::to_string(&Notification {
             event: NotificationEvent::WindowManager(*event),
-            state: (&*self).into(),
+            state: self.as_ref().into(),
         })?)?;
 
         tracing::info!("processed: {}", event.window().to_string());

komorebi/src/ring.rs

@@ -1,8 +1,9 @@
 use std::collections::VecDeque;
 
+use schemars::JsonSchema;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, JsonSchema)]
 pub struct Ring<T> {
     elements: VecDeque<T>,
     focused: usize,

komorebi/src/set_window_position.rs

@@ -1,20 +1,19 @@
 use bitflags::bitflags;
-
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_ASYNCWINDOWPOS;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_DEFERERASE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_DRAWFRAME;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_FRAMECHANGED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_HIDEWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOACTIVATE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOCOPYBITS;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOMOVE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOOWNERZORDER;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOREDRAW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOREPOSITION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOSENDCHANGING;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOSIZE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_NOZORDER;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SWP_SHOWWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::SWP_ASYNCWINDOWPOS;
+use windows::Win32::UI::WindowsAndMessaging::SWP_DEFERERASE;
+use windows::Win32::UI::WindowsAndMessaging::SWP_DRAWFRAME;
+use windows::Win32::UI::WindowsAndMessaging::SWP_FRAMECHANGED;
+use windows::Win32::UI::WindowsAndMessaging::SWP_HIDEWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOACTIVATE;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOCOPYBITS;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOMOVE;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOOWNERZORDER;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOREPOSITION;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOSENDCHANGING;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOSIZE;
+use windows::Win32::UI::WindowsAndMessaging::SWP_NOZORDER;
+use windows::Win32::UI::WindowsAndMessaging::SWP_SHOWWINDOW;
 
 bitflags! {
     #[derive(Default)]

komorebi/src/styles.rs

@@ -1,63 +1,63 @@
 use bitflags::bitflags;
+use windows::Win32::UI::WindowsAndMessaging::WS_BORDER;
+use windows::Win32::UI::WindowsAndMessaging::WS_CAPTION;
+use windows::Win32::UI::WindowsAndMessaging::WS_CHILD;
+use windows::Win32::UI::WindowsAndMessaging::WS_CHILDWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_CLIPCHILDREN;
+use windows::Win32::UI::WindowsAndMessaging::WS_CLIPSIBLINGS;
+use windows::Win32::UI::WindowsAndMessaging::WS_DISABLED;
+use windows::Win32::UI::WindowsAndMessaging::WS_DLGFRAME;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_ACCEPTFILES;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_APPWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_CLIENTEDGE;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_COMPOSITED;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_CONTEXTHELP;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_CONTROLPARENT;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_DLGMODALFRAME;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYOUTRTL;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LEFT;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LEFTSCROLLBAR;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LTRREADING;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_MDICHILD;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOINHERITLAYOUT;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOPARENTNOTIFY;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOREDIRECTIONBITMAP;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_OVERLAPPEDWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_PALETTEWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_RIGHT;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_RIGHTSCROLLBAR;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_RTLREADING;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_STATICEDGE;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOPMOST;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_TRANSPARENT;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_WINDOWEDGE;
+use windows::Win32::UI::WindowsAndMessaging::WS_GROUP;
+use windows::Win32::UI::WindowsAndMessaging::WS_HSCROLL;
+use windows::Win32::UI::WindowsAndMessaging::WS_ICONIC;
+use windows::Win32::UI::WindowsAndMessaging::WS_MAXIMIZE;
+use windows::Win32::UI::WindowsAndMessaging::WS_MAXIMIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_MINIMIZE;
+use windows::Win32::UI::WindowsAndMessaging::WS_MINIMIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_OVERLAPPED;
+use windows::Win32::UI::WindowsAndMessaging::WS_OVERLAPPEDWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
+use windows::Win32::UI::WindowsAndMessaging::WS_POPUPWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_SIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;
+use windows::Win32::UI::WindowsAndMessaging::WS_TABSTOP;
+use windows::Win32::UI::WindowsAndMessaging::WS_THICKFRAME;
+use windows::Win32::UI::WindowsAndMessaging::WS_TILED;
+use windows::Win32::UI::WindowsAndMessaging::WS_TILEDWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_VISIBLE;
+use windows::Win32::UI::WindowsAndMessaging::WS_VSCROLL;
 
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_BORDER;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_CAPTION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_CHILD;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_CHILDWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_CLIPCHILDREN;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_CLIPSIBLINGS;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_DISABLED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_DLGFRAME;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_ACCEPTFILES;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_APPWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_CLIENTEDGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_COMPOSITED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_CONTEXTHELP;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_CONTROLPARENT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_DLGMODALFRAME;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYOUTRTL;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_LEFT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_LEFTSCROLLBAR;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_LTRREADING;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_MDICHILD;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_NOINHERITLAYOUT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_NOPARENTNOTIFY;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_NOREDIRECTIONBITMAP;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_OVERLAPPEDWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_PALETTEWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_RIGHT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_RIGHTSCROLLBAR;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_RTLREADING;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_STATICEDGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_TOPMOST;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_TRANSPARENT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_EX_WINDOWEDGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_GROUP;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_HSCROLL;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_ICONIC;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_MAXIMIZE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_MAXIMIZEBOX;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_MINIMIZE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_MINIMIZEBOX;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_OVERLAPPED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_OVERLAPPEDWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_POPUPWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_SIZEBOX;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_TABSTOP;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_THICKFRAME;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_TILED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_TILEDWINDOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_VISIBLE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WS_VSCROLL;
-
+// https://docs.microsoft.com/en-us/windows/win32/winmsg/window-styles
 bitflags! {
     #[derive(Default)]
-    pub struct GwlStyle: u32 {
+    pub struct WindowStyle: u32 {
         const BORDER = WS_BORDER.0;
         const CAPTION = WS_CAPTION.0;
         const CHILD = WS_CHILD.0;
@@ -88,9 +88,10 @@ bitflags! {
     }
 }
 
+// https://docs.microsoft.com/en-us/windows/win32/winmsg/extended-window-styles
 bitflags! {
     #[derive(Default)]
-    pub struct GwlExStyle: u32 {
+    pub struct ExtendedWindowStyle: u32 {
         const ACCEPTFILES = WS_EX_ACCEPTFILES.0;
         const APPWINDOW = WS_EX_APPWINDOW.0;
         const CLIENTEDGE = WS_EX_CLIENTEDGE.0;

komorebi/src/window.rs

@@ -4,26 +4,29 @@ use std::fmt::Formatter;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
-use serde::ser::Error;
+use schemars::JsonSchema;
+
 use serde::ser::SerializeStruct;
 use serde::Serialize;
 use serde::Serializer;
+use windows::Win32::Foundation::HWND;
 
-use bindings::Windows::Win32::Foundation::HWND;
+use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 
-use crate::styles::GwlExStyle;
-use crate::styles::GwlStyle;
+use crate::styles::ExtendedWindowStyle;
+use crate::styles::WindowStyle;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::FLOAT_IDENTIFIERS;
 use crate::HIDDEN_HWNDS;
-use crate::LAYERED_EXE_WHITELIST;
+use crate::HIDING_BEHAVIOUR;
+use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, JsonSchema)]
 pub struct Window {
     pub(crate) hwnd: isize,
 }
@@ -61,24 +64,23 @@ impl Serialize for Window {
             "title",
             &self
                 .title()
-                .map_err(|_| S::Error::custom("could not get window title"))?,
+                .unwrap_or_else(|_| "could not get window title".to_string()),
         )?;
         state.serialize_field(
             "exe",
             &self
                 .exe()
-                .map_err(|_| S::Error::custom("could not get window exe"))?,
+                .unwrap_or_else(|_| "could not get window exe".to_string()),
         )?;
         state.serialize_field(
             "class",
             &self
                 .class()
-                .map_err(|_| S::Error::custom("could not get window class"))?,
+                .unwrap_or_else(|_| "could not get window class".to_string()),
         )?;
         state.serialize_field(
             "rect",
-            &WindowsApi::window_rect(self.hwnd())
-                .map_err(|_| S::Error::custom("could not get window rect"))?,
+            &WindowsApi::window_rect(self.hwnd()).unwrap_or_default(),
         )?;
         state.end()
     }
@@ -139,7 +141,11 @@ impl Window {
             programmatically_hidden_hwnds.push(self.hwnd);
         }
 
-        WindowsApi::hide_window(self.hwnd());
+        let hiding_behaviour = HIDING_BEHAVIOUR.lock();
+        match *hiding_behaviour {
+            HidingBehaviour::Hide => WindowsApi::hide_window(self.hwnd()),
+            HidingBehaviour::Minimize => WindowsApi::minimize_window(self.hwnd()),
+        }
     }
 
     pub fn restore(self) {
@@ -187,7 +193,7 @@ impl Window {
         WindowsApi::set_focus(self.hwnd())
     }
 
-    pub fn focus(self) -> Result<()> {
+    pub fn focus(self, mouse_follows_focus: bool) -> Result<()> {
         // Attach komorebi thread to Window thread
         let (_, window_thread_id) = WindowsApi::window_thread_process_id(self.hwnd());
         let current_thread_id = WindowsApi::current_thread_id();
@@ -205,25 +211,27 @@ impl Window {
         };
 
         // Center cursor in Window
-        WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd())?)?;
+        if mouse_follows_focus {
+            WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd())?)?;
+        }
 
         // This isn't really needed when the above command works as expected via AHK
         WindowsApi::set_focus(self.hwnd())
     }
 
     #[allow(dead_code)]
-    pub fn update_style(self, style: GwlStyle) -> Result<()> {
+    pub fn update_style(self, style: WindowStyle) -> Result<()> {
         WindowsApi::update_style(self.hwnd(), isize::try_from(style.bits())?)
     }
 
-    pub fn style(self) -> Result<GwlStyle> {
+    pub fn style(self) -> Result<WindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd())?)?;
-        GwlStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
+        WindowStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
     }
 
-    pub fn ex_style(self) -> Result<GwlExStyle> {
+    pub fn ex_style(self) -> Result<ExtendedWindowStyle> {
         let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd())?)?;
-        GwlExStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
+        ExtendedWindowStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
     }
 
     pub fn title(self) -> Result<String> {
@@ -286,8 +294,8 @@ impl Window {
                     };
 
                     let allow_layered = {
-                        let layered_exe_whitelist = LAYERED_EXE_WHITELIST.lock();
-                        layered_exe_whitelist.contains(&exe_name)
+                        let layered_whitelist = LAYERED_WHITELIST.lock();
+                        layered_whitelist.contains(&exe_name) || layered_whitelist.contains(&class)
                     };
 
                     let allow_wsl2_gui = {
@@ -298,13 +306,13 @@ impl Window {
                     let style = self.style()?;
                     let ex_style = self.ex_style()?;
 
-                    if (allow_wsl2_gui || style.contains(GwlStyle::CAPTION) && ex_style.contains(GwlExStyle::WINDOWEDGE))
-                        && !ex_style.contains(GwlExStyle::DLGMODALFRAME)
+                    if (allow_wsl2_gui || 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
                         // allowing a specific layered window on the whitelist (like Steam), it should
                         // pass this check
-                        && (allow_layered || !ex_style.contains(GwlExStyle::LAYERED))
+                        && (allow_layered || !ex_style.contains(ExtendedWindowStyle::LAYERED))
                         || managed_override
                     {
                         return Ok(true);

komorebi/src/window_manager.rs

@@ -11,21 +11,25 @@ use crossbeam_channel::Receiver;
 use hotwatch::notify::DebouncedEvent;
 use hotwatch::Hotwatch;
 use parking_lot::Mutex;
+use schemars::JsonSchema;
 use serde::Serialize;
 use uds_windows::UnixListener;
 
 use komorebi_core::custom_layout::CustomLayout;
 use komorebi_core::Arrangement;
+use komorebi_core::Axis;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
-use komorebi_core::Flip;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
+use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
+use komorebi_core::WindowContainerBehaviour;
 
 use crate::container::Container;
+use crate::current_virtual_desktop;
 use crate::load_configuration;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
@@ -36,8 +40,10 @@ use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
 use crate::workspace::Workspace;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::FLOAT_IDENTIFIERS;
-use crate::LAYERED_EXE_WHITELIST;
+use crate::HOME_DIR;
+use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
 
@@ -49,25 +55,40 @@ pub struct WindowManager {
     pub is_paused: bool,
     pub invisible_borders: Rect,
     pub work_area_offset: Option<Rect>,
+    pub resize_delta: i32,
+    pub window_container_behaviour: WindowContainerBehaviour,
+    pub unmanaged_window_operation_behaviour: OperationBehaviour,
     pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
+    pub mouse_follows_focus: bool,
     pub hotwatch: Hotwatch,
-    pub virtual_desktop_id: Option<usize>,
+    pub virtual_desktop_id: Option<Vec<u8>>,
     pub has_pending_raise_op: bool,
+    pub pending_move_op: Option<(usize, usize, usize)>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, JsonSchema)]
 pub struct State {
     pub monitors: Ring<Monitor>,
     pub is_paused: bool,
     pub invisible_borders: Rect,
+    pub resize_delta: i32,
+    pub new_window_behaviour: WindowContainerBehaviour,
     pub work_area_offset: Option<Rect>,
     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_exe_whitelist: 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>,
+}
+
+impl AsRef<Self> for WindowManager {
+    fn as_ref(&self) -> &Self {
+        self
+    }
 }
 
 impl From<&WindowManager> for State {
@@ -77,13 +98,17 @@ impl From<&WindowManager> for State {
             is_paused: wm.is_paused,
             invisible_borders: wm.invisible_borders,
             work_area_offset: wm.work_area_offset,
+            resize_delta: wm.resize_delta,
+            new_window_behaviour: wm.window_container_behaviour,
             focus_follows_mouse: wm.focus_follows_mouse.clone(),
+            mouse_follows_focus: wm.mouse_follows_focus,
             has_pending_raise_op: wm.has_pending_raise_op,
             float_identifiers: FLOAT_IDENTIFIERS.lock().clone(),
             manage_identifiers: MANAGE_IDENTIFIERS.lock().clone(),
-            layered_exe_whitelist: LAYERED_EXE_WHITELIST.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(),
         }
     }
 }
@@ -117,7 +142,7 @@ impl EnforceWorkspaceRuleOp {
 impl WindowManager {
     #[tracing::instrument]
     pub fn new(incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>) -> Result<Self> {
-        let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+        let home = HOME_DIR.clone();
         let mut socket = home;
         socket.push("komorebi.sock");
         let socket = socket.as_path();
@@ -135,8 +160,6 @@ impl WindowManager {
 
         let listener = UnixListener::bind(&socket)?;
 
-        let virtual_desktop_id = winvd::helpers::get_current_desktop_number().ok();
-
         Ok(Self {
             monitors: Ring::default(),
             incoming_events: incoming,
@@ -148,11 +171,16 @@ impl WindowManager {
                 right: 14,
                 bottom: 7,
             },
+            virtual_desktop_id: current_virtual_desktop(),
             work_area_offset: None,
+            window_container_behaviour: WindowContainerBehaviour::Create,
+            unmanaged_window_operation_behaviour: OperationBehaviour::Op,
+            resize_delta: 50,
             focus_follows_mouse: None,
+            mouse_follows_focus: true,
             hotwatch: Hotwatch::new()?,
-            virtual_desktop_id,
             has_pending_raise_op: false,
+            pending_move_op: None,
         })
     }
 
@@ -172,7 +200,7 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn watch_configuration(&mut self, enable: bool) -> Result<()> {
-        let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+        let home = HOME_DIR.clone();
 
         let mut config_v1 = home.clone();
         config_v1.push("komorebi.ahk");
@@ -288,6 +316,7 @@ impl WindowManager {
 
                 should_update = true;
             }
+
             if reference.size() != monitor.size() {
                 monitor.set_size(Rect {
                     left: reference.size().left,
@@ -428,7 +457,7 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn retile_all(&mut self) -> Result<()> {
+    pub fn retile_all(&mut self, preserve_resize_dimensions: bool) -> Result<()> {
         let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
 
@@ -439,8 +468,10 @@ impl WindowManager {
                 .ok_or_else(|| anyhow!("there is no workspace"))?;
 
             // Reset any resize adjustments if we want to force a retile
-            for resize in workspace.resize_dimensions_mut() {
-                *resize = None;
+            if !preserve_resize_dimensions {
+                for resize in workspace.resize_dimensions_mut() {
+                    *resize = None;
+                }
             }
 
             workspace.update(&work_area, offset, &invisible_borders)?;
@@ -449,20 +480,6 @@ impl WindowManager {
         Ok(())
     }
 
-    #[tracing::instrument(skip(self))]
-    pub fn validate_virtual_desktop_id(&self) {
-        let virtual_desktop_id = winvd::helpers::get_current_desktop_number().ok();
-        if let (Some(id), Some(virtual_desktop_id)) = (virtual_desktop_id, self.virtual_desktop_id)
-        {
-            if id != virtual_desktop_id {
-                tracing::warn!(
-                    "ignoring events while not on virtual desktop {}",
-                    virtual_desktop_id
-                );
-            }
-        }
-    }
-
     #[tracing::instrument(skip(self))]
     pub fn manage_focused_window(&mut self) -> Result<()> {
         let hwnd = WindowsApi::foreground_window()?;
@@ -539,7 +556,94 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn update_focused_workspace(&mut self, mouse_follows_focus: bool) -> Result<()> {
+    pub fn transfer_container(
+        &mut self,
+        origin: (usize, usize, usize),
+        target: (usize, usize, usize),
+    ) -> Result<()> {
+        let (origin_monitor_idx, origin_workspace_idx, origin_container_idx) = origin;
+        let (target_monitor_idx, target_workspace_idx, target_container_idx) = target;
+
+        let origin_container = self
+            .monitors_mut()
+            .get_mut(origin_monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .workspaces_mut()
+            .get_mut(origin_workspace_idx)
+            .ok_or_else(|| anyhow!("there is no workspace at this index"))?
+            .remove_container(origin_container_idx)
+            .ok_or_else(|| anyhow!("there is no container at this index"))?;
+
+        let target_workspace = self
+            .monitors_mut()
+            .get_mut(target_monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .workspaces_mut()
+            .get_mut(target_workspace_idx)
+            .ok_or_else(|| anyhow!("there is no workspace at this index"))?;
+
+        target_workspace
+            .containers_mut()
+            .insert(target_container_idx, origin_container);
+
+        target_workspace.focus_container(target_container_idx);
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn swap_containers(
+        &mut self,
+        origin: (usize, usize, usize),
+        target: (usize, usize, usize),
+    ) -> Result<()> {
+        let (origin_monitor_idx, origin_workspace_idx, origin_container_idx) = origin;
+        let (target_monitor_idx, target_workspace_idx, target_container_idx) = target;
+
+        let origin_container = self
+            .monitors_mut()
+            .get_mut(origin_monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .workspaces_mut()
+            .get_mut(origin_workspace_idx)
+            .ok_or_else(|| anyhow!("there is no workspace at this index"))?
+            .remove_container(origin_container_idx)
+            .ok_or_else(|| anyhow!("there is no container at this index"))?;
+
+        let target_container = self
+            .monitors_mut()
+            .get_mut(target_monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .workspaces_mut()
+            .get_mut(target_workspace_idx)
+            .ok_or_else(|| anyhow!("there is no workspace at this index"))?
+            .remove_container(target_container_idx);
+
+        self.monitors_mut()
+            .get_mut(target_monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .workspaces_mut()
+            .get_mut(target_workspace_idx)
+            .ok_or_else(|| anyhow!("there is no workspace at this index"))?
+            .containers_mut()
+            .insert(target_container_idx, origin_container);
+
+        if let Some(target_container) = target_container {
+            self.monitors_mut()
+                .get_mut(origin_monitor_idx)
+                .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+                .workspaces_mut()
+                .get_mut(origin_workspace_idx)
+                .ok_or_else(|| anyhow!("there is no workspace at this index"))?
+                .containers_mut()
+                .insert(origin_container_idx, target_container);
+        }
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn update_focused_workspace(&mut self, follow_focus: bool) -> Result<()> {
         tracing::info!("updating");
 
         let invisible_borders = self.invisible_borders;
@@ -549,15 +653,15 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?
             .update_focused_workspace(offset, &invisible_borders)?;
 
-        if mouse_follows_focus {
+        if follow_focus {
             if let Some(window) = self.focused_workspace()?.maximized_window() {
-                window.focus()?;
+                window.focus(self.mouse_follows_focus)?;
             } else if let Some(container) = self.focused_workspace()?.monocle_container() {
                 if let Some(window) = container.focused_window() {
-                    window.focus()?;
+                    window.focus(self.mouse_follows_focus)?;
                 }
             } else if let Ok(window) = self.focused_window_mut() {
-                window.focus()?;
+                window.focus(self.mouse_follows_focus)?;
             } else {
                 let desktop_window = Window {
                     hwnd: WindowsApi::desktop_window()?,
@@ -583,7 +687,8 @@ impl WindowManager {
         &mut self,
         direction: OperationDirection,
         sizing: Sizing,
-        step: Option<i32>,
+        delta: i32,
+        update: bool,
     ) -> Result<()> {
         let work_area = self.focused_monitor_work_area()?;
         let workspace = self.focused_workspace_mut()?;
@@ -622,21 +727,21 @@ impl WindowManager {
                     // can flip them however they need to be flipped once the resizing has been done
                     if let Some(flip) = workspace.layout_flip() {
                         match flip {
-                            Flip::Horizontal => {
+                            Axis::Horizontal => {
                                 if matches!(direction, OperationDirection::Left)
                                     || matches!(direction, OperationDirection::Right)
                                 {
                                     direction = direction.opposite();
                                 }
                             }
-                            Flip::Vertical => {
+                            Axis::Vertical => {
                                 if matches!(direction, OperationDirection::Up)
                                     || matches!(direction, OperationDirection::Down)
                                 {
                                     direction = direction.opposite();
                                 }
                             }
-                            Flip::HorizontalAndVertical => direction = direction.opposite(),
+                            Axis::HorizontalAndVertical => direction = direction.opposite(),
                         }
                     }
 
@@ -647,11 +752,16 @@ impl WindowManager {
                         focused_idx_resize,
                         direction,
                         sizing,
-                        step,
+                        delta,
                     );
 
                     workspace.resize_dimensions_mut()[focused_idx] = resize;
-                    return self.update_focused_workspace(false);
+
+                    return if update {
+                        self.update_focused_workspace(false)
+                    } else {
+                        Ok(())
+                    };
                 }
 
                 tracing::warn!("cannot resize container in this direction");
@@ -679,11 +789,34 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn move_container_to_monitor(&mut self, idx: usize, follow: bool) -> Result<()> {
+    fn handle_unmanaged_window_behaviour(&self) -> Result<()> {
+        if let OperationBehaviour::NoOp = self.unmanaged_window_operation_behaviour {
+            let workspace = self.focused_workspace()?;
+            let focused_hwnd = WindowsApi::foreground_window()?;
+            if !workspace.contains_managed_window(focused_hwnd) {
+                return Err(anyhow!(
+                    "ignoring commands while active window is not managed by komorebi"
+                ));
+            }
+        }
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn move_container_to_monitor(
+        &mut self,
+        monitor_idx: usize,
+        workspace_idx: Option<usize>,
+        follow: bool,
+    ) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("moving container");
 
         let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
+        let mouse_follows_focus = self.mouse_follows_focus;
 
         let monitor = self
             .focused_monitor_mut()
@@ -702,39 +835,76 @@ impl WindowManager {
             .remove_focused_container()
             .ok_or_else(|| anyhow!("there is no container"))?;
 
+        monitor.update_focused_workspace(offset, &invisible_borders)?;
+
         let target_monitor = self
             .monitors_mut()
-            .get_mut(idx)
+            .get_mut(monitor_idx)
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
-        target_monitor.add_container(container)?;
-        target_monitor.load_focused_workspace()?;
+        target_monitor.add_container(container, workspace_idx)?;
+        target_monitor.load_focused_workspace(mouse_follows_focus)?;
         target_monitor.update_focused_workspace(offset, &invisible_borders)?;
 
         if follow {
-            self.focus_monitor(idx)?;
+            self.focus_monitor(monitor_idx)?;
         }
 
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn move_container_to_workspace(&mut self, idx: usize, follow: bool) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("moving container");
 
+        let mouse_follows_focus = self.mouse_follows_focus;
         let monitor = self
             .focused_monitor_mut()
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         monitor.move_container_to_workspace(idx, follow)?;
-        monitor.load_focused_workspace()?;
+        monitor.load_focused_workspace(mouse_follows_focus)?;
 
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(mouse_follows_focus)
+    }
+
+    pub fn remove_focused_workspace(&mut self) -> Option<Workspace> {
+        let focused_monitor: &mut Monitor = self.focused_monitor_mut()?;
+        let focused_workspace_idx = focused_monitor.focused_workspace_idx();
+        focused_monitor.remove_workspace_by_idx(focused_workspace_idx)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn move_workspace_to_monitor(&mut self, idx: usize) -> Result<()> {
+        tracing::info!("moving workspace");
+        let mouse_follows_focus = self.mouse_follows_focus;
+        let workspace = self
+            .remove_focused_workspace()
+            .ok_or_else(|| anyhow!("there is no workspace"))?;
+
+        {
+            let target_monitor: &mut Monitor = self
+                .monitors_mut()
+                .get_mut(idx)
+                .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+            target_monitor.workspaces_mut().push_back(workspace);
+            target_monitor.focus_workspace(target_monitor.workspaces().len() - 1)?;
+            target_monitor.load_focused_workspace(mouse_follows_focus)?;
+        }
+
+        self.focus_monitor(idx)?;
+        self.update_focused_workspace(mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn focus_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("focusing container");
+
         let workspace = self.focused_workspace_mut()?;
 
         let new_idx = workspace
@@ -742,13 +912,15 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("this is not a valid direction from the current position"))?;
 
         workspace.focus_container(new_idx);
-        self.focused_window_mut()?.focus()?;
+        self.focused_window_mut()?.focus(self.mouse_follows_focus)?;
 
         Ok(())
     }
 
     #[tracing::instrument(skip(self))]
     pub fn move_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("moving container");
 
         let workspace = self.focused_workspace_mut()?;
@@ -760,12 +932,27 @@ impl WindowManager {
 
         workspace.swap_containers(current_idx, new_idx);
         workspace.focus_container(new_idx);
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn focus_container_in_cycle_direction(&mut self, direction: CycleDirection) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("focusing container");
+        let mut maximize_next = false;
+        let mut monocle_next = false;
+
+        if self.focused_workspace_mut()?.maximized_window().is_some() {
+            maximize_next = true;
+            self.unmaximize_window()?;
+        }
+
+        if self.focused_workspace_mut()?.monocle_container().is_some() {
+            monocle_next = true;
+            self.monocle_off()?;
+        }
+
         let workspace = self.focused_workspace_mut()?;
 
         let new_idx = workspace
@@ -773,13 +960,22 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("this is not a valid direction from the current position"))?;
 
         workspace.focus_container(new_idx);
-        self.focused_window_mut()?.focus()?;
+
+        if maximize_next {
+            self.toggle_maximize()?;
+        } else if monocle_next {
+            self.toggle_monocle()?;
+        } else {
+            self.focused_window_mut()?.focus(self.mouse_follows_focus)?;
+        }
 
         Ok(())
     }
 
     #[tracing::instrument(skip(self))]
     pub fn move_container_in_cycle_direction(&mut self, direction: CycleDirection) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("moving container");
 
         let workspace = self.focused_workspace_mut()?;
@@ -791,11 +987,13 @@ impl WindowManager {
 
         workspace.swap_containers(current_idx, new_idx);
         workspace.focus_container(new_idx);
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn cycle_container_window_in_direction(&mut self, direction: CycleDirection) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("cycling container windows");
 
         let container = self.focused_container_mut()?;
@@ -813,11 +1011,13 @@ impl WindowManager {
         container.focus_window(next_idx);
         container.load_focused_window();
 
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn add_window_to_container(&mut self, direction: OperationDirection) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("adding window to container");
 
         let workspace = self.focused_workspace_mut()?;
@@ -846,7 +1046,7 @@ impl WindowManager {
             };
 
             workspace.move_window_to_container(adjusted_new_index)?;
-            self.update_focused_workspace(true)?;
+            self.update_focused_workspace(self.mouse_follows_focus)?;
         }
 
         Ok(())
@@ -854,15 +1054,19 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn promote_container_to_front(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("promoting container");
 
         let workspace = self.focused_workspace_mut()?;
         workspace.promote_container()?;
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn remove_window_from_container(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         tracing::info!("removing window");
 
         if self.focused_container()?.windows().len() == 1 {
@@ -872,7 +1076,7 @@ impl WindowManager {
         let workspace = self.focused_workspace_mut()?;
 
         workspace.new_container_for_focused_window()?;
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
@@ -920,7 +1124,7 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no floating window"))?;
 
         window.center(&work_area, &invisible_borders)?;
-        window.focus()?;
+        window.focus(self.mouse_follows_focus)?;
 
         Ok(())
     }
@@ -935,6 +1139,8 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn toggle_monocle(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         let workspace = self.focused_workspace_mut()?;
 
         match workspace.monocle_container() {
@@ -942,7 +1148,7 @@ impl WindowManager {
             Some(_) => self.monocle_off()?,
         }
 
-        self.update_focused_workspace(false)
+        self.update_focused_workspace(true)
     }
 
     #[tracing::instrument(skip(self))]
@@ -963,6 +1169,8 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn toggle_maximize(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
         let workspace = self.focused_workspace_mut()?;
 
         match workspace.maximized_window() {
@@ -970,7 +1178,7 @@ impl WindowManager {
             Some(_) => self.unmaximize_window()?,
         }
 
-        self.update_focused_workspace(false)
+        self.update_focused_workspace(true)
     }
 
     #[tracing::instrument(skip(self))]
@@ -990,7 +1198,7 @@ impl WindowManager {
     }
 
     #[tracing::instrument(skip(self))]
-    pub fn flip_layout(&mut self, layout_flip: Flip) -> Result<()> {
+    pub fn flip_layout(&mut self, layout_flip: Axis) -> Result<()> {
         tracing::info!("flipping layout");
 
         let workspace = self.focused_workspace_mut()?;
@@ -1002,28 +1210,28 @@ impl WindowManager {
             }
             Some(current_layout_flip) => {
                 match current_layout_flip {
-                    Flip::Horizontal => match layout_flip {
-                        Flip::Horizontal => workspace.set_layout_flip(None),
-                        Flip::Vertical => {
-                            workspace.set_layout_flip(Option::from(Flip::HorizontalAndVertical))
+                    Axis::Horizontal => match layout_flip {
+                        Axis::Horizontal => workspace.set_layout_flip(None),
+                        Axis::Vertical => {
+                            workspace.set_layout_flip(Option::from(Axis::HorizontalAndVertical))
                         }
-                        Flip::HorizontalAndVertical => {
-                            workspace.set_layout_flip(Option::from(Flip::HorizontalAndVertical))
+                        Axis::HorizontalAndVertical => {
+                            workspace.set_layout_flip(Option::from(Axis::HorizontalAndVertical))
                         }
                     },
-                    Flip::Vertical => match layout_flip {
-                        Flip::Horizontal => {
-                            workspace.set_layout_flip(Option::from(Flip::HorizontalAndVertical))
+                    Axis::Vertical => match layout_flip {
+                        Axis::Horizontal => {
+                            workspace.set_layout_flip(Option::from(Axis::HorizontalAndVertical))
                         }
-                        Flip::Vertical => workspace.set_layout_flip(None),
-                        Flip::HorizontalAndVertical => {
-                            workspace.set_layout_flip(Option::from(Flip::HorizontalAndVertical))
+                        Axis::Vertical => workspace.set_layout_flip(None),
+                        Axis::HorizontalAndVertical => {
+                            workspace.set_layout_flip(Option::from(Axis::HorizontalAndVertical))
                         }
                     },
-                    Flip::HorizontalAndVertical => match layout_flip {
-                        Flip::Horizontal => workspace.set_layout_flip(Option::from(Flip::Vertical)),
-                        Flip::Vertical => workspace.set_layout_flip(Option::from(Flip::Horizontal)),
-                        Flip::HorizontalAndVertical => workspace.set_layout_flip(None),
+                    Axis::HorizontalAndVertical => match layout_flip {
+                        Axis::Horizontal => workspace.set_layout_flip(Option::from(Axis::Vertical)),
+                        Axis::Vertical => workspace.set_layout_flip(Option::from(Axis::Horizontal)),
+                        Axis::HorizontalAndVertical => workspace.set_layout_flip(None),
                     },
                 };
             }
@@ -1054,7 +1262,7 @@ impl WindowManager {
         }
 
         workspace.set_layout(Layout::Default(layout));
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
@@ -1080,7 +1288,7 @@ impl WindowManager {
         }
 
         workspace.set_layout(Layout::Custom(layout));
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
@@ -1135,6 +1343,127 @@ impl WindowManager {
         self.update_focused_workspace(false)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn add_workspace_layout_default_rule(
+        &mut self,
+        monitor_idx: usize,
+        workspace_idx: usize,
+        at_container_count: usize,
+        layout: DefaultLayout,
+    ) -> Result<()> {
+        tracing::info!("setting workspace layout");
+
+        let invisible_borders = self.invisible_borders;
+        let offset = self.work_area_offset;
+        let focused_monitor_idx = self.focused_monitor_idx();
+
+        let monitor = self
+            .monitors_mut()
+            .get_mut(monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+        let work_area = *monitor.work_area_size();
+        let focused_workspace_idx = monitor.focused_workspace_idx();
+
+        let workspace = monitor
+            .workspaces_mut()
+            .get_mut(workspace_idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+        let rules: &mut Vec<(usize, Layout)> = workspace.layout_rules_mut();
+        rules.retain(|pair| pair.0 != at_container_count);
+        rules.push((at_container_count, Layout::Default(layout)));
+        rules.sort_by(|a, b| a.0.cmp(&b.0));
+
+        // If this is the focused workspace on a non-focused screen, let's update it
+        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
+            workspace.update(&work_area, offset, &invisible_borders)?;
+            Ok(())
+        } else {
+            Ok(self.update_focused_workspace(false)?)
+        }
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn add_workspace_layout_custom_rule(
+        &mut self,
+        monitor_idx: usize,
+        workspace_idx: usize,
+        at_container_count: usize,
+        path: PathBuf,
+    ) -> Result<()> {
+        tracing::info!("setting workspace layout");
+
+        let invisible_borders = self.invisible_borders;
+        let offset = self.work_area_offset;
+        let focused_monitor_idx = self.focused_monitor_idx();
+
+        let monitor = self
+            .monitors_mut()
+            .get_mut(monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+        let work_area = *monitor.work_area_size();
+        let focused_workspace_idx = monitor.focused_workspace_idx();
+
+        let workspace = monitor
+            .workspaces_mut()
+            .get_mut(workspace_idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+        let layout = CustomLayout::from_path_buf(path)?;
+
+        let rules: &mut Vec<(usize, Layout)> = workspace.layout_rules_mut();
+        rules.retain(|pair| pair.0 != at_container_count);
+        rules.push((at_container_count, Layout::Custom(layout)));
+        rules.sort_by(|a, b| a.0.cmp(&b.0));
+
+        // If this is the focused workspace on a non-focused screen, let's update it
+        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
+            workspace.update(&work_area, offset, &invisible_borders)?;
+            Ok(())
+        } else {
+            Ok(self.update_focused_workspace(false)?)
+        }
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn clear_workspace_layout_rules(
+        &mut self,
+        monitor_idx: usize,
+        workspace_idx: usize,
+    ) -> Result<()> {
+        tracing::info!("setting workspace layout");
+
+        let invisible_borders = self.invisible_borders;
+        let offset = self.work_area_offset;
+        let focused_monitor_idx = self.focused_monitor_idx();
+
+        let monitor = self
+            .monitors_mut()
+            .get_mut(monitor_idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+        let work_area = *monitor.work_area_size();
+        let focused_workspace_idx = monitor.focused_workspace_idx();
+
+        let workspace = monitor
+            .workspaces_mut()
+            .get_mut(workspace_idx)
+            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+        let rules: &mut Vec<(usize, Layout)> = workspace.layout_rules_mut();
+        rules.clear();
+
+        // If this is the focused workspace on a non-focused screen, let's update it
+        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
+            workspace.update(&work_area, offset, &invisible_borders)?;
+            Ok(())
+        } else {
+            Ok(self.update_focused_workspace(false)?)
+        }
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn set_workspace_layout_default(
         &mut self,
@@ -1362,28 +1691,30 @@ impl WindowManager {
     pub fn focus_workspace(&mut self, idx: usize) -> Result<()> {
         tracing::info!("focusing workspace");
 
+        let mouse_follows_focus = self.mouse_follows_focus;
         let monitor = self
             .focused_monitor_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?;
 
         monitor.focus_workspace(idx)?;
-        monitor.load_focused_workspace()?;
+        monitor.load_focused_workspace(mouse_follows_focus)?;
 
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(mouse_follows_focus)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn new_workspace(&mut self) -> Result<()> {
         tracing::info!("adding new workspace");
 
+        let mouse_follows_focus = self.mouse_follows_focus;
         let monitor = self
             .focused_monitor_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?;
 
         monitor.focus_workspace(monitor.new_workspace_idx())?;
-        monitor.load_focused_workspace()?;
+        monitor.load_focused_workspace(mouse_follows_focus)?;
 
-        self.update_focused_workspace(true)
+        self.update_focused_workspace(self.mouse_follows_focus)
     }
 
     pub fn focused_container(&self) -> Result<&Container> {

komorebi/src/window_manager_event.rs

@@ -1,13 +1,14 @@
 use std::fmt::Display;
 use std::fmt::Formatter;
 
+use schemars::JsonSchema;
 use serde::Serialize;
 
 use crate::window::Window;
 use crate::winevent::WinEvent;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 
-#[derive(Debug, Copy, Clone, Serialize)]
+#[derive(Debug, Copy, Clone, Serialize, JsonSchema)]
 #[serde(tag = "type", content = "content")]
 pub enum WindowManagerEvent {
     Destroy(WinEvent, Window),
@@ -15,6 +16,7 @@ pub enum WindowManagerEvent {
     Hide(WinEvent, Window),
     Minimize(WinEvent, Window),
     Show(WinEvent, Window),
+    MoveResizeStart(WinEvent, Window),
     MoveResizeEnd(WinEvent, Window),
     MouseCapture(WinEvent, Window),
     Manage(Window),
@@ -51,6 +53,13 @@ impl Display for WindowManagerEvent {
             WindowManagerEvent::Show(winevent, window) => {
                 write!(f, "Show (WinEvent: {}, Window: {})", winevent, window)
             }
+            WindowManagerEvent::MoveResizeStart(winevent, window) => {
+                write!(
+                    f,
+                    "MoveResizeStart (WinEvent: {}, Window: {})",
+                    winevent, window
+                )
+            }
             WindowManagerEvent::MoveResizeEnd(winevent, window) => {
                 write!(
                     f,
@@ -87,6 +96,7 @@ impl WindowManagerEvent {
             | WindowManagerEvent::Hide(_, window)
             | WindowManagerEvent::Minimize(_, window)
             | WindowManagerEvent::Show(_, window)
+            | WindowManagerEvent::MoveResizeStart(_, window)
             | WindowManagerEvent::MoveResizeEnd(_, window)
             | WindowManagerEvent::MouseCapture(_, window)
             | WindowManagerEvent::MonitorPoll(_, window)
@@ -113,6 +123,7 @@ impl WindowManagerEvent {
             WinEvent::ObjectFocus | WinEvent::SystemForeground => {
                 Option::from(Self::FocusChange(winevent, window))
             }
+            WinEvent::SystemMoveSizeStart => Option::from(Self::MoveResizeStart(winevent, window)),
             WinEvent::SystemMoveSizeEnd => Option::from(Self::MoveResizeEnd(winevent, window)),
             WinEvent::SystemCaptureStart | WinEvent::SystemCaptureEnd => {
                 Option::from(Self::MouseCapture(winevent, window))
@@ -127,7 +138,10 @@ impl WindowManagerEvent {
 
                 let object_name_change_on_launch = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
 
-                if object_name_change_on_launch.contains(&window.exe().ok()?) {
+                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()?)
+                {
                     Option::from(Self::Show(winevent, window))
                 } else {
                     None

komorebi/src/windows_api.rs

@@ -1,85 +1,85 @@
 use std::collections::VecDeque;
 use std::convert::TryFrom;
-use std::convert::TryInto;
 use std::ffi::c_void;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::Error;
 use color_eyre::Result;
+use windows::core::Result as WindowsCrateResult;
+use windows::core::PWSTR;
+use windows::Win32::Foundation::BOOL;
+use windows::Win32::Foundation::HANDLE;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::Foundation::LPARAM;
+use windows::Win32::Foundation::POINT;
+use windows::Win32::Foundation::RECT;
+use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
+use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
+use windows::Win32::Graphics::Dwm::DWMWINDOWATTRIBUTE;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
+use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
+use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
+use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
+use windows::Win32::Graphics::Gdi::MonitorFromPoint;
+use windows::Win32::Graphics::Gdi::MonitorFromWindow;
+use windows::Win32::Graphics::Gdi::HDC;
+use windows::Win32::Graphics::Gdi::HMONITOR;
+use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
+use windows::Win32::Graphics::Gdi::MONITORINFO;
+use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
+use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
+use windows::Win32::System::Threading::AttachThreadInput;
+use windows::Win32::System::Threading::GetCurrentProcessId;
+use windows::Win32::System::Threading::GetCurrentThreadId;
+use windows::Win32::System::Threading::OpenProcess;
+use windows::Win32::System::Threading::QueryFullProcessImageNameW;
+use windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS;
+use windows::Win32::System::Threading::PROCESS_NAME_WIN32;
+use windows::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
+use windows::Win32::UI::Input::KeyboardAndMouse::SetFocus;
+use windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::EnumWindows;
+use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
+use windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
+use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::GetTopWindow;
+use windows::Win32::UI::WindowsAndMessaging::GetWindow;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowRect;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowTextW;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
+use windows::Win32::UI::WindowsAndMessaging::IsIconic;
+use windows::Win32::UI::WindowsAndMessaging::IsWindow;
+use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
+use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
+use windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
+use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
+use windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
+use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
+use windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
+use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
+use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
+use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
+use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
+use windows::Win32::UI::WindowsAndMessaging::HWND_NOTOPMOST;
+use windows::Win32::UI::WindowsAndMessaging::HWND_TOPMOST;
+use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
+use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
+use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::SPI_GETACTIVEWINDOWTRACKING;
+use windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
+use windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
+use windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
+use windows::Win32::UI::WindowsAndMessaging::SW_MINIMIZE;
+use windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
+use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
+use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
+use windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
+use windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
 
-use bindings::Handle;
-use bindings::Result as WindowsCrateResult;
-use bindings::Windows::Win32::Foundation::BOOL;
-use bindings::Windows::Win32::Foundation::HANDLE;
-use bindings::Windows::Win32::Foundation::HWND;
-use bindings::Windows::Win32::Foundation::LPARAM;
-use bindings::Windows::Win32::Foundation::POINT;
-use bindings::Windows::Win32::Foundation::PWSTR;
-use bindings::Windows::Win32::Foundation::RECT;
-use bindings::Windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
-use bindings::Windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
-use bindings::Windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
-use bindings::Windows::Win32::Graphics::Dwm::DWMWINDOWATTRIBUTE;
-use bindings::Windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
-use bindings::Windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
-use bindings::Windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
-use bindings::Windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
-use bindings::Windows::Win32::Graphics::Gdi::GetMonitorInfoW;
-use bindings::Windows::Win32::Graphics::Gdi::MonitorFromPoint;
-use bindings::Windows::Win32::Graphics::Gdi::MonitorFromWindow;
-use bindings::Windows::Win32::Graphics::Gdi::HDC;
-use bindings::Windows::Win32::Graphics::Gdi::HMONITOR;
-use bindings::Windows::Win32::Graphics::Gdi::MONITORENUMPROC;
-use bindings::Windows::Win32::Graphics::Gdi::MONITORINFO;
-use bindings::Windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
-use bindings::Windows::Win32::System::Threading::AttachThreadInput;
-use bindings::Windows::Win32::System::Threading::GetCurrentProcessId;
-use bindings::Windows::Win32::System::Threading::GetCurrentThreadId;
-use bindings::Windows::Win32::System::Threading::OpenProcess;
-use bindings::Windows::Win32::System::Threading::QueryFullProcessImageNameW;
-use bindings::Windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS;
-use bindings::Windows::Win32::System::Threading::PROCESS_NAME_FORMAT;
-use bindings::Windows::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
-use bindings::Windows::Win32::UI::KeyboardAndMouseInput::SetFocus;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EnumWindows;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetTopWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindowRect;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindowTextW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::IsIconic;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::IsWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::ShowWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::HWND_NOTOPMOST;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::HWND_TOPMOST;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SPI_GETACTIVEWINDOWTRACKING;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
 use komorebi_core::Rect;
 
 use crate::container::Container;
@@ -124,15 +124,16 @@ pub trait ProcessWindowsCrateResult<T> {
     fn process(self) -> Result<T>;
 }
 
-macro_rules! impl_process_windows_crate_result {
+macro_rules! impl_process_windows_crate_integer_wrapper_result {
     ( $($input:ty => $deref:ty),+ $(,)? ) => (
         paste::paste! {
             $(
-                impl ProcessWindowsCrateResult<$deref> for WindowsCrateResult<$input> {
+                impl ProcessWindowsCrateResult<$deref> for $input {
                     fn process(self) -> Result<$deref> {
-                        match self {
-                            Ok(value) => Ok(value.0),
-                            Err(error) => Err(error.into()),
+                        if self == HWND(0) {
+                            Err(std::io::Error::last_os_error().into())
+                        } else {
+                            Ok(self.0)
                         }
                     }
                 }
@@ -141,7 +142,7 @@ macro_rules! impl_process_windows_crate_result {
     );
 }
 
-impl_process_windows_crate_result!(
+impl_process_windows_crate_integer_wrapper_result!(
     HWND => isize,
 );
 
@@ -165,7 +166,7 @@ impl WindowsApi {
             EnumDisplayMonitors(
                 HDC(0),
                 std::ptr::null_mut(),
-                Option::from(callback),
+                callback,
                 LPARAM(callback_data_address),
             )
         }
@@ -177,7 +178,7 @@ impl WindowsApi {
         let mut monitors: Vec<isize> = vec![];
         let monitors_ref: &mut Vec<isize> = monitors.as_mut();
         Self::enum_display_monitors(
-            windows_callbacks::valid_display_monitors,
+            Option::Some(windows_callbacks::valid_display_monitors),
             monitors_ref as *mut Vec<isize> as isize,
         )?;
 
@@ -186,13 +187,13 @@ impl WindowsApi {
 
     pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
         Self::enum_display_monitors(
-            windows_callbacks::enum_display_monitor,
+            Option::Some(windows_callbacks::enum_display_monitor),
             monitors as *mut Ring<Monitor> as isize,
         )
     }
 
     pub fn enum_windows(callback: WNDENUMPROC, callback_data_address: isize) -> Result<()> {
-        unsafe { EnumWindows(Option::from(callback), LPARAM(callback_data_address)) }
+        unsafe { EnumWindows(callback, LPARAM(callback_data_address)) }
             .ok()
             .process()
     }
@@ -203,7 +204,7 @@ impl WindowsApi {
             if let Some(workspace) = monitor.workspaces_mut().front_mut() {
                 // EnumWindows will enumerate through windows on all monitors
                 Self::enum_windows(
-                    windows_callbacks::enum_window,
+                    Option::Some(windows_callbacks::enum_window),
                     workspace.containers_mut() as *mut VecDeque<Container> as isize,
                 )?;
 
@@ -279,6 +280,10 @@ impl WindowsApi {
         unsafe { ShowWindow(hwnd, command) };
     }
 
+    pub fn minimize_window(hwnd: HWND) {
+        Self::show_window(hwnd, SW_MINIMIZE);
+    }
+
     pub fn hide_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_HIDE);
     }
@@ -292,7 +297,7 @@ impl WindowsApi {
     }
 
     pub fn foreground_window() -> Result<isize> {
-        unsafe { GetForegroundWindow() }.ok().process()
+        unsafe { GetForegroundWindow() }.process()
     }
 
     pub fn set_foreground_window(hwnd: HWND) -> Result<()> {
@@ -301,16 +306,16 @@ impl WindowsApi {
 
     #[allow(dead_code)]
     pub fn top_window() -> Result<isize> {
-        unsafe { GetTopWindow(HWND::default()) }.ok().process()
+        unsafe { GetTopWindow(HWND::default()) }.process()
     }
 
     pub fn desktop_window() -> Result<isize> {
-        unsafe { GetDesktopWindow() }.ok().process()
+        unsafe { GetDesktopWindow() }.process()
     }
 
     #[allow(dead_code)]
     pub fn next_window(hwnd: HWND) -> Result<isize> {
-        unsafe { GetWindow(hwnd, GW_HWNDNEXT) }.ok().process()
+        unsafe { GetWindow(hwnd, GW_HWNDNEXT) }.process()
     }
 
     #[allow(dead_code)]
@@ -348,7 +353,7 @@ impl WindowsApi {
     }
 
     pub fn window_from_point(point: POINT) -> Result<isize> {
-        unsafe { WindowFromPoint(point) }.ok().process()
+        unsafe { WindowFromPoint(point) }.process()
     }
 
     pub fn window_at_cursor_pos() -> Result<isize> {
@@ -377,6 +382,19 @@ impl WindowsApi {
         unsafe { GetCurrentProcessId() }
     }
 
+    pub fn process_id_to_session_id() -> Result<u32> {
+        let process_id = Self::current_process_id();
+        let mut session_id = 0;
+
+        unsafe {
+            if ProcessIdToSessionId(process_id, &mut session_id).as_bool() {
+                Ok(session_id)
+            } else {
+                Err(anyhow!("could not determine current session id"))
+            }
+        }
+    }
+
     pub fn attach_thread_input(thread_id: u32, target_thread_id: u32, attach: bool) -> Result<()> {
         unsafe { AttachThreadInput(thread_id, target_thread_id, attach) }
             .ok()
@@ -384,7 +402,7 @@ impl WindowsApi {
     }
 
     pub fn set_focus(hwnd: HWND) -> Result<()> {
-        unsafe { SetFocus(hwnd) }.ok().map(|_| ()).process()
+        unsafe { SetFocus(hwnd) }.process().map(|_| ())
     }
 
     #[allow(dead_code)]
@@ -420,9 +438,7 @@ impl WindowsApi {
 
     pub fn window_text_w(hwnd: HWND) -> Result<String> {
         let mut text: [u16; 512] = [0; 512];
-        match WindowsResult::from(unsafe {
-            GetWindowTextW(hwnd, PWSTR(text.as_mut_ptr()), text.len().try_into()?)
-        }) {
+        match WindowsResult::from(unsafe { GetWindowTextW(hwnd, &mut text) }) {
             WindowsResult::Ok(len) => {
                 let length = usize::try_from(len)?;
                 Ok(String::from_utf16(&text[..length])?)
@@ -436,9 +452,7 @@ impl WindowsApi {
         inherit_handle: bool,
         process_id: u32,
     ) -> Result<HANDLE> {
-        unsafe { OpenProcess(access_rights, inherit_handle, process_id) }
-            .ok()
-            .process()
+        unsafe { OpenProcess(access_rights, inherit_handle, process_id) }.process()
     }
 
     pub fn process_handle(process_id: u32) -> Result<HANDLE> {
@@ -453,9 +467,9 @@ impl WindowsApi {
         unsafe {
             QueryFullProcessImageNameW(
                 handle,
-                PROCESS_NAME_FORMAT(0),
+                PROCESS_NAME_WIN32,
                 PWSTR(text_ptr),
-                &mut len as *mut u32,
+                std::ptr::addr_of_mut!(len),
             )
         }
         .ok()
@@ -477,7 +491,7 @@ impl WindowsApi {
         let mut class: [u16; BUF_SIZE] = [0; BUF_SIZE];
 
         let len = Result::from(WindowsResult::from(unsafe {
-            RealGetWindowClassW(hwnd, PWSTR(class.as_mut_ptr()), u32::try_from(BUF_SIZE)?)
+            RealGetWindowClassW(hwnd, &mut class)
         }))?;
 
         Ok(String::from_utf16(&class[0..len as usize])?)
@@ -491,7 +505,7 @@ impl WindowsApi {
         unsafe {
             DwmGetWindowAttribute(
                 hwnd,
-                std::mem::transmute::<_, u32>(attribute),
+                attribute,
                 (value as *mut T).cast(),
                 u32::try_from(std::mem::size_of::<T>())?,
             )?;
@@ -534,7 +548,7 @@ impl WindowsApi {
         let mut monitor_info: MONITORINFO = unsafe { std::mem::zeroed() };
         monitor_info.cbSize = u32::try_from(std::mem::size_of::<MONITORINFO>())?;
 
-        unsafe { GetMonitorInfoW(hmonitor, (&mut monitor_info as *mut MONITORINFO).cast()) }
+        unsafe { GetMonitorInfoW(hmonitor, std::ptr::addr_of_mut!(monitor_info).cast()) }
             .ok()
             .process()?;
 
@@ -570,7 +584,7 @@ impl WindowsApi {
         Self::system_parameters_info_w(
             SPI_GETACTIVEWINDOWTRACKING,
             0,
-            (&mut is_enabled as *mut BOOL).cast(),
+            std::ptr::addr_of_mut!(is_enabled).cast(),
             SPIF_SENDCHANGE,
         )?;
 

komorebi/src/windows_callbacks.rs

@@ -1,12 +1,12 @@
 use std::collections::VecDeque;
 
-use bindings::Windows::Win32::Foundation::BOOL;
-use bindings::Windows::Win32::Foundation::HWND;
-use bindings::Windows::Win32::Foundation::LPARAM;
-use bindings::Windows::Win32::Foundation::RECT;
-use bindings::Windows::Win32::Graphics::Gdi::HDC;
-use bindings::Windows::Win32::Graphics::Gdi::HMONITOR;
-use bindings::Windows::Win32::UI::Accessibility::HWINEVENTHOOK;
+use windows::Win32::Foundation::BOOL;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::Foundation::LPARAM;
+use windows::Win32::Foundation::RECT;
+use windows::Win32::Graphics::Gdi::HDC;
+use windows::Win32::Graphics::Gdi::HMONITOR;
+use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
 
 use crate::container::Container;
 use crate::monitor::Monitor;

komorebi/src/winevent.rs

@@ -1,92 +1,94 @@
+#![allow(clippy::use_self)]
+
+use schemars::JsonSchema;
 use serde::Serialize;
 use strum::Display;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_AIA_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_AIA_START;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_CARET;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_END_APPLICATION;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_LAYOUT;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_START_APPLICATION;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_UPDATE_REGION;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_UPDATE_SCROLL;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_UPDATE_SIMPLE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_ACCELERATORCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_CLOAKED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_CONTENTSCROLLED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_CREATE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DEFACTIONCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESCRIPTIONCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESTROY;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGCANCEL;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGCOMPLETE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGDROPPED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGENTER;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGLEAVE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_FOCUS;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_HELPCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_HIDE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_HOSTEDOBJECTSINVALIDATED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_IME_CHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_IME_HIDE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_IME_SHOW;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_INVOKED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LIVEREGIONCHANGED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LOCATIONCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_NAMECHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_PARENTCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_REORDER;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTION;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTIONADD;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTIONREMOVE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTIONWITHIN;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SHOW;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_STATECHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_TEXTEDIT_CONVERSIONTARGETCHANGED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_TEXTSELECTIONCHANGED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_UNCLOAKED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_VALUECHANGE;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OEM_DEFINED_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_OEM_DEFINED_START;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_ALERT;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_ARRANGMENTPREVIEW;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CAPTUREEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CAPTURESTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CONTEXTHELPEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CONTEXTHELPSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DESKTOPSWITCH;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DIALOGEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DIALOGSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DRAGDROPEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DRAGDROPSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_FOREGROUND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_IME_KEY_NOTIFICATION;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUPOPUPEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUPOPUPSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MINIMIZEEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MINIMIZESTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MOVESIZEEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MOVESIZESTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SCROLLINGEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SCROLLINGSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SOUND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHEND;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_APPDROPPED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_APPGRABBED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_APPOVERTARGET;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_CANCELLED;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHSTART;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;
 
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_AIA_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_AIA_START;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_CARET;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_END_APPLICATION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_LAYOUT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_START_APPLICATION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_UPDATE_REGION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_UPDATE_SCROLL;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_CONSOLE_UPDATE_SIMPLE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_ACCELERATORCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_CLOAKED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_CONTENTSCROLLED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_CREATE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DEFACTIONCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESCRIPTIONCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESTROY;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGCANCEL;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGCOMPLETE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGDROPPED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGENTER;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGLEAVE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DRAGSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_FOCUS;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_HELPCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_HIDE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_HOSTEDOBJECTSINVALIDATED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_IME_CHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_IME_HIDE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_IME_SHOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_INVOKED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LIVEREGIONCHANGED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LOCATIONCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_NAMECHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_PARENTCHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_REORDER;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTIONADD;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTIONREMOVE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SELECTIONWITHIN;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_SHOW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_STATECHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_TEXTEDIT_CONVERSIONTARGETCHANGED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_TEXTSELECTIONCHANGED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_UNCLOAKED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_VALUECHANGE;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OEM_DEFINED_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_OEM_DEFINED_START;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_ALERT;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_ARRANGMENTPREVIEW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CAPTUREEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CAPTURESTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CONTEXTHELPEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_CONTEXTHELPSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DESKTOPSWITCH;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DIALOGEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DIALOGSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DRAGDROPEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_DRAGDROPSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_FOREGROUND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_IME_KEY_NOTIFICATION;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUPOPUPEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUPOPUPSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MENUSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MINIMIZEEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MINIMIZESTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MOVESIZEEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_MOVESIZESTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SCROLLINGEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SCROLLINGSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SOUND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHEND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_APPDROPPED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_APPGRABBED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_APPOVERTARGET;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHER_CANCELLED;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_SYSTEM_SWITCHSTART;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;
-
-#[derive(Clone, Copy, PartialEq, Debug, Serialize, Display)]
+#[derive(Clone, Copy, PartialEq, Debug, Serialize, Display, JsonSchema)]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {

komorebi/src/winevent_listener.rs

@@ -8,16 +8,15 @@ use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
-
-use bindings::Windows::Win32::Foundation::HWND;
-use bindings::Windows::Win32::UI::Accessibility::SetWinEventHook;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::PeekMessageW;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_MAX;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_MIN;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::MSG;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::PM_REMOVE;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::Accessibility::SetWinEventHook;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
+use windows::Win32::UI::WindowsAndMessaging::PeekMessageW;
+use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_MAX;
+use windows::Win32::UI::WindowsAndMessaging::EVENT_MIN;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::PM_REMOVE;
 
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_callbacks;

komorebi/src/workspace.rs

@@ -7,11 +7,12 @@ use getset::CopyGetters;
 use getset::Getters;
 use getset::MutGetters;
 use getset::Setters;
+use schemars::JsonSchema;
 use serde::Serialize;
 
+use komorebi_core::Axis;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
-use komorebi_core::Flip;
 use komorebi_core::Layout;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
@@ -21,7 +22,7 @@ use crate::ring::Ring;
 use crate::window::Window;
 use crate::windows_api::WindowsApi;
 
-#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters)]
+#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
 pub struct Workspace {
     #[getset(set = "pub")]
     name: Option<String>,
@@ -38,10 +39,12 @@ pub struct Workspace {
     maximized_window_restore_idx: Option<usize>,
     #[getset(get = "pub", get_mut = "pub")]
     floating_windows: Vec<Window>,
-    #[getset(get = "pub", set = "pub")]
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
     layout: Layout,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    layout_rules: Vec<(usize, Layout)>,
     #[getset(get_copy = "pub", set = "pub")]
-    layout_flip: Option<Flip>,
+    layout_flip: Option<Axis>,
     #[getset(get_copy = "pub", set = "pub")]
     workspace_padding: Option<i32>,
     #[getset(get_copy = "pub", set = "pub")]
@@ -68,6 +71,7 @@ impl Default for Workspace {
             monocle_container_restore_idx: None,
             floating_windows: Vec::default(),
             layout: Layout::Default(DefaultLayout::BSP),
+            layout_rules: vec![],
             layout_flip: None,
             workspace_padding: Option::from(10),
             container_padding: Option::from(10),
@@ -101,7 +105,7 @@ impl Workspace {
         }
     }
 
-    pub fn restore(&mut self) -> Result<()> {
+    pub fn restore(&mut self, mouse_follows_focus: bool) -> Result<()> {
         let idx = self.focused_container_idx();
         let mut to_focus = None;
         for (i, container) in self.containers_mut().iter_mut().enumerate() {
@@ -132,7 +136,7 @@ impl Workspace {
         // Maximised windows should always be drawn at the top of the Z order
         if let Some(window) = to_focus {
             if self.maximized_window().is_none() {
-                window.focus()?;
+                window.focus(mouse_follows_focus)?;
             }
         }
 
@@ -163,6 +167,20 @@ impl Workspace {
 
         self.enforce_resize_constraints();
 
+        if !self.layout_rules().is_empty() {
+            let mut updated_layout = None;
+
+            for rule in self.layout_rules() {
+                if self.containers().len() >= rule.0 {
+                    updated_layout = Option::from(rule.1.clone());
+                }
+            }
+
+            if let Some(updated_layout) = updated_layout {
+                self.set_layout(updated_layout);
+            }
+        }
+
         if *self.tile() {
             if let Some(container) = self.monocle_container_mut() {
                 if let Some(window) = container.focused_window_mut() {
@@ -316,6 +334,28 @@ impl Workspace {
         None
     }
 
+    pub fn contains_managed_window(&self, hwnd: isize) -> bool {
+        for container in self.containers() {
+            if container.contains_window(hwnd) {
+                return true;
+            }
+        }
+
+        if let Some(window) = self.maximized_window() {
+            if hwnd == window.hwnd {
+                return true;
+            }
+        }
+
+        if let Some(container) = self.monocle_container() {
+            if container.contains_window(hwnd) {
+                return true;
+            }
+        }
+
+        false
+    }
+
     pub fn contains_window(&self, hwnd: isize) -> bool {
         for container in self.containers() {
             if container.contains_window(hwnd) {
@@ -456,9 +496,11 @@ impl Workspace {
             if self.resize_dimensions().get(container_idx).is_some() {
                 self.resize_dimensions_mut().remove(container_idx);
             }
-        }
 
-        self.focus_previous_container();
+            self.focus_previous_container();
+        } else {
+            container.load_focused_window();
+        }
 
         Ok(())
     }
@@ -471,6 +513,13 @@ impl Workspace {
         container
     }
 
+    pub fn remove_container(&mut self, idx: usize) -> Option<Container> {
+        let container = self.remove_container_by_idx(idx);
+        self.focus_previous_container();
+
+        container
+    }
+
     pub fn new_idx_for_direction(&self, direction: OperationDirection) -> Option<usize> {
         let len = NonZeroUsize::new(self.containers().len())?;
 

komorebic.lib.sample.ahk

@@ -28,20 +28,20 @@ Log() {
     Run, komorebic.exe log, , Hide
 }
 
-QuickSave() {
-    Run, komorebic.exe quick-save, , Hide
+QuickSaveResize() {
+    Run, komorebic.exe quick-save-resize, , Hide
 }
 
-QuickLoad() {
-    Run, komorebic.exe quick-load, , Hide
+QuickLoadResize() {
+    Run, komorebic.exe quick-load-resize, , Hide
 }
 
-Save(path) {
-    Run, komorebic.exe save %path%, , Hide
+SaveResize(path) {
+    Run, komorebic.exe save-resize %path%, , Hide
 }
 
-Load(path) {
-    Run, komorebic.exe load %path%, , Hide
+LoadResize(path) {
+    Run, komorebic.exe load-resize %path%, , Hide
 }
 
 Focus(operation_direction) {
@@ -68,6 +68,10 @@ Resize(edge, sizing) {
     Run, komorebic.exe resize %edge% %sizing%, , Hide
 }
 
+ResizeAxis(axis, sizing) {
+    Run, komorebic.exe resize-axis %axis% %sizing%, , Hide
+}
+
 Unstack() {
     Run, komorebic.exe unstack, , Hide
 }
@@ -92,6 +96,10 @@ SendToWorkspace(target) {
     Run, komorebic.exe send-to-workspace %target%, , Hide
 }
 
+SendToMonitorWorkspace(target_monitor, target_workspace) {
+    Run, komorebic.exe send-to-monitor-workspace %target_monitor% %target_workspace%, , Hide
+}
+
 FocusMonitor(target) {
     Run, komorebic.exe focus-monitor %target%, , Hide
 }
@@ -100,6 +108,10 @@ FocusWorkspace(target) {
     Run, komorebic.exe focus-workspace %target%, , Hide
 }
 
+FocusMonitorWorkspace(target_monitor, target_workspace) {
+    Run, komorebic.exe focus-monitor-workspace %target_monitor% %target_workspace%, , Hide
+}
+
 CycleMonitor(cycle_direction) {
     Run, komorebic.exe cycle-monitor %cycle_direction%, , Hide
 }
@@ -108,10 +120,18 @@ CycleWorkspace(cycle_direction) {
     Run, komorebic.exe cycle-workspace %cycle_direction%, , Hide
 }
 
+MoveWorkspaceToMonitor(target) {
+    Run, komorebic.exe move-workspace-to-monitor %target%, , Hide
+}
+
 NewWorkspace() {
     Run, komorebic.exe new-workspace, , Hide
 }
 
+ResizeDelta(pixels) {
+    Run, komorebic.exe resize-delta %pixels%, , Hide
+}
+
 InvisibleBorders(left, top, right, bottom) {
     Run, komorebic.exe invisible-borders %left% %top% %right% %bottom%, , Hide
 }
@@ -136,8 +156,8 @@ LoadCustomLayout(path) {
     Run, komorebic.exe load-custom-layout %path%, , Hide
 }
 
-FlipLayout(flip) {
-    Run, komorebic.exe flip-layout %flip%, , Hide
+FlipLayout(axis) {
+    Run, komorebic.exe flip-layout %axis%, , Hide
 }
 
 Promote() {
@@ -168,6 +188,18 @@ WorkspaceCustomLayout(monitor, workspace, path) {
     Run, komorebic.exe workspace-custom-layout %monitor% %workspace% %path%, , Hide
 }
 
+WorkspaceLayoutRule(monitor, workspace, at_container_count, layout) {
+    Run, komorebic.exe workspace-layout-rule %monitor% %workspace% %at_container_count% %layout%, , Hide
+}
+
+WorkspaceCustomLayoutRule(monitor, workspace, at_container_count, path) {
+    Run, komorebic.exe workspace-custom-layout-rule %monitor% %workspace% %at_container_count% %path%, , Hide
+}
+
+ClearWorkspaceLayoutRules(monitor, workspace) {
+    Run, komorebic.exe clear-workspace-layout-rules %monitor% %workspace%, , Hide
+}
+
 WorkspaceTiling(monitor, workspace, value) {
     Run, komorebic.exe workspace-tiling %monitor% %workspace% %value%, , Hide
 }
@@ -176,6 +208,10 @@ WorkspaceName(monitor, workspace, value) {
     Run, komorebic.exe workspace-name %monitor% %workspace% %value%, , Hide
 }
 
+ToggleWindowContainerBehaviour() {
+    Run, komorebic.exe toggle-window-container-behaviour, , Hide
+}
+
 TogglePause() {
     Run, komorebic.exe toggle-pause, , Hide
 }
@@ -216,24 +252,40 @@ WatchConfiguration(boolean_state) {
     Run, komorebic.exe watch-configuration %boolean_state%, , Hide
 }
 
+WindowHidingBehaviour(hiding_behaviour) {
+    Run, komorebic.exe window-hiding-behaviour %hiding_behaviour%, , Hide
+}
+
+UnmanagedWindowOperationBehaviour(operation_behaviour) {
+    Run, komorebic.exe unmanaged-window-operation-behaviour %operation_behaviour%, , Hide
+}
+
 FloatRule(identifier, id) {
-    Run, komorebic.exe float-rule %identifier% %id%, , Hide
+    Run, komorebic.exe float-rule %identifier% "%id%", , Hide
 }
 
 ManageRule(identifier, id) {
-    Run, komorebic.exe manage-rule %identifier% %id%, , Hide
+    Run, komorebic.exe manage-rule %identifier% "%id%", , Hide
 }
 
 WorkspaceRule(identifier, id, monitor, workspace) {
-    Run, komorebic.exe workspace-rule %identifier% %id% %monitor% %workspace%, , Hide
+    Run, komorebic.exe workspace-rule %identifier% "%id%" %monitor% %workspace%, , Hide
+}
+
+IdentifyObjectNameChangeApplication(identifier, id) {
+    Run, komorebic.exe identify-object-name-change-application %identifier% "%id%", , Hide
 }
 
 IdentifyTrayApplication(identifier, id) {
-    Run, komorebic.exe identify-tray-application %identifier% %id%, , Hide
+    Run, komorebic.exe identify-tray-application %identifier% "%id%", , Hide
 }
 
-IdentifyBorderOverflow(identifier, id) {
-    Run, komorebic.exe identify-border-overflow %identifier% %id%, , Hide
+IdentifyLayeredApplication(identifier, id) {
+    Run, komorebic.exe identify-layered-application %identifier% "%id%", , Hide
+}
+
+IdentifyBorderOverflowApplication(identifier, id) {
+    Run, komorebic.exe identify-border-overflow-application %identifier% "%id%", , Hide
 }
 
 FocusFollowsMouse(boolean_state, implementation) {
@@ -244,6 +296,26 @@ ToggleFocusFollowsMouse(implementation) {
     Run, komorebic.exe toggle-focus-follows-mouse  --implementation %implementation%, , Hide
 }
 
+MouseFollowsFocus(boolean_state) {
+    Run, komorebic.exe mouse-follows-focus %boolean_state%, , Hide
+}
+
+ToggleMouseFollowsFocus() {
+    Run, komorebic.exe toggle-mouse-follows-focus, , Hide
+}
+
 AhkLibrary() {
     Run, komorebic.exe ahk-library, , Hide
 }
+
+AhkAppSpecificConfiguration(path, override_path) {
+    Run, komorebic.exe ahk-app-specific-configuration %path% %override_path%, , Hide
+}
+
+FormatAppSpecificConfiguration(path) {
+    Run, komorebic.exe format-app-specific-configuration %path%, , Hide
+}
+
+NotificationSchema() {
+    Run, komorebic.exe notification-schema, , Hide
+}

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.6"
+version = "0.1.8"
 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"]
@@ -11,17 +11,25 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bindings = { package = "bindings", path = "../bindings" }
 derive-ahk = { path = "../derive-ahk" }
 komorebi-core = { path = "../komorebi-core" }
 
-clap = "3.0.0-beta.4"
-color-eyre = "0.5"
+clap = { version = "3", features = ["derive", "wrap_help"] }
+color-eyre = "0.6"
 dirs = "4"
 fs-tail = "0.1"
-heck = "0.3"
+heck = "0.4"
+lazy_static = "1"
 paste = "1"
-powershell_script = "0.2"
+powershell_script = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+serde_yaml = "0.8"
 uds_windows = "1"
+
+[dependencies.windows]
+version = "0.35"
+features = [
+    "Win32_Foundation",
+    "Win32_UI_WindowsAndMessaging"
+]

komorebic/src/main.rs

@@ -1,6 +1,7 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(clippy::missing_errors_doc)]
 
+use std::fs;
 use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
@@ -12,32 +13,55 @@ use std::process::Command;
 
 use clap::AppSettings;
 use clap::ArgEnum;
-use clap::Clap;
+use clap::Parser;
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use fs_tail::TailedFile;
-use heck::KebabCase;
+use heck::ToKebabCase;
+use lazy_static::lazy_static;
 use paste::paste;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
+use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
+use windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
 
-use bindings::Windows::Win32::Foundation::HWND;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::ShowWindow;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
-use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
 use derive_ahk::AhkFunction;
 use derive_ahk::AhkLibrary;
+use komorebi_core::config_generation::ApplicationConfigurationGenerator;
 use komorebi_core::ApplicationIdentifier;
+use komorebi_core::Axis;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
-use komorebi_core::Flip;
 use komorebi_core::FocusFollowsMouseImplementation;
+use komorebi_core::HidingBehaviour;
+use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::SocketMessage;
 use komorebi_core::StateQuery;
 
+lazy_static! {
+    static ref HOME_DIR: PathBuf = {
+        if let Ok(home_path) = std::env::var("KOMOREBI_CONFIG_HOME") {
+            let home = PathBuf::from(&home_path);
+
+            if home.as_path().is_dir() {
+                home
+            } else {
+                panic!(
+                    "$Env:KOMOREBI_CONFIG_HOME is set to '{}', which is not a valid directory",
+                    home_path
+                );
+            }
+        } else {
+            dirs::home_dir().expect("there is no home directory")
+        }
+    };
+}
+
 trait AhkLibrary {
     fn generate_ahk_library() -> String;
 }
@@ -46,7 +70,7 @@ trait AhkFunction {
     fn generate_ahk_function() -> String;
 }
 
-#[derive(ArgEnum)]
+#[derive(Copy, Clone, ArgEnum)]
 enum BooleanState {
     Enable,
     Disable,
@@ -66,7 +90,7 @@ macro_rules! gen_enum_subcommand_args {
     ( $( $name:ident: $element:ty ),+ $(,)? ) => {
         $(
             paste! {
-                #[derive(clap::Clap, derive_ahk::AhkFunction)]
+                #[derive(clap::Parser, derive_ahk::AhkFunction)]
                 pub struct $name {
                     #[clap(arg_enum)]
                     [<$element:snake>]: $element
@@ -85,17 +109,20 @@ gen_enum_subcommand_args! {
     CycleWorkspace: CycleDirection,
     Stack: OperationDirection,
     CycleStack: CycleDirection,
-    FlipLayout: Flip,
+    FlipLayout: Axis,
     ChangeLayout: DefaultLayout,
     WatchConfiguration: BooleanState,
+    MouseFollowsFocus: BooleanState,
     Query: StateQuery,
+    WindowHidingBehaviour: HidingBehaviour,
+    UnmanagedWindowOperationBehaviour: OperationBehaviour,
 }
 
 macro_rules! gen_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Target index (zero-indexed)
                 target: usize,
@@ -111,6 +138,7 @@ gen_target_subcommand_args! {
     SendToWorkspace,
     FocusMonitor,
     FocusWorkspace,
+    MoveWorkspaceToMonitor,
 }
 
 // Thanks to @danielhenrymantilla for showing me how to use cfg_attr with an optional argument like
@@ -121,7 +149,7 @@ macro_rules! gen_workspace_subcommand_args {
     ( $( $name:ident: $(#[enum] $(@$arg_enum:tt)?)? $value:ty ),+ $(,)? ) => (
         paste! {
             $(
-                #[derive(clap::Clap, derive_ahk::AhkFunction)]
+                #[derive(clap::Parser, derive_ahk::AhkFunction)]
                 pub struct [<Workspace $name>] {
                     /// Monitor index (zero-indexed)
                     monitor: usize,
@@ -147,7 +175,16 @@ gen_workspace_subcommand_args! {
     Tiling: #[enum] BooleanState,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
+pub struct ClearWorkspaceLayoutRules {
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+}
+
+#[derive(Parser, AhkFunction)]
 pub struct WorkspaceCustomLayout {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -159,7 +196,36 @@ pub struct WorkspaceCustomLayout {
     path: String,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
+pub struct WorkspaceLayoutRule {
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+
+    /// The number of window containers on-screen required to trigger this layout rule
+    at_container_count: usize,
+
+    layout: DefaultLayout,
+}
+
+#[derive(Parser, AhkFunction)]
+pub struct WorkspaceCustomLayoutRule {
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+
+    /// The number of window containers on-screen required to trigger this layout rule
+    at_container_count: usize,
+
+    /// JSON or YAML file from which the custom layout definition should be loaded
+    path: String,
+}
+
+#[derive(Parser, AhkFunction)]
 struct Resize {
     #[clap(arg_enum)]
     edge: OperationDirection,
@@ -167,7 +233,21 @@ struct Resize {
     sizing: Sizing,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
+struct ResizeAxis {
+    #[clap(arg_enum)]
+    axis: Axis,
+    #[clap(arg_enum)]
+    sizing: Sizing,
+}
+
+#[derive(Parser, AhkFunction)]
+struct ResizeDelta {
+    /// The delta of pixels by which to increase or decrease window dimensions when resizing
+    pixels: i32,
+}
+
+#[derive(Parser, AhkFunction)]
 struct InvisibleBorders {
     /// Size of the left invisible border
     left: i32,
@@ -179,7 +259,7 @@ struct InvisibleBorders {
     bottom: i32,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct WorkAreaOffset {
     /// Size of the left work area offset (set right to left * 2 to maintain right padding)
     left: i32,
@@ -191,7 +271,7 @@ struct WorkAreaOffset {
     bottom: i32,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct EnsureWorkspaces {
     /// Monitor index (zero-indexed)
     monitor: usize,
@@ -199,11 +279,27 @@ struct EnsureWorkspaces {
     workspace_count: usize,
 }
 
+#[derive(Parser, AhkFunction)]
+struct FocusMonitorWorkspace {
+    /// Target monitor index (zero-indexed)
+    target_monitor: usize,
+    /// Workspace index on the target monitor (zero-indexed)
+    target_workspace: usize,
+}
+
+#[derive(Parser, AhkFunction)]
+pub struct SendToMonitorWorkspace {
+    /// Target monitor index (zero-indexed)
+    target_monitor: usize,
+    /// Workspace index on the target monitor (zero-indexed)
+    target_workspace: usize,
+}
+
 macro_rules! gen_padding_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 /// Monitor index (zero-indexed)
                 monitor: usize,
@@ -225,7 +321,7 @@ macro_rules! gen_padding_adjustment_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 #[clap(arg_enum)]
                 sizing: Sizing,
@@ -245,7 +341,7 @@ macro_rules! gen_application_target_subcommand_args {
     // SubCommand Pattern
     ( $( $name:ident ),+ $(,)? ) => {
         $(
-            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            #[derive(clap::Parser, derive_ahk::AhkFunction)]
             pub struct $name {
                 #[clap(arg_enum)]
                 identifier: ApplicationIdentifier,
@@ -260,10 +356,12 @@ gen_application_target_subcommand_args! {
     FloatRule,
     ManageRule,
     IdentifyTrayApplication,
-    IdentifyBorderOverflow,
+    IdentifyLayeredApplication,
+    IdentifyObjectNameChangeApplication,
+    IdentifyBorderOverflowApplication,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct WorkspaceRule {
     #[clap(arg_enum)]
     identifier: ApplicationIdentifier,
@@ -275,13 +373,13 @@ struct WorkspaceRule {
     workspace: usize,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct ToggleFocusFollowsMouse {
     #[clap(arg_enum, short, long, default_value = "windows")]
     implementation: FocusFollowsMouseImplementation,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct FocusFollowsMouse {
     #[clap(arg_enum, short, long, default_value = "windows")]
     implementation: FocusFollowsMouseImplementation,
@@ -289,51 +387,65 @@ struct FocusFollowsMouse {
     boolean_state: BooleanState,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct Start {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
     #[clap(long)]
     ffm: bool,
 }
 
-#[derive(Clap, AhkFunction)]
-struct Save {
+#[derive(Parser, AhkFunction)]
+struct SaveResize {
     /// File to which the resize layout dimensions should be saved
     path: String,
 }
 
-#[derive(Clap, AhkFunction)]
-struct Load {
+#[derive(Parser, AhkFunction)]
+struct LoadResize {
     /// File from which the resize layout dimensions should be loaded
     path: String,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct LoadCustomLayout {
     /// JSON or YAML file from which the custom layout definition should be loaded
     path: String,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct Subscribe {
     /// Name of the pipe to send event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
-#[derive(Clap, AhkFunction)]
+#[derive(Parser, AhkFunction)]
 struct Unsubscribe {
     /// Name of the pipe to stop sending event notifications to (without "\\.\pipe\" prepended)
     named_pipe: String,
 }
 
-#[derive(Clap)]
+#[derive(Parser, AhkFunction)]
+struct AhkAppSpecificConfiguration {
+    /// YAML file from which the application-specific configurations should be loaded
+    path: String,
+    /// Optional YAML file of overrides to apply over the first file
+    override_path: Option<String>,
+}
+
+#[derive(Parser, AhkFunction)]
+struct FormatAppSpecificConfiguration {
+    /// YAML file from which the application-specific configurations should be loaded
+    path: String,
+}
+
+#[derive(Parser)]
 #[clap(author, about, version, setting = AppSettings::DeriveDisplayOrder)]
 struct Opts {
     #[clap(subcommand)]
     subcmd: SubCommand,
 }
 
-#[derive(Clap, AhkLibrary)]
+#[derive(Parser, AhkLibrary)]
 enum SubCommand {
     /// Start komorebi.exe as a background process
     Start(Start),
@@ -342,122 +454,153 @@ enum SubCommand {
     /// Show a JSON representation of the current window manager state
     State,
     /// Query the current window manager state
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     Query(Query),
     /// Subscribe to komorebi events
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     Subscribe(Subscribe),
     /// Unsubscribe from komorebi events
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     Unsubscribe(Unsubscribe),
     /// Tail komorebi.exe's process logs (cancel with Ctrl-C)
     Log,
     /// Quicksave the current resize layout dimensions
-    QuickSave,
+    #[clap(alias = "quick-save")]
+    QuickSaveResize,
     /// Load the last quicksaved resize layout dimensions
-    QuickLoad,
+    #[clap(alias = "quick-load")]
+    QuickLoadResize,
     /// Save the current resize layout dimensions to a file
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    Save(Save),
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "save")]
+    SaveResize(SaveResize),
     /// Load the resize layout dimensions from a file
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    Load(Load),
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "load")]
+    LoadResize(LoadResize),
     /// Change focus to the window in the specified direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     Focus(Focus),
     /// Move the focused window in the specified direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     Move(Move),
     /// Change focus to the window in the specified cycle direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     CycleFocus(CycleFocus),
     /// Move the focused window in the specified cycle direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     CycleMove(CycleMove),
     /// Stack the focused window in the specified direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     Stack(Stack),
     /// Resize the focused window in the specified direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    Resize(Resize),
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "resize")]
+    ResizeEdge(Resize),
+    /// Resize the focused window or primary column along the specified axis
+    #[clap(arg_required_else_help = true)]
+    ResizeAxis(ResizeAxis),
     /// Unstack the focused window
     Unstack,
     /// Cycle the focused stack in the specified cycle direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     CycleStack(CycleStack),
     /// Move the focused window to the specified monitor
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     MoveToMonitor(MoveToMonitor),
     /// Move the focused window to the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     MoveToWorkspace(MoveToWorkspace),
     /// Send the focused window to the specified monitor
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     SendToMonitor(SendToMonitor),
     /// Send the focused window to the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     SendToWorkspace(SendToWorkspace),
+    /// Send the focused window to the specified monitor workspace
+    #[clap(arg_required_else_help = true)]
+    SendToMonitorWorkspace(SendToMonitorWorkspace),
     /// Focus the specified monitor
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     FocusMonitor(FocusMonitor),
     /// Focus the specified workspace on the focused monitor
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     FocusWorkspace(FocusWorkspace),
+    /// Focus the specified workspace on the target monitor
+    #[clap(arg_required_else_help = true)]
+    FocusMonitorWorkspace(FocusMonitorWorkspace),
     /// Focus the monitor in the given cycle direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     CycleMonitor(CycleMonitor),
     /// Focus the workspace in the given cycle direction
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     CycleWorkspace(CycleWorkspace),
+    /// Move the focused workspace to the specified monitor
+    #[clap(arg_required_else_help = true)]
+    MoveWorkspaceToMonitor(MoveWorkspaceToMonitor),
     /// Create and append a new workspace on the focused monitor
     NewWorkspace,
+    /// Set the resize delta (used by resize-edge and resize-axis)
+    #[clap(arg_required_else_help = true)]
+    ResizeDelta(ResizeDelta),
     /// Set the invisible border dimensions around each window
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     InvisibleBorders(InvisibleBorders),
     /// Set offsets to exclude parts of the work area from tiling
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkAreaOffset(WorkAreaOffset),
     /// Adjust container padding on the focused workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     AdjustContainerPadding(AdjustContainerPadding),
     /// Adjust workspace padding on the focused workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     AdjustWorkspacePadding(AdjustWorkspacePadding),
     /// Set the layout on the focused workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     ChangeLayout(ChangeLayout),
     /// Load a custom layout from file for the focused workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     LoadCustomLayout(LoadCustomLayout),
     /// Flip the layout on the focused workspace (BSP only)
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     FlipLayout(FlipLayout),
     /// Promote the focused window to the top of the tree
     Promote,
     /// Force the retiling of all managed windows
     Retile,
     /// Create at least this many workspaces for the specified monitor
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     EnsureWorkspaces(EnsureWorkspaces),
     /// Set the container padding for the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     ContainerPadding(ContainerPadding),
     /// Set the workspace padding for the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkspacePadding(WorkspacePadding),
     /// Set the layout for the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkspaceLayout(WorkspaceLayout),
     /// Set a custom layout for the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkspaceCustomLayout(WorkspaceCustomLayout),
+    /// Add a dynamic layout rule for the specified workspace
+    #[clap(arg_required_else_help = true)]
+    WorkspaceLayoutRule(WorkspaceLayoutRule),
+    /// Add a dynamic custom layout for the specified workspace
+    #[clap(arg_required_else_help = true)]
+    WorkspaceCustomLayoutRule(WorkspaceCustomLayoutRule),
+    /// Clear all dynamic layout rules for the specified workspace
+    #[clap(arg_required_else_help = true)]
+    ClearWorkspaceLayoutRules(ClearWorkspaceLayoutRules),
     /// Enable or disable window tiling for the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkspaceTiling(WorkspaceTiling),
     /// Set the workspace name for the specified workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkspaceName(WorkspaceName),
-    /// Toggle the window manager on and off across all monitors
+    /// Toggle the behaviour for new windows (stacking or dynamic tiling)
+    ToggleWindowContainerBehaviour,
+    /// Toggle window tiling on the focused workspace
     TogglePause,
     /// Toggle window tiling on the focused workspace
     ToggleTiling,
@@ -476,35 +619,63 @@ enum SubCommand {
     /// Reload ~/komorebi.ahk (if it exists)
     ReloadConfiguration,
     /// Enable or disable watching of ~/komorebi.ahk (if it exists)
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WatchConfiguration(WatchConfiguration),
+    /// Set the window behaviour when switching workspaces / cycling stacks
+    #[clap(arg_required_else_help = true)]
+    WindowHidingBehaviour(WindowHidingBehaviour),
+    /// Set the operation behaviour when the focused window is not managed
+    #[clap(arg_required_else_help = true)]
+    UnmanagedWindowOperationBehaviour(UnmanagedWindowOperationBehaviour),
     /// Add a rule to always float the specified application
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     FloatRule(FloatRule),
     /// Add a rule to always manage the specified application
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     ManageRule(ManageRule),
     /// Add a rule to associate an application with a workspace
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     WorkspaceRule(WorkspaceRule),
+    /// Identify an application that sends EVENT_OBJECT_NAMECHANGE on launch
+    #[clap(arg_required_else_help = true)]
+    IdentifyObjectNameChangeApplication(IdentifyObjectNameChangeApplication),
     /// Identify an application that closes to the system tray
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     IdentifyTrayApplication(IdentifyTrayApplication),
+    /// Identify an application that has WS_EX_LAYERED, but should still be managed
+    #[clap(arg_required_else_help = true)]
+    IdentifyLayeredApplication(IdentifyLayeredApplication),
     /// Identify an application that has overflowing borders
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    IdentifyBorderOverflow(IdentifyBorderOverflow),
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "identify-border-overflow")]
+    IdentifyBorderOverflowApplication(IdentifyBorderOverflowApplication),
     /// Enable or disable focus follows mouse for the operating system
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     FocusFollowsMouse(FocusFollowsMouse),
     /// Toggle focus follows mouse for the operating system
-    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    #[clap(arg_required_else_help = true)]
     ToggleFocusFollowsMouse(ToggleFocusFollowsMouse),
+    /// Enable or disable mouse follows focus on all workspaces
+    #[clap(arg_required_else_help = true)]
+    MouseFollowsFocus(MouseFollowsFocus),
+    /// Toggle mouse follows focus on all workspaces
+    ToggleMouseFollowsFocus,
     /// Generate a library of AutoHotKey helper functions
     AhkLibrary,
+    /// Generate common app-specific configurations and fixes to use in komorebi.ahk
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "ahk-asc")]
+    AhkAppSpecificConfiguration(AhkAppSpecificConfiguration),
+    /// Format a YAML file for use with the 'ahk-app-specific-configuration' command
+    #[clap(arg_required_else_help = true)]
+    #[clap(alias = "fmt-asc")]
+    FormatAppSpecificConfiguration(FormatAppSpecificConfiguration),
+    /// Generate a JSON Schema of subscription notifications
+    NotificationSchema,
 }
 
 pub fn send_message(bytes: &[u8]) -> Result<()> {
-    let mut socket = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+    let mut socket = HOME_DIR.clone();
     socket.push("komorebi.sock");
     let socket = socket.as_path();
 
@@ -518,8 +689,7 @@ fn main() -> Result<()> {
 
     match opts.subcmd {
         SubCommand::AhkLibrary => {
-            let mut library =
-                dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+            let mut library = HOME_DIR.clone();
             library.push("komorebic.lib.ahk");
             let mut file = OpenOptions::new()
                 .write(true)
@@ -527,7 +697,10 @@ fn main() -> Result<()> {
                 .truncate(true)
                 .open(library.clone())?;
 
-            file.write_all(SubCommand::generate_ahk_library().as_bytes())?;
+            let output: String = SubCommand::generate_ahk_library();
+            let fixed_output = output.replace("%id%", "\"%id%\"");
+
+            file.write_all(fixed_output.as_bytes())?;
 
             println!(
                 "\nAHK helper library for komorebic written to {}",
@@ -584,6 +757,18 @@ fn main() -> Result<()> {
         SubCommand::SendToWorkspace(arg) => {
             send_message(&*SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
         }
+        SubCommand::SendToMonitorWorkspace(arg) => {
+            send_message(
+                &*SocketMessage::SendContainerToMonitorWorkspaceNumber(
+                    arg.target_monitor,
+                    arg.target_workspace,
+                )
+                .as_bytes()?,
+            )?;
+        }
+        SubCommand::MoveWorkspaceToMonitor(arg) => {
+            send_message(&*SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
+        }
         SubCommand::InvisibleBorders(arg) => {
             send_message(
                 &*SocketMessage::InvisibleBorders(Rect {
@@ -659,6 +844,34 @@ fn main() -> Result<()> {
                 .as_bytes()?,
             )?;
         }
+        SubCommand::WorkspaceLayoutRule(arg) => {
+            send_message(
+                &*SocketMessage::WorkspaceLayoutRule(
+                    arg.monitor,
+                    arg.workspace,
+                    arg.at_container_count,
+                    arg.layout,
+                )
+                .as_bytes()?,
+            )?;
+        }
+        SubCommand::WorkspaceCustomLayoutRule(arg) => {
+            send_message(
+                &*SocketMessage::WorkspaceLayoutCustomRule(
+                    arg.monitor,
+                    arg.workspace,
+                    arg.at_container_count,
+                    resolve_windows_path(&arg.path)?,
+                )
+                .as_bytes()?,
+            )?;
+        }
+        SubCommand::ClearWorkspaceLayoutRules(arg) => {
+            send_message(
+                &*SocketMessage::ClearWorkspaceLayoutRules(arg.monitor, arg.workspace)
+                    .as_bytes()?,
+            )?;
+        }
         SubCommand::WorkspaceTiling(arg) => {
             send_message(
                 &*SocketMessage::WorkspaceTiling(arg.monitor, arg.workspace, arg.value.into())
@@ -751,7 +964,7 @@ fn main() -> Result<()> {
             )?;
         }
         SubCommand::FlipLayout(arg) => {
-            send_message(&*SocketMessage::FlipLayout(arg.flip).as_bytes()?)?;
+            send_message(&*SocketMessage::FlipLayout(arg.axis).as_bytes()?)?;
         }
         SubCommand::FocusMonitor(arg) => {
             send_message(&*SocketMessage::FocusMonitorNumber(arg.target).as_bytes()?)?;
@@ -759,6 +972,15 @@ fn main() -> Result<()> {
         SubCommand::FocusWorkspace(arg) => {
             send_message(&*SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
         }
+        SubCommand::FocusMonitorWorkspace(arg) => {
+            send_message(
+                &*SocketMessage::FocusMonitorWorkspaceNumber(
+                    arg.target_monitor,
+                    arg.target_workspace,
+                )
+                .as_bytes()?,
+            )?;
+        }
         SubCommand::CycleMonitor(arg) => {
             send_message(&*SocketMessage::CycleFocusMonitor(arg.cycle_direction).as_bytes()?)?;
         }
@@ -781,7 +1003,7 @@ fn main() -> Result<()> {
             )?;
         }
         SubCommand::State => {
-            let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+            let home = HOME_DIR.clone();
             let mut socket = home;
             socket.push("komorebic.sock");
             let socket = socket.as_path();
@@ -815,7 +1037,7 @@ fn main() -> Result<()> {
             }
         }
         SubCommand::Query(arg) => {
-            let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+            let home = HOME_DIR.clone();
             let mut socket = home;
             socket.push("komorebic.sock");
             let socket = socket.as_path();
@@ -849,8 +1071,7 @@ fn main() -> Result<()> {
             }
         }
         SubCommand::RestoreWindows => {
-            let mut hwnd_json =
-                dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+            let mut hwnd_json = HOME_DIR.clone();
             hwnd_json.push("komorebi.hwnd.json");
 
             let file = File::open(hwnd_json)?;
@@ -861,28 +1082,33 @@ fn main() -> Result<()> {
                 restore_window(HWND(hwnd));
             }
         }
-        SubCommand::Resize(resize) => {
-            send_message(&*SocketMessage::ResizeWindow(resize.edge, resize.sizing).as_bytes()?)?;
+        SubCommand::ResizeEdge(resize) => {
+            send_message(
+                &*SocketMessage::ResizeWindowEdge(resize.edge, resize.sizing).as_bytes()?,
+            )?;
+        }
+        SubCommand::ResizeAxis(arg) => {
+            send_message(&*SocketMessage::ResizeWindowAxis(arg.axis, arg.sizing).as_bytes()?)?;
         }
         SubCommand::FocusFollowsMouse(arg) => {
-            let enable = match arg.boolean_state {
-                BooleanState::Enable => true,
-                BooleanState::Disable => false,
-            };
-
             send_message(
-                &*SocketMessage::FocusFollowsMouse(arg.implementation, enable).as_bytes()?,
+                &*SocketMessage::FocusFollowsMouse(arg.implementation, arg.boolean_state.into())
+                    .as_bytes()?,
             )?;
         }
         SubCommand::ReloadConfiguration => {
             send_message(&*SocketMessage::ReloadConfiguration.as_bytes()?)?;
         }
         SubCommand::WatchConfiguration(arg) => {
-            let enable = match arg.boolean_state {
-                BooleanState::Enable => true,
-                BooleanState::Disable => false,
-            };
-            send_message(&*SocketMessage::WatchConfiguration(enable).as_bytes()?)?;
+            send_message(
+                &*SocketMessage::WatchConfiguration(arg.boolean_state.into()).as_bytes()?,
+            )?;
+        }
+        SubCommand::IdentifyObjectNameChangeApplication(target) => {
+            send_message(
+                &*SocketMessage::IdentifyObjectNameChangeApplication(target.identifier, target.id)
+                    .as_bytes()?,
+            )?;
         }
         SubCommand::IdentifyTrayApplication(target) => {
             send_message(
@@ -890,9 +1116,16 @@ fn main() -> Result<()> {
                     .as_bytes()?,
             )?;
         }
-        SubCommand::IdentifyBorderOverflow(target) => {
+        SubCommand::IdentifyLayeredApplication(target) => {
             send_message(
-                &*SocketMessage::IdentifyBorderOverflow(target.identifier, target.id).as_bytes()?,
+                &*SocketMessage::IdentifyLayeredApplication(target.identifier, target.id)
+                    .as_bytes()?,
+            )?;
+        }
+        SubCommand::IdentifyBorderOverflowApplication(target) => {
+            send_message(
+                &*SocketMessage::IdentifyBorderOverflowApplication(target.identifier, target.id)
+                    .as_bytes()?,
             )?;
         }
         SubCommand::Manage => {
@@ -901,16 +1134,16 @@ fn main() -> Result<()> {
         SubCommand::Unmanage => {
             send_message(&*SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
         }
-        SubCommand::QuickSave => {
+        SubCommand::QuickSaveResize => {
             send_message(&*SocketMessage::QuickSave.as_bytes()?)?;
         }
-        SubCommand::QuickLoad => {
+        SubCommand::QuickLoadResize => {
             send_message(&*SocketMessage::QuickLoad.as_bytes()?)?;
         }
-        SubCommand::Save(arg) => {
+        SubCommand::SaveResize(arg) => {
             send_message(&*SocketMessage::Save(resolve_windows_path(&arg.path)?).as_bytes()?)?;
         }
-        SubCommand::Load(arg) => {
+        SubCommand::LoadResize(arg) => {
             send_message(&*SocketMessage::Load(resolve_windows_path(&arg.path)?).as_bytes()?)?;
         }
         SubCommand::Subscribe(arg) => {
@@ -919,6 +1152,112 @@ fn main() -> Result<()> {
         SubCommand::Unsubscribe(arg) => {
             send_message(&*SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
         }
+        SubCommand::ToggleMouseFollowsFocus => {
+            send_message(&*SocketMessage::ToggleMouseFollowsFocus.as_bytes()?)?;
+        }
+        SubCommand::MouseFollowsFocus(arg) => {
+            send_message(&*SocketMessage::MouseFollowsFocus(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::ResizeDelta(arg) => {
+            send_message(&*SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
+        }
+        SubCommand::ToggleWindowContainerBehaviour => {
+            send_message(&*SocketMessage::ToggleWindowContainerBehaviour.as_bytes()?)?;
+        }
+        SubCommand::WindowHidingBehaviour(arg) => {
+            send_message(&*SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour).as_bytes()?)?;
+        }
+        SubCommand::UnmanagedWindowOperationBehaviour(arg) => {
+            send_message(
+                &*SocketMessage::UnmanagedWindowOperationBehaviour(arg.operation_behaviour)
+                    .as_bytes()?,
+            )?;
+        }
+        SubCommand::AhkAppSpecificConfiguration(arg) => {
+            let content = fs::read_to_string(resolve_windows_path(&arg.path)?)?;
+            let lines = if let Some(override_path) = arg.override_path {
+                let override_content = fs::read_to_string(resolve_windows_path(&override_path)?)?;
+
+                ApplicationConfigurationGenerator::generate_ahk(
+                    &content,
+                    Option::from(override_content.as_str()),
+                )?
+            } else {
+                ApplicationConfigurationGenerator::generate_ahk(&content, None)?
+            };
+
+            let mut generated_config = HOME_DIR.clone();
+            generated_config.push("komorebi.generated.ahk");
+            let mut file = OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(generated_config.clone())?;
+
+            file.write_all(lines.join("\n").as_bytes())?;
+
+            println!(
+                "\nApplication-specific generated configuration written to {}",
+                generated_config.to_str().ok_or_else(|| anyhow!(
+                    "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::FormatAppSpecificConfiguration(arg) => {
+            let file_path = resolve_windows_path(&arg.path)?;
+            let content = fs::read_to_string(&file_path)?;
+            let formatted_content = ApplicationConfigurationGenerator::format(&content)?;
+
+            let mut file = OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(file_path)?;
+
+            file.write_all(formatted_content.as_bytes())?;
+
+            println!("File successfully formatted for PRs to https://github.com/LGUG2Z/komorebi-application-specific-configuration");
+        }
+        SubCommand::NotificationSchema => {
+            let home = HOME_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::NotificationSchema.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);
+                }
+            }
+        }
     }
 
     Ok(())
@@ -927,7 +1266,7 @@ fn main() -> Result<()> {
 fn resolve_windows_path(raw_path: &str) -> Result<PathBuf> {
     let path = if raw_path.starts_with('~') {
         raw_path.replacen(
-            "~",
+            '~',
             &dirs::home_dir()
                 .ok_or_else(|| anyhow!("there is no home directory"))?
                 .display()