chore(release): v0.1.13

This commit ensures that when navigating away from and then back to a
workspace with a monocle window container, that the monocle window
container will be properly focused when navigating back, including
having the focus of the active window border.

fix #219

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: LGUG2Z

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]: Short descriptive title"
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See bug
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots and Videos**
+Add screenshots and videos to help explain your problem.
+
+**Operating System**
+Provide the output of `systeminfo | grep "^OS Name\|^OS Version"`
+
+For example:
+```
+OS Name:                   Microsoft Windows 11 Pro
+OS Version:                10.0.22000 N/A Build 22000
+```
+
+**Additional context**
+Add any other context about the problem here.
+
+In particular, if you have any other AHK scripts or software running that handle any aspect of window management or manipulation

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEAT]: Short descriptive title"
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -13,7 +13,7 @@ updates:
   - package-ecosystem: "cargo"
     directory: "/"
     schedule:
-      interval: "monthly"
+      interval: "weekly"
     assignees:
       - "LGUG2Z"
     commit-message:

.github/workflows/windows.yaml

@@ -76,6 +76,10 @@ jobs:
       - name: Run a full build
         run: |
           cargo build --locked --release --target ${{ matrix.target }}
+      - name: Create MSI installer
+        run: |
+          cargo install cargo-wix
+          cargo wix -p komorebi --nocapture -I .\wix\main.wxs --target x86_64-pc-windows-msvc
       - name: Upload the built artifacts
         uses: actions/upload-artifact@v3
         with:
@@ -85,6 +89,7 @@ jobs:
             target/${{ matrix.target }}/release/komorebic.exe
             target/${{ matrix.target }}/release/komorebi.pdb
             target/${{ matrix.target }}/release/komorebic.pdb
+            target/wix/komorebi-*.msi
           retention-days: 7
       - name: Generate changelog
         if: startsWith(github.ref, 'refs/tags/')
@@ -93,7 +98,7 @@ jobs:
           if ! type kokai >/dev/null; then cargo install --locked kokai --force; fi
           kokai release --no-emoji --add-links github:commits,issues --ref "$(git tag --points-at HEAD)" >"CHANGELOG.md"
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
+        uses: goreleaser/goreleaser-action@v3
         if: startsWith(github.ref, 'refs/tags/')
         with:
           version: latest
@@ -101,3 +106,8 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SCOOP_TOKEN: ${{ secrets.SCOOP_TOKEN }}
+      - name: Add MSI to release
+        uses: softprops/action-gh-release@v1
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: "target/wix/komorebi-*.msi"

.goreleaser.yml

@@ -35,11 +35,10 @@ archives:
     name_template: "{{ .ProjectName }}-{{ .Version }}-{{ .Arch }}-{{ .Os }}"
     files:
       - LICENSE
-      - komorebi.sample.ahk
       - CHANGELOG.md
 
 checksum:
   name_template: checksums.txt
 
 changelog:
-  sort: asc
+  sort: asc

Cargo.toml

@@ -4,5 +4,5 @@ members = [
     "derive-ahk",
     "komorebi",
     "komorebi-core",
-    "komorebic"
+    "komorebic",
 ]

README.md

@@ -2,7 +2,14 @@
 
 Tiling Window Management for Windows.
 
-![screenshot](https://i.ibb.co/BTqNS45/komorebi.png)
+![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/LGUG2Z/komorebi/Windows/master)
+![GitHub](https://img.shields.io/github/license/LGUG2Z/komorebi)
+![GitHub all releases](https://img.shields.io/github/downloads/LGUG2Z/komorebi/total)
+![GitHub commits since latest release (by date) for a branch](https://img.shields.io/github/commits-since/LGUG2Z/komorebi/latest/master)
+![Discord](https://img.shields.io/discord/898554690126630914?label=discord)
+![GitHub Sponsors](https://img.shields.io/github/sponsors/LGUG2Z)
+
+![screenshot](https://user-images.githubusercontent.com/13164844/184027064-f5a6cec2-2865-4d65-a549-a1f1da589abf.png)
 
 ## About
 
@@ -27,6 +34,27 @@ Articles, blog posts, demos, and videos about _komorebi_ can be added to this li
 - [Moving to Windows from Linux Pt 1](https://kvwu.io/posts/moving-to-windows/)
 - [Windows 下的现代化平铺窗口管理器 komorebi](https://zhuanlan.zhihu.com/p/455064481)
 
+## GitHub Sponsors Early Access
+
+[GitHub Sponsors is enabled for this project](https://github.com/sponsors/LGUG2Z). Users who sponsor my work
+on `komorebi` at any of the predefined monthly tiers will be given access to a private fork of this repository where I
+push features-in-progress that are not yet quite ready to be pushed on the main repository.
+
+There will never be any feature of `komorebi` that is gated behind sponsorship; every new feature will always be
+available for free in the public repository once it meets the requisite level of code quality and completion.
+
+Features-in-progress that are available in early access will be tagged in the issues with
+an ["early access" label](https://github.com/LGUG2Z/komorebi/issues?q=is%3Aopen+is%3Aissue+label%3A%22early+access%22).
+
+## Charitable Donations
+
+`komorebi`, like `vim`, is a free and open-source project, and one that encourages you to make charitable donations if
+you find the software to be useful and have the financial means.
+
+I encourage you to make a charitable donation
+to [Fresh Start Refugee](https://www.freshstartrefugee.org/donate) before
+you consider sponsoring me on GitHub.
+
 ## Demonstrations
 
 [@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
@@ -108,10 +136,14 @@ binaries from the latest GitHub Release:
 ```powershell
 scoop bucket add extras
 scoop install komorebi
+
+# To download the example configuration
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/master/komorebi.sample.ahk -OutFile $Env:USERPROFILE\komorebi.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/master/komorebic.lib.ahk -OutFile $Env:USERPROFILE\komorebic.lib.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/master/komorebi.generated.ahk -OutFile $Env:USERPROFILE\komorebi.generated.ahk
 ```
 
-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.
+If you install _komorebi_ using Scoop, the binaries will automatically be added to your `Path`.
 
 Thanks to [@sitiom](https://github.com/sitiom) for getting _komorebi_ added to the popular Scoop Extras bucket.
 
@@ -133,7 +165,7 @@ cargo install --path komorebic --locked
 
 Once you have either the prebuilt binaries in your `Path`, or have compiled the binaries from source (these will already
 be in your `Path` if you installed Rust with [rustup](https://rustup.rs), which you absolutely should), you can
-run `komorebic start` at a Powershell prompt, and you will see the following output:
+run `komorebic start --await-configuration` at a Powershell prompt, and you will see the following output:
 
 ```
 Start-Process komorebi -WindowStyle hidden
@@ -155,6 +187,26 @@ the `AutoHotKey64.exe` executable for AutoHotKey v2 is in your `Path`. If both `
 exist in your home directory, only `komorebi.ahk` will be loaded. An example of an AutoHotKey v2 configuration file
 for _komorebi_ can be found [here](https://gist.github.com/crosstyan/dafacc0778dabf693ce9236c57b201cd).
 
+#### Using Different AHK Executables
+
+The preferred way to install AutoHotKey for use with `komorebi` is to install it via `scoop`:
+
+```powershell
+scoop install autohotkey
+```
+
+If you install AutoHotKey using a different method, the name of the executable file may differ from the name given by
+`scoop`, and thus what is expected by default in `komorebi`.
+
+You may override the executables that `komorebi` looks for to launch and reload `komorebi.ahk` configuration files using
+by setting one of the following two environment variables depending on which version of AutoHotKey you wish to use:
+
+- `$Env:KOMOREBI_AHK_V1_EXE`
+- `$Env:KOMOREBI_AHK_V2_EXE`
+
+Please keep in mind that even when setting a custom executable name using these environment variables, the executables
+are still required to be in your `Path`.
+
 ### Common First-Time Tips
 
 #### Generating Common Application-Specific Configurations
@@ -219,6 +271,42 @@ If you already have configuration files that you wish to keep, move them to the
 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.
 
+#### Adding an Active Window Border
+
+If you would like to add a visual border around the currently focused window, two commands are available:
+
+```powershell
+komorebic.exe active-window-border [enable|disable]
+komorebic.exe active-window-border-colour [R G B] --window-kind single
+
+# optionally, if you want a different colour for stacks of windows
+komorebic.exe active-window-border-colour [R G B] --window-kind stack
+```
+
+It is important to note that the active window border will only apply to windows managed by `komorebi`.
+
+#### Removing Gaps
+
+If you would like to remove all gaps from a given workspace, both between windows themselves, and between the monitor edges and the windows, you can set the following two configuration options to `0` for the desired monitors and workspaces:
+
+```powershell
+komorebic.exe container-padding <MONITOR_INDEX> <WORKSPACE_INDEX> 0
+komorebic.exe workspace padding <MONITOR_INDEX> <WORKSPACE_INDEX> 0
+```
+
+#### Multiple Layout Changes on Startup
+
+Depending on what is in your configuration, when `komorebi` is started, you may experience the layout rapidly being adjusted
+with many retile events.
+
+If you would like to avoid this, you can start `komorebi` with a flag which tells `komorebi` to wait until all configuration
+has been loaded before listening to and responding to window manager events: `komorebic start --await-configuration`.
+
+If you start `komorebi` with the `--await-configuration` flag, you _must_ send the `komorebic complete-configuration`
+command at the end of the configuration section of your `komorebi.ahk` config (before you start defining the key
+bindings). The layout will not be updated and `komorebi` will not respond to `komorebic` commands until this command has
+been received.
+
 #### Floating Windows
 
 Sometimes you will want a specific application to never be tiled, and instead float all the time. You add add rules to
@@ -366,11 +454,9 @@ YAML
 
 ```yaml
 - column: Secondary
-  configuration:
-    Horizontal: 2 # max number of rows,
+  configuration: !Horizontal 2 # max number of rows
 - column: Primary
-  configuration:
-    WidthPercentage: 45 # percentage of screen
+  configuration: !WidthPercentage 50 # percentage of screen
 - column: Tertiary
   configuration: Horizontal
 ```
@@ -410,90 +496,6 @@ You can run `komorebic.exe` to get a full list of the commands that you can use
 keybindings with. You can run `komorebic.exe <COMMAND> --help` to get a full explanation of the arguments required for
 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-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`
 
 Additionally, you may run `komorebic.exe ahk-library` to
@@ -511,7 +513,9 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [x] Window stacks
 - [x] Cycle through stacked windows
 - [x] Change focused window by direction
+- [x] Change focused window by direction across monitor boundary
 - [x] Move focused window container in direction
+- [x] Move focused window container in direction across monitor boundary
 - [x] Move focused window container to monitor and follow
 - [x] Move focused window container to workspace follow
 - [x] Send focused window container to monitor
@@ -521,7 +525,7 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [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] Active window border
 - [x] Quicksave and quickload layouts with resize dimensions
 - [x] Save and load layouts with resize dimensions to/from specific files
 - [x] Mouse drag to swap window container position
@@ -542,7 +546,7 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [x] Identify applications which overflow their borders by exe name and class
 - [x] Identify 'close/minimize to tray' applications by exe name and class
 - [x] Configure work area offsets to preserve space for custom taskbars
-- [x] Configure and compensate for the size of Windows 10's invisible borders
+- [x] Configure and compensate for the size of Windows invisible borders
 - [x] Toggle floating windows
 - [x] Toggle monocle window
 - [x] Toggle native maximization
@@ -584,14 +588,14 @@ the IDE for completions and navigation:
 
 ## Logs and Debugging
 
-Logs from `komorebi` will be appended to `~/komorebi.log`; this file is never rotated or overwritten, so it will keep
+Logs from `komorebi` will be appended to `%LOCALAPPDATA%/komorebi/komorebi.log`; this file is never rotated or overwritten, so it will keep
 growing until it is deleted by the user.
 
 Whenever running the `komorebic stop` command or sending a Ctrl-C signal to `komorebi` directly, the `komorebi` process
 ensures that all hidden windows are restored before termination.
 
 If however, you ever end up with windows that are hidden and cannot be restored, a list of window handles known
-to `komorebi` are stored and continuously updated in `~/komorebi.hwnd.json`.
+to `komorebi` are stored and continuously updated in `%LOCALAPPDATA%/komorebi//komorebi.hwnd.json`.
 
 ### Restoring Windows
 
@@ -652,9 +656,35 @@ An example of how to create a named pipe and a subscription to `komorebi`'s hand
 by [@denBot](https://github.com/denBot) can be
 found [here](https://gist.github.com/denBot/4136279812f87819f86d99eba77c1ee0).
 
+An example of how to create a named pipe and a subscription to `komorebi`'s handled events in Rust can also be found
+in the [`komokana`](https://github.com/LGUG2Z/komokana) repository.
+
 ### 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.
+
+### Communication over TCP
+
+A TCP listener can optionally be exposed on a port of your choosing with the `--tcp-port=N` flag. If this flag is not
+provided to `komorebi` or `komorebic start`, no TCP listener will be created.
+
+Once created, your client may send
+any [SocketMessage](https://github.com/LGUG2Z/komorebi/blob/master/komorebi-core/src/lib.rs#L37) to `komorebi` in the
+same way that `komorebic` would.
+
+This can be used if you would like to create your own alternative to `komorebic` which incorporates scripting and
+various middleware layers, and similarly it can be used if you would like to integrate `komorebi` with
+a [custom input handler](https://github.com/LGUG2Z/komorebi/issues/176#issue-1302643961).
+
+If a client sends an unrecognized message, it will be disconnected and have to reconnect before trying to communicate
+again.
+
+### Socket Message Schema
+
+A [JSON Schema](https://json-schema.org/) of socket messages used to send instructions to `komorebi` can be generated
+with the `komorebic socket-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.

derive-ahk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "derive-ahk"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 
 [lib]

derive-ahk/src/lib.rs

@@ -5,12 +5,15 @@
 use ::std::clone::Clone;
 use ::std::convert::From;
 use ::std::convert::Into;
+use ::std::format;
 use ::std::iter::Extend;
 use ::std::iter::Iterator;
 use ::std::matches;
 use ::std::option::Option::Some;
+use ::std::string::String;
 use ::std::string::ToString;
 use ::std::unreachable;
+use ::std::vec::Vec;
 
 use ::quote::quote;
 use ::syn::parse_macro_input;
@@ -102,7 +105,8 @@ pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStre
                     let flag_idents_clone = flag_idents.clone();
                     let flags = quote! {#(--#flag_idents_clone) *}
                         .to_string()
-                        .replace("- - ", "--");
+                        .replace("- - ", "--")
+                        .replace('_', "-");
 
                     let called_flag_arguments = quote! {#(%#flag_idents%) *}
                         .to_string()
@@ -110,19 +114,28 @@ pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStre
                         .replace("% ", "%")
                         .replace("%%", "% %");
 
+                    let flags_split: Vec<_> = flags.split(' ').collect();
+                    let flag_args_split: Vec<_> = called_flag_arguments.split(' ').collect();
+                    let mut consolidated_flags: Vec<String> = Vec::new();
+
+                    for (idx, flag) in flags_split.iter().enumerate() {
+                        consolidated_flags.push(format!("{} {}", flag, flag_args_split[idx]));
+                    }
+
+                    let all_flags = consolidated_flags.join(" ");
+
                     quote! {
                         impl AhkFunction for #name {
                             fn generate_ahk_function() -> String {
                                 ::std::format!(r#"
 {}({}) {{
-    Run, komorebic.exe {} {} {} {}, , Hide
+    Run, komorebic.exe {} {} {}, , Hide
 }}"#,
                                     ::std::stringify!(#name),
                                     #all_arguments,
                                     ::std::stringify!(#name).to_kebab_case(),
                                     #called_arguments,
-                                    #flags,
-                                    #called_flag_arguments
+                                    #all_flags,
                                 )
                            }
                         }

justfile

@@ -6,8 +6,12 @@ clean:
 
 fmt:
     cargo +nightly fmt
-    cargo +nightly clippy
+    cargo +stable clippy
     prettier --write README.md
+    prettier --write .goreleaser.yml
+    prettier --write .github/dependabot.yml
+    prettier --write .github/FUNDING.yml
+    prettier --write .github/workflows/windows.yaml
 
 install-komorebic:
     cargo +stable install --path komorebic --locked
@@ -19,7 +23,8 @@ install:
     just install-komorebic
     just install-komorebi
     komorebic ahk-library
-    cat '%USERPROFILE%\.config\komorebi\komorebic.lib.ahk' > komorebic.lib.sample.ahk
+    cat '%USERPROFILE%\.config\komorebi\komorebic.lib.ahk' > komorebic.lib.ahk
+    cat '%USERPROFILE%\.config\komorebi\komorebi.generated.ahk' > komorebi.generated.ahk
 
 run:
     just install-komorebic

komorebi-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.9"
+version = "0.1.13"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,12 +10,12 @@ clap = { version = "3", features = ["derive"] }
 color-eyre = "0.6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-serde_yaml = "0.8"
+serde_yaml = "0.9"
 strum = { version = "0.24", features = ["derive"] }
 schemars = "0.8"
 
 [dependencies.windows]
-version = "0.36"
+version = "0.39"
 features = [
     "Win32_Foundation",
 ]

komorebi-core/src/lib.rs

@@ -52,11 +52,14 @@ pub enum SocketMessage {
     SendContainerToMonitorWorkspaceNumber(usize, usize),
     MoveWorkspaceToMonitorNumber(usize),
     Promote,
+    PromoteFocus,
     ToggleFloat,
     ToggleMonocle,
     ToggleMaximize,
     ToggleWindowContainerBehaviour,
     WindowHidingBehaviour(HidingBehaviour),
+    ToggleCrossMonitorMoveBehaviour,
+    CrossMonitorMoveBehaviour(MoveBehaviour),
     UnmanagedWindowOperationBehaviour(OperationBehaviour),
     // Current Workspace Commands
     ManageFocusedWindow,
@@ -94,6 +97,9 @@ pub enum SocketMessage {
     // Configuration
     ReloadConfiguration,
     WatchConfiguration(bool),
+    CompleteConfiguration,
+    ActiveWindowBorder(bool),
+    ActiveWindowBorderColour(WindowKind, u32, u32, u32),
     InvisibleBorders(Rect),
     WorkAreaOffset(Rect),
     ResizeDelta(i32),
@@ -113,6 +119,7 @@ pub enum SocketMessage {
     AddSubscriber(String),
     RemoveSubscriber(String),
     NotificationSchema,
+    SocketSchema,
 }
 
 impl SocketMessage {
@@ -129,7 +136,14 @@ impl FromStr for SocketMessage {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+pub enum WindowKind {
+    Single,
+    Stack,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum StateQuery {
     FocusedMonitorIndex,
@@ -138,7 +152,7 @@ pub enum StateQuery {
     FocusedWindowIndex,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum ApplicationIdentifier {
@@ -147,7 +161,7 @@ pub enum ApplicationIdentifier {
     Title,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum FocusFollowsMouseImplementation {
     Komorebi,
@@ -161,7 +175,14 @@ pub enum WindowContainerBehaviour {
     Append,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+pub enum MoveBehaviour {
+    Swap,
+    Insert,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum HidingBehaviour {
     Hide,

komorebi.generated.ahk

@@ -0,0 +1,348 @@
+; Generated by komorebic.exe
+; To use this file, add the line below to the top of your komorebi.ahk configuration file
+; #Include %A_ScriptDir%\komorebi.generated.ahk
+
+; 1Password
+Run, komorebic.exe float-rule exe "1Password.exe", , Hide
+
+; Adobe Creative Cloud
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application class "CreativeCloudDesktopWindowClass", , Hide
+
+; AutoHotkey
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "AutoHotkeyU64.exe", , Hide
+Run, komorebic.exe float-rule title "Window Spy", , Hide
+
+; Beeper
+Run, komorebic.exe identify-border-overflow-application exe "Beeper.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Beeper.exe", , Hide
+
+; Bitwarden
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Bitwarden.exe", , Hide
+
+; Calculator
+Run, komorebic.exe float-rule title "Calculator", , Hide
+
+; Credential Manager UI Host
+; Targets the Windows popup prompting you for a PIN instead of a password on 1Password etc.
+Run, komorebic.exe float-rule exe "CredentialUIBroker.exe", , Hide
+
+; Cron
+Run, komorebic.exe identify-border-overflow-application exe "Cron.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Cron.exe", , Hide
+
+; Discord
+Run, komorebic.exe identify-border-overflow-application exe "Discord.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Discord.exe", , Hide
+
+; DiscordCanary
+Run, komorebic.exe identify-border-overflow-application exe "DiscordCanary.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "DiscordCanary.exe", , Hide
+
+; DiscordDevelopment
+Run, komorebic.exe identify-border-overflow-application exe "DiscordDeveloper.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "DiscordDeveloper.exe", , Hide
+
+; DiscordPTB
+Run, komorebic.exe identify-border-overflow-application exe "DiscordPTB.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "DiscordPTB.exe", , Hide
+
+; ElectronMail
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ElectronMail.exe", , Hide
+
+; Element
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Element.exe", , Hide
+
+; ElevenClock
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ElevenClock.exe", , Hide
+
+; Epic Games Launcher
+Run, komorebic.exe identify-border-overflow-application exe "EpicGamesLauncher.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "EpicGamesLauncher.exe", , Hide
+
+; Flow Launcher
+Run, komorebic.exe identify-border-overflow-application exe "Flow.Launcher.exe", , Hide
+
+; GOG Galaxy
+Run, komorebic.exe identify-border-overflow-application exe "GalaxyClient.exe", , Hide
+Run, komorebic.exe manage-rule exe "GalaxyClient.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "GalaxyClient.exe", , Hide
+; Targets a hidden window spawned by GOG Galaxy
+Run, komorebic.exe float-rule class "Chrome_RenderWidgetHostHWND", , Hide
+
+; GoPro Webcam
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application class "GoPro Webcam", , Hide
+
+; Google Chrome
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "chrome.exe", , Hide
+
+; Google Drive
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "GoogleDriveFS.exe", , Hide
+
+; Inno Setup
+; Target hidden window spawned by Inno Setup applications
+Run, komorebic.exe float-rule class "TApplication", , Hide
+; Target Inno Setup installers
+Run, komorebic.exe float-rule class "TWizardForm", , Hide
+
+; IntelliJ IDEA
+Run, komorebic.exe identify-object-name-change-application exe "idea64.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "idea64.exe", , Hide
+; Targets JetBrains IDE popups and floating windows
+Run, komorebic.exe float-rule class "SunAwtDialog", , Hide
+
+; Kleopatra
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "kleopatra.exe", , Hide
+
+; Kotatogram
+Run, komorebic.exe identify-border-overflow-application exe "Kotatogram.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Kotatogram.exe", , Hide
+
+; Logi Bolt
+Run, komorebic.exe float-rule exe "LogiBolt.exe", , Hide
+
+; LogiTune
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "LogiTune.exe", , Hide
+Run, komorebic.exe float-rule exe "LogiTune.exe", , Hide
+
+; Logitech G HUB
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "lghub.exe", , Hide
+Run, komorebic.exe identify-border-overflow-application exe "lghub.exe", , Hide
+
+; Logitech Options
+Run, komorebic.exe float-rule exe "LogiOptionsUI.exe", , Hide
+
+; Mailspring
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "mailspring.exe", , Hide
+
+; ManyCam
+Run, komorebic.exe identify-border-overflow-application exe "ManyCam.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ManyCam.exe", , Hide
+
+; Mica For Everyone
+
+; Microsoft Excel
+Run, komorebic.exe identify-border-overflow-application exe "EXCEL.EXE", , Hide
+Run, komorebic.exe identify-layered-application exe "EXCEL.EXE", , Hide
+; Targets a hidden window spawned by Microsoft Office applications
+Run, komorebic.exe float-rule class "_WwB", , Hide
+
+; Microsoft Outlook
+Run, komorebic.exe identify-border-overflow-application exe "OUTLOOK.EXE", , Hide
+Run, komorebic.exe identify-layered-application exe "OUTLOOK.EXE", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "OUTLOOK.EXE", , Hide
+
+; Microsoft PowerPoint
+Run, komorebic.exe identify-border-overflow-application exe "POWERPNT.EXE", , Hide
+Run, komorebic.exe identify-layered-application exe "POWERPNT.EXE", , Hide
+
+; Microsoft Teams
+; Target Teams pop-up notification windows
+Run, komorebic.exe float-rule title "Microsoft Teams Notifications", , Hide
+
+; Microsoft Word
+Run, komorebic.exe identify-border-overflow-application exe "WINWORD.EXE", , Hide
+Run, komorebic.exe identify-layered-application exe "WINWORD.EXE", , Hide
+
+; Modern Flyouts
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ModernFlyoutsHost.exe", , Hide
+
+; Mozilla Firefox
+Run, komorebic.exe identify-object-name-change-application exe "firefox.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "firefox.exe", , Hide
+; Targets invisible windows spawned by Firefox to show tab previews in the taskbar
+Run, komorebic.exe float-rule class "MozillaTaskbarPreviewClass", , Hide
+
+; NVIDIA GeForce Experience
+Run, komorebic.exe identify-border-overflow-application exe "NVIDIA GeForce Experience.exe", , Hide
+
+; NiceHash Miner
+Run, komorebic.exe identify-border-overflow-application exe "nhm_app.exe", , Hide
+Run, komorebic.exe manage-rule exe "nhm_app.exe", , Hide
+
+; NohBoard
+Run, komorebic.exe float-rule exe "NohBoard.exe", , Hide
+
+; Notion Enhanced
+Run, komorebic.exe identify-border-overflow-application exe "Notion Enhanced.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Notion Enhanced.exe", , Hide
+
+; OBS Studio (32-bit)
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "obs32.exe", , Hide
+
+; OBS Studio (64-bit)
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "obs64.exe", , Hide
+
+; ONLYOFFICE Editors
+Run, komorebic.exe identify-border-overflow-application class "DocEditorsWindowClass", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application class "DocEditorsWindowClass", , Hide
+
+; Obsidian
+Run, komorebic.exe identify-border-overflow-application exe "Obsidian.exe", , Hide
+Run, komorebic.exe manage-rule exe "Obsidian.exe", , Hide
+
+; OpenRGB
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "OpenRGB.exe", , Hide
+
+; Paradox Launcher
+Run, komorebic.exe float-rule exe "Paradox Launcher.exe", , Hide
+
+; PowerToys
+; Target color picker dialog
+Run, komorebic.exe float-rule exe "PowerToys.ColorPickerUI.exe", , Hide
+; Target image resizer dialog
+Run, komorebic.exe float-rule exe "PowerToys.ImageResizer.exe", , Hide
+
+; Process Hacker
+Run, komorebic.exe identify-border-overflow-application exe "ProcessHacker.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ProcessHacker.exe", , Hide
+Run, komorebic.exe float-rule exe "ProcessHacker.exe", , Hide
+
+; ProtonVPN
+Run, komorebic.exe identify-border-overflow-application exe "ProtonVPN.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ProtonVPN.exe", , Hide
+
+; PyCharm
+Run, komorebic.exe identify-object-name-change-application exe "pycharm64.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "pycharm64.exe", , Hide
+
+; QuickLook
+Run, komorebic.exe float-rule exe "QuickLook.exe", , Hide
+
+; RepoZ
+Run, komorebic.exe float-rule exe "RepoZ.exe", , Hide
+
+; Roblox FPS Unlocker
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "rbxfpsunlocker.exe", , Hide
+
+; RoundedTB
+Run, komorebic.exe float-rule exe "RoundedTB.exe", , Hide
+
+; RoundedTB
+Run, komorebic.exe identify-border-overflow-application exe "RoundedTB.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "RoundedTB.exe", , Hide
+
+; ShareX
+Run, komorebic.exe identify-border-overflow-application exe "ShareX.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ShareX.exe", , Hide
+
+; Signal
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "signal.exe", , Hide
+
+; SiriKali
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "sirikali.exe", , Hide
+
+; Slack
+Run, komorebic.exe identify-border-overflow-application exe "Slack.exe", , Hide
+Run, komorebic.exe manage-rule exe "Slack.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Slack.exe", , Hide
+
+; Slack
+Run, komorebic.exe identify-border-overflow-application exe "slack.exe", , Hide
+Run, komorebic.exe manage-rule exe "slack.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "slack.exe", , Hide
+
+; Spotify
+Run, komorebic.exe identify-border-overflow-application exe "Spotify.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Spotify.exe", , Hide
+
+; Steam
+Run, komorebic.exe identify-border-overflow-application class "vguiPopupWindow", , Hide
+
+; Task Manager
+Run, komorebic.exe float-rule class "TaskManagerWindow", , Hide
+
+; Telegram
+Run, komorebic.exe identify-border-overflow-application exe "Telegram.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "Telegram.exe", , Hide
+
+; TouchCursor
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "tcconfig.exe", , Hide
+Run, komorebic.exe float-rule exe "tcconfig.exe", , Hide
+
+; TranslucentTB
+Run, komorebic.exe float-rule exe "TranslucentTB.exe", , Hide
+
+; TranslucentTB
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "TranslucentTB.exe", , Hide
+
+; Unreal Editor
+Run, komorebic.exe identify-border-overflow-application exe "UnrealEditor.exe", , Hide
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "UnrealEditor.exe", , Hide
+
+; Visual Studio Code
+Run, komorebic.exe identify-border-overflow-application exe "Code.exe", , Hide
+
+; Windows Console (conhost.exe)
+Run, komorebic.exe manage-rule class "ConsoleWindowClass", , Hide
+
+; Windows Explorer
+; Targets copy/move operation windows
+Run, komorebic.exe float-rule class "OperationStatusWindow", , Hide
+Run, komorebic.exe float-rule title "Control Panel", , Hide
+
+; Windows Installer
+; Targets MSI Installers
+Run, komorebic.exe float-rule class "MsiDialogCloseClass", , Hide
+
+; Wox
+; Targets a hidden window spawned by Wox
+Run, komorebic.exe float-rule title "Hotkey sink", , Hide
+
+; Zoom
+Run, komorebic.exe float-rule exe "Zoom.exe", , Hide
+
+; qBittorrent
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "qbittorrent.exe", , Hide
+
+; ueli
+; If you have disabled minimize/close to tray for this application, you can delete/comment out the next line
+Run, komorebic.exe identify-tray-application exe "ueli.exe", , Hide
+Run, komorebic.exe float-rule exe "ueli.exe", , Hide

komorebi.iml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="RUST_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/bindings/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/komorebi-core/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/komorebi/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/komorebic/src" isTestSource="false" />
-      <excludeFolder url="file://$MODULE_DIR$/target" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

komorebi.sample.ahk

@@ -1,225 +1,93 @@
 #SingleInstance Force
 
+; You can generate a fresh version of this file with "komorebic ahk-library"
+#Include %A_ScriptDir%\komorebic.lib.ahk
+; https://github.com/LGUG2Z/komorebi/#generating-common-application-specific-configurations
+#Include %A_ScriptDir%\komorebi.generated.ahk
+
+; Default to minimizing windows when switching workspaces
+WindowHidingBehaviour("minimize")
+
+; Set cross-monitor move behaviour to insert instead of swap
+CrossMonitorMoveBehaviour("insert")
+
 ; Enable hot reloading of changes to this file
-Run, komorebic.exe watch-configuration enable, , Hide
+WatchConfiguration("enable")
+
+; Ensure there is 1 workspace created on monitor 0
+EnsureWorkspaces(0, 1)
 
 ; Configure the invisible border dimensions
-Run, komorebic.exe invisible-borders 7 0 14 7, , Hide
+InvisibleBorders(7, 0, 14, 7)
 
-; Enable focus follows mouse
-Run, komorebic.exe focus-follows-mouse enable, , Hide
+; Configure the 1st workspace
+WorkspaceName(0, 0, "I")
 
-; Ensure there are 3 workspaces created on monitor 0
-Run, komorebic.exe ensure-workspaces 0 5, , Hide
+; Uncomment the next two lines if you want a visual border drawn around the focused window
+; ActiveWindowBorderColour(66, 165, 245) ; this is a nice blue colour
+; ActiveWindowBorder("enable")
 
-; Give the workspaces some optional names
-Run, komorebic.exe workspace-name 0 0 bsp, , Hide
-Run, komorebic.exe workspace-name 0 1 columns, , Hide
-Run, komorebic.exe workspace-name 0 2 thicc, , Hide
-Run, komorebic.exe workspace-name 0 3 matrix, , Hide
-Run, komorebic.exe workspace-name 0 4 floaty, , Hide
+; Allow komorebi to start managing windows
+CompleteConfiguration()
 
-; Set the padding of the different workspaces
-Run, komorebic.exe workspace-padding 0 1 30, , Hide
-Run, komorebic.exe container-padding 0 1 30, , Hide
-Run, komorebic.exe workspace-padding 0 2 200, , Hide
-Run, komorebic.exe workspace-padding 0 3 0, , Hide
-Run, komorebic.exe container-padding 0 3 0, , Hide
-
-; Set the layouts of different workspaces
-Run, komorebic.exe workspace-layout 0 1 columns, , Hide
-
-; Set the floaty layout to not tile any windows
-Run, komorebic.exe workspace-tiling 0 4 disable, , Hide
-
-; Always show chat apps on the second workspace
-Run, komorebic.exe workspace-rule exe slack.exe 0 1, , Hide
-Run, komorebic.exe workspace-rule exe Discord.exe 0 1, , Hide
-
-; Always float IntelliJ popups, matching on class
-Run, komorebic.exe float-rule class SunAwtDialog, , Hide
-; Always float Control Panel, matching on title
-Run, komorebic.exe float-rule title "Control Panel", , Hide
-; Always float Task Manager, matching on class
-Run, komorebic.exe float-rule class TaskManagerWindow, , Hide
-; Always float Wally, matching on executable name
-Run, komorebic.exe float-rule exe Wally.exe, , Hide
-Run, komorebic.exe float-rule exe wincompose.exe, , Hide
-; Always float Calculator app, matching on window title
-Run, komorebic.exe float-rule title Calculator, , Hide
-Run, komorebic.exe float-rule exe 1Password.exe, , Hide
-
-; Always manage forcibly these applications that don't automatically get picked up by komorebi
-Run, komorebic.exe manage-rule exe TIM.exe, , Hide
-
-; Identify applications that close to the tray
-Run, komorebic.exe identify-tray-application exe Discord.exe, , Hide
-
-; Identify applications that have overflowing borders
-Run, komorebic.exe identify-border-overflow exe Discord.exe, , Hide
-
-; Change the focused window, Alt + Vim direction keys
+; Change the focused window, Alt + Vim direction keys (HJKL)
 !h::
-Run, komorebic.exe focus left, , Hide
+Focus("left")
 return
 
 !j::
-Run, komorebic.exe focus down, , Hide
+Focus("down")
 return
 
 !k::
-Run, komorebic.exe focus up, , Hide
+Focus("up")
 return
 
 !l::
-Run, komorebic.exe focus right, , Hide
+Focus("right")
 return
 
-; Move the focused window in a given direction, Alt + Shift + Vim direction keys
+; Move the focused window in a given direction, Alt + Shift + Vim direction keys (HJKL)
 !+h::
-Run, komorebic.exe move left, , Hide
+Move("left")
 return
 
 !+j::
-Run, komorebic.exe move down, , Hide
+Move("down")
 return
 
 !+k::
-Run, komorebic.exe move up, , Hide
+Move("up")
 return
 
 !+l::
-Run, komorebic.exe move right, , Hide
+Move("right")
 return
 
-; Stack the focused window in a given direction, Alt + Shift + direction keys
-!+Left::
-Run, komorebic.exe stack left, , Hide
-return
-
-!+Down::
-Run, komorebic.exe stack down, , Hide
-return
-
-!+Up::
-Run, komorebic.exe stack up, , Hide
-return
-
-!+Right::
-Run, komorebic.exe stack right, , Hide
-return
-
-!]::
-Run, komorebic.exe cycle-stack next, , Hide
-return
-
-![::
-Run, komorebic.exe cycle-stack previous, , Hide
-return
-
-; Unstack the focused window, Alt + Shift + D
-!+d::
-Run, komorebic.exe unstack, , Hide
-return
-
-; Promote the focused window to the top of the tree, Alt + Shift + Enter
-!+Enter::
-Run, komorebic.exe promote, , Hide
-return
-
-; Switch to an equal-width, max-height column layout on the main workspace, Alt + Shift + C
-!+c::
-Run, komorebic.exe workspace-layout 0 0 columns, , Hide
-return
-
-; Switch to the default bsp tiling layout on the main workspace, Alt + Shift + T
-!+t::
-Run, komorebic.exe workspace-layout 0 0 bsp, , Hide
-return
-
-; Toggle the Monocle layout for the focused window, Alt + Shift + F
-!+f::
-Run, komorebic.exe toggle-monocle, , Hide
-return
-
-; Toggle native maximize for the focused window, Alt + Shift + =
-!+=::
-Run, komorebic.exe toggle-maximize, , Hide
-return
-
-; Flip horizontally, Alt + X
-!x::
-Run, komorebic.exe flip-layout horizontal, , Hide
-return
-
-; Flip vertically, Alt + Y
-!y::
-Run, komorebic.exe flip-layout vertical, , Hide
-return
-
-; Force a retile if things get janky, Alt + Shift + R
-!+r::
-Run, komorebic.exe retile, , Hide
-return
-
-; Float the focused window, Alt + T
-!t::
-Run, komorebic.exe toggle-float, , Hide
-return
-
-; Reload ~/komorebi.ahk, Alt + O
-!o::
-Run, komorebic.exe reload-configuration, , Hide
-return
-
-; Pause responding to any window events or komorebic commands, Alt + P
-!p::
-Run, komorebic.exe toggle-pause, , Hide
-return
-
-; Switch to workspace
-!1::
-Send !
-Run, komorebic.exe focus-workspace 0, , Hide
-return
-
-!2::
-Send !
-Run, komorebic.exe focus-workspace 1, , Hide
-return
-
-!3::
-Send !
-Run, komorebic.exe focus-workspace 2, , Hide
-return
-
-!4::
-Send !
-Run, komorebic.exe focus-workspace 3, , Hide
-return
-
-!5::
-Send !
-Run, komorebic.exe focus-workspace 4, , Hide
-return
-
-; Move window to workspace
-!+1::
-Run, komorebic.exe move-to-workspace 0, , Hide
-return
-
-!+2::
-Run, komorebic.exe move-to-workspace 1, , Hide
-return
-
-!+3::
-Run, komorebic.exe move-to-workspace 2, , Hide
-return
-
-!+4::
-Run, komorebic.exe move-to-workspace 3, , Hide
-return
-
-!+5::
-Run, komorebic.exe move-to-workspace 4, , Hide
-return
+; There are many more commands that you can bind to whatever keys combinations you want!
+;
+; Have a look at the komorebic.lib.ahk file to see which arguments are required by different commands
+;
+; If you want more information about a command, you can run every komorebic command with "--help"
+;
+; For example, if you see this in komorebic.lib.ahk
+;
+; WorkspaceLayout(monitor, workspace, value) {
+;    Run, komorebic.exe workspace-layout %monitor% %workspace% %value%, , Hide
+; }
+;
+; Just run "komorebic.exe workspace-layout --help" and you'll get all the information you need to use the command
+;
+; komorebic.exe-workspace-layout
+; Set the layout for the specified workspace
+;
+; USAGE:
+;    komorebic.exe workspace-layout <MONITOR> <WORKSPACE> <VALUE>
+;
+; ARGS:
+;    <MONITOR>      Monitor index (zero-indexed)
+;    <WORKSPACE>    Workspace index on the specified monitor (zero-indexed)
+;    <VALUE>        [possible values: bsp, columns, rows, vertical-stack, horizontal-stack, ultrawide-vertical-stack]
+;
+; OPTIONS:
+;    -h, --help    Print help information

komorebi.sample.with.lib.ahk

@@ -1,243 +0,0 @@
-#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")
-
-; Ensure there are 5 workspaces created on monitor 0
-EnsureWorkspaces(0, 5)
-
-; Configure the invisible border dimensions
-InvisibleBorders(7, 0, 14, 7)
-
-; Configure the 1st workspace
-WorkspaceName(0, 0, "bsp")
-
-; Configure the 2nd workspace
-WorkspaceName(0, 1, "columns") ; Optionally set the name of the workspace
-WorkspacePadding(0, 1, 30) ; Set the padding around the edge of the screen
-ContainerPadding(0, 1, 30) ; Set the padding between the containers on the screen
-WorkspaceRule("exe", "slack.exe", 0, 1) ; Always show chat apps on this workspace
-
-; Configure the 3rd workspace
-WorkspaceName(0, 2, "thicc")
-WorkspacePadding(0, 2, 200) ; Set some super thicc padding
-
-; Configure the 4th workspace
-WorkspaceName(0, 3, "matrix")
-WorkspacePadding(0, 3, 0) ; No padding at all
-ContainerPadding(0, 3, 0) ; Matrix-y hacker vibes
-
-; Configure the 5th workspace
-WorkspaceName(0, 4, "floaty")
-WorkspaceTiling(0, 4, "disable") ; Everything floats here
-
-; Configure floating rules
-FloatRule("class", "SunAwtDialog") ; All the IntelliJ popups
-FloatRule("title", "Control Panel")
-FloatRule("class", "TaskManagerWindow")
-FloatRule("exe", "Wally.exe")
-FloatRule("exe", "wincompose.exe")
-FloatRule("exe", "1Password.exe")
-FloatRule("exe", "Wox.exe")
-FloatRule("exe", "ddm.exe")
-FloatRule("class", "Chrome_RenderWidgetHostHWND") ; GOG Electron invisible overlay
-FloatRule("class", "CEFCLIENT")
-
-; Identify Minimize-to-Tray Applications
-IdentifyTrayApplication("exe", "Discord.exe")
-IdentifyTrayApplication("exe", "Spotify.exe")
-IdentifyTrayApplication("exe", "GalaxyClient.exe")
-
-; Identify Electron applications with overflowing borders
-IdentifyBorderOverflow("exe", "Discord.exe")
-IdentifyBorderOverflow("exe", "Spotify.exe")
-IdentifyBorderOverflow("exe", "GalaxyClient.exe")
-IdentifyBorderOverflow("class", "ZPFTEWndClass")
-
-; Identify applications to be forcibly managed
-ManageRule("exe", "GalaxyClient.exe")
-
-; Change the focused window, Alt + Vim direction keys
-!h::
-Focus("left")
-return
-
-!j::
-Focus("down")
-return
-
-!k::
-Focus("up")
-return
-
-!l::
-Focus("right")
-return
-
-; Move the focused window in a given direction, Alt + Shift + Vim direction keys
-!+h::
-Move("left")
-return
-
-!+j::
-Move("down")
-return
-
-!+k::
-Move("up")
-return
-
-!+l::
-Move("right")
-return
-
-; Stack the focused window in a given direction, Alt + Shift + direction keys
-!+Left::
-Stack("left")
-return
-
-!+Down::
-Stack("down")
-return
-
-!+Up::
-Stack("up")
-return
-
-!+Right::
-Stack("right")
-return
-
-!]::
-CycleStack("next")
-return
-
-![::
-CycleStack("previous")
-return
-
-; Unstack the focused window, Alt + Shift + D
-!+d::
-Unstack()
-return
-
-; Promote the focused window to the top of the tree, Alt + Shift + Enter
-!+Enter::
-Promote()
-return
-
-; Manage the focused window
-!=::
-Manage()
-return
-
-; Unmanage the focused window
-!-::
-Unmanage()
-return
-
-; Switch to an equal-width, max-height column layout on the main workspace, Alt + Shift + C
-!+c::
-ChangeLayout("columns")
-return
-
-; Switch to the default bsp tiling layout on the main workspace, Alt + Shift + T
-!+t::
-ChangeLayout("bsp")
-return
-
-; Toggle the Monocle layout for the focused window, Alt + Shift + F
-!+f::
-ToggleMonocle()
-return
-
-; Toggle native maximize for the focused window, Alt + Shift + =
-!+=::
-ToggleMaximize()
-return
-
-; Flip horizontally, Alt + X
-!x::
-FlipLayout("horizontal")
-return
-
-; Flip vertically, Alt + Y
-!y::
-FlipLayout("vertical")
-return
-
-; Force a retile if things get janky, Alt + Shift + R
-!+r::
-Retile()
-return
-
-; Float the focused window, Alt + T
-!t::
-ToggleFloat()
-return
-
-; Reload ~/komorebi.ahk, Alt + O
-!o::
-ReloadConfiguration()
-return
-
-; Pause responding to any window events or komorebic commands, Alt + P
-!p::
-TogglePause()
-return
-
-; Enable focus follows mouse
-!0::
-ToggleFocusFollowsMouse("komorebi")
-return
-
-; Switch to workspace
-!1::
-Send !
-FocusWorkspace(0)
-return
-
-!2::
-Send !
-FocusWorkspace(1)
-return
-
-!3::
-Send !
-FocusWorkspace(2)
-return
-
-!4::
-Send !
-FocusWorkspace(3)
-return
-
-!5::
-Send !
-FocusWorkspace(4)
-return
-
-; Move window to workspace
-!+1::
-MoveToWorkspace(0)
-return
-
-!+2::
-MoveToWorkspace(1)
-return
-
-!+3::
-MoveToWorkspace(2)
-return
-
-!+4::
-MoveToWorkspace(3)
-return
-
-!+5::
-MoveToWorkspace(4)
-return

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.9"
+version = "0.1.13"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -23,33 +23,39 @@ dirs = "4"
 getset = "0.1"
 hotwatch = "0.4"
 lazy_static = "1"
+miow = "0.4"
 nanoid = "0.4"
+net2 = "0.2"
+os_info = "3.4"
 parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 paste = "1"
+schemars = "0.8"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 strum = { version = "0.24", features = ["derive"] }
-sysinfo = "0.23"
+sysinfo = "0.25"
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uds_windows = "1"
 which = "4"
 winput = "0.2"
-miow = "0.4"
 winreg = "0.10"
-schemars = "0.8"
 
 [dependencies.windows]
-version = "0.36"
+version = "0.39"
 features = [
     "Win32_Foundation",
     "Win32_Graphics_Dwm",
     "Win32_Graphics_Gdi",
-    "Win32_System_Threading",
+    "Win32_System_LibraryLoader",
     "Win32_System_RemoteDesktop",
-    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_System_Threading",
     "Win32_UI_Accessibility",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Shell",
+    "Win32_UI_Shell_Common",
     "Win32_UI_WindowsAndMessaging"
 ]
 

komorebi/src/border.rs

@@ -0,0 +1,132 @@
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use color_eyre::Result;
+use windows::core::PCSTR;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageA;
+use windows::Win32::UI::WindowsAndMessaging::FindWindowA;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageA;
+use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::WNDCLASSA;
+
+use komorebi_core::Rect;
+
+use crate::window::Window;
+use crate::windows_callbacks;
+use crate::WindowsApi;
+use crate::BORDER_HWND;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::BORDER_RECT;
+use crate::TRANSPARENCY_COLOUR;
+use crate::WINDOWS_11;
+
+#[derive(Debug, Clone, Copy)]
+pub struct Border {
+    pub(crate) hwnd: isize,
+}
+
+impl From<isize> for Border {
+    fn from(hwnd: isize) -> Self {
+        Self { hwnd }
+    }
+}
+
+impl Border {
+    pub const fn hwnd(self) -> HWND {
+        HWND(self.hwnd)
+    }
+
+    pub fn create(name: &str) -> Result<()> {
+        let name = format!("{name}\0");
+        let instance = WindowsApi::module_handle_w()?;
+        let class_name = PCSTR(name.as_ptr());
+        let brush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
+        let window_class = WNDCLASSA {
+            hInstance: instance,
+            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
+            lpfnWndProc: Some(windows_callbacks::border_window),
+            hbrBackground: brush,
+            ..Default::default()
+        };
+
+        let _atom = WindowsApi::register_class_a(&window_class)?;
+
+        let name_cl = name.clone();
+        std::thread::spawn(move || -> Result<()> {
+            let hwnd = WindowsApi::create_border_window(PCSTR(name_cl.as_ptr()), instance)?;
+            let border = Self::from(hwnd);
+
+            let mut message = MSG::default();
+
+            unsafe {
+                while GetMessageA(&mut message, border.hwnd(), 0, 0).into() {
+                    DispatchMessageA(&message);
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+            }
+
+            Ok(())
+        });
+
+        let mut hwnd = HWND(0);
+        while hwnd == HWND(0) {
+            hwnd = unsafe { FindWindowA(PCSTR(name.as_ptr()), PCSTR::null()) };
+        }
+
+        BORDER_HWND.store(hwnd.0, Ordering::SeqCst);
+
+        if *WINDOWS_11 {
+            WindowsApi::round_corners(hwnd.0)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn hide(self) -> Result<()> {
+        if self.hwnd == 0 {
+            Ok(())
+        } else {
+            WindowsApi::hide_border_window(self.hwnd())
+        }
+    }
+
+    pub fn set_position(
+        self,
+        window: Window,
+        invisible_borders: &Rect,
+        activate: bool,
+    ) -> Result<()> {
+        if self.hwnd == 0 {
+            Ok(())
+        } else {
+            let mut should_expand_border = false;
+
+            let mut rect = WindowsApi::window_rect(window.hwnd())?;
+            rect.top -= invisible_borders.bottom;
+            rect.bottom += invisible_borders.bottom;
+
+            let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
+            if border_overflows.contains(&window.title()?)
+                || border_overflows.contains(&window.exe()?)
+                || border_overflows.contains(&window.class()?)
+            {
+                should_expand_border = true;
+            }
+
+            if should_expand_border {
+                rect.left -= invisible_borders.left;
+                rect.top -= invisible_borders.top;
+                rect.right += invisible_borders.right;
+                rect.bottom += invisible_borders.bottom;
+            }
+
+            *BORDER_RECT.lock() = rect;
+
+            WindowsApi::position_border_window(self.hwnd(), &rect, activate)
+        }
+    }
+}

komorebi/src/main.rs

@@ -4,15 +4,15 @@
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
+use std::net::TcpStream;
 use std::path::PathBuf;
 use std::process::Command;
 use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 #[cfg(feature = "deadlock_detection")]
-use std::thread;
-#[cfg(feature = "deadlock_detection")]
 use std::time::Duration;
 
 use clap::Parser;
@@ -20,7 +20,9 @@ use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
+use crossbeam_utils::Backoff;
 use lazy_static::lazy_static;
+use os_info::Version;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
@@ -37,9 +39,11 @@ use winreg::enums::HKEY_CURRENT_USER;
 use winreg::RegKey;
 
 use komorebi_core::HidingBehaviour;
+use komorebi_core::Rect;
 use komorebi_core::SocketMessage;
 
 use crate::process_command::listen_for_commands;
+use crate::process_command::listen_for_commands_tcp;
 use crate::process_event::listen_for_events;
 use crate::process_movement::listen_for_movements;
 use crate::window_manager::State;
@@ -50,6 +54,7 @@ use crate::windows_api::WindowsApi;
 #[macro_use]
 mod ring;
 
+mod border;
 mod container;
 mod monitor;
 mod process_command;
@@ -95,11 +100,12 @@ lazy_static! {
     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(),
-        "mstsc.exe".to_string(),
         "vcxsrv.exe".to_string(),
     ]));
     static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
         Arc::new(Mutex::new(HashMap::new()));
+    static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
+        Arc::new(Mutex::new(HashMap::new()));
     static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
         Arc::new(Mutex::new(HidingBehaviour::Minimize));
     static ref HOME_DIR: PathBuf = {
@@ -118,10 +124,52 @@ lazy_static! {
             dirs::home_dir().expect("there is no home directory")
         }
     };
+    static ref DATA_DIR: PathBuf = dirs::data_local_dir().expect("there is no local data directory").join("komorebi");
+    static ref AHK_V1_EXE: String = {
+        let mut ahk_v1: String = String::from("autohotkey.exe");
+
+        if let Ok(komorebi_ahk_v1_exe) = std::env::var("KOMOREBI_AHK_V1_EXE") {
+            if which(&komorebi_ahk_v1_exe).is_ok() {
+                ahk_v1 = komorebi_ahk_v1_exe;
+            }
+        }
+
+        ahk_v1
+    };
+    static ref AHK_V2_EXE: String = {
+        let mut ahk_v2: String = String::from("AutoHotkey64.exe");
+
+        if let Ok(komorebi_ahk_v2_exe) = std::env::var("KOMOREBI_AHK_V2_EXE") {
+            if which(&komorebi_ahk_v2_exe).is_ok() {
+                ahk_v2 = komorebi_ahk_v2_exe;
+            }
+        }
+
+        ahk_v2
+    };
+
+    static ref WINDOWS_11: bool = {
+        matches!(
+            os_info::get().version(),
+            Version::Semantic(_, _, x) if x >= &22000
+        )
+    };
+
+    static ref BORDER_RECT: Arc<Mutex<Rect>> =
+        Arc::new(Mutex::new(Rect::default()));
 }
 
+pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(false);
+pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
+pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);
+pub static BORDER_COLOUR_SINGLE: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_COLOUR_STACK: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_COLOUR_CURRENT: AtomicU32 = AtomicU32::new(0);
+// 0 0 0 aka pure black, I doubt anyone will want this as a border colour
+pub const TRANSPARENCY_COLOUR: u32 = 0;
 
 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
@@ -134,8 +182,7 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
         std::env::set_var("RUST_LOG", "info");
     }
 
-    let home = HOME_DIR.clone();
-    let appender = tracing_appender::rolling::never(home, "komorebi.log");
+    let appender = tracing_appender::rolling::never(DATA_DIR.clone(), "komorebi.log");
     let color_appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi.log");
     let (non_blocking, guard) = tracing_appender::non_blocking(appender);
     let (color_non_blocking, color_guard) = tracing_appender::non_blocking(color_appender);
@@ -196,7 +243,7 @@ pub fn load_configuration() -> Result<()> {
     let mut config_v2 = home;
     config_v2.push("komorebi.ahk2");
 
-    if config_v1.exists() && which("autohotkey.exe").is_ok() {
+    if config_v1.exists() && which(&*AHK_V1_EXE).is_ok() {
         tracing::info!(
             "loading configuration file: {}",
             config_v1
@@ -208,7 +255,7 @@ pub fn load_configuration() -> Result<()> {
         Command::new("autohotkey.exe")
             .arg(config_v1.as_os_str())
             .output()?;
-    } else if config_v2.exists() && which("AutoHotkey64.exe").is_ok() {
+    } else if config_v2.exists() && which(&*AHK_V2_EXE).is_ok() {
         tracing::info!(
             "loading configuration file: {}",
             config_v2
@@ -220,7 +267,7 @@ pub fn load_configuration() -> Result<()> {
         Command::new("AutoHotkey64.exe")
             .arg(config_v2.as_os_str())
             .output()?;
-    };
+    }
 
     Ok(())
 }
@@ -319,9 +366,9 @@ pub fn notify_subscribers(notification: &str) -> Result<()> {
 #[tracing::instrument]
 fn detect_deadlocks() {
     // Create a background thread which checks for deadlocks every 10s
-    thread::spawn(move || loop {
+    std::thread::spawn(move || loop {
         tracing::info!("running deadlock detector");
-        thread::sleep(Duration::from_secs(5));
+        std::thread::sleep(Duration::from_secs(5));
         let deadlocks = deadlock::check_deadlock();
         if deadlocks.is_empty() {
             continue;
@@ -342,19 +389,38 @@ fn detect_deadlocks() {
 #[clap(author, about, version)]
 struct Opts {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
-    #[clap(long = "ffm")]
+    #[clap(action, short, long = "ffm")]
     focus_follows_mouse: bool,
+    /// Wait for 'komorebic complete-configuration' to be sent before processing events
+    #[clap(action, short, long)]
+    await_configuration: bool,
+    /// Start a TCP server on the given port to allow the direct sending of SocketMessages
+    #[clap(action, short, long)]
+    tcp_port: Option<usize>,
 }
 
 #[tracing::instrument]
+#[allow(clippy::nonminimal_bool)]
 fn main() -> Result<()> {
     let opts: Opts = Opts::parse();
     CUSTOM_FFM.store(opts.focus_follows_mouse, Ordering::SeqCst);
 
     let arg_count = std::env::args().count();
-    let has_valid_args = arg_count == 1 || (arg_count == 2 && CUSTOM_FFM.load(Ordering::SeqCst));
+
+    let has_valid_args = arg_count == 1
+        || (arg_count == 2
+            && (opts.await_configuration || opts.focus_follows_mouse || opts.tcp_port.is_some()))
+        || (arg_count == 3 && opts.await_configuration && opts.focus_follows_mouse)
+        || (arg_count == 3 && opts.tcp_port.is_some() && opts.focus_follows_mouse)
+        || (arg_count == 3 && opts.tcp_port.is_some() && opts.await_configuration)
+        || (arg_count == 4
+            && (opts.focus_follows_mouse && opts.await_configuration && opts.tcp_port.is_some()));
 
     if has_valid_args {
+        let process_id = WindowsApi::current_process_id();
+        WindowsApi::allow_set_foreground_window(process_id)?;
+        WindowsApi::set_process_dpi_awareness_context()?;
+
         let session_id = WindowsApi::process_id_to_session_id()?;
         SESSION_ID.store(session_id, Ordering::SeqCst);
 
@@ -364,14 +430,14 @@ fn main() -> Result<()> {
         let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
 
         if matched_procs.len() > 1 {
-            let mut shim_is_active = false;
+            let mut len = matched_procs.len();
             for proc in matched_procs {
                 if proc.root().ends_with("shims") {
-                    shim_is_active = true;
+                    len -= 1;
                 }
             }
 
-            if !shim_is_active {
+            if len > 1 {
                 tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
                 std::process::exit(1);
             }
@@ -383,9 +449,6 @@ fn main() -> Result<()> {
         #[cfg(feature = "deadlock_detection")]
         detect_deadlocks();
 
-        let process_id = WindowsApi::current_process_id();
-        WindowsApi::allow_set_foreground_window(process_id)?;
-
         let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
             crossbeam_channel::unbounded();
 
@@ -398,14 +461,32 @@ fn main() -> Result<()> {
 
         wm.lock().init()?;
         listen_for_commands(wm.clone());
+
+        if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+            INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
+        };
+
+        if let Some(port) = opts.tcp_port {
+            listen_for_commands_tcp(wm.clone(), port);
+        }
+
+        std::thread::spawn(|| {
+            load_configuration().expect("could not load configuration");
+        });
+
+        if opts.await_configuration {
+            let backoff = Backoff::new();
+            while !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+                backoff.snooze();
+            }
+        }
+
         listen_for_events(wm.clone());
 
         if CUSTOM_FFM.load(Ordering::SeqCst) {
             listen_for_movements(wm.clone());
         }
 
-        load_configuration()?;
-
         let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
         ctrlc::set_handler(move || {
             ctrlc_sender

komorebi/src/process_command.rs

@@ -2,16 +2,20 @@ use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
+use std::io::Read;
 use std::io::Write;
+use std::net::TcpListener;
+use std::net::TcpStream;
 use std::num::NonZeroUsize;
 use std::str::FromStr;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;
+use std::time::Duration;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use miow::pipe::connect;
+use net2::TcpStreamExt;
 use parking_lot::Mutex;
 use schemars::schema_for;
 use uds_windows::UnixStream;
@@ -20,29 +24,40 @@ use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
 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 komorebi_core::WindowKind;
 
+use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
+use crate::window::Window;
 use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_COLOUR_SINGLE;
+use crate::BORDER_COLOUR_STACK;
+use crate::BORDER_ENABLED;
+use crate::BORDER_HWND;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::CUSTOM_FFM;
 use crate::FLOAT_IDENTIFIERS;
 use crate::HIDING_BEHAVIOUR;
 use crate::HOME_DIR;
+use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::SUBSCRIPTION_PIPES;
+use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
 
@@ -54,11 +69,11 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
         .try_clone()
         .expect("could not clone unix listener");
 
-    thread::spawn(move || {
-        tracing::info!("listening");
+    std::thread::spawn(move || {
+        tracing::info!("listening on komorebi.sock");
         for client in listener.incoming() {
             match client {
-                Ok(stream) => match wm.lock().read_commands(stream) {
+                Ok(stream) => match read_commands_uds(&wm, stream) {
                     Ok(()) => {}
                     Err(error) => tracing::error!("{}", error),
                 },
@@ -71,6 +86,48 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
     });
 }
 
+#[tracing::instrument]
+pub fn listen_for_commands_tcp(wm: Arc<Mutex<WindowManager>>, port: usize) {
+    let listener =
+        TcpListener::bind(format!("0.0.0.0:{}", port)).expect("could not start tcp server");
+
+    std::thread::spawn(move || {
+        tracing::info!("listening on 0.0.0.0:43663");
+        for client in listener.incoming() {
+            match client {
+                Ok(mut stream) => {
+                    stream
+                        .set_keepalive(Some(Duration::from_secs(30)))
+                        .expect("TCP keepalive should be set");
+
+                    let addr = stream
+                        .peer_addr()
+                        .expect("incoming connection should have an address")
+                        .to_string();
+
+                    let mut connections = TCP_CONNECTIONS.lock();
+
+                    connections.insert(
+                        addr.clone(),
+                        stream.try_clone().expect("stream should be cloneable"),
+                    );
+
+                    tracing::info!("listening for incoming tcp messages from {}", &addr);
+
+                    match read_commands_tcp(&wm, &mut stream, &addr) {
+                        Ok(()) => {}
+                        Err(error) => tracing::error!("{}", error),
+                    }
+                }
+                Err(error) => {
+                    tracing::error!("{}", error);
+                    break;
+                }
+            }
+        }
+    });
+}
+
 impl WindowManager {
     #[tracing::instrument(skip(self))]
     pub fn process_command(&mut self, message: SocketMessage) -> Result<()> {
@@ -86,8 +143,23 @@ impl WindowManager {
             }
         }
 
+        match message {
+            SocketMessage::CycleFocusMonitor(_)
+            | SocketMessage::CycleFocusWorkspace(_)
+            | SocketMessage::FocusMonitorNumber(_)
+            | SocketMessage::FocusMonitorWorkspaceNumber(_, _)
+            | SocketMessage::FocusWorkspaceNumber(_) => {
+                if self.focused_workspace()?.visible_windows().is_empty() {
+                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                    border.hide()?;
+                }
+            }
+            _ => {}
+        };
+
         match message {
             SocketMessage::Promote => self.promote_container_to_front()?,
+            SocketMessage::PromoteFocus => self.promote_focus_to_front()?,
             SocketMessage::FocusWindow(direction) => {
                 self.focus_container_in_direction(direction)?;
             }
@@ -114,24 +186,24 @@ impl WindowManager {
             SocketMessage::WorkspacePadding(monitor_idx, workspace_idx, size) => {
                 self.set_workspace_padding(monitor_idx, workspace_idx, size)?;
             }
-            SocketMessage::WorkspaceRule(_, id, monitor_idx, workspace_idx) => {
+            SocketMessage::WorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
                 {
                     let mut workspace_rules = WORKSPACE_RULES.lock();
-                    workspace_rules.insert(id, (monitor_idx, workspace_idx));
+                    workspace_rules.insert(id.to_string(), (monitor_idx, workspace_idx));
                 }
 
                 self.enforce_workspace_rules()?;
             }
-            SocketMessage::ManageRule(_, id) => {
+            SocketMessage::ManageRule(_, ref id) => {
                 let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
-                if !manage_identifiers.contains(&id) {
-                    manage_identifiers.push(id);
+                if !manage_identifiers.contains(id) {
+                    manage_identifiers.push(id.to_string());
                 }
             }
-            SocketMessage::FloatRule(identifier, id) => {
+            SocketMessage::FloatRule(identifier, ref id) => {
                 let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
-                if !float_identifiers.contains(&id) {
-                    float_identifiers.push(id.clone());
+                if !float_identifiers.contains(id) {
+                    float_identifiers.push(id.to_string());
                 }
 
                 let invisible_borders = self.invisible_borders;
@@ -148,17 +220,17 @@ impl WindowManager {
                         for window in container.windows().iter() {
                             match identifier {
                                 ApplicationIdentifier::Exe => {
-                                    if window.exe()? == id {
+                                    if window.exe()? == *id {
                                         hwnds_to_purge.push((i, window.hwnd));
                                     }
                                 }
                                 ApplicationIdentifier::Class => {
-                                    if window.class()? == id {
+                                    if window.class()? == *id {
                                         hwnds_to_purge.push((i, window.hwnd));
                                     }
                                 }
                                 ApplicationIdentifier::Title => {
-                                    if window.title()? == id {
+                                    if window.title()? == *id {
                                         hwnds_to_purge.push((i, window.hwnd));
                                     }
                                 }
@@ -235,9 +307,11 @@ impl WindowManager {
             SocketMessage::Retile => self.retile_all(false)?,
             SocketMessage::FlipLayout(layout_flip) => self.flip_layout(layout_flip)?,
             SocketMessage::ChangeLayout(layout) => self.change_workspace_layout_default(layout)?,
-            SocketMessage::ChangeLayoutCustom(path) => self.change_workspace_custom_layout(path)?,
-            SocketMessage::WorkspaceLayoutCustom(monitor_idx, workspace_idx, path) => {
-                self.set_workspace_layout_custom(monitor_idx, workspace_idx, path)?;
+            SocketMessage::ChangeLayoutCustom(ref path) => {
+                self.change_workspace_custom_layout(path.clone())?;
+            }
+            SocketMessage::WorkspaceLayoutCustom(monitor_idx, workspace_idx, ref path) => {
+                self.set_workspace_layout_custom(monitor_idx, workspace_idx, path.clone())?;
             }
             SocketMessage::WorkspaceTiling(monitor_idx, workspace_idx, tile) => {
                 self.set_workspace_tiling(monitor_idx, workspace_idx, tile)?;
@@ -262,13 +336,13 @@ impl WindowManager {
                 monitor_idx,
                 workspace_idx,
                 at_container_count,
-                path,
+                ref path,
             ) => {
                 self.add_workspace_layout_custom_rule(
                     monitor_idx,
                     workspace_idx,
                     at_container_count,
-                    path,
+                    path.clone(),
                 )?;
             }
             SocketMessage::ClearWorkspaceLayoutRules(monitor_idx, workspace_idx) => {
@@ -332,8 +406,8 @@ impl WindowManager {
             SocketMessage::NewWorkspace => {
                 self.new_workspace()?;
             }
-            SocketMessage::WorkspaceName(monitor_idx, workspace_idx, name) => {
-                self.set_workspace_name(monitor_idx, workspace_idx, name)?;
+            SocketMessage::WorkspaceName(monitor_idx, workspace_idx, ref name) => {
+                self.set_workspace_name(monitor_idx, workspace_idx, name.to_string())?;
             }
             SocketMessage::State => {
                 let state = match serde_json::to_string_pretty(&window_manager::State::from(&*self))
@@ -378,15 +452,40 @@ impl WindowManager {
             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() {
+                let workspace = self.focused_workspace_mut()?;
+                let container_len = workspace.containers().len();
+                let no_layout_rules = workspace.layout_rules().is_empty();
+
+                if let Layout::Custom(ref mut custom) = workspace.layout_mut() {
                     if 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),
+                        if no_layout_rules {
+                            match sizing {
+                                Sizing::Increase => {
+                                    custom.set_primary_width_percentage(percentage + 5);
+                                }
+                                Sizing::Decrease => {
+                                    custom.set_primary_width_percentage(percentage - 5);
+                                }
+                            }
+                        } else {
+                            for rule in workspace.layout_rules_mut() {
+                                if container_len >= rule.0 {
+                                    if let Layout::Custom(ref mut custom) = rule.1 {
+                                        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
@@ -548,31 +647,37 @@ impl WindowManager {
             SocketMessage::ReloadConfiguration => {
                 Self::reload_configuration();
             }
+            SocketMessage::CompleteConfiguration => {
+                if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+                    INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
+                    self.update_focused_workspace(false)?;
+                }
+            }
             SocketMessage::WatchConfiguration(enable) => {
                 self.watch_configuration(enable)?;
             }
-            SocketMessage::IdentifyBorderOverflowApplication(_, id) => {
+            SocketMessage::IdentifyBorderOverflowApplication(_, ref id) => {
                 let mut identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                 }
             }
-            SocketMessage::IdentifyObjectNameChangeApplication(_, id) => {
+            SocketMessage::IdentifyObjectNameChangeApplication(_, ref id) => {
                 let mut identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                 }
             }
-            SocketMessage::IdentifyTrayApplication(_, id) => {
+            SocketMessage::IdentifyTrayApplication(_, ref id) => {
                 let mut identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                 }
             }
-            SocketMessage::IdentifyLayeredApplication(_, id) => {
+            SocketMessage::IdentifyLayeredApplication(_, ref id) => {
                 let mut identifiers = LAYERED_WHITELIST.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                 }
             }
             SocketMessage::ManageFocusedWindow => {
@@ -622,7 +727,7 @@ impl WindowManager {
                 workspace.set_resize_dimensions(resize);
                 self.update_focused_workspace(false)?;
             }
-            SocketMessage::Save(path) => {
+            SocketMessage::Save(ref path) => {
                 let workspace = self.focused_workspace_mut()?;
                 let resize = workspace.resize_dimensions();
 
@@ -630,14 +735,14 @@ impl WindowManager {
                     .write(true)
                     .truncate(true)
                     .create(true)
-                    .open(path)?;
+                    .open(path.clone())?;
 
                 serde_json::to_writer_pretty(&file, &resize)?;
             }
-            SocketMessage::Load(path) => {
+            SocketMessage::Load(ref path) => {
                 let workspace = self.focused_workspace_mut()?;
 
-                let file = File::open(&path)
+                let file = File::open(path)
                     .map_err(|_| anyhow!("no file found at {}", path.display().to_string()))?;
 
                 let resize: Vec<Option<Rect>> = serde_json::from_reader(file)?;
@@ -645,18 +750,18 @@ impl WindowManager {
                 workspace.set_resize_dimensions(resize);
                 self.update_focused_workspace(false)?;
             }
-            SocketMessage::AddSubscriber(subscriber) => {
+            SocketMessage::AddSubscriber(ref subscriber) => {
                 let mut pipes = SUBSCRIPTION_PIPES.lock();
                 let pipe_path = format!(r"\\.\pipe\{}", subscriber);
                 let pipe = connect(&pipe_path).map_err(|_| {
                     anyhow!("the named pipe '{}' has not yet been created; please create it before running this command", pipe_path)
                 })?;
 
-                pipes.insert(subscriber, pipe);
+                pipes.insert(subscriber.clone(), pipe);
             }
-            SocketMessage::RemoveSubscriber(subscriber) => {
+            SocketMessage::RemoveSubscriber(ref subscriber) => {
                 let mut pipes = SUBSCRIPTION_PIPES.lock();
-                pipes.remove(&subscriber);
+                pipes.remove(subscriber);
             }
             SocketMessage::MouseFollowsFocus(enable) => {
                 self.mouse_follows_focus = enable;
@@ -681,9 +786,48 @@ impl WindowManager {
                 let mut hiding_behaviour = HIDING_BEHAVIOUR.lock();
                 *hiding_behaviour = behaviour;
             }
+            SocketMessage::ToggleCrossMonitorMoveBehaviour => {
+                match self.cross_monitor_move_behaviour {
+                    MoveBehaviour::Swap => {
+                        self.cross_monitor_move_behaviour = MoveBehaviour::Insert;
+                    }
+                    MoveBehaviour::Insert => {
+                        self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
+                    }
+                }
+            }
+            SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {
+                self.cross_monitor_move_behaviour = behaviour;
+            }
             SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
                 self.unmanaged_window_operation_behaviour = behaviour;
             }
+            SocketMessage::ActiveWindowBorder(enable) => {
+                if enable {
+                    if BORDER_HWND.load(Ordering::SeqCst) == 0 {
+                        Border::create("komorebi-border-window")?;
+                    }
+
+                    BORDER_ENABLED.store(true, Ordering::SeqCst);
+                    self.show_border()?;
+                } else {
+                    BORDER_ENABLED.store(false, Ordering::SeqCst);
+                    self.hide_border()?;
+                }
+            }
+            SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => {
+                match kind {
+                    WindowKind::Single => {
+                        BORDER_COLOUR_SINGLE.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
+                        BORDER_COLOUR_CURRENT.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
+                    }
+                    WindowKind::Stack => {
+                        BORDER_COLOUR_STACK.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
+                    }
+                }
+
+                WindowsApi::invalidate_border_rect()?;
+            }
             SocketMessage::NotificationSchema => {
                 let notification = schema_for!(Notification);
                 let schema = serde_json::to_string_pretty(&notification)?;
@@ -694,37 +838,157 @@ impl WindowManager {
                 let mut stream = UnixStream::connect(&socket)?;
                 stream.write_all(schema.as_bytes())?;
             }
+            SocketMessage::SocketSchema => {
+                let socket_message = schema_for!(SocketMessage);
+                let schema = serde_json::to_string_pretty(&socket_message)?;
+                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())?;
+            }
+        };
+
+        match message {
+            SocketMessage::ChangeLayout(_)
+            | SocketMessage::ChangeLayoutCustom(_)
+            | SocketMessage::FlipLayout(_)
+            | SocketMessage::ManageFocusedWindow
+            | SocketMessage::MoveWorkspaceToMonitorNumber(_)
+            | SocketMessage::MoveContainerToMonitorNumber(_)
+            | SocketMessage::MoveContainerToWorkspaceNumber(_)
+            | SocketMessage::ResizeWindowEdge(_, _)
+            | SocketMessage::ResizeWindowAxis(_, _)
+            | SocketMessage::ToggleFloat
+            | SocketMessage::ToggleMonocle
+            | SocketMessage::ToggleMaximize
+            | SocketMessage::Promote
+            | SocketMessage::PromoteFocus
+            | SocketMessage::Retile
+            | SocketMessage::InvisibleBorders(_)
+            | SocketMessage::WorkAreaOffset(_)
+            | SocketMessage::MoveWindow(_) => {
+                let foreground = WindowsApi::foreground_window()?;
+                let foreground_window = Window { hwnd: foreground };
+                let mut rect = WindowsApi::window_rect(foreground_window.hwnd())?;
+                rect.top -= self.invisible_borders.bottom;
+                rect.bottom += self.invisible_borders.bottom;
+
+                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                border.set_position(foreground_window, &self.invisible_borders, false)?;
+            }
+            SocketMessage::TogglePause => {
+                let is_paused = self.is_paused;
+                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+
+                if is_paused {
+                    border.hide()?;
+                } else {
+                    let focused = self.focused_window()?;
+                    border.set_position(*focused, &self.invisible_borders, true)?;
+                    focused.focus(false)?;
+                }
+            }
+            SocketMessage::ToggleTiling | SocketMessage::WorkspaceTiling(..) => {
+                let tiling_enabled = *self.focused_workspace_mut()?.tile();
+                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+
+                if tiling_enabled {
+                    let focused = self.focused_window()?;
+                    border.set_position(*focused, &self.invisible_borders, true)?;
+                    focused.focus(false)?;
+                } else {
+                    border.hide()?;
+                }
+            }
+            _ => {}
         };
 
         tracing::info!("processed");
         Ok(())
     }
+}
 
-    #[tracing::instrument(skip(self, stream))]
-    pub fn read_commands(&mut self, stream: UnixStream) -> Result<()> {
-        let stream = BufReader::new(stream);
-        for line in stream.lines() {
-            let message = SocketMessage::from_str(&line?)?;
+pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, stream: UnixStream) -> Result<()> {
+    let stream = BufReader::new(stream);
+    for line in stream.lines() {
+        let message = SocketMessage::from_str(&line?)?;
 
-            if self.is_paused {
-                return match message {
-                    SocketMessage::TogglePause | SocketMessage::State | SocketMessage::Stop => {
-                        Ok(self.process_command(message)?)
-                    }
-                    _ => {
-                        tracing::trace!("ignoring while paused");
-                        Ok(())
-                    }
-                };
-            }
+        let mut wm = wm.lock();
 
-            self.process_command(message.clone())?;
-            notify_subscribers(&serde_json::to_string(&Notification {
-                event: NotificationEvent::Socket(message.clone()),
-                state: self.as_ref().into(),
-            })?)?;
+        if wm.is_paused {
+            return match message {
+                SocketMessage::TogglePause | SocketMessage::State | SocketMessage::Stop => {
+                    Ok(wm.process_command(message)?)
+                }
+                _ => {
+                    tracing::trace!("ignoring while paused");
+                    Ok(())
+                }
+            };
         }
 
-        Ok(())
+        wm.process_command(message.clone())?;
+        notify_subscribers(&serde_json::to_string(&Notification {
+            event: NotificationEvent::Socket(message.clone()),
+            state: wm.as_ref().into(),
+        })?)?;
     }
+
+    Ok(())
+}
+
+pub fn read_commands_tcp(
+    wm: &Arc<Mutex<WindowManager>>,
+    stream: &mut TcpStream,
+    addr: &str,
+) -> Result<()> {
+    let mut stream = BufReader::new(stream);
+
+    loop {
+        let mut buf = vec![0; 1024];
+        match stream.read(&mut buf) {
+            Err(..) => {
+                tracing::warn!("removing disconnected tcp client: {addr}");
+                let mut connections = TCP_CONNECTIONS.lock();
+                connections.remove(addr);
+                break;
+            }
+            Ok(size) => {
+                let message = if let Ok(message) =
+                    SocketMessage::from_str(&String::from_utf8_lossy(&buf[..size]))
+                {
+                    message
+                } else {
+                    tracing::warn!("client sent an invalid message, disconnecting: {addr}");
+                    let mut connections = TCP_CONNECTIONS.lock();
+                    connections.remove(addr);
+                    break;
+                };
+
+                let mut wm = wm.lock();
+
+                if wm.is_paused {
+                    return match message {
+                        SocketMessage::TogglePause | SocketMessage::State | SocketMessage::Stop => {
+                            Ok(wm.process_command(message)?)
+                        }
+                        _ => {
+                            tracing::trace!("ignoring while paused");
+                            Ok(())
+                        }
+                    };
+                }
+
+                wm.process_command(message.clone())?;
+                notify_subscribers(&serde_json::to_string(&Notification {
+                    event: NotificationEvent::Socket(message.clone()),
+                    state: wm.as_ref().into(),
+                })?)?;
+            }
+        }
+    }
+
+    Ok(())
 }

komorebi/src/process_event.rs

@@ -1,6 +1,6 @@
 use std::fs::OpenOptions;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -12,6 +12,7 @@ use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::WindowContainerBehaviour;
 
+use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::window_manager::WindowManager;
@@ -19,15 +20,21 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_COLOUR_SINGLE;
+use crate::BORDER_COLOUR_STACK;
+use crate::BORDER_ENABLED;
+use crate::BORDER_HIDDEN;
+use crate::BORDER_HWND;
+use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
-use crate::HOME_DIR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
     let receiver = wm.lock().incoming_events.lock().clone();
 
-    thread::spawn(move || {
+    std::thread::spawn(move || {
         tracing::info!("listening");
         loop {
             select! {
@@ -128,7 +135,7 @@ impl WindowManager {
 
         match event {
             WindowManagerEvent::Raise(window) => {
-                window.raise()?;
+                window.raise();
                 self.has_pending_raise_op = false;
             }
             WindowManagerEvent::Destroy(_, window) | WindowManagerEvent::Unmanage(window) => {
@@ -180,22 +187,20 @@ impl WindowManager {
             }
             WindowManagerEvent::FocusChange(_, window) => {
                 let workspace = self.focused_workspace_mut()?;
-                if workspace
+                if !workspace
                     .floating_windows()
                     .iter()
                     .any(|w| w.hwnd == window.hwnd)
                 {
-                    return Ok(());
-                }
-
-                if let Some(w) = workspace.maximized_window() {
-                    if w.hwnd == window.hwnd {
-                        return Ok(());
+                    if let Some(w) = workspace.maximized_window() {
+                        if w.hwnd == window.hwnd {
+                            return Ok(());
+                        }
                     }
-                }
 
-                self.focused_workspace_mut()?
-                    .focus_container_by_window(window.hwnd)?;
+                    self.focused_workspace_mut()?
+                        .focus_container_by_window(window.hwnd)?;
+                }
             }
             WindowManagerEvent::Show(_, window) | WindowManagerEvent::Manage(window) => {
                 let mut switch_to = None;
@@ -261,7 +266,7 @@ impl WindowManager {
                     }
                 }
             }
-            WindowManagerEvent::MoveResizeStart(_, _) => {
+            WindowManagerEvent::MoveResizeStart(_, window) => {
                 let monitor_idx = self.focused_monitor_idx();
                 let workspace_idx = self
                     .focused_monitor()
@@ -274,6 +279,8 @@ impl WindowManager {
                     .ok_or_else(|| anyhow!("there is no workspace with this idx"))?
                     .focused_container_idx();
 
+                WindowsApi::bring_window_to_top(window.hwnd())?;
+
                 self.pending_move_op = Option::from((monitor_idx, workspace_idx, container_idx));
             }
             WindowManagerEvent::MoveResizeEnd(_, window) => {
@@ -288,146 +295,151 @@ impl WindowManager {
                     .ok_or_else(|| anyhow!("cannot get monitor idx from current position"))?;
 
                 let new_window_behaviour = self.window_container_behaviour;
+                let invisible_borders = self.invisible_borders;
 
                 let workspace = self.focused_workspace_mut()?;
-                if workspace
+                if !workspace
                     .floating_windows()
                     .iter()
                     .any(|w| w.hwnd == window.hwnd)
                 {
-                    return Ok(());
-                }
+                    let focused_container_idx = workspace.focused_container_idx();
 
-                let focused_container_idx = workspace.focused_container_idx();
+                    let mut new_position = WindowsApi::window_rect(window.hwnd())?;
 
-                let mut new_position = WindowsApi::window_rect(window.hwnd())?;
+                    let old_position = *workspace
+                        .latest_layout()
+                        .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());
 
-                let old_position = *workspace
-                    .latest_layout()
-                    .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();
 
-                // 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;
-                new_position.top += invisible_borders.top;
-                new_position.right -= invisible_borders.right;
-                new_position.bottom -= invisible_borders.bottom;
-
-                let resize = Rect {
-                    left: new_position.left - old_position.left,
-                    top: new_position.top - old_position.top,
-                    right: new_position.right - old_position.right,
-                    bottom: new_position.bottom - old_position.bottom,
-                };
-
-                // 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");
-
-                    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)?;
+                    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;
+                    new_position.top += invisible_borders.top;
+                    new_position.right -= invisible_borders.right;
+                    new_position.bottom -= invisible_borders.bottom;
+
+                    let resize = Rect {
+                        left: new_position.left - old_position.left,
+                        top: new_position.top - old_position.top,
+                        right: new_position.right - old_position.right,
+                        bottom: new_position.bottom - old_position.bottom,
+                    };
+
+                    // 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
+                        || resize.right.abs() == invisible_borders.right
+                            && resize.bottom.abs() == invisible_borders.bottom;
+
+                    if is_move {
+                        tracing::info!("moving with mouse");
+
+                        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)?;
+                            }
+                            // 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,
+                                            )?;
+                                        }
+                                    }
+                                }
+                            }
                         }
-                    // 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");
-                    let mut ops = vec![];
+                        tracing::info!("resizing with mouse");
+                        let mut ops = vec![];
 
-                    macro_rules! resize_op {
+                        macro_rules! resize_op {
                         ($coordinate:expr, $comparator:tt, $direction:expr) => {{
                             let adjusted = $coordinate * 2;
                             let sizing = if adjusted $comparator 0 {
@@ -440,37 +452,124 @@ impl WindowManager {
                         }};
                     }
 
-                    if resize.left != 0 {
-                        ops.push(resize_op!(resize.left, >, OperationDirection::Left));
-                    }
+                        if resize.left != 0 {
+                            ops.push(resize_op!(resize.left, >, OperationDirection::Left));
+                        }
 
-                    if resize.top != 0 {
-                        ops.push(resize_op!(resize.top, >, OperationDirection::Up));
-                    }
+                        if resize.top != 0 {
+                            ops.push(resize_op!(resize.top, >, OperationDirection::Up));
+                        }
 
-                    if resize.right != 0 && resize.left == 0 {
-                        ops.push(resize_op!(resize.right, <, OperationDirection::Right));
-                    }
+                        if resize.right != 0 && resize.left == 0 {
+                            ops.push(resize_op!(resize.right, <, OperationDirection::Right));
+                        }
 
-                    if resize.bottom != 0 && resize.top == 0 {
-                        ops.push(resize_op!(resize.bottom, <, OperationDirection::Down));
-                    }
+                        if resize.bottom != 0 && resize.top == 0 {
+                            ops.push(resize_op!(resize.bottom, <, OperationDirection::Down));
+                        }
 
-                    for (edge, sizing, delta) in ops {
-                        self.resize_window(edge, sizing, delta, true)?;
-                    }
+                        for (edge, sizing, delta) in ops {
+                            self.resize_window(edge, sizing, delta, true)?;
+                        }
 
-                    self.update_focused_workspace(false)?;
+                        self.update_focused_workspace(false)?;
+                    }
                 }
             }
             WindowManagerEvent::MonitorPoll(..) | WindowManagerEvent::MouseCapture(..) => {}
         };
 
+        if *self.focused_workspace()?.tile() && BORDER_ENABLED.load(Ordering::SeqCst) {
+            match event {
+                WindowManagerEvent::MoveResizeStart(_, _) => {
+                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                    border.hide()?;
+                    BORDER_HIDDEN.store(true, Ordering::SeqCst);
+                }
+                WindowManagerEvent::MoveResizeEnd(_, window)
+                | WindowManagerEvent::Show(_, window)
+                | WindowManagerEvent::FocusChange(_, window)
+                | WindowManagerEvent::Hide(_, window)
+                | WindowManagerEvent::Minimize(_, window) => {
+                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                    let mut target_window = None;
+                    if self
+                        .focused_workspace()?
+                        .floating_windows()
+                        .iter()
+                        .any(|w| w.hwnd == window.hwnd)
+                    {
+                        target_window = Option::from(*window);
+                        WindowsApi::raise_window(border.hwnd())?;
+                    };
+
+                    if let Some(monocle_container) = self.focused_workspace()?.monocle_container() {
+                        if let Some(window) = monocle_container.focused_window() {
+                            target_window = Option::from(*window);
+                        }
+                    }
+
+                    if target_window.is_none() {
+                        match self.focused_container() {
+                            // if there is no focused container, the desktop is empty
+                            Err(..) => {
+                                WindowsApi::hide_border_window(border.hwnd())?;
+                            }
+                            Ok(container) => {
+                                if !(matches!(event, WindowManagerEvent::Minimize(_, _))
+                                    && container.windows().len() == 1)
+                                {
+                                    let container_size = self.focused_container()?.windows().len();
+                                    target_window = Option::from(*self.focused_window()?);
+
+                                    if container_size > 1 {
+                                        BORDER_COLOUR_CURRENT.store(
+                                            BORDER_COLOUR_STACK.load(Ordering::SeqCst),
+                                            Ordering::SeqCst,
+                                        );
+                                    } else {
+                                        BORDER_COLOUR_CURRENT.store(
+                                            BORDER_COLOUR_SINGLE.load(Ordering::SeqCst),
+                                            Ordering::SeqCst,
+                                        );
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    if let Some(target_window) = target_window {
+                        let window = target_window;
+                        let mut rect = WindowsApi::window_rect(window.hwnd())?;
+                        rect.top -= self.invisible_borders.bottom;
+                        rect.bottom += self.invisible_borders.bottom;
+
+                        let activate = BORDER_HIDDEN.load(Ordering::SeqCst);
+
+                        WindowsApi::invalidate_border_rect()?;
+                        border.set_position(target_window, &self.invisible_borders, activate)?;
+
+                        if activate {
+                            BORDER_HIDDEN.store(false, Ordering::SeqCst);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
         // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
         if let WindowManagerEvent::Unmanage(window) = event {
             window.center(&self.focused_monitor_work_area()?, &invisible_borders)?;
         }
 
+        // If there are no more windows on the workspace, we shouldn't show the border window
+        if self.focused_workspace()?.containers().is_empty() {
+            let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+            border.hide()?;
+            BORDER_HIDDEN.store(true, Ordering::SeqCst);
+        }
+
         tracing::trace!("updating list of known hwnds");
         let mut known_hwnds = vec![];
         for monitor in self.monitors() {
@@ -483,8 +582,7 @@ impl WindowManager {
             }
         }
 
-        let mut hwnd_json = HOME_DIR.clone();
-        hwnd_json.push("komorebi.hwnd.json");
+        let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
         let file = OpenOptions::new()
             .write(true)
             .truncate(true)

komorebi/src/process_movement.rs

@@ -17,7 +17,7 @@ pub fn listen_for_movements(wm: Arc<Mutex<WindowManager>>) {
         let receiver = message_loop::start().expect("could not start winput message loop");
 
         loop {
-            let focus_follows_mouse = wm.lock().focus_follows_mouse.clone();
+            let focus_follows_mouse = wm.lock().focus_follows_mouse;
             if let Some(FocusFollowsMouseImplementation::Komorebi) = focus_follows_mouse {
                 match receiver.next_event() {
                     // Don't want to send any raise events while we are dragging or resizing

komorebi/src/window.rs

@@ -1,6 +1,7 @@
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;
+use std::fmt::Write as _;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -11,6 +12,7 @@ use serde::Serialize;
 use serde::Serializer;
 use windows::Win32::Foundation::HWND;
 
+use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 
@@ -36,18 +38,18 @@ impl Display for Window {
         let mut display = format!("(hwnd: {}", self.hwnd);
 
         if let Ok(title) = self.title() {
-            display.push_str(&format!(", title: {}", title));
+            write!(display, ", title: {}", title)?;
         }
 
         if let Ok(exe) = self.exe() {
-            display.push_str(&format!(", exe: {}", exe));
+            write!(display, ", exe: {}", exe)?;
         }
 
         if let Ok(class) = self.class() {
-            display.push_str(&format!(", class: {}", class));
+            write!(display, ", class: {}", class)?;
         }
 
-        display.push(')');
+        write!(display, ")")?;
 
         write!(f, "{}", display)
     }
@@ -173,32 +175,86 @@ impl Window {
         WindowsApi::maximize_window(self.hwnd());
     }
 
-    pub fn raise(self) -> Result<()> {
+    pub fn unmaximize(self) {
+        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
+        if let Some(idx) = programmatically_hidden_hwnds
+            .iter()
+            .position(|&hwnd| hwnd == self.hwnd)
+        {
+            programmatically_hidden_hwnds.remove(idx);
+        }
+
+        WindowsApi::unmaximize_window(self.hwnd());
+    }
+
+    pub fn raise(self) {
         // 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();
-        WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true)?;
+
+        // This can be allowed to fail if a window doesn't have a message queue or if a journal record
+        // hook has been installed
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-attachthreadinput#remarks
+        match WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true) {
+            Ok(()) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not attach to window thread input processing mechanism, but continuing execution of raise(): {}",
+                    error
+                );
+            }
+        };
 
         // Raise Window to foreground
         match WindowsApi::set_foreground_window(self.hwnd()) {
             Ok(_) => {}
             Err(error) => {
                 tracing::error!(
-                    "could not set as foreground window, but continuing execution of focus(): {}",
+                    "could not set as foreground window, but continuing execution of raise(): {}",
                     error
                 );
             }
         };
 
         // This isn't really needed when the above command works as expected via AHK
-        WindowsApi::set_focus(self.hwnd())
+        match WindowsApi::set_focus(self.hwnd()) {
+            Ok(_) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not set focus, but continuing execution of raise(): {}",
+                    error
+                );
+            }
+        };
+
+        match WindowsApi::attach_thread_input(current_thread_id, window_thread_id, false) {
+            Ok(()) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not detach from window thread input processing mechanism, but continuing execution of raise(): {}",
+                    error
+                );
+            }
+        };
     }
 
     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();
-        WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true)?;
+
+        // This can be allowed to fail if a window doesn't have a message queue or if a journal record
+        // hook has been installed
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-attachthreadinput#remarks
+        match WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true) {
+            Ok(()) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not attach to window thread input processing mechanism, but continuing execution of focus(): {}",
+                    error
+                );
+            }
+        };
 
         // Raise Window to foreground
         match WindowsApi::set_foreground_window(self.hwnd()) {
@@ -217,7 +273,27 @@ impl Window {
         }
 
         // This isn't really needed when the above command works as expected via AHK
-        WindowsApi::set_focus(self.hwnd())
+        match WindowsApi::set_focus(self.hwnd()) {
+            Ok(_) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not set focus, but continuing execution of focus(): {}",
+                    error
+                );
+            }
+        };
+
+        match WindowsApi::attach_thread_input(current_thread_id, window_thread_id, false) {
+            Ok(()) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not detach from window thread input processing mechanism, but continuing execution of focus(): {}",
+                    error
+                );
+            }
+        };
+
+        Ok(())
     }
 
     #[allow(dead_code)]
@@ -280,46 +356,7 @@ impl Window {
             // If not allowing cloaked windows, we need to ensure the window is not cloaked
             (false, false) => {
                 if let (Ok(title), Ok(exe_name), Ok(class)) = (self.title(), self.exe(), self.class()) {
-                    {
-                        let float_identifiers = FLOAT_IDENTIFIERS.lock();
-                        if float_identifiers.contains(&title)
-                            || float_identifiers.contains(&exe_name)
-                            || float_identifiers.contains(&class) {
-                            return Ok(false);
-                        }
-                    }
-
-                    let managed_override = {
-                        let manage_identifiers = MANAGE_IDENTIFIERS.lock();
-                        manage_identifiers.contains(&exe_name) || manage_identifiers.contains(&class)
-                    };
-
-                    let allow_layered = {
-                        let layered_whitelist = LAYERED_WHITELIST.lock();
-                        layered_whitelist.contains(&exe_name) || layered_whitelist.contains(&class)
-                    };
-
-                    let allow_wsl2_gui = {
-                        let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();
-                        wsl2_ui_processes.contains(&exe_name)
-                    };
-
-                    let style = self.style()?;
-                    let ex_style = self.ex_style()?;
-
-                    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(ExtendedWindowStyle::LAYERED))
-                        || managed_override
-                    {
-                        return Ok(true);
-                    } else if event.is_some() {
-                        tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
-                    }
+                    return Ok(window_is_eligible(&title, &exe_name, &class, self.style()?, self.ex_style()?, event));
                 }
             }
             _ => {}
@@ -328,3 +365,83 @@ impl Window {
         Ok(false)
     }
 }
+
+fn window_is_eligible(
+    title: &String,
+    exe_name: &String,
+    class: &String,
+    style: WindowStyle,
+    ex_style: ExtendedWindowStyle,
+    event: Option<WindowManagerEvent>,
+) -> bool {
+    let mut should_float = false;
+    let mut matched_identifier = None;
+
+    {
+        let float_identifiers = FLOAT_IDENTIFIERS.lock();
+        for identifier in float_identifiers.iter() {
+            if title.starts_with(identifier) || title.ends_with(identifier) {
+                should_float = true;
+                matched_identifier = Option::from(ApplicationIdentifier::Title);
+            }
+
+            if class.starts_with(identifier) || class.ends_with(identifier) {
+                should_float = true;
+                matched_identifier = Option::from(ApplicationIdentifier::Class);
+            }
+
+            if identifier == exe_name {
+                should_float = true;
+                matched_identifier = Option::from(ApplicationIdentifier::Exe);
+            }
+        }
+    };
+
+    let managed_override = {
+        let manage_identifiers = MANAGE_IDENTIFIERS.lock();
+        matched_identifier.map_or_else(
+            || {
+                manage_identifiers.contains(exe_name)
+                    || manage_identifiers.contains(class)
+                    || manage_identifiers.contains(title)
+            },
+            |matched_identifier| match matched_identifier {
+                ApplicationIdentifier::Exe => manage_identifiers.contains(exe_name),
+                ApplicationIdentifier::Class => manage_identifiers.contains(class),
+                ApplicationIdentifier::Title => manage_identifiers.contains(title),
+            },
+        )
+    };
+
+    if should_float && !managed_override {
+        return false;
+    }
+
+    let allow_layered = {
+        let layered_whitelist = LAYERED_WHITELIST.lock();
+        layered_whitelist.contains(exe_name)
+            || layered_whitelist.contains(class)
+            || layered_whitelist.contains(title)
+    };
+
+    let allow_wsl2_gui = {
+        let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();
+        wsl2_ui_processes.contains(exe_name)
+    };
+
+    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(ExtendedWindowStyle::LAYERED))
+        || managed_override
+    {
+        return true;
+    } else if event.is_some() {
+        tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
+    }
+
+    false
+}

komorebi/src/window_manager.rs

@@ -2,8 +2,8 @@ use std::collections::VecDeque;
 use std::io::ErrorKind;
 use std::num::NonZeroUsize;
 use std::path::PathBuf;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -22,12 +22,14 @@ use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
 use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::WindowContainerBehaviour;
 
+use crate::border::Border;
 use crate::container::Container;
 use crate::current_virtual_desktop;
 use crate::load_configuration;
@@ -38,7 +40,9 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
 use crate::workspace::Workspace;
+use crate::BORDER_HWND;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::DATA_DIR;
 use crate::FLOAT_IDENTIFIERS;
 use crate::HOME_DIR;
 use crate::LAYERED_WHITELIST;
@@ -57,6 +61,7 @@ pub struct WindowManager {
     pub work_area_offset: Option<Rect>,
     pub resize_delta: i32,
     pub window_container_behaviour: WindowContainerBehaviour,
+    pub cross_monitor_move_behaviour: MoveBehaviour,
     pub unmanaged_window_operation_behaviour: OperationBehaviour,
     pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
     pub mouse_follows_focus: bool,
@@ -73,6 +78,7 @@ pub struct State {
     pub invisible_borders: Rect,
     pub resize_delta: i32,
     pub new_window_behaviour: WindowContainerBehaviour,
+    pub cross_monitor_move_behaviour: MoveBehaviour,
     pub work_area_offset: Option<Rect>,
     pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
     pub mouse_follows_focus: bool,
@@ -100,7 +106,8 @@ impl From<&WindowManager> for State {
             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(),
+            cross_monitor_move_behaviour: wm.cross_monitor_move_behaviour,
+            focus_follows_mouse: wm.focus_follows_mouse,
             mouse_follows_focus: wm.mouse_follows_focus,
             has_pending_raise_op: wm.has_pending_raise_op,
             float_identifiers: FLOAT_IDENTIFIERS.lock().clone(),
@@ -142,10 +149,7 @@ impl EnforceWorkspaceRuleOp {
 impl WindowManager {
     #[tracing::instrument]
     pub fn new(incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>) -> Result<Self> {
-        let home = HOME_DIR.clone();
-        let mut socket = home;
-        socket.push("komorebi.sock");
-        let socket = socket.as_path();
+        let socket = DATA_DIR.join("komorebi.sock");
 
         match std::fs::remove_file(&socket) {
             Ok(_) => {}
@@ -174,6 +178,7 @@ impl WindowManager {
             virtual_desktop_id: current_virtual_desktop(),
             work_area_offset: None,
             window_container_behaviour: WindowContainerBehaviour::Create,
+            cross_monitor_move_behaviour: MoveBehaviour::Swap,
             unmanaged_window_operation_behaviour: OperationBehaviour::Op,
             resize_delta: 50,
             focus_follows_mouse: None,
@@ -188,14 +193,34 @@ impl WindowManager {
     pub fn init(&mut self) -> Result<()> {
         tracing::info!("initialising");
         WindowsApi::load_monitor_information(&mut self.monitors)?;
-        WindowsApi::load_workspace_information(&mut self.monitors)?;
-        self.update_focused_workspace(false)
+        WindowsApi::load_workspace_information(&mut self.monitors)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn show_border(&self) -> Result<()> {
+        let foreground = WindowsApi::foreground_window()?;
+        let foreground_window = Window { hwnd: foreground };
+        let mut rect = WindowsApi::window_rect(foreground_window.hwnd())?;
+        rect.top -= self.invisible_borders.bottom;
+        rect.bottom += self.invisible_borders.bottom;
+
+        let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+        border.set_position(foreground_window, &self.invisible_borders, true)?;
+        WindowsApi::invalidate_border_rect()
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn hide_border(&self) -> Result<()> {
+        let focused = self.focused_window()?;
+        let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+        border.hide()?;
+        focused.focus(false)
     }
 
     #[tracing::instrument]
     pub fn reload_configuration() {
         tracing::info!("reloading configuration");
-        thread::spawn(|| load_configuration().expect("could not load configuration"));
+        std::thread::spawn(|| load_configuration().expect("could not load configuration"));
     }
 
     #[tracing::instrument(skip(self))]
@@ -244,7 +269,7 @@ impl WindowManager {
                     // Editing in Notepad sends a NoticeWrite while editing in (Neo)Vim sends
                     // a NoticeRemove, presumably because of the use of swap files?
                     DebouncedEvent::NoticeWrite(_) | DebouncedEvent::NoticeRemove(_) => {
-                        thread::spawn(|| {
+                        std::thread::spawn(|| {
                             load_configuration().expect("could not load configuration");
                         });
                     }
@@ -266,6 +291,39 @@ impl WindowManager {
         Ok(())
     }
 
+    pub fn monitor_idx_in_direction(&self, direction: OperationDirection) -> Option<usize> {
+        let current_monitor_size = self.focused_monitor_size().ok()?;
+
+        for (idx, monitor) in self.monitors.elements().iter().enumerate() {
+            match direction {
+                OperationDirection::Left => {
+                    if monitor.size().left + monitor.size().right == current_monitor_size.left {
+                        return Option::from(idx);
+                    }
+                }
+                OperationDirection::Right => {
+                    if current_monitor_size.right + current_monitor_size.left == monitor.size().left
+                    {
+                        return Option::from(idx);
+                    }
+                }
+                OperationDirection::Up => {
+                    if monitor.size().top + monitor.size().bottom == current_monitor_size.top {
+                        return Option::from(idx);
+                    }
+                }
+                OperationDirection::Down => {
+                    if current_monitor_size.top + current_monitor_size.bottom == monitor.size().top
+                    {
+                        return Option::from(idx);
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn reconcile_monitors(&mut self) -> Result<()> {
         let valid_hmonitors = WindowsApi::valid_hmonitors()?;
@@ -903,15 +961,33 @@ impl WindowManager {
     pub fn focus_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
 
+        let workspace = self.focused_workspace()?;
+
+        if workspace.is_focused_window_monocle_or_maximized()? {
+            return Err(anyhow!(
+                "ignoring command while active window is in monocle mode or maximized"
+            ));
+        }
+
         tracing::info!("focusing container");
 
-        let workspace = self.focused_workspace_mut()?;
+        let new_idx = workspace.new_idx_for_direction(direction);
 
-        let new_idx = workspace
-            .new_idx_for_direction(direction)
-            .ok_or_else(|| anyhow!("this is not a valid direction from the current position"))?;
+        // if there is no container in that direction for this workspace
+        match new_idx {
+            None => {
+                let monitor_idx = self
+                    .monitor_idx_in_direction(direction)
+                    .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
+
+                self.focus_monitor(monitor_idx)?;
+            }
+            Some(idx) => {
+                let workspace = self.focused_workspace_mut()?;
+                workspace.focus_container(idx);
+            }
+        }
 
-        workspace.focus_container(new_idx);
         self.focused_window_mut()?.focus(self.mouse_follows_focus)?;
 
         Ok(())
@@ -921,17 +997,126 @@ impl WindowManager {
     pub fn move_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
 
+        let workspace = self.focused_workspace()?;
+        if workspace.is_focused_window_monocle_or_maximized()? {
+            return Err(anyhow!(
+                "ignoring command while active window is in monocle mode or maximized"
+            ));
+        }
+
         tracing::info!("moving container");
 
-        let workspace = self.focused_workspace_mut()?;
+        let origin_container_idx = workspace.focused_container_idx();
+        let origin_monitor_idx = self.focused_monitor_idx();
+        let target_container_idx = workspace.new_idx_for_direction(direction);
 
-        let current_idx = workspace.focused_container_idx();
-        let new_idx = workspace
-            .new_idx_for_direction(direction)
-            .ok_or_else(|| anyhow!("this is not a valid direction from the current position"))?;
+        match target_container_idx {
+            // If there is nowhere to move on the current workspace, try to move it onto the monitor
+            // in that direction if there is one
+            None => {
+                let target_monitor_idx = self
+                    .monitor_idx_in_direction(direction)
+                    .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
+
+                {
+                    // remove the container from the origin monitor workspace
+                    let origin_container = self
+                        .focused_workspace_mut()?
+                        .remove_container_by_idx(origin_container_idx)
+                        .ok_or_else(|| {
+                            anyhow!("could not remove container at given origin index")
+                        })?;
+
+                    // focus the target monitor
+                    self.focus_monitor(target_monitor_idx)?;
+
+                    // get the focused workspace on the target monitor
+                    let target_workspace = self.focused_workspace_mut()?;
+
+                    // insert the origin container into the focused workspace on the target monitor
+                    // at the position where the currently focused container on that workspace is
+                    target_workspace.insert_container_at_idx(
+                        target_workspace.focused_container_idx(),
+                        origin_container,
+                    );
+
+                    // if there is only one container on the target workspace after the insertion
+                    // it means that there won't be one swapped back, so we have to decrement the
+                    // focused position
+                    if target_workspace.containers().len() == 1 {
+                        let origin_workspace =
+                            self.focused_workspace_for_monitor_idx_mut(origin_monitor_idx)?;
+
+                        if origin_workspace.focused_container_idx() != 0 {
+                            origin_workspace
+                                .focus_container(origin_workspace.focused_container_idx() - 1);
+                        }
+                    }
+                }
+
+                // if our MoveBehaviour is Swap, let's try to send back the window container
+                // whose position which just took over
+                if matches!(self.cross_monitor_move_behaviour, MoveBehaviour::Swap) {
+                    {
+                        let target_workspace = self.focused_workspace_mut()?;
+
+                        // if the target workspace doesn't have more than one container, this means it
+                        // was previously empty, by only doing the second part of the swap when there is
+                        // more than one container, we can fall back to a "move" if there is nothing to
+                        // swap with on the target monitor
+                        if target_workspace.containers().len() > 1 {
+                            // remove the container from the target monitor workspace
+                            let target_container = target_workspace
+                                // this is now focused_container_idx + 1 because we have inserted our origin container
+                                .remove_container_by_idx(
+                                    target_workspace.focused_container_idx() + 1,
+                                )
+                                .ok_or_else(|| {
+                                    anyhow!("could not remove container at given target index")
+                                })?;
+
+                            let origin_workspace =
+                                self.focused_workspace_for_monitor_idx_mut(origin_monitor_idx)?;
+
+                            // insert the container from the target monitor workspace into the origin monitor workspace
+                            // at the same position from which our origin container was removed
+                            origin_workspace
+                                .insert_container_at_idx(origin_container_idx, target_container);
+                        }
+                    }
+                }
+
+                // make sure to update the origin monitor workspace layout because it is no
+                // longer focused so it won't get updated at the end of this fn
+                let offset = self.work_area_offset;
+                let invisible_borders = self.invisible_borders;
+
+                self.monitors_mut()
+                    .get_mut(origin_monitor_idx)
+                    .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+                    .update_focused_workspace(offset, &invisible_borders)?;
+
+                let a = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor focused monitor"))?
+                    .id();
+                let b = self
+                    .monitors_mut()
+                    .get_mut(origin_monitor_idx)
+                    .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+                    .id();
+
+                if !WindowsApi::monitors_have_same_scale_factor(a, b)? {
+                    self.update_focused_workspace(self.mouse_follows_focus)?;
+                }
+            }
+            Some(new_idx) => {
+                let workspace = self.focused_workspace_mut()?;
+                workspace.swap_containers(origin_container_idx, new_idx);
+                workspace.focus_container(new_idx);
+            }
+        }
 
-        workspace.swap_containers(current_idx, new_idx);
-        workspace.focus_container(new_idx);
         self.update_focused_workspace(self.mouse_follows_focus)
     }
 
@@ -976,9 +1161,14 @@ impl WindowManager {
     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()?;
+        if workspace.is_focused_window_monocle_or_maximized()? {
+            return Err(anyhow!(
+                "ignoring command while active window is in monocle mode or maximized"
+            ));
+        }
+
+        tracing::info!("moving container");
 
         let current_idx = workspace.focused_container_idx();
         let new_idx = workspace
@@ -1063,6 +1253,23 @@ impl WindowManager {
         self.update_focused_workspace(self.mouse_follows_focus)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn promote_focus_to_front(&mut self) -> Result<()> {
+        self.handle_unmanaged_window_behaviour()?;
+
+        tracing::info!("promoting focus");
+
+        let workspace = self.focused_workspace_mut()?;
+        let target_idx = match workspace.layout() {
+            Layout::Default(_) => 0,
+            Layout::Custom(custom) => custom
+                .first_container_idx(custom.primary_idx().map_or(0, |primary_idx| primary_idx)),
+        };
+
+        workspace.focus_container(target_idx);
+        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()?;
@@ -1288,6 +1495,7 @@ impl WindowManager {
         }
 
         workspace.set_layout(Layout::Custom(layout));
+        workspace.set_layout_flip(None);
         self.update_focused_workspace(self.mouse_follows_focus)
     }
 
@@ -1528,6 +1736,7 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
         workspace.set_layout(Layout::Custom(layout));
+        workspace.set_layout_flip(None);
 
         // 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 {
@@ -1629,6 +1838,13 @@ impl WindowManager {
         self.update_focused_workspace(false)
     }
 
+    pub fn focused_monitor_size(&self) -> Result<Rect> {
+        Ok(*self
+            .focused_monitor()
+            .ok_or_else(|| anyhow!("there is no monitor"))?
+            .size())
+    }
+
     pub fn focused_monitor_work_area(&self) -> Result<Rect> {
         Ok(*self
             .focused_monitor()
@@ -1661,7 +1877,7 @@ impl WindowManager {
         None
     }
 
-    pub fn monitor_idx_from_current_pos(&mut self) -> Option<usize> {
+    pub fn monitor_idx_from_current_pos(&self) -> Option<usize> {
         let hmonitor = WindowsApi::monitor_from_point(WindowsApi::cursor_pos().ok()?);
 
         for (i, monitor) in self.monitors().iter().enumerate() {
@@ -1687,6 +1903,22 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no workspace"))
     }
 
+    pub fn focused_workspace_for_monitor_idx(&self, idx: usize) -> Result<&Workspace> {
+        self.monitors()
+            .get(idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .focused_workspace()
+            .ok_or_else(|| anyhow!("there is no workspace"))
+    }
+
+    pub fn focused_workspace_for_monitor_idx_mut(&mut self, idx: usize) -> Result<&mut Workspace> {
+        self.monitors_mut()
+            .get_mut(idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .focused_workspace_mut()
+            .ok_or_else(|| anyhow!("there is no workspace"))
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn focus_workspace(&mut self, idx: usize) -> Result<()> {
         tracing::info!("focusing workspace");
@@ -1699,7 +1931,7 @@ impl WindowManager {
         monitor.focus_workspace(idx)?;
         monitor.load_focused_workspace(mouse_follows_focus)?;
 
-        self.update_focused_workspace(mouse_follows_focus)
+        self.update_focused_workspace(false)
     }
 
     #[tracing::instrument(skip(self))]

komorebi/src/window_manager_event.rs

@@ -28,56 +28,56 @@ pub enum WindowManagerEvent {
 impl Display for WindowManagerEvent {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            WindowManagerEvent::Manage(window) => {
+            Self::Manage(window) => {
                 write!(f, "Manage (Window: {})", window)
             }
-            WindowManagerEvent::Unmanage(window) => {
+            Self::Unmanage(window) => {
                 write!(f, "Unmanage (Window: {})", window)
             }
-            WindowManagerEvent::Destroy(winevent, window) => {
+            Self::Destroy(winevent, window) => {
                 write!(f, "Destroy (WinEvent: {}, Window: {})", winevent, window)
             }
-            WindowManagerEvent::FocusChange(winevent, window) => {
+            Self::FocusChange(winevent, window) => {
                 write!(
                     f,
                     "FocusChange (WinEvent: {}, Window: {})",
                     winevent, window
                 )
             }
-            WindowManagerEvent::Hide(winevent, window) => {
+            Self::Hide(winevent, window) => {
                 write!(f, "Hide (WinEvent: {}, Window: {})", winevent, window)
             }
-            WindowManagerEvent::Minimize(winevent, window) => {
+            Self::Minimize(winevent, window) => {
                 write!(f, "Minimize (WinEvent: {}, Window: {})", winevent, window)
             }
-            WindowManagerEvent::Show(winevent, window) => {
+            Self::Show(winevent, window) => {
                 write!(f, "Show (WinEvent: {}, Window: {})", winevent, window)
             }
-            WindowManagerEvent::MoveResizeStart(winevent, window) => {
+            Self::MoveResizeStart(winevent, window) => {
                 write!(
                     f,
                     "MoveResizeStart (WinEvent: {}, Window: {})",
                     winevent, window
                 )
             }
-            WindowManagerEvent::MoveResizeEnd(winevent, window) => {
+            Self::MoveResizeEnd(winevent, window) => {
                 write!(
                     f,
                     "MoveResizeEnd (WinEvent: {}, Window: {})",
                     winevent, window
                 )
             }
-            WindowManagerEvent::MouseCapture(winevent, window) => {
+            Self::MouseCapture(winevent, window) => {
                 write!(
                     f,
                     "MouseCapture (WinEvent: {}, Window: {})",
                     winevent, window
                 )
             }
-            WindowManagerEvent::Raise(window) => {
+            Self::Raise(window) => {
                 write!(f, "Raise (Window: {})", window)
             }
-            WindowManagerEvent::MonitorPoll(winevent, window) => {
+            Self::MonitorPoll(winevent, window) => {
                 write!(
                     f,
                     "MonitorPoll (WinEvent: {}, Window: {})",
@@ -91,18 +91,18 @@ impl Display for WindowManagerEvent {
 impl WindowManagerEvent {
     pub const fn window(self) -> Window {
         match self {
-            WindowManagerEvent::Destroy(_, window)
-            | WindowManagerEvent::FocusChange(_, window)
-            | WindowManagerEvent::Hide(_, window)
-            | WindowManagerEvent::Minimize(_, window)
-            | WindowManagerEvent::Show(_, window)
-            | WindowManagerEvent::MoveResizeStart(_, window)
-            | WindowManagerEvent::MoveResizeEnd(_, window)
-            | WindowManagerEvent::MouseCapture(_, window)
-            | WindowManagerEvent::MonitorPoll(_, window)
-            | WindowManagerEvent::Raise(window)
-            | WindowManagerEvent::Manage(window)
-            | WindowManagerEvent::Unmanage(window) => window,
+            Self::Destroy(_, window)
+            | Self::FocusChange(_, window)
+            | Self::Hide(_, window)
+            | Self::Minimize(_, window)
+            | Self::Show(_, window)
+            | Self::MoveResizeStart(_, window)
+            | Self::MoveResizeEnd(_, window)
+            | Self::MouseCapture(_, window)
+            | Self::MonitorPoll(_, window)
+            | Self::Raise(window)
+            | Self::Manage(window)
+            | Self::Unmanage(window) => window,
         }
     }
 

komorebi/src/windows_api.rs

@@ -1,34 +1,44 @@
 use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::ffi::c_void;
+use std::sync::atomic::Ordering;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::Error;
 use color_eyre::Result;
 use windows::core::Result as WindowsCrateResult;
+use windows::core::PCSTR;
 use windows::core::PWSTR;
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HANDLE;
+use windows::Win32::Foundation::HINSTANCE;
 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::DwmSetWindowAttribute;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
 use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
+use windows::Win32::Graphics::Dwm::DWMWA_WINDOW_CORNER_PREFERENCE;
+use windows::Win32::Graphics::Dwm::DWMWCP_ROUND;
 use windows::Win32::Graphics::Dwm::DWMWINDOWATTRIBUTE;
 use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
 use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
 use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
+use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
+use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
+use windows::Win32::Graphics::Gdi::HBRUSH;
 use windows::Win32::Graphics::Gdi::HDC;
 use windows::Win32::Graphics::Gdi::HMONITOR;
 use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
 use windows::Win32::Graphics::Gdi::MONITORINFO;
 use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
 use windows::Win32::System::Threading::AttachThreadInput;
 use windows::Win32::System::Threading::GetCurrentProcessId;
@@ -38,8 +48,14 @@ use windows::Win32::System::Threading::QueryFullProcessImageNameW;
 use windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS;
 use windows::Win32::System::Threading::PROCESS_NAME_WIN32;
 use windows::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
+use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::Input::KeyboardAndMouse::SetFocus;
+use windows::Win32::UI::Shell::Common::DEVICE_SCALE_FACTOR;
+use windows::Win32::UI::Shell::GetScaleFactorForMonitor;
 use windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::BringWindowToTop;
+use windows::Win32::UI::WindowsAndMessaging::CreateWindowExA;
 use windows::Win32::UI::WindowsAndMessaging::EnumWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
@@ -54,18 +70,23 @@ 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::RegisterClassA;
 use windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
 use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
 use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
 use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
+use windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
+use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
 use windows::Win32::UI::WindowsAndMessaging::HWND_NOTOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::HWND_TOPMOST;
+use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
 use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
@@ -74,11 +95,19 @@ 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::SW_NORMAL;
+use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNOACTIVATE;
 use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
 use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
+use windows::Win32::UI::WindowsAndMessaging::WNDCLASSA;
 use windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_MAXIMIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_MINIMIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
+use windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;
 
 use komorebi_core::Rect;
 
@@ -88,6 +117,8 @@ use crate::monitor::Monitor;
 use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
+use crate::BORDER_HWND;
+use crate::TRANSPARENCY_COLOUR;
 
 pub enum WindowsResult<T, E> {
     Err(E),
@@ -109,7 +140,7 @@ macro_rules! impl_from_integer_for_windows_result {
     };
 }
 
-impl_from_integer_for_windows_result!(isize, u32, i32);
+impl_from_integer_for_windows_result!(usize, isize, u16, u32, i32);
 
 impl<T, E> From<WindowsResult<T, E>> for Result<T, E> {
     fn from(result: WindowsResult<T, E>) -> Self {
@@ -254,10 +285,39 @@ impl WindowsApi {
     pub fn position_window(hwnd: HWND, layout: &Rect, top: bool) -> Result<()> {
         let flags = SetWindowPosition::NO_ACTIVATE;
 
-        let position = if top { HWND_TOPMOST } else { HWND_NOTOPMOST };
+        let position = if top { HWND_TOPMOST } else { HWND_BOTTOM };
         Self::set_window_pos(hwnd, layout, position, flags.bits())
     }
 
+    pub fn bring_window_to_top(hwnd: HWND) -> Result<()> {
+        unsafe { BringWindowToTop(hwnd) }.ok().process()
+    }
+
+    pub fn raise_window(hwnd: HWND) -> Result<()> {
+        let flags = SetWindowPosition::NO_MOVE;
+
+        let position = HWND_TOPMOST;
+        Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
+    }
+
+    pub fn position_border_window(hwnd: HWND, layout: &Rect, activate: bool) -> Result<()> {
+        let flags = if activate {
+            SetWindowPosition::SHOW_WINDOW | SetWindowPosition::NO_ACTIVATE
+        } else {
+            SetWindowPosition::NO_ACTIVATE
+        };
+
+        let position = HWND_NOTOPMOST;
+        Self::set_window_pos(hwnd, layout, position, flags.bits())
+    }
+
+    pub fn hide_border_window(hwnd: HWND) -> Result<()> {
+        let flags = SetWindowPosition::HIDE_WINDOW;
+
+        let position = HWND_BOTTOM;
+        Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
+    }
+
     pub fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> Result<()> {
         unsafe {
             SetWindowPos(
@@ -289,7 +349,11 @@ impl WindowsApi {
     }
 
     pub fn restore_window(hwnd: HWND) {
-        Self::show_window(hwnd, SW_RESTORE);
+        Self::show_window(hwnd, SW_SHOWNOACTIVATE);
+    }
+
+    pub fn unmaximize_window(hwnd: HWND) {
+        Self::show_window(hwnd, SW_NORMAL);
     }
 
     pub fn maximize_window(hwnd: HWND) {
@@ -436,6 +500,11 @@ impl WindowsApi {
         Self::set_window_long_ptr_w(hwnd, GWL_STYLE, new_value)
     }
 
+    #[allow(dead_code)]
+    pub fn update_ex_style(hwnd: HWND, new_value: isize) -> Result<()> {
+        Self::set_window_long_ptr_w(hwnd, GWL_EXSTYLE, new_value)
+    }
+
     pub fn window_text_w(hwnd: HWND) -> Result<String> {
         let mut text: [u16; 512] = [0; 512];
         match WindowsResult::from(unsafe { GetWindowTextW(hwnd, &mut text) }) {
@@ -565,6 +634,12 @@ impl WindowsApi {
         ))
     }
 
+    pub fn set_process_dpi_awareness_context() -> Result<()> {
+        unsafe { SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) }
+            .ok()
+            .process()
+    }
+
     #[allow(dead_code)]
     pub fn system_parameters_info_w(
         action: SYSTEM_PARAMETERS_INFO_ACTION,
@@ -610,4 +685,77 @@ impl WindowsApi {
             SPIF_SENDCHANGE,
         )
     }
+
+    pub fn module_handle_w() -> Result<HINSTANCE> {
+        unsafe { GetModuleHandleW(None) }.process()
+    }
+
+    pub fn create_solid_brush(colour: u32) -> HBRUSH {
+        unsafe { CreateSolidBrush(colour) }
+    }
+
+    pub fn register_class_a(window_class: &WNDCLASSA) -> Result<u16> {
+        Result::from(WindowsResult::from(unsafe { RegisterClassA(window_class) }))
+    }
+
+    pub fn scale_factor_for_monitor(hmonitor: isize) -> Result<DEVICE_SCALE_FACTOR> {
+        unsafe { GetScaleFactorForMonitor(HMONITOR(hmonitor)) }.process()
+    }
+
+    pub fn monitors_have_same_scale_factor(a: isize, b: isize) -> Result<bool> {
+        let a = Self::scale_factor_for_monitor(a)?;
+        let b = Self::scale_factor_for_monitor(b)?;
+
+        Ok(a == b)
+    }
+
+    pub fn round_corners(hwnd: isize) -> Result<()> {
+        let round = DWMWCP_ROUND;
+
+        unsafe {
+            DwmSetWindowAttribute(
+                HWND(hwnd),
+                DWMWA_WINDOW_CORNER_PREFERENCE,
+                std::ptr::addr_of!(round).cast(),
+                4,
+            )
+        }
+        .process()
+    }
+
+    pub fn create_border_window(name: PCSTR, instance: HINSTANCE) -> Result<isize> {
+        unsafe {
+            let hwnd = CreateWindowExA(
+                WS_EX_TOOLWINDOW | WS_EX_LAYERED,
+                name,
+                name,
+                WS_POPUP | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                None,
+                None,
+                instance,
+                std::ptr::null(),
+            );
+
+            SetLayeredWindowAttributes(hwnd, TRANSPARENCY_COLOUR, 0, LWA_COLORKEY);
+
+            hwnd
+        }
+        .process()
+    }
+
+    pub fn invalidate_border_rect() -> Result<()> {
+        unsafe {
+            InvalidateRect(
+                HWND(BORDER_HWND.load(Ordering::SeqCst)),
+                std::ptr::null(),
+                false,
+            )
+        }
+        .ok()
+        .process()
+    }
 }

komorebi/src/windows_callbacks.rs

@@ -1,12 +1,27 @@
 use std::collections::VecDeque;
+use std::sync::atomic::Ordering;
 
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
+use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::RECT;
+use windows::Win32::Foundation::WPARAM;
+use windows::Win32::Graphics::Gdi::BeginPaint;
+use windows::Win32::Graphics::Gdi::CreatePen;
+use windows::Win32::Graphics::Gdi::EndPaint;
+use windows::Win32::Graphics::Gdi::Rectangle;
+use windows::Win32::Graphics::Gdi::SelectObject;
+use windows::Win32::Graphics::Gdi::ValidateRect;
 use windows::Win32::Graphics::Gdi::HDC;
 use windows::Win32::Graphics::Gdi::HMONITOR;
+use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
+use windows::Win32::Graphics::Gdi::PS_SOLID;
 use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
+use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
+use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
+use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
+use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 
 use crate::container::Container;
 use crate::monitor::Monitor;
@@ -15,6 +30,9 @@ use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
+use crate::BORDER_COLOUR_CURRENT;
+use crate::BORDER_RECT;
+use crate::TRANSPARENCY_COLOUR;
 
 pub extern "system" fn valid_display_monitors(
     hmonitor: HMONITOR,
@@ -103,3 +121,35 @@ pub extern "system" fn win_event_hook(
         }
     }
 }
+
+pub extern "system" fn border_window(
+    window: HWND,
+    message: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    unsafe {
+        match message as u32 {
+            WM_PAINT => {
+                let border_rect = *BORDER_RECT.lock();
+                let mut ps = PAINTSTRUCT::default();
+                let hdc = BeginPaint(window, std::ptr::addr_of_mut!(ps).cast());
+                let hpen = CreatePen(PS_SOLID, 20, BORDER_COLOUR_CURRENT.load(Ordering::SeqCst));
+                let hbrush = WindowsApi::create_solid_brush(TRANSPARENCY_COLOUR);
+
+                SelectObject(hdc, hpen);
+                SelectObject(hdc, hbrush);
+                Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
+                EndPaint(window, &ps);
+                ValidateRect(window, std::ptr::null());
+
+                LRESULT(0)
+            }
+            WM_DESTROY => {
+                PostQuitMessage(0);
+                LRESULT(0)
+            }
+            _ => DefWindowProcW(window, message, wparam, lparam),
+        }
+    }
+}

komorebi/src/winevent.rs

@@ -88,7 +88,7 @@ use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;
 
-#[derive(Clone, Copy, PartialEq, Debug, Serialize, Display, JsonSchema)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Display, JsonSchema)]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {

komorebi/src/winevent_listener.rs

@@ -1,7 +1,6 @@
 use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;
 use std::time::Duration;
 
 use crossbeam_channel::Receiver;
@@ -44,10 +43,10 @@ impl WinEventListener {
         let hook = self.hook.clone();
         let outgoing = self.outgoing_events.lock().clone();
 
-        thread::spawn(move || unsafe {
+        std::thread::spawn(move || unsafe {
             let hook_ref = SetWinEventHook(
-                EVENT_MIN as u32,
-                EVENT_MAX as u32,
+                EVENT_MIN,
+                EVENT_MAX,
                 None,
                 Some(windows_callbacks::win_event_hook),
                 0,
@@ -96,7 +95,7 @@ impl MessageLoop {
                 }
             }
 
-            thread::sleep(Duration::from_millis(sleep));
+            std::thread::sleep(Duration::from_millis(sleep));
 
             if !cb(value) {
                 break;

komorebi/src/workspace.rs

@@ -1,5 +1,6 @@
 use std::collections::VecDeque;
 use std::num::NonZeroUsize;
+use std::sync::atomic::Ordering;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -21,6 +22,7 @@ use crate::container::Container;
 use crate::ring::Ring;
 use crate::window::Window;
 use crate::windows_api::WindowsApi;
+use crate::INITIAL_CONFIGURATION_LOADED;
 
 #[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
 pub struct Workspace {
@@ -149,6 +151,10 @@ impl Workspace {
         offset: Option<Rect>,
         invisible_borders: &Rect,
     ) -> Result<()> {
+        if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
         let container_padding = self.container_padding();
         let mut adjusted_work_area = offset.map_or_else(
             || *work_area,
@@ -177,6 +183,10 @@ impl Workspace {
             }
 
             if let Some(updated_layout) = updated_layout {
+                if !matches!(updated_layout, Layout::Default(DefaultLayout::BSP)) {
+                    self.set_layout_flip(None);
+                }
+
                 self.set_layout(updated_layout);
             }
         }
@@ -356,6 +366,23 @@ impl Workspace {
         false
     }
 
+    pub fn is_focused_window_monocle_or_maximized(&self) -> Result<bool> {
+        let hwnd = WindowsApi::foreground_window()?;
+        if let Some(window) = self.maximized_window() {
+            if hwnd == window.hwnd {
+                return Ok(true);
+            }
+        }
+
+        if let Some(container) = self.monocle_container() {
+            if container.contains_window(hwnd) {
+                return Ok(true);
+            }
+        }
+
+        Ok(false)
+    }
+
     pub fn contains_window(&self, hwnd: isize) -> bool {
         for container in self.containers() {
             if container.contains_window(hwnd) {
@@ -412,7 +439,11 @@ impl Workspace {
         self.focus_last_container();
     }
 
-    fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
+    pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) {
+        self.containers_mut().insert(idx, container);
+    }
+
+    pub fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
         if idx < self.resize_dimensions().len() {
             self.resize_dimensions_mut().remove(idx);
         }
@@ -462,6 +493,7 @@ impl Workspace {
 
         if let Some(window) = self.maximized_window() {
             if window.hwnd == hwnd {
+                window.unmaximize();
                 self.set_maximized_window(None);
                 self.set_maximized_window_restore_idx(None);
                 return Ok(());
@@ -643,22 +675,44 @@ impl Workspace {
     }
 
     pub fn new_floating_window(&mut self) -> Result<()> {
-        let focused_idx = self.focused_container_idx();
+        let window = if let Some(maximized_window) = self.maximized_window() {
+            let window = *maximized_window;
+            self.set_maximized_window(None);
+            self.set_maximized_window_restore_idx(None);
+            window
+        } else if let Some(monocle_container) = self.monocle_container_mut() {
+            let window = monocle_container
+                .remove_focused_window()
+                .ok_or_else(|| anyhow!("there is no window"))?;
 
-        let container = self
-            .focused_container_mut()
-            .ok_or_else(|| anyhow!("there is no container"))?;
+            if monocle_container.windows().is_empty() {
+                self.set_monocle_container(None);
+                self.set_monocle_container_restore_idx(None);
+            } else {
+                monocle_container.load_focused_window();
+            }
 
-        let window = container
-            .remove_focused_window()
-            .ok_or_else(|| anyhow!("there is no window"))?;
-
-        if container.windows().is_empty() {
-            self.containers_mut().remove(focused_idx);
-            self.resize_dimensions_mut().remove(focused_idx);
+            window
         } else {
-            container.load_focused_window();
-        }
+            let focused_idx = self.focused_container_idx();
+
+            let container = self
+                .focused_container_mut()
+                .ok_or_else(|| anyhow!("there is no container"))?;
+
+            let window = container
+                .remove_focused_window()
+                .ok_or_else(|| anyhow!("there is no window"))?;
+
+            if container.windows().is_empty() {
+                self.containers_mut().remove(focused_idx);
+                self.resize_dimensions_mut().remove(focused_idx);
+            } else {
+                container.load_focused_window();
+            }
+
+            window
+        };
 
         self.floating_windows_mut().push(window);
 
@@ -744,6 +798,53 @@ impl Workspace {
 
     pub fn new_maximized_window(&mut self) -> Result<()> {
         let focused_idx = self.focused_container_idx();
+        let foreground_hwnd = WindowsApi::foreground_window()?;
+        let mut floating_window = None;
+
+        if !self.floating_windows().is_empty() {
+            let mut focused_floating_window_idx = None;
+            for (i, w) in self.floating_windows().iter().enumerate() {
+                if w.hwnd == foreground_hwnd {
+                    focused_floating_window_idx = Option::from(i);
+                }
+            }
+
+            if let Some(idx) = focused_floating_window_idx {
+                floating_window = Option::from(self.floating_windows_mut().remove(idx));
+            }
+        }
+
+        if let Some(floating_window) = floating_window {
+            self.set_maximized_window(Option::from(floating_window));
+            self.set_maximized_window_restore_idx(Option::from(focused_idx));
+            if let Some(window) = self.maximized_window() {
+                window.maximize();
+            }
+
+            return Ok(());
+        }
+
+        let monocle_restore_idx = self.monocle_container_restore_idx();
+        if let Some(monocle_container) = self.monocle_container_mut() {
+            let window = monocle_container
+                .remove_focused_window()
+                .ok_or_else(|| anyhow!("there is no window"))?;
+
+            if monocle_container.windows().is_empty() {
+                self.set_monocle_container(None);
+                self.set_monocle_container_restore_idx(None);
+            } else {
+                monocle_container.load_focused_window();
+            }
+
+            self.set_maximized_window(Option::from(window));
+            self.set_maximized_window_restore_idx(monocle_restore_idx);
+            if let Some(window) = self.maximized_window() {
+                window.maximize();
+            }
+
+            return Ok(());
+        }
 
         let container = self
             .focused_container_mut()

komorebic.lib.ahk

@@ -1,7 +1,7 @@
 ; Generated by komorebic.exe
 
-Start(ffm) {
-    Run, komorebic.exe start  --ffm %ffm%, , Hide
+Start(ffm, await_configuration, tcp_port) {
+    Run, komorebic.exe start %ffm% --await-configuration %await_configuration% --tcp-port %tcp_port%, , Hide
 }
 
 Stop() {
@@ -164,6 +164,10 @@ Promote() {
     Run, komorebic.exe promote, , Hide
 }
 
+PromoteFocus() {
+    Run, komorebic.exe promote-focus, , Hide
+}
+
 Retile() {
     Run, komorebic.exe retile, , Hide
 }
@@ -252,10 +256,22 @@ WatchConfiguration(boolean_state) {
     Run, komorebic.exe watch-configuration %boolean_state%, , Hide
 }
 
+CompleteConfiguration() {
+    Run, komorebic.exe complete-configuration, , Hide
+}
+
 WindowHidingBehaviour(hiding_behaviour) {
     Run, komorebic.exe window-hiding-behaviour %hiding_behaviour%, , Hide
 }
 
+CrossMonitorMoveBehaviour(move_behaviour) {
+    Run, komorebic.exe cross-monitor-move-behaviour %move_behaviour%, , Hide
+}
+
+ToggleCrossMonitorMoveBehaviour() {
+    Run, komorebic.exe toggle-cross-monitor-move-behaviour, , Hide
+}
+
 UnmanagedWindowOperationBehaviour(operation_behaviour) {
     Run, komorebic.exe unmanaged-window-operation-behaviour %operation_behaviour%, , Hide
 }
@@ -288,6 +304,14 @@ IdentifyBorderOverflowApplication(identifier, id) {
     Run, komorebic.exe identify-border-overflow-application %identifier% "%id%", , Hide
 }
 
+ActiveWindowBorder(boolean_state) {
+    Run, komorebic.exe active-window-border %boolean_state%, , Hide
+}
+
+ActiveWindowBorderColour(r, g, b, window_kind) {
+    Run, komorebic.exe active-window-border-colour %r% %g% %b% --window-kind %window_kind%, , Hide
+}
+
 FocusFollowsMouse(boolean_state, implementation) {
     Run, komorebic.exe focus-follows-mouse %boolean_state% --implementation %implementation%, , Hide
 }
@@ -318,4 +342,8 @@ FormatAppSpecificConfiguration(path) {
 
 NotificationSchema() {
     Run, komorebic.exe notification-schema, , Hide
+}
+
+SocketSchema() {
+    Run, komorebic.exe socket-schema, , Hide
 }

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.9"
+version = "0.1.13"
 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"]
@@ -21,14 +21,15 @@ fs-tail = "0.1"
 heck = "0.4"
 lazy_static = "1"
 paste = "1"
-powershell_script = "0.3"
+powershell_script = "1.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-serde_yaml = "0.8"
+serde_yaml = "0.9"
+sysinfo = "0.25"
 uds_windows = "1"
 
 [dependencies.windows]
-version = "0.36"
+version = "0.39"
 features = [
     "Win32_Foundation",
     "Win32_UI_WindowsAndMessaging"

komorebic/src/main.rs

@@ -10,6 +10,7 @@ use std::io::ErrorKind;
 use std::io::Write;
 use std::path::PathBuf;
 use std::process::Command;
+use std::time::Duration;
 
 use clap::AppSettings;
 use clap::ArgEnum;
@@ -20,6 +21,7 @@ use fs_tail::TailedFile;
 use heck::ToKebabCase;
 use lazy_static::lazy_static;
 use paste::paste;
+use sysinfo::SystemExt;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 use windows::Win32::Foundation::HWND;
@@ -36,12 +38,14 @@ use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::HidingBehaviour;
+use komorebi_core::MoveBehaviour;
 use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::SocketMessage;
 use komorebi_core::StateQuery;
+use komorebi_core::WindowKind;
 
 lazy_static! {
     static ref HOME_DIR: PathBuf = {
@@ -60,6 +64,9 @@ lazy_static! {
             dirs::home_dir().expect("there is no home directory")
         }
     };
+    static ref DATA_DIR: PathBuf = dirs::data_local_dir()
+        .expect("there is no local data directory")
+        .join("komorebi");
 }
 
 trait AhkLibrary {
@@ -115,6 +122,7 @@ gen_enum_subcommand_args! {
     MouseFollowsFocus: BooleanState,
     Query: StateQuery,
     WindowHidingBehaviour: HidingBehaviour,
+    CrossMonitorMoveBehaviour: MoveBehaviour,
     UnmanagedWindowOperationBehaviour: OperationBehaviour,
 }
 
@@ -207,6 +215,7 @@ pub struct WorkspaceLayoutRule {
     /// The number of window containers on-screen required to trigger this layout rule
     at_container_count: usize,
 
+    #[clap(arg_enum)]
     layout: DefaultLayout,
 }
 
@@ -387,11 +396,35 @@ struct FocusFollowsMouse {
     boolean_state: BooleanState,
 }
 
+#[derive(Parser, AhkFunction)]
+struct ActiveWindowBorder {
+    #[clap(arg_enum)]
+    boolean_state: BooleanState,
+}
+
+#[derive(Parser, AhkFunction)]
+struct ActiveWindowBorderColour {
+    #[clap(arg_enum, short, long, default_value = "single")]
+    window_kind: WindowKind,
+    /// Red
+    r: u32,
+    /// Green
+    g: u32,
+    /// Blue
+    b: u32,
+}
+
 #[derive(Parser, AhkFunction)]
 struct Start {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
-    #[clap(long)]
+    #[clap(action, short, long = "ffm")]
     ffm: bool,
+    /// Wait for 'komorebic complete-configuration' to be sent before processing events
+    #[clap(action, short, long)]
+    await_configuration: bool,
+    /// Start a TCP server on the given port to allow the direct sending of SocketMessages
+    #[clap(action, short, long)]
+    tcp_port: Option<usize>,
 }
 
 #[derive(Parser, AhkFunction)]
@@ -566,6 +599,8 @@ enum SubCommand {
     FlipLayout(FlipLayout),
     /// Promote the focused window to the top of the tree
     Promote,
+    /// Promote the user focus to the top of the tree
+    PromoteFocus,
     /// Force the retiling of all managed windows
     Retile,
     /// Create at least this many workspaces for the specified monitor
@@ -621,9 +656,16 @@ enum SubCommand {
     /// Enable or disable watching of ~/komorebi.ahk (if it exists)
     #[clap(arg_required_else_help = true)]
     WatchConfiguration(WatchConfiguration),
+    /// Signal that the final configuration option has been sent
+    CompleteConfiguration,
     /// Set the window behaviour when switching workspaces / cycling stacks
     #[clap(arg_required_else_help = true)]
     WindowHidingBehaviour(WindowHidingBehaviour),
+    /// Set the behaviour when moving windows across monitor boundaries
+    #[clap(arg_required_else_help = true)]
+    CrossMonitorMoveBehaviour(CrossMonitorMoveBehaviour),
+    /// Toggle the behaviour when moving windows across monitor boundaries
+    ToggleCrossMonitorMoveBehaviour,
     /// Set the operation behaviour when the focused window is not managed
     #[clap(arg_required_else_help = true)]
     UnmanagedWindowOperationBehaviour(UnmanagedWindowOperationBehaviour),
@@ -649,6 +691,12 @@ enum SubCommand {
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "identify-border-overflow")]
     IdentifyBorderOverflowApplication(IdentifyBorderOverflowApplication),
+    /// Enable or disable the active window border
+    #[clap(arg_required_else_help = true)]
+    ActiveWindowBorder(ActiveWindowBorder),
+    /// Set the colour for the active window border
+    #[clap(arg_required_else_help = true)]
+    ActiveWindowBorderColour(ActiveWindowBorderColour),
     /// Enable or disable focus follows mouse for the operating system
     #[clap(arg_required_else_help = true)]
     FocusFollowsMouse(FocusFollowsMouse),
@@ -672,15 +720,14 @@ enum SubCommand {
     FormatAppSpecificConfiguration(FormatAppSpecificConfiguration),
     /// Generate a JSON Schema of subscription notifications
     NotificationSchema,
+    /// Generate a JSON Schema of socket messages
+    SocketSchema,
 }
 
 pub fn send_message(bytes: &[u8]) -> Result<()> {
-    let mut socket = HOME_DIR.clone();
-    socket.push("komorebi.sock");
-    let socket = socket.as_path();
-
+    let socket = DATA_DIR.join("komorebi.sock");
     let mut stream = UnixStream::connect(&socket)?;
-    Ok(stream.write_all(&*bytes)?)
+    Ok(stream.write_all(bytes)?)
 }
 
 #[allow(clippy::too_many_lines)]
@@ -720,46 +767,50 @@ fn main() -> Result<()> {
             color_log.push("komorebi.log");
             let file = TailedFile::new(File::open(color_log)?);
             let locked = file.lock();
-            for line in locked.lines() {
-                println!("{}", line?);
+            #[allow(clippy::significant_drop_in_scrutinee)]
+            for line in locked.lines().flatten() {
+                println!("{}", line);
             }
         }
         SubCommand::Focus(arg) => {
-            send_message(&*SocketMessage::FocusWindow(arg.operation_direction).as_bytes()?)?;
+            send_message(&SocketMessage::FocusWindow(arg.operation_direction).as_bytes()?)?;
         }
         SubCommand::Promote => {
-            send_message(&*SocketMessage::Promote.as_bytes()?)?;
+            send_message(&SocketMessage::Promote.as_bytes()?)?;
+        }
+        SubCommand::PromoteFocus => {
+            send_message(&SocketMessage::PromoteFocus.as_bytes()?)?;
         }
         SubCommand::TogglePause => {
-            send_message(&*SocketMessage::TogglePause.as_bytes()?)?;
+            send_message(&SocketMessage::TogglePause.as_bytes()?)?;
         }
         SubCommand::Retile => {
-            send_message(&*SocketMessage::Retile.as_bytes()?)?;
+            send_message(&SocketMessage::Retile.as_bytes()?)?;
         }
         SubCommand::Move(arg) => {
-            send_message(&*SocketMessage::MoveWindow(arg.operation_direction).as_bytes()?)?;
+            send_message(&SocketMessage::MoveWindow(arg.operation_direction).as_bytes()?)?;
         }
         SubCommand::CycleFocus(arg) => {
-            send_message(&*SocketMessage::CycleFocusWindow(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleFocusWindow(arg.cycle_direction).as_bytes()?)?;
         }
         SubCommand::CycleMove(arg) => {
-            send_message(&*SocketMessage::CycleMoveWindow(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleMoveWindow(arg.cycle_direction).as_bytes()?)?;
         }
         SubCommand::MoveToMonitor(arg) => {
-            send_message(&*SocketMessage::MoveContainerToMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::MoveContainerToMonitorNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::MoveToWorkspace(arg) => {
-            send_message(&*SocketMessage::MoveContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::MoveContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::SendToMonitor(arg) => {
-            send_message(&*SocketMessage::SendContainerToMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::SendContainerToMonitorNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::SendToWorkspace(arg) => {
-            send_message(&*SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::SendToMonitorWorkspace(arg) => {
             send_message(
-                &*SocketMessage::SendContainerToMonitorWorkspaceNumber(
+                &SocketMessage::SendContainerToMonitorWorkspaceNumber(
                     arg.target_monitor,
                     arg.target_workspace,
                 )
@@ -767,11 +818,11 @@ fn main() -> Result<()> {
             )?;
         }
         SubCommand::MoveWorkspaceToMonitor(arg) => {
-            send_message(&*SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::InvisibleBorders(arg) => {
             send_message(
-                &*SocketMessage::InvisibleBorders(Rect {
+                &SocketMessage::InvisibleBorders(Rect {
                     left: arg.left,
                     top: arg.top,
                     right: arg.right,
@@ -782,7 +833,7 @@ fn main() -> Result<()> {
         }
         SubCommand::WorkAreaOffset(arg) => {
             send_message(
-                &*SocketMessage::WorkAreaOffset(Rect {
+                &SocketMessage::WorkAreaOffset(Rect {
                     left: arg.left,
                     top: arg.top,
                     right: arg.right,
@@ -793,50 +844,50 @@ fn main() -> Result<()> {
         }
         SubCommand::ContainerPadding(arg) => {
             send_message(
-                &*SocketMessage::ContainerPadding(arg.monitor, arg.workspace, arg.size)
+                &SocketMessage::ContainerPadding(arg.monitor, arg.workspace, arg.size)
                     .as_bytes()?,
             )?;
         }
         SubCommand::WorkspacePadding(arg) => {
             send_message(
-                &*SocketMessage::WorkspacePadding(arg.monitor, arg.workspace, arg.size)
+                &SocketMessage::WorkspacePadding(arg.monitor, arg.workspace, arg.size)
                     .as_bytes()?,
             )?;
         }
         SubCommand::AdjustWorkspacePadding(arg) => {
             send_message(
-                &*SocketMessage::AdjustWorkspacePadding(arg.sizing, arg.adjustment).as_bytes()?,
+                &SocketMessage::AdjustWorkspacePadding(arg.sizing, arg.adjustment).as_bytes()?,
             )?;
         }
         SubCommand::AdjustContainerPadding(arg) => {
             send_message(
-                &*SocketMessage::AdjustContainerPadding(arg.sizing, arg.adjustment).as_bytes()?,
+                &SocketMessage::AdjustContainerPadding(arg.sizing, arg.adjustment).as_bytes()?,
             )?;
         }
         SubCommand::ToggleFocusFollowsMouse(arg) => {
-            send_message(&*SocketMessage::ToggleFocusFollowsMouse(arg.implementation).as_bytes()?)?;
+            send_message(&SocketMessage::ToggleFocusFollowsMouse(arg.implementation).as_bytes()?)?;
         }
         SubCommand::ToggleTiling => {
-            send_message(&*SocketMessage::ToggleTiling.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleTiling.as_bytes()?)?;
         }
         SubCommand::ToggleFloat => {
-            send_message(&*SocketMessage::ToggleFloat.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleFloat.as_bytes()?)?;
         }
         SubCommand::ToggleMonocle => {
-            send_message(&*SocketMessage::ToggleMonocle.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleMonocle.as_bytes()?)?;
         }
         SubCommand::ToggleMaximize => {
-            send_message(&*SocketMessage::ToggleMaximize.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleMaximize.as_bytes()?)?;
         }
         SubCommand::WorkspaceLayout(arg) => {
             send_message(
-                &*SocketMessage::WorkspaceLayout(arg.monitor, arg.workspace, arg.value)
+                &SocketMessage::WorkspaceLayout(arg.monitor, arg.workspace, arg.value)
                     .as_bytes()?,
             )?;
         }
         SubCommand::WorkspaceCustomLayout(arg) => {
             send_message(
-                &*SocketMessage::WorkspaceLayoutCustom(
+                &SocketMessage::WorkspaceLayoutCustom(
                     arg.monitor,
                     arg.workspace,
                     resolve_windows_path(&arg.path)?,
@@ -846,7 +897,7 @@ fn main() -> Result<()> {
         }
         SubCommand::WorkspaceLayoutRule(arg) => {
             send_message(
-                &*SocketMessage::WorkspaceLayoutRule(
+                &SocketMessage::WorkspaceLayoutRule(
                     arg.monitor,
                     arg.workspace,
                     arg.at_container_count,
@@ -857,7 +908,7 @@ fn main() -> Result<()> {
         }
         SubCommand::WorkspaceCustomLayoutRule(arg) => {
             send_message(
-                &*SocketMessage::WorkspaceLayoutCustomRule(
+                &SocketMessage::WorkspaceLayoutCustomRule(
                     arg.monitor,
                     arg.workspace,
                     arg.at_container_count,
@@ -868,13 +919,12 @@ fn main() -> Result<()> {
         }
         SubCommand::ClearWorkspaceLayoutRules(arg) => {
             send_message(
-                &*SocketMessage::ClearWorkspaceLayoutRules(arg.monitor, arg.workspace)
-                    .as_bytes()?,
+                &SocketMessage::ClearWorkspaceLayoutRules(arg.monitor, arg.workspace).as_bytes()?,
             )?;
         }
         SubCommand::WorkspaceTiling(arg) => {
             send_message(
-                &*SocketMessage::WorkspaceTiling(arg.monitor, arg.workspace, arg.value.into())
+                &SocketMessage::WorkspaceTiling(arg.monitor, arg.workspace, arg.value.into())
                     .as_bytes()?,
             )?;
         }
@@ -902,19 +952,61 @@ fn main() -> Result<()> {
 
             let script = exec.map_or_else(
                 || {
-                    if arg.ffm {
-                        String::from(
-                            "Start-Process komorebi.exe -ArgumentList '--ffm' -WindowStyle hidden",
+                    if arg.ffm | arg.await_configuration | arg.tcp_port.is_some() {
+                        format!(
+                            "Start-Process komorebi.exe -ArgumentList {} -WindowStyle hidden",
+                            arg.tcp_port.map_or_else(
+                                || if arg.ffm && arg.await_configuration {
+                                    "'--ffm','--await-configuration'".to_string()
+                                } else if arg.ffm {
+                                    "'--ffm'".to_string()
+                                } else {
+                                    "'--await-configuration'".to_string()
+                                },
+                                |port| if arg.ffm {
+                                    format!("'--ffm','--tcp-server={}'", port)
+                                } else if arg.await_configuration {
+                                    format!("'--await-configuration','--tcp-server={}'", port)
+                                } else if arg.ffm && arg.await_configuration {
+                                    format!(
+                                        "'--ffm','--await-configuration','--tcp-server={}'",
+                                        port
+                                    )
+                                } else {
+                                    format!("'--tcp-server={}'", port)
+                                }
+                            )
                         )
                     } else {
                         String::from("Start-Process komorebi.exe -WindowStyle hidden")
                     }
                 },
                 |exec| {
-                    if arg.ffm {
+                    if arg.ffm | arg.await_configuration {
                         format!(
-                            "Start-Process '{}' -ArgumentList '--ffm' -WindowStyle hidden",
-                            exec
+                            "Start-Process '{}' -ArgumentList {} -WindowStyle hidden",
+                            exec,
+                            arg.tcp_port.map_or_else(
+                                || if arg.ffm && arg.await_configuration {
+                                    "'--ffm','--await-configuration'".to_string()
+                                } else if arg.ffm {
+                                    "'--ffm'".to_string()
+                                } else {
+                                    "'--await-configuration'".to_string()
+                                },
+                                |port| if arg.ffm {
+                                    format!("'--ffm','--tcp-server={}'", port)
+                                } else if arg.await_configuration {
+                                    format!("'--await-configuration','--tcp-server={}'", port)
+                                } else if arg.ffm && arg.await_configuration {
+                                    format!(
+                                        "'--ffm','--await-configuration','--tcp-server={}'",
+                                        port
+                                    )
+                                } else {
+                                    format!("'--tcp-server={}'", port)
+                                }
+                            )
                         )
                     } else {
                         format!("Start-Process '{}' -WindowStyle hidden", exec)
@@ -922,59 +1014,76 @@ fn main() -> Result<()> {
                 },
             );
 
-            match powershell_script::run(&script, true) {
-                Ok(output) => {
-                    println!("{}", output);
+            let mut running = false;
+
+            while !running {
+                match powershell_script::run(&script) {
+                    Ok(_) => {
+                        println!("{}", script);
+                    }
+                    Err(error) => {
+                        println!("Error: {}", error);
+                    }
                 }
-                Err(error) => {
-                    println!("Error: {}", error);
+
+                print!("Waiting for komorebi.exe to start...");
+                std::thread::sleep(Duration::from_secs(3));
+
+                let mut system = sysinfo::System::new_all();
+                system.refresh_processes();
+
+                if system.processes_by_name("komorebi.exe").next().is_some() {
+                    println!("Started!");
+                    running = true;
+                } else {
+                    println!("komorebi.exe did not start... Trying again");
                 }
             }
         }
         SubCommand::Stop => {
-            send_message(&*SocketMessage::Stop.as_bytes()?)?;
+            send_message(&SocketMessage::Stop.as_bytes()?)?;
         }
         SubCommand::FloatRule(arg) => {
-            send_message(&*SocketMessage::FloatRule(arg.identifier, arg.id).as_bytes()?)?;
+            send_message(&SocketMessage::FloatRule(arg.identifier, arg.id).as_bytes()?)?;
         }
         SubCommand::ManageRule(arg) => {
-            send_message(&*SocketMessage::ManageRule(arg.identifier, arg.id).as_bytes()?)?;
+            send_message(&SocketMessage::ManageRule(arg.identifier, arg.id).as_bytes()?)?;
         }
         SubCommand::WorkspaceRule(arg) => {
             send_message(
-                &*SocketMessage::WorkspaceRule(arg.identifier, arg.id, arg.monitor, arg.workspace)
+                &SocketMessage::WorkspaceRule(arg.identifier, arg.id, arg.monitor, arg.workspace)
                     .as_bytes()?,
             )?;
         }
         SubCommand::Stack(arg) => {
-            send_message(&*SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
+            send_message(&SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
         }
         SubCommand::Unstack => {
-            send_message(&*SocketMessage::UnstackWindow.as_bytes()?)?;
+            send_message(&SocketMessage::UnstackWindow.as_bytes()?)?;
         }
         SubCommand::CycleStack(arg) => {
-            send_message(&*SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
         }
         SubCommand::ChangeLayout(arg) => {
-            send_message(&*SocketMessage::ChangeLayout(arg.default_layout).as_bytes()?)?;
+            send_message(&SocketMessage::ChangeLayout(arg.default_layout).as_bytes()?)?;
         }
         SubCommand::LoadCustomLayout(arg) => {
             send_message(
-                &*SocketMessage::ChangeLayoutCustom(resolve_windows_path(&arg.path)?).as_bytes()?,
+                &SocketMessage::ChangeLayoutCustom(resolve_windows_path(&arg.path)?).as_bytes()?,
             )?;
         }
         SubCommand::FlipLayout(arg) => {
-            send_message(&*SocketMessage::FlipLayout(arg.axis).as_bytes()?)?;
+            send_message(&SocketMessage::FlipLayout(arg.axis).as_bytes()?)?;
         }
         SubCommand::FocusMonitor(arg) => {
-            send_message(&*SocketMessage::FocusMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::FocusMonitorNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::FocusWorkspace(arg) => {
-            send_message(&*SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
         }
         SubCommand::FocusMonitorWorkspace(arg) => {
             send_message(
-                &*SocketMessage::FocusMonitorWorkspaceNumber(
+                &SocketMessage::FocusMonitorWorkspaceNumber(
                     arg.target_monitor,
                     arg.target_workspace,
                 )
@@ -982,23 +1091,23 @@ fn main() -> Result<()> {
             )?;
         }
         SubCommand::CycleMonitor(arg) => {
-            send_message(&*SocketMessage::CycleFocusMonitor(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleFocusMonitor(arg.cycle_direction).as_bytes()?)?;
         }
         SubCommand::CycleWorkspace(arg) => {
-            send_message(&*SocketMessage::CycleFocusWorkspace(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleFocusWorkspace(arg.cycle_direction).as_bytes()?)?;
         }
         SubCommand::NewWorkspace => {
-            send_message(&*SocketMessage::NewWorkspace.as_bytes()?)?;
+            send_message(&SocketMessage::NewWorkspace.as_bytes()?)?;
         }
         SubCommand::WorkspaceName(name) => {
             send_message(
-                &*SocketMessage::WorkspaceName(name.monitor, name.workspace, name.value)
+                &SocketMessage::WorkspaceName(name.monitor, name.workspace, name.value)
                     .as_bytes()?,
             )?;
         }
         SubCommand::EnsureWorkspaces(workspaces) => {
             send_message(
-                &*SocketMessage::EnsureWorkspaces(workspaces.monitor, workspaces.workspace_count)
+                &SocketMessage::EnsureWorkspaces(workspaces.monitor, workspaces.workspace_count)
                     .as_bytes()?,
             )?;
         }
@@ -1019,7 +1128,7 @@ fn main() -> Result<()> {
                 },
             };
 
-            send_message(&*SocketMessage::State.as_bytes()?)?;
+            send_message(&SocketMessage::State.as_bytes()?)?;
 
             let listener = UnixListener::bind(&socket)?;
             match listener.accept() {
@@ -1053,7 +1162,7 @@ fn main() -> Result<()> {
                 },
             };
 
-            send_message(&*SocketMessage::Query(arg.state_query).as_bytes()?)?;
+            send_message(&SocketMessage::Query(arg.state_query).as_bytes()?)?;
 
             let listener = UnixListener::bind(&socket)?;
             match listener.accept() {
@@ -1071,8 +1180,7 @@ fn main() -> Result<()> {
             }
         }
         SubCommand::RestoreWindows => {
-            let mut hwnd_json = HOME_DIR.clone();
-            hwnd_json.push("komorebi.hwnd.json");
+            let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
 
             let file = File::open(hwnd_json)?;
             let reader = BufReader::new(file);
@@ -1083,93 +1191,108 @@ fn main() -> Result<()> {
             }
         }
         SubCommand::ResizeEdge(resize) => {
-            send_message(
-                &*SocketMessage::ResizeWindowEdge(resize.edge, resize.sizing).as_bytes()?,
-            )?;
+            send_message(&SocketMessage::ResizeWindowEdge(resize.edge, resize.sizing).as_bytes()?)?;
         }
         SubCommand::ResizeAxis(arg) => {
-            send_message(&*SocketMessage::ResizeWindowAxis(arg.axis, arg.sizing).as_bytes()?)?;
+            send_message(&SocketMessage::ResizeWindowAxis(arg.axis, arg.sizing).as_bytes()?)?;
         }
         SubCommand::FocusFollowsMouse(arg) => {
             send_message(
-                &*SocketMessage::FocusFollowsMouse(arg.implementation, arg.boolean_state.into())
+                &SocketMessage::FocusFollowsMouse(arg.implementation, arg.boolean_state.into())
                     .as_bytes()?,
             )?;
         }
         SubCommand::ReloadConfiguration => {
-            send_message(&*SocketMessage::ReloadConfiguration.as_bytes()?)?;
+            send_message(&SocketMessage::ReloadConfiguration.as_bytes()?)?;
         }
         SubCommand::WatchConfiguration(arg) => {
-            send_message(
-                &*SocketMessage::WatchConfiguration(arg.boolean_state.into()).as_bytes()?,
-            )?;
+            send_message(&SocketMessage::WatchConfiguration(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::CompleteConfiguration => {
+            send_message(&SocketMessage::CompleteConfiguration.as_bytes()?)?;
         }
         SubCommand::IdentifyObjectNameChangeApplication(target) => {
             send_message(
-                &*SocketMessage::IdentifyObjectNameChangeApplication(target.identifier, target.id)
+                &SocketMessage::IdentifyObjectNameChangeApplication(target.identifier, target.id)
                     .as_bytes()?,
             )?;
         }
         SubCommand::IdentifyTrayApplication(target) => {
             send_message(
-                &*SocketMessage::IdentifyTrayApplication(target.identifier, target.id)
-                    .as_bytes()?,
+                &SocketMessage::IdentifyTrayApplication(target.identifier, target.id).as_bytes()?,
             )?;
         }
         SubCommand::IdentifyLayeredApplication(target) => {
             send_message(
-                &*SocketMessage::IdentifyLayeredApplication(target.identifier, target.id)
+                &SocketMessage::IdentifyLayeredApplication(target.identifier, target.id)
                     .as_bytes()?,
             )?;
         }
         SubCommand::IdentifyBorderOverflowApplication(target) => {
             send_message(
-                &*SocketMessage::IdentifyBorderOverflowApplication(target.identifier, target.id)
+                &SocketMessage::IdentifyBorderOverflowApplication(target.identifier, target.id)
                     .as_bytes()?,
             )?;
         }
         SubCommand::Manage => {
-            send_message(&*SocketMessage::ManageFocusedWindow.as_bytes()?)?;
+            send_message(&SocketMessage::ManageFocusedWindow.as_bytes()?)?;
         }
         SubCommand::Unmanage => {
-            send_message(&*SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
+            send_message(&SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
         }
         SubCommand::QuickSaveResize => {
-            send_message(&*SocketMessage::QuickSave.as_bytes()?)?;
+            send_message(&SocketMessage::QuickSave.as_bytes()?)?;
         }
         SubCommand::QuickLoadResize => {
-            send_message(&*SocketMessage::QuickLoad.as_bytes()?)?;
+            send_message(&SocketMessage::QuickLoad.as_bytes()?)?;
         }
         SubCommand::SaveResize(arg) => {
-            send_message(&*SocketMessage::Save(resolve_windows_path(&arg.path)?).as_bytes()?)?;
+            send_message(&SocketMessage::Save(resolve_windows_path(&arg.path)?).as_bytes()?)?;
         }
         SubCommand::LoadResize(arg) => {
-            send_message(&*SocketMessage::Load(resolve_windows_path(&arg.path)?).as_bytes()?)?;
+            send_message(&SocketMessage::Load(resolve_windows_path(&arg.path)?).as_bytes()?)?;
         }
         SubCommand::Subscribe(arg) => {
-            send_message(&*SocketMessage::AddSubscriber(arg.named_pipe).as_bytes()?)?;
+            send_message(&SocketMessage::AddSubscriber(arg.named_pipe).as_bytes()?)?;
         }
         SubCommand::Unsubscribe(arg) => {
-            send_message(&*SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
+            send_message(&SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
         }
         SubCommand::ToggleMouseFollowsFocus => {
-            send_message(&*SocketMessage::ToggleMouseFollowsFocus.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleMouseFollowsFocus.as_bytes()?)?;
         }
         SubCommand::MouseFollowsFocus(arg) => {
-            send_message(&*SocketMessage::MouseFollowsFocus(arg.boolean_state.into()).as_bytes()?)?;
+            send_message(&SocketMessage::MouseFollowsFocus(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::ActiveWindowBorder(arg) => {
+            send_message(&SocketMessage::ActiveWindowBorder(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::ActiveWindowBorderColour(arg) => {
+            send_message(
+                &SocketMessage::ActiveWindowBorderColour(arg.window_kind, arg.r, arg.g, arg.b)
+                    .as_bytes()?,
+            )?;
         }
         SubCommand::ResizeDelta(arg) => {
-            send_message(&*SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
+            send_message(&SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
         }
         SubCommand::ToggleWindowContainerBehaviour => {
-            send_message(&*SocketMessage::ToggleWindowContainerBehaviour.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleWindowContainerBehaviour.as_bytes()?)?;
         }
         SubCommand::WindowHidingBehaviour(arg) => {
-            send_message(&*SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour).as_bytes()?)?;
+            send_message(&SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour).as_bytes()?)?;
+        }
+        SubCommand::CrossMonitorMoveBehaviour(arg) => {
+            send_message(
+                &SocketMessage::CrossMonitorMoveBehaviour(arg.move_behaviour).as_bytes()?,
+            )?;
+        }
+        SubCommand::ToggleCrossMonitorMoveBehaviour => {
+            send_message(&SocketMessage::ToggleCrossMonitorMoveBehaviour.as_bytes()?)?;
         }
         SubCommand::UnmanagedWindowOperationBehaviour(arg) => {
             send_message(
-                &*SocketMessage::UnmanagedWindowOperationBehaviour(arg.operation_behaviour)
+                &SocketMessage::UnmanagedWindowOperationBehaviour(arg.operation_behaviour)
                     .as_bytes()?,
             )?;
         }
@@ -1241,7 +1364,41 @@ fn main() -> Result<()> {
                 },
             };
 
-            send_message(&*SocketMessage::NotificationSchema.as_bytes()?)?;
+            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);
+                }
+            }
+        }
+        SubCommand::SocketSchema => {
+            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::SocketSchema.as_bytes()?)?;
 
             let listener = UnixListener::bind(&socket)?;
             match listener.accept() {
@@ -1283,15 +1440,18 @@ fn resolve_windows_path(raw_path: &str) -> Result<PathBuf> {
         .parent()
         .ok_or_else(|| anyhow!("cannot parse directory"))?;
 
-    let file = full_path
-        .components()
-        .last()
-        .ok_or_else(|| anyhow!("cannot parse filename"))?;
+    Ok(if parent.is_dir() {
+        let file = full_path
+            .components()
+            .last()
+            .ok_or_else(|| anyhow!("cannot parse filename"))?;
 
-    let mut canonicalized = std::fs::canonicalize(parent)?;
-    canonicalized.push(file);
-
-    Ok(canonicalized)
+        let mut canonicalized = std::fs::canonicalize(parent)?;
+        canonicalized.push(file);
+        canonicalized
+    } else {
+        full_path
+    })
 }
 
 fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "stable"

wix/main.wxs

@@ -0,0 +1,174 @@
+<?xml version='1.0' encoding='windows-1252'?>
+<!--
+  Copyright (C) 2017 Christopher R. Field.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<!--
+  The "cargo wix" subcommand provides a variety of predefined variables available
+  for customization of this template. The values for each variable are set at
+  installer creation time. The following variables are available:
+
+  TargetTriple      = The rustc target triple name.
+  TargetEnv         = The rustc target environment. This is typically either
+                      "msvc" or "gnu" depending on the toolchain downloaded and
+                      installed.
+  TargetVendor      = The rustc target vendor. This is typically "pc", but Rust
+                      does support other vendors, like "uwp".
+  CargoTargetBinDir = The complete path to the binary (exe). The default would
+                      be "target\release\<BINARY_NAME>.exe" where
+                      "<BINARY_NAME>" is replaced with the name of each binary
+                      target defined in the package's manifest (Cargo.toml). If
+                      a different rustc target triple is used than the host,
+                      i.e. cross-compiling, then the default path would be
+                      "target\<CARGO_TARGET>\<CARGO_PROFILE>\<BINARY_NAME>.exe",
+                      where "<CARGO_TARGET>" is replaced with the "CargoTarget"
+                      variable value and "<CARGO_PROFILE>" is replaced with the
+                      value from the `CargoProfile` variable.
+  CargoTargetDir    = The path to the directory for the build artifacts, i.e.
+                      "target".
+  CargoProfile      = Either "debug" or `release` depending on the build
+                      profile. The default is "release".
+  Version           = The version for the installer. The default is the
+                      "Major.Minor.Fix" semantic versioning number of the Rust
+                      package.
+-->
+
+<!--
+  Please do not remove these pre-processor If-Else blocks. These are used with
+  the `cargo wix` subcommand to automatically determine the installation
+  destination for 32-bit versus 64-bit installers. Removal of these lines will
+  cause installation errors.
+-->
+<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64?>
+<?define PlatformProgramFilesFolder = "ProgramFiles64Folder"?>
+<?else ?>
+<?define PlatformProgramFilesFolder = "ProgramFilesFolder"?>
+<?endif ?>
+
+<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
+
+  <Product Id='*' Name='komorebi' UpgradeCode='F8B967B5-7E7B-4E3A-895B-B789EC898B54' Manufacturer='LGUG2Z' Language='1033' Codepage='1252' Version='$(var.Version)'>
+
+    <Package Id='*' Keywords='Installer' Description='A tiling window manager for Windows' Manufacturer='LGUG2Z' InstallerVersion='450' Languages='1033' Compressed='yes' InstallScope='perMachine' SummaryCodepage='1252' />
+
+    <MajorUpgrade Schedule='afterInstallInitialize' DowngradeErrorMessage='A newer version of [ProductName] is already installed. Setup will now exit.' />
+
+    <Media Id='1' Cabinet='media1.cab' EmbedCab='yes' DiskPrompt='CD-ROM #1' />
+    <Property Id='DiskPrompt' Value='komorebi Installation' />
+
+    <Directory Id='TARGETDIR' Name='SourceDir'>
+      <Directory Id='$(var.PlatformProgramFilesFolder)' Name='PFiles'>
+        <Directory Id='APPLICATIONFOLDER' Name='komorebi'>
+          <!--
+                      Disabling the license sidecar file in the installer is a two step process:
+
+                      1. Comment out or remove the `Component` tag along with its contents.
+                      2. Comment out or remove the `ComponentRef` tag with the "License" Id
+                         attribute value further down in this file.
+                    -->
+          <Component Id='License' Guid='*'>
+            <File Id='LicenseFile' Name='License.rtf' DiskId='1' Source='wix\License.rtf' KeyPath='yes' />
+          </Component>
+
+          <Directory Id='Bin' Name='bin'>
+            <Component Id='Path' Guid='6C6DF276-06C4-4675-BDED-48C5C2BC9BC5' KeyPath='yes'>
+              <Environment Id='PATH' Name='PATH' Value='[Bin]' Permanent='no' Part='last' Action='set' System='yes' />
+            </Component>
+            <Component Id='binary0' Guid='*'>
+              <File Id='exe0' Name='komorebi.exe' DiskId='1' Source='$(var.CargoTargetBinDir)\komorebi.exe' KeyPath='yes' />
+            </Component>
+            <Component Id='binary1' Guid='*'>
+              <File Id='exe1' Name='komorebic.exe' DiskId='1' Source='$(var.CargoTargetBinDir)\komorebic.exe' KeyPath='yes' />
+            </Component>
+          </Directory>
+        </Directory>
+      </Directory>
+    </Directory>
+
+    <Feature Id='Binaries' Title='Application' Description='Installs all binaries and the license.' Level='1' ConfigurableDirectory='APPLICATIONFOLDER' AllowAdvertise='no' Display='expand' Absent='disallow'>
+      <!--
+              Comment out or remove the following `ComponentRef` tag to remove
+              the license sidecar file from the installer.
+            -->
+      <ComponentRef Id='License' />
+
+      <ComponentRef Id='binary0' />
+
+      <ComponentRef Id='binary1' />
+
+      <Feature Id='Environment' Title='PATH Environment Variable' Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.' Level='1' Absent='allow'>
+        <ComponentRef Id='Path' />
+      </Feature>
+    </Feature>
+
+    <SetProperty Id='ARPINSTALLLOCATION' Value='[APPLICATIONFOLDER]' After='CostFinalize' />
+
+
+    <!--
+          Uncomment the following `Icon` and `Property` tags to change the product icon.
+
+          The product icon is the graphic that appears in the Add/Remove
+          Programs control panel for the application.
+        -->
+    <!--<Icon Id='ProductICO' SourceFile='wix\Product.ico'/>-->
+    <!--<Property Id='ARPPRODUCTICON' Value='ProductICO' />-->
+
+    <Property Id='ARPHELPLINK' Value='https://github.com/LGUG2Z/komorebi' />
+
+    <UI>
+      <UIRef Id='WixUI_FeatureTree' />
+      <!--
+              Disabling the EULA dialog in the installer is a two step process:
+
+                 1. Uncomment the following two `Publish` tags
+                 2. Comment out or remove the `<WiXVariable Id='WixUILicenseRtf'...` tag further down
+
+            -->
+      <!--<Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>-->
+      <!--<Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>-->
+
+    </UI>
+
+    <!--
+          Disabling the EULA dialog in the installer requires commenting out
+          or removing the following `WixVariable` tag
+        -->
+    <WixVariable Id='WixUILicenseRtf' Value='wix\License.rtf' />
+
+
+    <!--
+          Uncomment the next `WixVaraible` tag to customize the installer's
+          Graphical User Interface (GUI) and add a custom banner image across
+          the top of each screen. See the WiX Toolset documentation for details
+          about customization.
+
+          The banner BMP dimensions are 493 x 58 pixels.
+        -->
+    <!--<WixVariable Id='WixUIBannerBmp' Value='wix\Banner.bmp'/>-->
+
+
+    <!--
+          Uncomment the next `WixVariable` tag to customize the installer's
+          Graphical User Interface (GUI) and add a custom image to the first
+          dialog, or screen. See the WiX Toolset documentation for details about
+          customization.
+
+          The dialog BMP dimensions are 493 x 312 pixels.
+        -->
+    <!--<WixVariable Id='WixUIDialogBmp' Value='wix\Dialog.bmp'/>-->
+
+  </Product>
+
+</Wix>