test

This commit splits the komorebi crate into a mixed binary and library
crate.

All types and logic related to window management have been moved under
lib.rs, and are imported from there for use in main.rs, which is now
only responsible for starting and running the window manager process.

In preparation for exposing a new komorebi-client crate in the future,
serde::Deserialize has been derived on Notification and any struct that
may appear in a notification receievd by a process that has subscribed
to event updates.

re #659

.github/workflows/windows.yaml

@@ -73,11 +73,6 @@ jobs:
       - name: Install the target
         run: |
           rustup target install ${{ matrix.target }}
-      - name: Run Cargo checks
-        run: |
-          cargo fmt --check
-          cargo check
-          cargo clippy
       - name: Run a full build
         run: |
           cargo build --locked --release --target ${{ matrix.target }}
@@ -98,11 +93,6 @@ jobs:
             target/${{ matrix.target }}/release/komorebic-no-console.pdb
             target/wix/komorebi-*.msi
           retention-days: 7
-      - name: Check GoReleaser
-        uses: goreleaser/goreleaser-action@v3
-        with:
-          version: latest
-          args: build --skip=validate --clean
 
       # Release
       - name: Generate changelog
@@ -116,12 +106,12 @@ jobs:
         if: startsWith(github.ref, 'refs/tags/v')
         with:
           version: latest
-          args: release --skip=validate --clean --release-notes=CHANGELOG.md
+          args: release --skip-validate --clean --release-notes=CHANGELOG.md
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SCOOP_TOKEN: ${{ secrets.SCOOP_TOKEN }}
       - name: Add MSI to release
-        uses: softprops/action-gh-release@v2
+        uses: softprops/action-gh-release@v1
         if: startsWith(github.ref, 'refs/tags/v')
         with:
           files: "target/wix/komorebi-*.msi"

Cargo.toml

@@ -4,22 +4,20 @@ resolver = "2"
 members = [
     "derive-ahk",
     "komorebi",
-    "komorebi-client",
     "komorebi-core",
     "komorebic",
     "komorebic-no-console",
 ]
 
 [workspace.dependencies]
-windows-interface = { version = "0.53" }
-windows-implement = { version = "0.53" }
+windows-interface = { version = "0.52" }
+windows-implement = { version = "0.52" }
 dunce = "1"
 dirs = "5"
 color-eyre = "0.6"
-serde_json = { package = "serde_json_lenient", version = "0.1" }
 
 [workspace.dependencies.windows]
-version = "0.54"
+version = "0.52"
 features = [
     "implement",
     "Win32_System_Com",

README.md

@@ -101,76 +101,20 @@ widget enabled. The original video can be viewed
 
 https://user-images.githubusercontent.com/13164844/163496414-a9cde3d1-b8a7-4a7a-96fb-a8985380bc70.mp4
 
-# Contribution Guidelines
+# Development
 
-If you would like to contribute to `komorebi` please take the time to carefully read the guidelines below.
-
-## Commit hygiene
+If you would like to contribute code to this repository, there are a few requests that I have to ensure a foundation of
+code quality, consistency and commit hygiene:
 
 - Flatten all `use` statements
-- Run `cargo +stable clippy` and ensure that all lints and suggestions have been addressed before committing
+- Run `cargo +nightly clippy` and ensure that all lints and suggestions have been addressed before committing
 - Run `cargo +nightly fmt --all` to ensure consistent formatting before committing
 - Use `git cz` with
   the [Commitizen CLI](https://github.com/commitizen/cz-cli#conventional-commit-messages-as-a-global-utility) to prepare
   commit messages
-- Provide **at least** one short sentence or paragraph in your commit message body to describe your thought process for the
+- Provide at least one short sentence or paragraph in your commit message body to describe your thought process for the
   changes being committed
 
-## PRs should contain only a single feature or bug fix
-
-It is very difficult to review pull requests which touch multiple unrelated features and parts of the codebase.
-
-Please do not submit pull requests like this; you will be asked to separate them into smaller PRs that deal only with
-one feature or bug fix at a time.
-
-If you are working on multiple features and bug fixes, I suggest that you cut a branch called `local-trunk`
-from `master` which you keep up to date, and rebase the various independent branches you are working on onto that branch
-if you want to test them together or create a build with everything integrated.
-
-## Refactors to the codebase must have prior approval
-
-`komorebi` is a mature codebase with an internal consistency and structure that has developed organically over close to
-half a decade.
-
-There are [countless hours of live coding videos](https://youtube.com/@LGUG2Z) demonstrating work on this project and
-showing new contributors how to do everything from basic tasks like implementing new `komorebic` commands to
-distinguishing monitors by manufacturer hardware identifiers and video card ports.
-
-Refactors to the structure of the codebase are not taken lightly and require prior discussion and approval.
-
-Please do not start refactoring the codebase with the expectation of having your changes integrated until you receive an
-explicit approval or a request to do so.
-
-Similarly, when implementing features and bug fixes, please stick to the structure of the codebase as much as possible
-and do not take this as an opportunity to do some "refactoring along the way".
-
-It is extremely difficult to review PRs for features and bug fixes if they are lost in sweeping changes to the structure
-of the codebase.
-
-## Breaking changes to user-facing interfaces are unacceptable
-
-This includes but is not limited to:
-
-- All `komorebic` commands
-- The `komorebi.json` schema
-- The [`komorebi-application-specific-configuration`](https://github.com/LGUG2Z/komorebi-application-specific-configuration)
-  schema
-
-No user should ever find that their configuration file has stopped working after upgrading to a new version
-of `komorebi`.
-
-More often than not there are ways to reformulate changes that may initially seem like they require breaking user-facing
-interfaces into additive changes.
-
-For some inspiration please take a look
-at [this commit](https://github.com/LGUG2Z/komorebi/commit/e7d928a065eb63bb4ea1fb864c69c1cae8cc763b) which added the
-ability for users to specify colours in `komorebi.json` in Hex format alongside RGB.
-
-There is also a process in place for graceful, non-breaking, deprecation of configuration options that are no longer
-required.
-
-# Development
-
 If you use IntelliJ, you should enable the following settings to ensure that code generated by macros is recognised by
 the IDE for completions and navigation:
 
@@ -209,21 +153,20 @@ found, information about it will appear in the log which can be shared when open
 # Window Manager State and Integrations
 
 The current state of the window manager can be queried using the `komorebic state` command, which returns a JSON
-representation of the `State` struct.
+representation of the `State` struct, which includes the current state of `WindowManager`.
 
-This may also be polled to build further integrations and widgets on top of.
+This may also be polled to build further integrations and widgets on top of (if you ever wanted to build something
+like [Stackline](https://github.com/AdamWagner/stackline) for Windows, you could do it by polling this command).
 
 # Window Manager Event Subscriptions
 
-## Named Pipes
-
-It is possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
+It is also possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
 by `komorebi` using [Named Pipes](https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes).
 
 First, your application must create a named pipe. Once the named pipe has been created, run the following command:
 
 ```powershell
-komorebic.exe subscribe-pipe <your pipe name>
+komorebic.exe subscribe <your pipe name>
 ```
 
 Note that you do not have to include the full path of the named pipe, just the name.
@@ -247,125 +190,12 @@ You may then filter on the `type` key to listen to the events that you are inter
 notification types, refer to the enum variants of `WindowManagerEvent` in `komorebi` and `SocketMessage`
 in `komorebi-core`.
 
-Below is an example of how you can subscribe to and filter on events using a named pipe in `nodejs`.
+An example of how to create a named pipe and a subscription to `komorebi`'s handled events in Python
+by [@denBot](https://github.com/denBot) can be
+found [here](https://gist.github.com/denBot/4136279812f87819f86d99eba77c1ee0).
 
-```javascript
-const { exec } = require("child_process");
-const net = require("net");
-
-const pipeName = "\\\\.\\pipe\\komorebi-js";
-const server = net.createServer((stream) => {
-  console.log("Client connected");
-
-  // Every time there is a workspace-related event, let's log the names of all
-  // workspaces on the currently focused monitor, and then log the name of the
-  // currently focused workspace on that monitor
-
-  stream.on("data", (data) => {
-    let json = JSON.parse(data.toString());
-    let event = json.event;
-
-    if (event.type.includes("Workspace")) {
-      let monitors = json.state.monitors;
-      let current_monitor = monitors.elements[monitors.focused];
-      let workspaces = monitors.elements[monitors.focused].workspaces;
-      let current_workspace = workspaces.elements[workspaces.focused];
-
-      console.log(
-        workspaces.elements
-          .map((workspace) => workspace.name)
-          .filter((name) => name !== null)
-      );
-      console.log(current_workspace.name);
-    }
-  });
-
-  stream.on("end", () => {
-    console.log("Client disconnected");
-  });
-});
-
-server.listen(pipeName, () => {
-  console.log("Named pipe server listening");
-});
-
-const command = "komorebic subscribe-pipe komorebi-js";
-
-exec(command, (error, stdout, stderr) => {
-  if (error) {
-    console.error(`Error executing command: ${error}`);
-    return;
-  }
-});
-```
-
-## Unix Domain Sockets
-
-It is possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
-by `komorebi` using [Unix Domain Sockets](https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/).
-
-UDS are also the only mode of communication between `komorebi` and `komorebic`.
-
-First, your application must create a socket in `$ENV:LocalAppData\komorebi`. Once the socket has been created, run the
-following command:
-
-```powershell
-komorebic.exe subscribe-socket <your socket name>
-```
-
-If the socket exists, komorebi will start pushing JSON data of successfully handled events and messages as in the
-example above in the Named Pipes section.
-
-## Rust Client
-
-As of `v0.1.22` it is possible to use the `komorebi-client` crate to subscribe to notifications of
-every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust codebase.
-
-Below is a simple example of how to use `komorebi-client` in a basic Rust application.
-
-```rust
-// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.22"}
-
-use anyhow::Result;
-use komorebi_client::Notification;
-use komorebi_client::NotificationEvent;
-use komorebi_client::UnixListener;
-use komorebi_client::WindowManagerEvent;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Read;
-
-pub fn main() -> anyhow::Result<()> {
-  let socket = komorebi_client::subscribe(NAME)?;
-
-  for incoming in socket.incoming() {
-    match incoming {
-      Ok(data) => {
-        let reader = BufReader::new(data.try_clone()?);
-
-        for line in reader.lines().flatten() {
-          let notification: Notification = match serde_json::from_str(&line) {
-            Ok(notification) => notification,
-            Err(error) => {
-              log::debug!("discarding malformed komorebi notification: {error}");
-              continue;
-            }
-          };
-
-          // match and filter on desired notifications
-        }
-      }
-      Err(error) => {
-        log::debug!("{error}");
-      }
-    }
-  }
-
-}
-```
-
-A read-world example can be found
-in [komokana](https://github.com/LGUG2Z/komokana/blob/feature/komorebi-uds/src/main.rs).
+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
 

docs/cli/alt-focus-hack.md

@@ -1,7 +1,7 @@
 # alt-focus-hack
 
 ```
-DEPRECATED since v0.1.22
+Enable or disable a hack simulating ALT key presses to ensure focus changes succeed
 
 Usage: komorebic.exe alt-focus-hack <BOOLEAN_STATE>
 

docs/cli/change-layout.md

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

docs/cli/check.md

@@ -1,7 +1,7 @@
 # check
 
 ```
-Check komorebi configuration and related files for common errors
+Output various important komorebi-related environment values
 
 Usage: komorebic.exe check
 

docs/cli/configuration.md

@@ -1,12 +0,0 @@
-# configuration
-
-```
-Show the path to komorebi.json
-
-Usage: komorebic.exe configuration
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/docgen.md

@@ -0,0 +1,10 @@
+# docgen
+
+```
+Usage: komorebic.exe docgen
+
+Options:
+  -h, --help
+          Print help
+
+```

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

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

docs/cli/named-workspace-layout.md

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

docs/cli/subscribe-socket.md

@@ -1,16 +0,0 @@
-# subscribe-socket
-
-```
-Subscribe to komorebi events using a Unix Domain Socket
-
-Usage: komorebic.exe subscribe-socket <SOCKET>
-
-Arguments:
-  <SOCKET>
-          Name of the socket to send event notifications to
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/subscribe.md

@@ -1,9 +1,9 @@
-# subscribe-pipe
+# subscribe
 
 ```
-Subscribe to komorebi events using a Named Pipe
+Subscribe to komorebi events
 
-Usage: komorebic.exe subscribe-pipe <NAMED_PIPE>
+Usage: komorebic.exe subscribe <NAMED_PIPE>
 
 Arguments:
   <NAMED_PIPE>

docs/cli/unsubscribe-socket.md

@@ -1,16 +0,0 @@
-# unsubscribe-socket
-
-```
-Unsubscribe from komorebi events
-
-Usage: komorebic.exe unsubscribe-socket <SOCKET>
-
-Arguments:
-  <SOCKET>
-          Name of the socket to stop sending event notifications to
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/unsubscribe.md

@@ -1,9 +1,9 @@
-# unsubscribe-pipe
+# unsubscribe
 
 ```
 Unsubscribe from komorebi events
 
-Usage: komorebic.exe unsubscribe-pipe <NAMED_PIPE>
+Usage: komorebic.exe unsubscribe <NAMED_PIPE>
 
 Arguments:
   <NAMED_PIPE>

docs/cli/whkdrc.md

@@ -1,12 +0,0 @@
-# whkdrc
-
-```
-Show the path to whkdrc
-
-Usage: komorebic.exe whkdrc
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/workspace-layout-rule.md

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

docs/cli/workspace-layout.md

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

docs/common-workflows/active-window-border.md

@@ -34,5 +34,7 @@ windows managed by `komorebi`.
 This feature is not considered stable and you may encounter visual artifacts
 from time to time.
 
+<!-- TODO: Record a new video -->
+
 [![Watch the tutorial
-video](https://img.youtube.com/vi/7_9D22t7KK4/hqdefault.jpg)](https://www.youtube.com/watch?v=7_9D22t7KK4)
+video](https://img.youtube.com/vi/ywiAvoMV_gE/hqdefault.jpg)](https://www.youtube.com/watch?v=ywiAvoMV_gE)

docs/common-workflows/komorebi-config-home.md

@@ -25,6 +25,3 @@ 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.
-
-[![Watch the tutorial
-video](https://img.youtube.com/vi/C_KWUqQ6kko/hqdefault.jpg)](https://www.youtube.com/watch?v=C_KWUqQ6kko)

docs/common-workflows/remove-gaps.md

@@ -2,18 +2,16 @@
 
 If you would like to remove all gaps by default, both between windows
 themselves, and between the monitor edges and the windows, you can set the
-following configuration options to `0` and `-1` in the `komorebi.json`
-configuration file.
+following two configuration options to `0` in the `komorebi.json` configuration
+file.
 
 ```json
 {
   "default_workspace_padding": 0,
-  "default_container_padding": 0,
-  "border_width": 0,
-  "border_offset": -1
+  "default_container_padding": 0
 }
 ```
 
-A restart of `komorebi` is required after changing these settings.
+<!-- TODO: Record a new video -->
 
-[![Watch the tutorial video](https://img.youtube.com/vi/6QYLao953XE/hqdefault.jpg)](https://www.youtube.com/watch?v=6QYLao953XE)
+[![Watch the tutorial video](https://img.youtube.com/vi/eGr07mymgWE/hqdefault.jpg)](https://www.youtube.com/watch?v=eGr07mymgWE)

docs/example-configurations.md

@@ -16,12 +16,6 @@ the example files have been downloaded. For most new users this will be in the
 komorebic quickstart
 ```
 
-With the example configurations downloaded, you can now start `komorebi` and `whkd.
-
-```powershell
-komorebic start --whkd
-```
-
 ## komorebi.json
 
 The example window manager configuration sets some sane defaults and provides
@@ -145,19 +139,6 @@ If you have an ultrawide monitor, I recommend using this layout.
 +-----+-----------+-----+
 ```
 
-### Grid
-If you like the `grid` layout in [LeftWM](https://github.com/leftwm/leftwm-layouts) this is almost exactly the same!
-
-```
-+-----+-----+   +---+---+---+   +---+---+---+   +---+---+---+
-|     |     |   |   |   |   |   |   |   |   |   |   |   |   |
-|     |     |   |   |   |   |   |   |   |   |   |   |   +---+
-+-----+-----+   |   +---+---+   +---+---+---+   +---+---|   |
-|     |     |   |   |   |   |   |   |   |   |   |   |   +---+
-|     |     |   |   |   |   |   |   |   |   |   |   |   |   |
-+-----+-----+   +---+---+---+   +---+---+---+   +---+---+---+
-  4 windows       5 windows       6 windows       7 windows
-```
 
 ## whkdrc
 

docs/komorebi.example.json

@@ -1,17 +1,15 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.22/schema.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.20/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.yaml",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",
   "default_workspace_padding": 20,
   "default_container_padding": 20,
-  "border_padding": 8,
-  "border_offset": -1,
   "active_window_border": false,
   "active_window_border_colours": {
-    "single": "#42a5f5",
-    "stack": "#00a542",
-    "monocle": "#ff3399"
+    "single": { "r": 66, "g": 165, "b": 245 },
+    "stack": { "r": 256, "g": 165, "b": 66 },
+    "monocle": { "r": 255, "g": 51, "b": 153 }
   },
   "monitors": [
     {

docs/release/v0-1-22.md

@@ -1,56 +0,0 @@
-In addition to the [changelog](https://github.com/LGUG2Z/komorebi/releases/tag/v0.1.22) of new features and fixes,
-please note the following changes from `v0.1.21` to adjust your configuration files accordingly.
-
-## tl;dr
-
-The way windows are sized and drawn has been improved to remove the need to manually specify and remove invisible
-borders for applications that overflow them. If you use the active window border, the first time you launch `v0.1.22`
-you may end up with a _huge_ border due to these changes.
-
-`active_window_border_width` and `active_window_border_offset` have been renamed to `border_width` and `border_offset`
-as they now also apply outside the context of the active window border.
-
-```json
-{
-  "active_window_border": true,
-  "border_width": 8,
-  "border_offset": -1
-}
-```
-
-Users of the active window border should start from these settings and read the notes below before making further
-adjustments.
-
-## Changes to `active_window_border`, and window sizing:
-
-- The border no longer creates a second drop-shadow around the active window
-- Windows are now sized to fill the layout region entirely, ignoring window decorations such as drop shadows
-- Border offset now starts exactly at the paint edge of the window on all sides
-- Windows are sized such that the border offset and border width are taken into account
-
-## Recommended patterns
-
-### Gapless
-
-- Disable "transparency effects" Personalization > Colors
-- Set the following settings in `komorebi.json`:
-```json
-{
-  "default_workspace_padding": 0,
-  "default_container_padding": 0,
-  "border_offset": -1,
-  "border_width": 0
-}
-```
-
-### 1px border
-
-A 1px border is drawn around the window edge. Users may see a gap for a single pixel, if the system theme has a
-transparent edge - this is the windows themed edge, and is not present for all applications.
-
-```json
-  {
-  "border_offset": 0,
-  "border_width": 1
-}
-```

komorebi-client/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "komorebi-client"
-version = "0.1.23-dev.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-komorebi = { path = "../komorebi" }
-komorebi-core = { path = "../komorebi-core" }
-uds_windows = "1"
-serde_json = { workspace = true }

komorebi-client/src/lib.rs

@@ -1,79 +0,0 @@
-#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc)]
-
-pub use komorebi::container::Container;
-pub use komorebi::monitor::Monitor;
-pub use komorebi::ring::Ring;
-pub use komorebi::window::Window;
-pub use komorebi::window_manager_event::WindowManagerEvent;
-pub use komorebi::workspace::Workspace;
-pub use komorebi::Notification;
-pub use komorebi::NotificationEvent;
-pub use komorebi::State;
-pub use komorebi_core::Arrangement;
-pub use komorebi_core::Axis;
-pub use komorebi_core::CustomLayout;
-pub use komorebi_core::CycleDirection;
-pub use komorebi_core::DefaultLayout;
-pub use komorebi_core::Direction;
-pub use komorebi_core::Layout;
-pub use komorebi_core::OperationDirection;
-pub use komorebi_core::Rect;
-pub use komorebi_core::SocketMessage;
-
-use komorebi::DATA_DIR;
-
-use std::io::BufReader;
-use std::io::Read;
-use std::io::Write;
-use std::net::Shutdown;
-pub use uds_windows::UnixListener;
-use uds_windows::UnixStream;
-
-const KOMOREBI: &str = "komorebi.sock";
-
-pub fn send_message(message: &SocketMessage) -> std::io::Result<()> {
-    let socket = DATA_DIR.join(KOMOREBI);
-    let mut connected = false;
-    while !connected {
-        if let Ok(mut stream) = UnixStream::connect(&socket) {
-            connected = true;
-            stream.write_all(serde_json::to_string(message)?.as_bytes())?;
-        }
-    }
-
-    Ok(())
-}
-pub fn send_query(message: &SocketMessage) -> std::io::Result<String> {
-    let socket = DATA_DIR.join(KOMOREBI);
-
-    let mut stream = UnixStream::connect(socket)?;
-    stream.write_all(serde_json::to_string(message)?.as_bytes())?;
-    stream.shutdown(Shutdown::Write)?;
-
-    let mut reader = BufReader::new(stream);
-    let mut response = String::new();
-    reader.read_to_string(&mut response)?;
-
-    Ok(response)
-}
-
-pub fn subscribe(name: &str) -> std::io::Result<UnixListener> {
-    let socket = DATA_DIR.join(name);
-
-    match std::fs::remove_file(&socket) {
-        Ok(()) => {}
-        Err(error) => match error.kind() {
-            std::io::ErrorKind::NotFound => {}
-            _ => {
-                return Err(error);
-            }
-        },
-    };
-
-    let listener = UnixListener::bind(&socket)?;
-
-    send_message(&SocketMessage::AddSubscriberSocket(name.to_string()))?;
-
-    Ok(listener)
-}

komorebi-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.23-dev.0"
+version = "0.1.22-dev.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 clap = { version = "4", features = ["derive"] }
 serde = { version = "1", features = ["derive"] }
-serde_json = { workspace = true }
+serde_json = "1"
 serde_yaml = "0.9"
 strum = { version = "0.26", features = ["derive"] }
 schemars = "0.8"

komorebi-core/src/arrangement.rs

@@ -131,65 +131,11 @@ impl Arrangement for DefaultLayout {
                 layouts
             }
             Self::UltrawideVerticalStack => ultrawide(area, len, layout_flip, resize_dimensions),
-            #[allow(
-                clippy::cast_precision_loss,
-                clippy::cast_possible_truncation,
-                clippy::cast_possible_wrap
-            )]
-            Self::Grid => {
-                // Shamelessly lifted from LeftWM
-                // https://github.com/leftwm/leftwm/blob/18675067b8450e520ef75db2ebbb0d973aa1199e/leftwm-core/src/layouts/grid_horizontal.rs
-                let mut layouts: Vec<Rect> = vec![];
-                layouts.resize(len, Rect::default());
-
-                let len = len as i32;
-
-                let num_cols = (len as f32).sqrt().ceil() as i32;
-                let mut iter = layouts.iter_mut().enumerate().peekable();
-
-                for col in 0..num_cols {
-                    let iter_peek = iter.peek().map(|x| x.0).unwrap_or_default() as i32;
-                    let remaining_windows = len - iter_peek;
-                    let remaining_columns = num_cols - col;
-                    let num_rows_in_this_col = remaining_windows / remaining_columns;
-
-                    let win_height = area.bottom / num_rows_in_this_col;
-                    let win_width = area.right / num_cols;
-
-                    for row in 0..num_rows_in_this_col {
-                        if let Some((_idx, win)) = iter.next() {
-                            let mut left = area.left + win_width * col;
-                            let mut top = area.top + win_height * row;
-
-                            match layout_flip {
-                                Some(Axis::Horizontal) => {
-                                    left = area.right - win_width * (col + 1) + area.left;
-                                }
-                                Some(Axis::Vertical) => {
-                                    top = area.bottom - win_height * (row + 1) + area.top;
-                                }
-                                Some(Axis::HorizontalAndVertical) => {
-                                    left = area.right - win_width * (col + 1) + area.left;
-                                    top = area.bottom - win_height * (row + 1) + area.top;
-                                }
-                                None => {} // No flip
-                            }
-
-                            win.bottom = win_height;
-                            win.right = win_width;
-                            win.left = left;
-                            win.top = top;
-                        }
-                    }
-                }
-
-                layouts
-            }
         };
 
         dimensions
             .iter_mut()
-            .for_each(|l| l.add_padding(container_padding.unwrap_or_default()));
+            .for_each(|l| l.add_padding(container_padding));
 
         dimensions
     }
@@ -312,7 +258,7 @@ impl Arrangement for CustomLayout {
 
         dimensions
             .iter_mut()
-            .for_each(|l| l.add_padding(container_padding.unwrap_or_default()));
+            .for_each(|l| l.add_padding(container_padding));
 
         dimensions
     }

komorebi-core/src/config_generation.rs

@@ -8,9 +8,7 @@ use strum::EnumString;
 
 use crate::ApplicationIdentifier;
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum ApplicationOptions {
@@ -52,13 +50,6 @@ impl ApplicationOptions {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
-#[serde(untagged)]
-pub enum MatchingRule {
-    Simple(IdWithIdentifier),
-    Composite(Vec<IdWithIdentifier>),
-}
-
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct IdWithIdentifier {
     pub kind: ApplicationIdentifier,
@@ -104,14 +95,14 @@ pub struct ApplicationConfiguration {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub options: Option<Vec<ApplicationOptions>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub float_identifiers: Option<Vec<MatchingRule>>,
+    pub float_identifiers: Option<Vec<IdWithIdentifierAndComment>>,
 }
 
 impl ApplicationConfiguration {
     pub fn populate_default_matching_strategies(&mut self) {
         if self.identifier.matching_strategy.is_none() {
             match self.identifier.kind {
-                ApplicationIdentifier::Exe | ApplicationIdentifier::Path => {
+                ApplicationIdentifier::Exe => {
                     self.identifier.matching_strategy = Option::from(MatchingStrategy::Equals);
                 }
                 ApplicationIdentifier::Class | ApplicationIdentifier::Title => {}
@@ -190,21 +181,19 @@ impl ApplicationConfigurationGenerator {
             }
 
             if let Some(float_identifiers) = app.float_identifiers {
-                for matching_rule in float_identifiers {
-                    if let MatchingRule::Simple(float) = matching_rule {
-                        let float_rule =
-                            format!("komorebic.exe float-rule {} \"{}\"", float.kind, float.id);
+                for float in float_identifiers {
+                    let float_rule =
+                        format!("komorebic.exe float-rule {} \"{}\"", float.kind, float.id);
 
-                        // Don't want to send duped signals especially as configs get larger
-                        if !float_rules.contains(&float_rule) {
-                            float_rules.push(float_rule.clone());
+                    // Don't want to send duped signals especially as configs get larger
+                    if !float_rules.contains(&float_rule) {
+                        float_rules.push(float_rule.clone());
 
-                            // if let Some(comment) = float.comment {
-                            //     lines.push(format!("# {comment}"));
-                            // };
+                        if let Some(comment) = float.comment {
+                            lines.push(format!("# {comment}"));
+                        };
 
-                            lines.push(float_rule);
-                        }
+                        lines.push(float_rule);
                     }
                 }
             }
@@ -241,23 +230,21 @@ impl ApplicationConfigurationGenerator {
             }
 
             if let Some(float_identifiers) = app.float_identifiers {
-                for matching_rule in float_identifiers {
-                    if let MatchingRule::Simple(float) = matching_rule {
-                        let float_rule = format!(
-                            "RunWait('komorebic.exe float-rule {} \"{}\"', , \"Hide\")",
-                            float.kind, float.id
-                        );
+                for float in float_identifiers {
+                    let float_rule = format!(
+                        "RunWait('komorebic.exe float-rule {} \"{}\"', , \"Hide\")",
+                        float.kind, float.id
+                    );
 
-                        // Don't want to send duped signals especially as configs get larger
-                        if !float_rules.contains(&float_rule) {
-                            float_rules.push(float_rule.clone());
+                    // Don't want to send duped signals especially as configs get larger
+                    if !float_rules.contains(&float_rule) {
+                        float_rules.push(float_rule.clone());
 
-                            // if let Some(comment) = float.comment {
-                            //     lines.push(format!("; {comment}"));
-                            // };
+                        if let Some(comment) = float.comment {
+                            lines.push(format!("; {comment}"));
+                        };
 
-                            lines.push(float_rule);
-                        }
+                        lines.push(float_rule);
                     }
                 }
             }

komorebi-core/src/default_layout.rs

@@ -20,7 +20,6 @@ pub enum DefaultLayout {
     VerticalStack,
     HorizontalStack,
     UltrawideVerticalStack,
-    Grid,
     // NOTE: If any new layout is added, please make sure to register the same in `DefaultLayout::cycle`
 }
 
@@ -136,8 +135,7 @@ impl DefaultLayout {
             Self::Rows => Self::VerticalStack,
             Self::VerticalStack => Self::HorizontalStack,
             Self::HorizontalStack => Self::UltrawideVerticalStack,
-            Self::UltrawideVerticalStack => Self::Grid,
-            Self::Grid => Self::BSP,
+            Self::UltrawideVerticalStack => Self::BSP,
         }
     }
 
@@ -149,8 +147,7 @@ impl DefaultLayout {
             Self::HorizontalStack => Self::VerticalStack,
             Self::VerticalStack => Self::Rows,
             Self::Rows => Self::Columns,
-            Self::Columns => Self::Grid,
-            Self::Grid => Self::BSP,
+            Self::Columns => Self::BSP,
         }
     }
 }

komorebi-core/src/direction.rs

@@ -19,30 +19,10 @@ pub trait Direction {
         idx: usize,
         count: usize,
     ) -> bool;
-    fn up_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize;
-    fn down_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize;
-    fn left_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize;
-    fn right_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize;
+    fn up_index(&self, idx: usize) -> usize;
+    fn down_index(&self, idx: usize) -> usize;
+    fn left_index(&self, idx: usize) -> usize;
+    fn right_index(&self, idx: usize) -> usize;
 }
 
 impl Direction for DefaultLayout {
@@ -55,28 +35,28 @@ impl Direction for DefaultLayout {
         match op_direction {
             OperationDirection::Left => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.left_index(Some(op_direction), idx, Some(count)))
+                    Option::from(self.left_index(idx))
                 } else {
                     None
                 }
             }
             OperationDirection::Right => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.right_index(Some(op_direction), idx, Some(count)))
+                    Option::from(self.right_index(idx))
                 } else {
                     None
                 }
             }
             OperationDirection::Up => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.up_index(Some(op_direction), idx, Some(count)))
+                    Option::from(self.up_index(idx))
                 } else {
                     None
                 }
             }
             OperationDirection::Down => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.down_index(Some(op_direction), idx, Some(count)))
+                    Option::from(self.down_index(idx))
                 } else {
                     None
                 }
@@ -97,7 +77,6 @@ impl Direction for DefaultLayout {
                 Self::Rows | Self::HorizontalStack => idx != 0,
                 Self::VerticalStack => idx != 0 && idx != 1,
                 Self::UltrawideVerticalStack => idx > 2,
-                Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Down => match self {
                 Self::BSP => count > 2 && idx != count - 1 && idx % 2 != 0,
@@ -106,7 +85,6 @@ impl Direction for DefaultLayout {
                 Self::VerticalStack => idx != 0 && idx != count - 1,
                 Self::HorizontalStack => idx == 0,
                 Self::UltrawideVerticalStack => idx > 1 && idx != count - 1,
-                Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Left => match self {
                 Self::BSP => count > 1 && idx != 0,
@@ -114,7 +92,6 @@ impl Direction for DefaultLayout {
                 Self::Rows => false,
                 Self::HorizontalStack => idx != 0 && idx != 1,
                 Self::UltrawideVerticalStack => count > 1 && idx != 1,
-                Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
             OperationDirection::Right => match self {
                 Self::BSP => count > 1 && idx % 2 == 0 && idx != count - 1,
@@ -127,17 +104,11 @@ impl Direction for DefaultLayout {
                     2 => idx != 0,
                     _ => idx < 2,
                 },
-                Self::Grid => !is_grid_edge(op_direction, idx, count),
             },
         }
     }
 
-    fn up_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize {
+    fn up_index(&self, idx: usize) -> usize {
         match self {
             Self::BSP => {
                 if idx % 2 == 0 {
@@ -149,30 +120,18 @@ impl Direction for DefaultLayout {
             Self::Columns => unreachable!(),
             Self::Rows | Self::VerticalStack | Self::UltrawideVerticalStack => idx - 1,
             Self::HorizontalStack => 0,
-            Self::Grid => grid_neighbor(op_direction, idx, count),
         }
     }
 
-    fn down_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize {
+    fn down_index(&self, idx: usize) -> usize {
         match self {
             Self::BSP | Self::Rows | Self::VerticalStack | Self::UltrawideVerticalStack => idx + 1,
             Self::Columns => unreachable!(),
             Self::HorizontalStack => 1,
-            Self::Grid => grid_neighbor(op_direction, idx, count),
         }
     }
 
-    fn left_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize {
+    fn left_index(&self, idx: usize) -> usize {
         match self {
             Self::BSP => {
                 if idx % 2 == 0 {
@@ -189,16 +148,10 @@ impl Direction for DefaultLayout {
                 1 => unreachable!(),
                 _ => 0,
             },
-            Self::Grid => grid_neighbor(op_direction, idx, count),
         }
     }
 
-    fn right_index(
-        &self,
-        op_direction: Option<OperationDirection>,
-        idx: usize,
-        count: Option<usize>,
-    ) -> usize {
+    fn right_index(&self, idx: usize) -> usize {
         match self {
             Self::BSP | Self::Columns | Self::HorizontalStack => idx + 1,
             Self::Rows => unreachable!(),
@@ -208,126 +161,10 @@ impl Direction for DefaultLayout {
                 0 => 2,
                 _ => unreachable!(),
             },
-            Self::Grid => grid_neighbor(op_direction, idx, count),
         }
     }
 }
 
-struct GridItem {
-    state: GridItemState,
-    row: usize,
-    num_rows: usize,
-    touching_edges: GridTouchingEdges,
-}
-
-enum GridItemState {
-    Valid,
-    Invalid,
-}
-
-#[allow(clippy::struct_excessive_bools)]
-struct GridTouchingEdges {
-    left: bool,
-    right: bool,
-    up: bool,
-    down: bool,
-}
-
-#[allow(
-    clippy::cast_possible_truncation,
-    clippy::cast_precision_loss,
-    clippy::cast_sign_loss
-)]
-fn get_grid_item(idx: usize, count: usize) -> GridItem {
-    let num_cols = (count as f32).sqrt().ceil() as usize;
-    let mut iter = 0;
-
-    for col in 0..num_cols {
-        let remaining_windows = count - iter;
-        let remaining_columns = num_cols - col;
-        let num_rows_in_this_col = remaining_windows / remaining_columns;
-
-        for row in 0..num_rows_in_this_col {
-            if iter == idx {
-                return GridItem {
-                    state: GridItemState::Valid,
-                    row: row + 1,
-                    num_rows: num_rows_in_this_col,
-                    touching_edges: GridTouchingEdges {
-                        left: col == 0,
-                        right: col == num_cols - 1,
-                        up: row == 0,
-                        down: row == num_rows_in_this_col - 1,
-                    },
-                };
-            }
-
-            iter += 1;
-        }
-    }
-
-    GridItem {
-        state: GridItemState::Invalid,
-        row: 0,
-        num_rows: 0,
-        touching_edges: GridTouchingEdges {
-            left: true,
-            right: true,
-            up: true,
-            down: true,
-        },
-    }
-}
-
-fn is_grid_edge(op_direction: OperationDirection, idx: usize, count: usize) -> bool {
-    let item = get_grid_item(idx, count);
-
-    match item.state {
-        GridItemState::Invalid => false,
-        GridItemState::Valid => match op_direction {
-            OperationDirection::Left => item.touching_edges.left,
-            OperationDirection::Right => item.touching_edges.right,
-            OperationDirection::Up => item.touching_edges.up,
-            OperationDirection::Down => item.touching_edges.down,
-        },
-    }
-}
-
-fn grid_neighbor(
-    op_direction: Option<OperationDirection>,
-    idx: usize,
-    count: Option<usize>,
-) -> usize {
-    let Some(op_direction) = op_direction else {
-        return 0;
-    };
-
-    let Some(count) = count else {
-        return 0;
-    };
-
-    let item = get_grid_item(idx, count);
-
-    match op_direction {
-        OperationDirection::Left => {
-            let item_from_prev_col = get_grid_item(idx - item.row, count);
-
-            if item.touching_edges.up && item.num_rows != item_from_prev_col.num_rows {
-                return idx - (item.num_rows - 1);
-            }
-
-            if item.num_rows != item_from_prev_col.num_rows && !item.touching_edges.down {
-                return idx - (item.num_rows - 1);
-            }
-
-            idx - item.num_rows
-        }
-        OperationDirection::Right => idx + item.num_rows,
-        OperationDirection::Up => idx - 1,
-        OperationDirection::Down => idx + 1,
-    }
-}
-
 impl Direction for CustomLayout {
     fn index_in_direction(
         &self,
@@ -342,28 +179,28 @@ impl Direction for CustomLayout {
         match op_direction {
             OperationDirection::Left => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.left_index(None, idx, None))
+                    Option::from(self.left_index(idx))
                 } else {
                     None
                 }
             }
             OperationDirection::Right => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.right_index(None, idx, None))
+                    Option::from(self.right_index(idx))
                 } else {
                     None
                 }
             }
             OperationDirection::Up => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.up_index(None, idx, None))
+                    Option::from(self.up_index(idx))
                 } else {
                     None
                 }
             }
             OperationDirection::Down => {
                 if self.is_valid_direction(op_direction, idx, count) {
-                    Option::from(self.down_index(None, idx, None))
+                    Option::from(self.down_index(idx))
                 } else {
                     None
                 }
@@ -417,30 +254,15 @@ impl Direction for CustomLayout {
         }
     }
 
-    fn up_index(
-        &self,
-        _op_direction: Option<OperationDirection>,
-        idx: usize,
-        _count: Option<usize>,
-    ) -> usize {
+    fn up_index(&self, idx: usize) -> usize {
         idx - 1
     }
 
-    fn down_index(
-        &self,
-        _op_direction: Option<OperationDirection>,
-        idx: usize,
-        _count: Option<usize>,
-    ) -> usize {
+    fn down_index(&self, idx: usize) -> usize {
         idx + 1
     }
 
-    fn left_index(
-        &self,
-        _op_direction: Option<OperationDirection>,
-        idx: usize,
-        _count: Option<usize>,
-    ) -> usize {
+    fn left_index(&self, idx: usize) -> usize {
         let column_idx = self.column_for_container_idx(idx);
         if column_idx - 1 == 0 {
             0
@@ -449,12 +271,7 @@ impl Direction for CustomLayout {
         }
     }
 
-    fn right_index(
-        &self,
-        _op_direction: Option<OperationDirection>,
-        idx: usize,
-        _count: Option<usize>,
-    ) -> usize {
+    fn right_index(&self, idx: usize) -> usize {
         let column_idx = self.column_for_container_idx(idx);
         self.first_container_idx(column_idx + 1)
     }

komorebi-core/src/lib.rs

@@ -223,8 +223,6 @@ pub enum ApplicationIdentifier {
     Class,
     #[serde(alias = "title")]
     Title,
-    #[serde(alias = "path")]
-    Path,
 }
 
 #[derive(

komorebi-core/src/rect.rs

@@ -27,20 +27,13 @@ impl From<RECT> for Rect {
 }
 
 impl Rect {
-    /// decrease the size of self by the padding amount.
-    pub fn add_padding(&mut self, padding: i32) {
-        self.left += padding;
-        self.top += padding;
-        self.right -= padding * 2;
-        self.bottom -= padding * 2;
-    }
-
-    /// increase the size of self by the margin amount.
-    pub fn add_margin(&mut self, margin: i32) {
-        self.left -= margin;
-        self.top -= margin;
-        self.right += margin * 2;
-        self.bottom += margin * 2;
+    pub fn add_padding(&mut self, padding: Option<i32>) {
+        if let Some(padding) = padding {
+            self.left += padding;
+            self.top += padding;
+            self.right -= padding * 2;
+            self.bottom -= padding * 2;
+        }
     }
 
     #[must_use]
@@ -50,14 +43,4 @@ impl Rect {
             && point.1 >= self.top
             && point.1 <= self.top + self.bottom
     }
-
-    #[must_use]
-    pub const fn scale(&self, system_dpi: i32, rect_dpi: i32) -> Rect {
-        Rect {
-            left: (self.left * rect_dpi) / system_dpi,
-            top: (self.top * rect_dpi) / system_dpi,
-            right: (self.right * rect_dpi) / system_dpi,
-            bottom: (self.bottom * rect_dpi) / system_dpi,
-        }
-    }
 }

komorebi.example.json

@@ -1,17 +1,15 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.22/schema.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.20/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.yaml",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",
   "default_workspace_padding": 20,
   "default_container_padding": 20,
-  "border_padding": 8,
-  "border_offset": -1,
   "active_window_border": false,
   "active_window_border_colours": {
-    "single": "#42a5f5",
-    "stack": "#00a542",
-    "monocle": "#ff3399"
+    "single": { "r": 66, "g": 165, "b": 245 },
+    "stack": { "r": 256, "g": 165, "b": 66 },
+    "monocle": { "r": 255, "g": 51, "b": 153 }
   },
   "monitors": [
     {

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.23-dev.0"
+version = "0.1.22-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -15,38 +15,37 @@ komorebi-core = { path = "../komorebi-core" }
 
 bitflags = "2"
 clap = { version = "4", features = ["derive"] }
-color-eyre = { workspace = true }
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 ctrlc = "3"
-dirs = { workspace = true }
 getset = "0.1"
-hex_color = { version = "3", features = ["serde"] }
-hotwatch = "0.5"
+hotwatch = "0.4"
 lazy_static = "1"
 miow = "0.5"
 nanoid = "0.4"
 net2 = "0.2"
-os_info = "3.8"
+os_info = "3.7"
 parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 paste = "1"
 regex = "1"
 schemars = "0.8"
 serde = { version = "1", features = ["derive"] }
-serde_json = { workspace = true }
+serde_json = "1"
 strum = { version = "0.26", features = ["derive"] }
 sysinfo = "0.30"
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uds_windows = "1"
-which = "6"
-widestring = "1"
-windows = { workspace = true }
-windows-implement = { workspace = true }
-windows-interface = { workspace = true }
+which = "5"
 winput = "0.2"
 winreg = "0.52"
+windows-interface = { workspace = true }
+windows-implement = { workspace = true }
+windows = { workspace = true }
+color-eyre = { workspace = true }
+dirs = { workspace = true }
+widestring = "1"
 
 [features]
 deadlock_detection = []

komorebi/src/border.rs

@@ -1,4 +1,5 @@
 use std::sync::atomic::Ordering;
+use std::time::Duration;
 
 use color_eyre::Result;
 use windows::core::PCWSTR;
@@ -11,14 +12,19 @@ use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 
+use komorebi_core::Rect;
+
+use crate::window::should_act;
 use crate::window::Window;
 use crate::windows_callbacks;
 use crate::WindowsApi;
 use crate::BORDER_HWND;
 use crate::BORDER_OFFSET;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::BORDER_RECT;
-use crate::BORDER_WIDTH;
+use crate::REGEX_IDENTIFIERS;
 use crate::TRANSPARENCY_COLOUR;
+use crate::WINDOWS_11;
 
 #[derive(Debug, Clone, Copy)]
 pub struct Border {
@@ -62,6 +68,7 @@ impl Border {
             unsafe {
                 while GetMessageW(&mut message, border.hwnd(), 0, 0).into() {
                     DispatchMessageW(&message);
+                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 
@@ -75,6 +82,10 @@ impl Border {
 
         BORDER_HWND.store(hwnd.0, Ordering::SeqCst);
 
+        if *WINDOWS_11 {
+            WindowsApi::round_corners(hwnd.0)?;
+        }
+
         Ok(())
     }
 
@@ -86,7 +97,12 @@ impl Border {
         }
     }
 
-    pub fn set_position(self, window: Window, activate: bool) -> Result<()> {
+    pub fn set_position(
+        self,
+        window: Window,
+        invisible_borders: &Rect,
+        activate: bool,
+    ) -> Result<()> {
         if self.hwnd == 0 {
             Ok(())
         } else {
@@ -95,10 +111,38 @@ impl Border {
             }
 
             let mut rect = WindowsApi::window_rect(window.hwnd())?;
-            rect.add_padding(-BORDER_OFFSET.load(Ordering::SeqCst));
+            rect.top -= invisible_borders.bottom;
+            rect.bottom += invisible_borders.bottom;
 
-            let border_width = BORDER_WIDTH.load(Ordering::SeqCst);
-            rect.add_margin(border_width);
+            let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
+            let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
+            let title = &window.title()?;
+            let exe_name = &window.exe()?;
+            let class = &window.class()?;
+
+            let should_expand_border = should_act(
+                title,
+                exe_name,
+                class,
+                &border_overflows,
+                &regex_identifiers,
+            );
+
+            if should_expand_border {
+                rect.left -= invisible_borders.left;
+                rect.top -= invisible_borders.top;
+                rect.right += invisible_borders.right;
+                rect.bottom += invisible_borders.bottom;
+            }
+
+            let border_offset = BORDER_OFFSET.lock();
+            if let Some(border_offset) = *border_offset {
+                rect.left -= border_offset.left;
+                rect.top -= border_offset.top;
+                rect.right += border_offset.right;
+                rect.bottom += border_offset.bottom;
+            }
 
             *BORDER_RECT.lock() = rect;
 

komorebi/src/colour.rs

@@ -1,103 +0,0 @@
-use hex_color::HexColor;
-use schemars::gen::SchemaGenerator;
-use schemars::schema::InstanceType;
-use schemars::schema::Schema;
-use schemars::schema::SchemaObject;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(untagged)]
-pub enum Colour {
-    /// Colour represented as RGB
-    Rgb(Rgb),
-    /// Colour represented as Hex
-    Hex(Hex),
-}
-
-impl From<Rgb> for Colour {
-    fn from(value: Rgb) -> Self {
-        Self::Rgb(value)
-    }
-}
-
-impl From<u32> for Colour {
-    fn from(value: u32) -> Self {
-        Self::Rgb(Rgb::from(value))
-    }
-}
-
-#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
-pub struct Hex(HexColor);
-
-impl JsonSchema for Hex {
-    fn schema_name() -> String {
-        String::from("Hex")
-    }
-
-    fn json_schema(_: &mut SchemaGenerator) -> Schema {
-        SchemaObject {
-            instance_type: Some(InstanceType::String.into()),
-            ..Default::default()
-        }
-        .into()
-    }
-}
-
-impl From<Colour> for u32 {
-    fn from(value: Colour) -> Self {
-        match value {
-            Colour::Rgb(val) => val.into(),
-            Colour::Hex(val) => (Rgb::from(val)).into(),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
-pub struct Rgb {
-    /// Red
-    pub r: u32,
-    /// Green
-    pub g: u32,
-    /// Blue
-    pub b: u32,
-}
-
-impl Rgb {
-    pub fn new(r: u32, g: u32, b: u32) -> Self {
-        Self { r, g, b }
-    }
-}
-
-impl From<Hex> for Rgb {
-    fn from(value: Hex) -> Self {
-        value.0.into()
-    }
-}
-
-impl From<HexColor> for Rgb {
-    fn from(value: HexColor) -> Self {
-        Self {
-            r: value.r as u32,
-            g: value.g as u32,
-            b: value.b as u32,
-        }
-    }
-}
-
-impl From<Rgb> for u32 {
-    fn from(value: Rgb) -> Self {
-        value.r | (value.g << 8) | (value.b << 16)
-    }
-}
-
-impl From<u32> for Rgb {
-    fn from(value: u32) -> Self {
-        Self {
-            r: value & 0xff,
-            g: value >> 8 & 0xff,
-            b: value >> 16 & 0xff,
-        }
-    }
-}

komorebi/src/com/mod.rs

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

komorebi/src/hidden.rs

@@ -1,4 +1,5 @@
 use std::sync::atomic::Ordering;
+use std::time::Duration;
 
 use color_eyre::Result;
 use windows::core::PCWSTR;
@@ -58,6 +59,7 @@ impl Hidden {
             unsafe {
                 while GetMessageW(&mut message, hidden.hwnd(), 0, 0).into() {
                     DispatchMessageW(&message);
+                    std::thread::sleep(Duration::from_millis(10));
                 }
             }
 

komorebi/src/lib.rs

@@ -2,7 +2,6 @@ pub mod border;
 pub mod com;
 #[macro_use]
 pub mod ring;
-pub mod colour;
 pub mod container;
 pub mod hidden;
 pub mod monitor;
@@ -46,7 +45,6 @@ pub use windows_api::*;
 
 use color_eyre::Result;
 use komorebi_core::config_generation::IdWithIdentifier;
-use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
@@ -67,57 +65,57 @@ type WorkspaceRule = (usize, usize, bool);
 
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
-    static ref LAYERED_WHITELIST: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
-        MatchingRule::Simple(IdWithIdentifier {
+    static ref LAYERED_WHITELIST: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        IdWithIdentifier {
             kind: ApplicationIdentifier::Exe,
             id: String::from("steam.exe"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
+        },
     ]));
-    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> =
+    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> =
         Arc::new(Mutex::new(vec![
-            MatchingRule::Simple(IdWithIdentifier {
+            IdWithIdentifier {
                 kind: ApplicationIdentifier::Exe,
                 id: String::from("explorer.exe"),
                 matching_strategy: Option::from(MatchingStrategy::Equals),
-            }),
-            MatchingRule::Simple(IdWithIdentifier {
+            },
+            IdWithIdentifier {
                 kind: ApplicationIdentifier::Exe,
                 id: String::from("firefox.exe"),
                 matching_strategy: Option::from(MatchingStrategy::Equals),
-            }),
-            MatchingRule::Simple(IdWithIdentifier {
+            },
+            IdWithIdentifier {
                 kind: ApplicationIdentifier::Exe,
                 id: String::from("chrome.exe"),
                 matching_strategy: Option::from(MatchingStrategy::Equals),
-            }),
-            MatchingRule::Simple(IdWithIdentifier {
+            },
+            IdWithIdentifier {
                 kind: ApplicationIdentifier::Exe,
                 id: String::from("idea64.exe"),
                 matching_strategy: Option::from(MatchingStrategy::Equals),
-            }),
-            MatchingRule::Simple(IdWithIdentifier {
+            },
+            IdWithIdentifier {
                 kind: ApplicationIdentifier::Exe,
                 id: String::from("ApplicationFrameHost.exe"),
                 matching_strategy: Option::from(MatchingStrategy::Equals),
-            }),
-            MatchingRule::Simple(IdWithIdentifier {
+            },
+            IdWithIdentifier {
                 kind: ApplicationIdentifier::Exe,
                 id: String::from("steam.exe"),
                 matching_strategy: Option::from(MatchingStrategy::Equals),
-            })
+            }
         ]));
-    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
-        MatchingRule::Simple(IdWithIdentifier {
+    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
+        IdWithIdentifier {
             kind: ApplicationIdentifier::Exe,
             id: String::from("firefox.exe"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
-        MatchingRule::Simple(IdWithIdentifier {
+        },
+        IdWithIdentifier {
             kind: ApplicationIdentifier::Exe,
             id: String::from("idea64.exe"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
+        },
     ]));
     static ref MONITOR_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, Rect>>> =
         Arc::new(Mutex::new(HashMap::new()));
@@ -127,26 +125,25 @@ lazy_static! {
         Arc::new(Mutex::new(HashMap::new()));
     static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
         Arc::new(Mutex::new(HashMap::new()));
-    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
-    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
+    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
+    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![
         // mstsc.exe creates these on Windows 11 when a WSL process is launched
         // https://github.com/LGUG2Z/komorebi/issues/74
-        MatchingRule::Simple(IdWithIdentifier {
+        IdWithIdentifier {
             kind: ApplicationIdentifier::Class,
             id: String::from("OPContainerClass"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
-        MatchingRule::Simple(IdWithIdentifier {
+        },
+        IdWithIdentifier {
             kind: ApplicationIdentifier::Class,
             id: String::from("IHWindowClass"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        })
+        }
     ]));
-
     static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "Chrome_RenderWidgetHostHWND".to_string(),
     ]));
-    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
+    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<IdWithIdentifier>>> = Arc::new(Mutex::new(vec![]));
     static ref WSL2_UI_PROCESSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "X410.exe".to_string(),
         "vcxsrv.exe".to_string(),
@@ -172,7 +169,7 @@ lazy_static! {
             }
         })
     };
-    pub static ref DATA_DIR: PathBuf = dirs::data_local_dir().expect("there is no local data directory").join("komorebi");
+    static ref DATA_DIR: PathBuf = dirs::data_local_dir().expect("there is no local data directory").join("komorebi");
     pub static ref AHK_EXE: String = {
         let mut ahk: String = String::from("autohotkey.exe");
 
@@ -194,6 +191,8 @@ lazy_static! {
     static ref BORDER_RECT: Arc<Mutex<Rect>> =
         Arc::new(Mutex::new(Rect::default()));
 
+    static ref BORDER_OFFSET: Arc<Mutex<Option<Rect>>> =
+        Arc::new(Mutex::new(None));
 
     // Use app-specific titlebar removal options where possible
     // eg. Windows Terminal, IntelliJ IDEA, Firefox
@@ -206,6 +205,7 @@ pub static DEFAULT_CONTAINER_PADDING: AtomicI32 = AtomicI32::new(10);
 pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
+pub static ALT_FOCUS_HACK: AtomicBool = AtomicBool::new(false);
 pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(false);
 pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
 pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);
@@ -213,9 +213,7 @@ pub static BORDER_COLOUR_SINGLE: AtomicU32 = AtomicU32::new(0);
 pub static BORDER_COLOUR_STACK: AtomicU32 = AtomicU32::new(0);
 pub static BORDER_COLOUR_MONOCLE: AtomicU32 = AtomicU32::new(0);
 pub static BORDER_COLOUR_CURRENT: AtomicU32 = AtomicU32::new(0);
-pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
-pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
-
+pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(20);
 // 0 0 0 aka pure black, I doubt anyone will want this as a border colour
 pub const TRANSPARENCY_COLOUR: u32 = 0;
 pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);

komorebi/src/main.rs

@@ -14,6 +14,8 @@ use std::time::Duration;
 
 use clap::Parser;
 use color_eyre::Result;
+use crossbeam_channel::Receiver;
+use crossbeam_channel::Sender;
 use crossbeam_utils::Backoff;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
@@ -31,6 +33,7 @@ use komorebi::process_event::listen_for_events;
 use komorebi::process_movement::listen_for_movements;
 use komorebi::static_config::StaticConfig;
 use komorebi::window_manager::WindowManager;
+use komorebi::window_manager_event::WindowManagerEvent;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
 use komorebi::CUSTOM_FFM;
@@ -180,11 +183,15 @@ fn main() -> Result<()> {
 
     WindowsApi::foreground_lock_timeout()?;
 
-    winevent_listener::start();
-
     #[cfg(feature = "deadlock_detection")]
     detect_deadlocks();
 
+    let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
+        crossbeam_channel::unbounded();
+
+    let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
+    winevent_listener.start();
+
     Hidden::create("komorebi-hidden")?;
 
     let static_config = opts.config.map_or_else(
@@ -207,12 +214,12 @@ fn main() -> Result<()> {
 
         Arc::new(Mutex::new(StaticConfig::preload(
             config,
-            winevent_listener::event_rx(),
+            Arc::new(Mutex::new(incoming)),
         )?))
     } else {
-        Arc::new(Mutex::new(WindowManager::new(
-            winevent_listener::event_rx(),
-        )?))
+        Arc::new(Mutex::new(WindowManager::new(Arc::new(Mutex::new(
+            incoming,
+        )))?))
     };
 
     wm.lock().init()?;

komorebi/src/monitor.rs

@@ -192,7 +192,11 @@ impl Monitor {
         self.workspaces().len()
     }
 
-    pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> Result<()> {
+    pub fn update_focused_workspace(
+        &mut self,
+        offset: Option<Rect>,
+        invisible_borders: &Rect,
+    ) -> Result<()> {
         let work_area = *self.work_area_size();
         let offset = if self.work_area_offset().is_some() {
             self.work_area_offset()
@@ -202,7 +206,7 @@ impl Monitor {
 
         self.focused_workspace_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?
-            .update(&work_area, offset)?;
+            .update(&work_area, offset, invisible_borders)?;
 
         Ok(())
     }

komorebi/src/process_command.rs

@@ -23,7 +23,6 @@ use uds_windows::UnixStream;
 
 use komorebi_core::config_generation::ApplicationConfiguration;
 use komorebi_core::config_generation::IdWithIdentifier;
-use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
@@ -39,7 +38,6 @@ use komorebi_core::WindowContainerBehaviour;
 use komorebi_core::WindowKind;
 
 use crate::border::Border;
-use crate::colour::Rgb;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::static_config::StaticConfig;
@@ -49,6 +47,7 @@ use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::ALT_FOCUS_HACK;
 use crate::BORDER_COLOUR_CURRENT;
 use crate::BORDER_COLOUR_MONOCLE;
 use crate::BORDER_COLOUR_SINGLE;
@@ -274,19 +273,17 @@ impl WindowManager {
 
                 let mut should_push = true;
                 for m in &*manage_identifiers {
-                    if let MatchingRule::Simple(m) = m {
-                        if m.id.eq(id) {
-                            should_push = false;
-                        }
+                    if m.id.eq(id) {
+                        should_push = false;
                     }
                 }
 
                 if should_push {
-                    manage_identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    manage_identifiers.push(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
-                    }));
+                    });
                 }
             }
             SocketMessage::FloatRule(identifier, ref id) => {
@@ -294,21 +291,20 @@ impl WindowManager {
 
                 let mut should_push = true;
                 for f in &*float_identifiers {
-                    if let MatchingRule::Simple(f) = f {
-                        if f.id.eq(id) {
-                            should_push = false;
-                        }
+                    if f.id.eq(id) {
+                        should_push = false;
                     }
                 }
 
                 if should_push {
-                    float_identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    float_identifiers.push(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
-                    }));
+                    });
                 }
 
+                let invisible_borders = self.invisible_borders;
                 let offset = self.work_area_offset;
 
                 let mut hwnds_to_purge = vec![];
@@ -320,11 +316,6 @@ impl WindowManager {
                     {
                         for window in container.windows() {
                             match identifier {
-                                ApplicationIdentifier::Path => {
-                                    if window.path()? == *id {
-                                        hwnds_to_purge.push((i, window.hwnd));
-                                    }
-                                }
                                 ApplicationIdentifier::Exe => {
                                     if window.exe()? == *id {
                                         hwnds_to_purge.push((i, window.hwnd));
@@ -356,7 +347,7 @@ impl WindowManager {
                         .ok_or_else(|| anyhow!("there is no focused workspace"))?
                         .remove_window(hwnd)?;
 
-                    monitor.update_focused_workspace(offset)?;
+                    monitor.update_focused_workspace(offset, &invisible_borders)?;
                 }
             }
             SocketMessage::FocusedWorkspaceContainerPadding(adjustment) => {
@@ -1030,19 +1021,17 @@ impl WindowManager {
 
                 let mut should_push = true;
                 for i in &*identifiers {
-                    if let MatchingRule::Simple(i) = i {
-                        if i.id.eq(id) {
-                            should_push = false;
-                        }
+                    if i.id.eq(id) {
+                        should_push = false;
                     }
                 }
 
                 if should_push {
-                    identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    identifiers.push(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
-                    }));
+                    });
                 }
             }
             SocketMessage::IdentifyObjectNameChangeApplication(identifier, ref id) => {
@@ -1050,38 +1039,34 @@ impl WindowManager {
 
                 let mut should_push = true;
                 for i in &*identifiers {
-                    if let MatchingRule::Simple(i) = i {
-                        if i.id.eq(id) {
-                            should_push = false;
-                        }
+                    if i.id.eq(id) {
+                        should_push = false;
                     }
                 }
 
                 if should_push {
-                    identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    identifiers.push(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
-                    }));
+                    });
                 }
             }
             SocketMessage::IdentifyTrayApplication(identifier, ref id) => {
                 let mut identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
                 let mut should_push = true;
                 for i in &*identifiers {
-                    if let MatchingRule::Simple(i) = i {
-                        if i.id.eq(id) {
-                            should_push = false;
-                        }
+                    if i.id.eq(id) {
+                        should_push = false;
                     }
                 }
 
                 if should_push {
-                    identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    identifiers.push(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
-                    }));
+                    });
                 }
             }
             SocketMessage::IdentifyLayeredApplication(identifier, ref id) => {
@@ -1089,19 +1074,17 @@ impl WindowManager {
 
                 let mut should_push = true;
                 for i in &*identifiers {
-                    if let MatchingRule::Simple(i) = i {
-                        if i.id.eq(id) {
-                            should_push = false;
-                        }
+                    if i.id.eq(id) {
+                        should_push = false;
                     }
                 }
 
                 if should_push {
-                    identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    identifiers.push(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
-                    }));
+                    });
                 }
             }
             SocketMessage::ManageFocusedWindow => {
@@ -1110,7 +1093,10 @@ impl WindowManager {
             SocketMessage::UnmanageFocusedWindow => {
                 self.unmanage_focused_window()?;
             }
-            SocketMessage::InvisibleBorders(_rect) => {}
+            SocketMessage::InvisibleBorders(rect) => {
+                self.invisible_borders = rect;
+                self.retile_all(false)?;
+            }
             SocketMessage::WorkAreaOffset(rect) => {
                 self.work_area_offset = Option::from(rect);
                 self.retile_all(false)?;
@@ -1248,14 +1234,14 @@ impl WindowManager {
             SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => {
                 match kind {
                     WindowKind::Single => {
-                        BORDER_COLOUR_SINGLE.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
-                        BORDER_COLOUR_CURRENT.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                        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(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                        BORDER_COLOUR_STACK.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
                     }
                     WindowKind::Monocle => {
-                        BORDER_COLOUR_MONOCLE.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                        BORDER_COLOUR_MONOCLE.store(r | (g << 8) | (b << 16), Ordering::SeqCst);
                     }
                 }
 
@@ -1266,11 +1252,21 @@ impl WindowManager {
                 WindowsApi::invalidate_border_rect()?;
             }
             SocketMessage::ActiveWindowBorderOffset(offset) => {
-                BORDER_OFFSET.store(offset, Ordering::SeqCst);
+                let mut current_border_offset = BORDER_OFFSET.lock();
+
+                let new_border_offset = Rect {
+                    left: offset,
+                    top: offset,
+                    right: offset * 2,
+                    bottom: offset * 2,
+                };
+
+                *current_border_offset = Option::from(new_border_offset);
+
                 WindowsApi::invalidate_border_rect()?;
             }
-            SocketMessage::AltFocusHack(_) => {
-                tracing::info!("this action is deprecated");
+            SocketMessage::AltFocusHack(enable) => {
+                ALT_FOCUS_HACK.store(enable, Ordering::SeqCst);
             }
             SocketMessage::ApplicationSpecificConfigurationSchema => {
                 let asc = schema_for!(Vec<ApplicationConfiguration>);
@@ -1393,6 +1389,9 @@ impl WindowManager {
             | SocketMessage::FocusWorkspaceNumber(_) => {
                 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 monocle = BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst);
                 if monocle != 0 && self.focused_workspace()?.monocle_container().is_some() {
@@ -1402,18 +1401,14 @@ impl WindowManager {
                     );
                 }
 
-                // it is not acceptable to fail here; we need to be able to send the event to
-                // subscribers
-                if self.focused_container().is_ok() {
-                    let stack = BORDER_COLOUR_STACK.load(Ordering::SeqCst);
-                    if stack != 0 && self.focused_container()?.windows().len() > 1 {
-                        BORDER_COLOUR_CURRENT
-                            .store(stack, Ordering::SeqCst);
-                    }
+                let stack = BORDER_COLOUR_STACK.load(Ordering::SeqCst);
+                if stack != 0 && self.focused_container()?.windows().len() > 1 {
+                    BORDER_COLOUR_CURRENT
+                        .store(stack, Ordering::SeqCst);
                 }
 
                 let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-                border.set_position(foreground_window, false)?;
+                border.set_position(foreground_window, &self.invisible_borders, false)?;
             }
             SocketMessage::TogglePause => {
                 let is_paused = self.is_paused;
@@ -1423,7 +1418,7 @@ impl WindowManager {
                     border.hide()?;
                 } else {
                     let focused = self.focused_window()?;
-                    border.set_position(*focused, true)?;
+                    border.set_position(*focused, &self.invisible_borders, true)?;
                     focused.focus(false)?;
                 }
             }
@@ -1433,7 +1428,7 @@ impl WindowManager {
 
                 if tiling_enabled {
                     let focused = self.focused_window()?;
-                    border.set_position(*focused, true)?;
+                    border.set_position(*focused, &self.invisible_borders, true)?;
                     focused.focus(false)?;
                 } else {
                     border.hide()?;

komorebi/src/process_event.rs

@@ -28,8 +28,6 @@ use crate::BORDER_COLOUR_STACK;
 use crate::BORDER_ENABLED;
 use crate::BORDER_HIDDEN;
 use crate::BORDER_HWND;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
@@ -37,7 +35,7 @@ use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 
 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
-    let receiver = wm.lock().incoming_events.clone();
+    let receiver = wm.lock().incoming_events.lock().clone();
 
     std::thread::spawn(move || {
         tracing::info!("listening");
@@ -111,6 +109,7 @@ impl WindowManager {
             _ => {}
         }
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
 
         for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
@@ -124,7 +123,7 @@ impl WindowManager {
             for (j, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
                 let reaped_orphans = workspace.reap_orphans()?;
                 if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
-                    workspace.update(&work_area, offset)?;
+                    workspace.update(&work_area, offset, &invisible_borders)?;
                     tracing::info!(
                         "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                         reaped_orphans.0,
@@ -147,7 +146,7 @@ impl WindowManager {
 
         match event {
             WindowManagerEvent::Raise(window) => {
-                window.focus(false)?;
+                window.raise();
                 self.has_pending_raise_op = false;
             }
             WindowManagerEvent::Destroy(_, window) | WindowManagerEvent::Unmanage(window) => {
@@ -187,7 +186,6 @@ impl WindowManager {
                     let title = &window.title()?;
                     let exe_name = &window.exe()?;
                     let class = &window.class()?;
-                    let path = &window.path()?;
 
                     // We don't want to purge windows that have been deliberately hidden by us, eg. when
                     // they are not on the top of a container stack.
@@ -196,7 +194,6 @@ impl WindowManager {
                         title,
                         exe_name,
                         class,
-                        path,
                         &tray_and_multi_window_identifiers,
                         &regex_identifiers,
                     );
@@ -306,24 +303,21 @@ impl WindowManager {
                 }
             }
             WindowManagerEvent::MoveResizeStart(_, window) => {
-                if *self.focused_workspace()?.tile() {
-                    let monitor_idx = self.focused_monitor_idx();
-                    let workspace_idx = self
-                        .focused_monitor()
-                        .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
-                        .focused_workspace_idx();
-                    let container_idx = self
-                        .focused_monitor()
-                        .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
-                        .focused_workspace()
-                        .ok_or_else(|| anyhow!("there is no workspace with this idx"))?
-                        .focused_container_idx();
+                let monitor_idx = self.focused_monitor_idx();
+                let workspace_idx = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
+                    .focused_workspace_idx();
+                let container_idx = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
+                    .focused_workspace()
+                    .ok_or_else(|| anyhow!("there is no workspace with this idx"))?
+                    .focused_container_idx();
 
-                    WindowsApi::bring_window_to_top(window.hwnd())?;
+                WindowsApi::bring_window_to_top(window.hwnd())?;
 
-                    self.pending_move_op =
-                        Option::from((monitor_idx, workspace_idx, container_idx));
-                }
+                self.pending_move_op = Option::from((monitor_idx, workspace_idx, container_idx));
             }
             WindowManagerEvent::MoveResizeEnd(_, window) => {
                 // We need this because if the event ends on a different monitor,
@@ -337,6 +331,7 @@ 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
@@ -346,7 +341,7 @@ impl WindowManager {
                 {
                     let focused_container_idx = workspace.focused_container_idx();
 
-                    let new_position = WindowsApi::window_rect(window.hwnd())?;
+                    let mut new_position = WindowsApi::window_rect(window.hwnd())?;
 
                     let old_position = *workspace
                         .latest_layout()
@@ -371,6 +366,12 @@ impl WindowManager {
                         }
                     }
 
+                    // 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,
@@ -380,14 +381,10 @@ impl WindowManager {
 
                     // If we have moved across the monitors, use that override, otherwise determine
                     // if a move has taken place by ruling out a resize
-                    let right_bottom_constant = ((BORDER_WIDTH.load(Ordering::SeqCst)
-                        + BORDER_OFFSET.load(Ordering::SeqCst))
-                        * 2)
-                    .abs();
-
                     let is_move = moved_across_monitors
-                        || resize.right.abs() == right_bottom_constant
-                            && resize.bottom.abs() == right_bottom_constant;
+                        || 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");
@@ -479,17 +476,17 @@ impl WindowManager {
                         let mut ops = vec![];
 
                         macro_rules! resize_op {
-                            ($coordinate:expr, $comparator:tt, $direction:expr) => {{
-                                let adjusted = $coordinate * 2;
-                                let sizing = if adjusted $comparator 0 {
-                                    Sizing::Decrease
-                                } else {
-                                    Sizing::Increase
-                                };
+                        ($coordinate:expr, $comparator:tt, $direction:expr) => {{
+                            let adjusted = $coordinate * 2;
+                            let sizing = if adjusted $comparator 0 {
+                                Sizing::Decrease
+                            } else {
+                                Sizing::Increase
+                            };
 
-                                ($direction, sizing, adjusted.abs())
-                            }};
-                        }
+                            ($direction, sizing, adjusted.abs())
+                        }};
+                    }
 
                         if resize.left != 0 {
                             ops.push(resize_op!(resize.left, >, OperationDirection::Left));
@@ -499,14 +496,11 @@ impl WindowManager {
                             ops.push(resize_op!(resize.top, >, OperationDirection::Up));
                         }
 
-                        let top_left_constant = BORDER_WIDTH.load(Ordering::SeqCst)
-                            + BORDER_OFFSET.load(Ordering::SeqCst);
-
-                        if resize.right != 0 && resize.left == top_left_constant {
+                        if resize.right != 0 && resize.left == 0 {
                             ops.push(resize_op!(resize.right, <, OperationDirection::Right));
                         }
 
-                        if resize.bottom != 0 && resize.top == top_left_constant {
+                        if resize.bottom != 0 && resize.top == 0 {
                             ops.push(resize_op!(resize.bottom, <, OperationDirection::Down));
                         }
 
@@ -524,12 +518,6 @@ impl WindowManager {
             | WindowManagerEvent::Uncloak(..) => {}
         };
 
-        if !self.focused_workspace()?.tile() {
-            let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
-            border.hide()?;
-            BORDER_HIDDEN.store(true, Ordering::SeqCst);
-        }
-
         if *self.focused_workspace()?.tile() && BORDER_ENABLED.load(Ordering::SeqCst) {
             match event {
                 WindowManagerEvent::MoveResizeStart(_, _) => {
@@ -541,7 +529,6 @@ impl WindowManager {
                 | WindowManagerEvent::Show(_, window)
                 | WindowManagerEvent::FocusChange(_, window)
                 | WindowManagerEvent::Hide(_, window)
-                | WindowManagerEvent::Uncloak(_, window)
                 | WindowManagerEvent::Minimize(_, window) => {
                     let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
                     let mut target_window = None;
@@ -598,10 +585,15 @@ impl WindowManager {
                     }
 
                     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, activate)?;
+                        border.set_position(target_window, &self.invisible_borders, activate)?;
 
                         if activate {
                             BORDER_HIDDEN.store(false, Ordering::SeqCst);
@@ -614,7 +606,7 @@ impl WindowManager {
 
         // 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()?)?;
+            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

komorebi/src/static_config.rs

@@ -1,5 +1,4 @@
 use crate::border::Border;
-use crate::colour::Colour;
 use crate::current_virtual_desktop;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
@@ -29,16 +28,13 @@ use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
-
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
-use hotwatch::EventKind;
+use hotwatch::notify::DebouncedEvent;
 use hotwatch::Hotwatch;
-use komorebi_core::config_generation::ApplicationConfiguration;
 use komorebi_core::config_generation::ApplicationConfigurationGenerator;
 use komorebi_core::config_generation::ApplicationOptions;
 use komorebi_core::config_generation::IdWithIdentifier;
-use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::resolve_home_path;
 use komorebi_core::ApplicationIdentifier;
@@ -66,14 +62,34 @@ use std::sync::Arc;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct Rgb {
+    /// Red
+    pub r: u32,
+    /// Green
+    pub g: u32,
+    /// Blue
+    pub b: u32,
+}
+
+impl From<u32> for Rgb {
+    fn from(value: u32) -> Self {
+        Self {
+            r: value & 0xff,
+            g: value >> 8 & 0xff,
+            b: value >> 16 & 0xff,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct ActiveWindowBorderColours {
     /// Border colour when the container contains a single window
-    pub single: Colour,
+    pub single: Rgb,
     /// Border colour when the container contains multiple windows
-    pub stack: Colour,
+    pub stack: Rgb,
     /// Border colour when the container is in monocle mode
-    pub monocle: Colour,
+    pub monocle: Rgb,
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -216,7 +232,7 @@ impl From<&Monitor> for MonitorConfig {
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 /// The `komorebi.json` static configuration file reference for `v0.1.20`
 pub struct StaticConfig {
-    /// DEPRECATED from v0.1.22: no longer required
+    /// Dimensions of Windows' own invisible borders; don't set these yourself unless you are told to
     #[serde(skip_serializing_if = "Option::is_none")]
     pub invisible_borders: Option<Rect>,
     /// Delta to resize windows by (default 50)
@@ -240,14 +256,12 @@ pub struct StaticConfig {
     /// Path to applications.yaml from komorebi-application-specific-configurations (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub app_specific_configuration_path: Option<PathBuf>,
-    /// Width of the window border (default: 8)
+    /// Width of the active window border (default: 20)
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border_width")]
-    pub border_width: Option<i32>,
-    /// Offset of the window border (default: -1)
+    pub active_window_border_width: Option<i32>,
+    /// Offset of the active window border (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border_offset")]
-    pub border_offset: Option<i32>,
+    pub active_window_border_offset: Option<i32>,
     /// Display an active window border (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub active_window_border: Option<bool>,
@@ -263,6 +277,10 @@ pub struct StaticConfig {
     /// Monitor and workspace configurations
     #[serde(skip_serializing_if = "Option::is_none")]
     pub monitors: Option<Vec<MonitorConfig>>,
+    /// DEPRECATED from v0.1.20: no longer required
+    #[schemars(skip)]
+    #[serde(skip_serializing)]
+    pub alt_focus_hack: Option<bool>,
     /// Which Windows signal to use when hiding windows (default: minimize)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_hiding_behaviour: Option<HidingBehaviour>,
@@ -271,22 +289,22 @@ pub struct StaticConfig {
     pub global_work_area_offset: Option<Rect>,
     /// Individual window floating rules
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub float_rules: Option<Vec<MatchingRule>>,
+    pub float_rules: Option<Vec<IdWithIdentifier>>,
     /// Individual window force-manage rules
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub manage_rules: Option<Vec<MatchingRule>>,
+    pub manage_rules: Option<Vec<IdWithIdentifier>>,
     /// Identify border overflow applications
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub border_overflow_applications: Option<Vec<MatchingRule>>,
+    pub border_overflow_applications: Option<Vec<IdWithIdentifier>>,
     /// Identify tray and multi-window applications
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub tray_and_multi_window_applications: Option<Vec<MatchingRule>>,
+    pub tray_and_multi_window_applications: Option<Vec<IdWithIdentifier>>,
     /// Identify applications that have the WS_EX_LAYERED extended window style
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub layered_applications: Option<Vec<MatchingRule>>,
+    pub layered_applications: Option<Vec<IdWithIdentifier>>,
     /// Identify applications that send EVENT_OBJECT_NAMECHANGE on launch (very rare)
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub object_name_change_applications: Option<Vec<MatchingRule>>,
+    pub object_name_change_applications: Option<Vec<IdWithIdentifier>>,
     /// Set monitor index preferences
     #[serde(skip_serializing_if = "Option::is_none")]
     pub monitor_index_preferences: Option<HashMap<usize, Rect>>,
@@ -298,6 +316,13 @@ pub struct StaticConfig {
 impl From<&WindowManager> for StaticConfig {
     #[allow(clippy::too_many_lines)]
     fn from(value: &WindowManager) -> Self {
+        let default_invisible_borders = Rect {
+            left: 7,
+            top: 0,
+            right: 14,
+            bottom: 7,
+        };
+
         let mut monitors = vec![];
         for m in value.monitors() {
             monitors.push(MonitorConfig::from(m));
@@ -352,13 +377,13 @@ impl From<&WindowManager> for StaticConfig {
             None
         } else {
             Option::from(ActiveWindowBorderColours {
-                single: Colour::from(BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)),
-                stack: Colour::from(if BORDER_COLOUR_STACK.load(Ordering::SeqCst) == 0 {
+                single: Rgb::from(BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)),
+                stack: Rgb::from(if BORDER_COLOUR_STACK.load(Ordering::SeqCst) == 0 {
                     BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)
                 } else {
                     BORDER_COLOUR_STACK.load(Ordering::SeqCst)
                 }),
-                monocle: Colour::from(if BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst) == 0 {
+                monocle: Rgb::from(if BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst) == 0 {
                     BORDER_COLOUR_SINGLE.load(Ordering::SeqCst)
                 } else {
                     BORDER_COLOUR_MONOCLE.load(Ordering::SeqCst)
@@ -367,7 +392,11 @@ impl From<&WindowManager> for StaticConfig {
         };
 
         Self {
-            invisible_borders: None,
+            invisible_borders: if value.invisible_borders == default_invisible_borders {
+                None
+            } else {
+                Option::from(value.invisible_borders)
+            },
             resize_delta: Option::from(value.resize_delta),
             window_container_behaviour: Option::from(value.window_container_behaviour),
             cross_monitor_move_behaviour: Option::from(value.cross_monitor_move_behaviour),
@@ -377,8 +406,10 @@ impl From<&WindowManager> for StaticConfig {
             focus_follows_mouse: value.focus_follows_mouse,
             mouse_follows_focus: Option::from(value.mouse_follows_focus),
             app_specific_configuration_path: None,
-            border_width: Option::from(BORDER_WIDTH.load(Ordering::SeqCst)),
-            border_offset: Option::from(BORDER_OFFSET.load(Ordering::SeqCst)),
+            active_window_border_width: Option::from(BORDER_WIDTH.load(Ordering::SeqCst)),
+            active_window_border_offset: BORDER_OFFSET
+                .lock()
+                .map_or(None, |offset| Option::from(offset.left)),
             active_window_border: Option::from(BORDER_ENABLED.load(Ordering::SeqCst)),
             active_window_border_colours: border_colours,
             default_workspace_padding: Option::from(
@@ -388,6 +419,7 @@ impl From<&WindowManager> for StaticConfig {
                 DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst),
             ),
             monitors: Option::from(monitors),
+            alt_focus_hack: None,
             window_hiding_behaviour: Option::from(*HIDING_BEHAVIOUR.lock()),
             global_work_area_offset: value.work_area_offset,
             float_rules: None,
@@ -428,22 +460,49 @@ impl StaticConfig {
             DEFAULT_WORKSPACE_PADDING.store(workspace, Ordering::SeqCst);
         }
 
-        self.border_width.map_or_else(
+        self.active_window_border_width.map_or_else(
             || {
-                BORDER_WIDTH.store(8, Ordering::SeqCst);
+                BORDER_WIDTH.store(20, Ordering::SeqCst);
             },
             |width| {
                 BORDER_WIDTH.store(width, Ordering::SeqCst);
             },
         );
+        self.active_window_border_offset.map_or_else(
+            || {
+                let mut border_offset = BORDER_OFFSET.lock();
+                *border_offset = None;
+            },
+            |offset| {
+                let new_border_offset = Rect {
+                    left: offset,
+                    top: offset,
+                    right: offset * 2,
+                    bottom: offset * 2,
+                };
 
-        BORDER_OFFSET.store(self.border_offset.unwrap_or(-1), Ordering::SeqCst);
+                let mut border_offset = BORDER_OFFSET.lock();
+                *border_offset = Some(new_border_offset);
+            },
+        );
 
         if let Some(colours) = &self.active_window_border_colours {
-            BORDER_COLOUR_SINGLE.store(u32::from(colours.single), Ordering::SeqCst);
-            BORDER_COLOUR_CURRENT.store(u32::from(colours.single), Ordering::SeqCst);
-            BORDER_COLOUR_STACK.store(u32::from(colours.stack), Ordering::SeqCst);
-            BORDER_COLOUR_MONOCLE.store(u32::from(colours.monocle), Ordering::SeqCst);
+            BORDER_COLOUR_SINGLE.store(
+                colours.single.r | (colours.single.g << 8) | (colours.single.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_CURRENT.store(
+                colours.single.r | (colours.single.g << 8) | (colours.single.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_STACK.store(
+                colours.stack.r | (colours.stack.g << 8) | (colours.stack.b << 16),
+                Ordering::SeqCst,
+            );
+            BORDER_COLOUR_MONOCLE.store(
+                colours.monocle.r | (colours.monocle.g << 8) | (colours.monocle.b << 16),
+                Ordering::SeqCst,
+            );
         }
 
         let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
@@ -454,40 +513,106 @@ impl StaticConfig {
         let mut object_name_change_identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
         let mut layered_identifiers = LAYERED_WHITELIST.lock();
 
-        if let Some(rules) = &mut self.float_rules {
-            populate_rules(rules, &mut float_identifiers, &mut regex_identifiers)?;
+        if let Some(float) = &mut self.float_rules {
+            for identifier in float {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !float_identifiers.contains(identifier) {
+                    float_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
         }
 
-        if let Some(rules) = &mut self.manage_rules {
-            populate_rules(rules, &mut manage_identifiers, &mut regex_identifiers)?;
+        if let Some(manage) = &mut self.manage_rules {
+            for identifier in manage {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !manage_identifiers.contains(identifier) {
+                    manage_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
         }
 
-        if let Some(rules) = &mut self.object_name_change_applications {
-            populate_rules(
-                rules,
-                &mut object_name_change_identifiers,
-                &mut regex_identifiers,
-            )?;
+        if let Some(identifiers) = &mut self.object_name_change_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !object_name_change_identifiers.contains(identifier) {
+                    object_name_change_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
         }
 
-        if let Some(rules) = &mut self.layered_applications {
-            populate_rules(rules, &mut layered_identifiers, &mut regex_identifiers)?;
+        if let Some(identifiers) = &mut self.layered_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !layered_identifiers.contains(identifier) {
+                    layered_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
         }
 
-        if let Some(rules) = &mut self.border_overflow_applications {
-            populate_rules(
-                rules,
-                &mut border_overflow_identifiers,
-                &mut regex_identifiers,
-            )?;
+        if let Some(identifiers) = &mut self.border_overflow_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !border_overflow_identifiers.contains(identifier) {
+                    border_overflow_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
         }
 
-        if let Some(rules) = &mut self.tray_and_multi_window_applications {
-            populate_rules(
-                rules,
-                &mut tray_and_multi_window_identifiers,
-                &mut regex_identifiers,
-            )?;
+        if let Some(identifiers) = &mut self.tray_and_multi_window_applications {
+            for identifier in identifiers {
+                if identifier.matching_strategy.is_none() {
+                    identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
+                }
+
+                if !tray_and_multi_window_identifiers.contains(identifier) {
+                    tray_and_multi_window_identifiers.push(identifier.clone());
+
+                    if matches!(identifier.matching_strategy, Some(MatchingStrategy::Regex)) {
+                        let re = Regex::new(&identifier.id)?;
+                        regex_identifiers.insert(identifier.id.clone(), re);
+                    }
+                }
+            }
         }
 
         if let Some(path) = &self.app_specific_configuration_path {
@@ -496,48 +621,120 @@ impl StaticConfig {
             let asc = ApplicationConfigurationGenerator::load(&content)?;
 
             for mut entry in asc {
-                if let Some(rules) = &mut entry.float_identifiers {
-                    populate_rules(rules, &mut float_identifiers, &mut regex_identifiers)?;
-                }
+                if let Some(float) = entry.float_identifiers {
+                    for f in float {
+                        let mut without_comment: IdWithIdentifier = f.into();
+                        if without_comment.matching_strategy.is_none() {
+                            without_comment.matching_strategy =
+                                Option::from(MatchingStrategy::Legacy);
+                        }
 
-                if let Some(ref options) = entry.options {
-                    let options = options.clone();
+                        if !float_identifiers.contains(&without_comment) {
+                            float_identifiers.push(without_comment.clone());
+
+                            if matches!(
+                                without_comment.matching_strategy,
+                                Some(MatchingStrategy::Regex)
+                            ) {
+                                let re = Regex::new(&without_comment.id)?;
+                                regex_identifiers.insert(without_comment.id.clone(), re);
+                            }
+                        }
+                    }
+                }
+                if let Some(options) = entry.options {
                     for o in options {
                         match o {
                             ApplicationOptions::ObjectNameChange => {
-                                populate_option(
-                                    &mut entry,
-                                    &mut object_name_change_identifiers,
-                                    &mut regex_identifiers,
-                                )?;
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !object_name_change_identifiers.contains(&entry.identifier) {
+                                    object_name_change_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
                             }
                             ApplicationOptions::Layered => {
-                                populate_option(
-                                    &mut entry,
-                                    &mut layered_identifiers,
-                                    &mut regex_identifiers,
-                                )?;
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !layered_identifiers.contains(&entry.identifier) {
+                                    layered_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
                             }
                             ApplicationOptions::BorderOverflow => {
-                                populate_option(
-                                    &mut entry,
-                                    &mut border_overflow_identifiers,
-                                    &mut regex_identifiers,
-                                )?;
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !border_overflow_identifiers.contains(&entry.identifier) {
+                                    border_overflow_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
                             }
                             ApplicationOptions::TrayAndMultiWindow => {
-                                populate_option(
-                                    &mut entry,
-                                    &mut tray_and_multi_window_identifiers,
-                                    &mut regex_identifiers,
-                                )?;
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !tray_and_multi_window_identifiers.contains(&entry.identifier) {
+                                    tray_and_multi_window_identifiers
+                                        .push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
                             }
                             ApplicationOptions::Force => {
-                                populate_option(
-                                    &mut entry,
-                                    &mut manage_identifiers,
-                                    &mut regex_identifiers,
-                                )?;
+                                if entry.identifier.matching_strategy.is_none() {
+                                    entry.identifier.matching_strategy =
+                                        Option::from(MatchingStrategy::Legacy);
+                                }
+
+                                if !manage_identifiers.contains(&entry.identifier) {
+                                    manage_identifiers.push(entry.identifier.clone());
+
+                                    if matches!(
+                                        entry.identifier.matching_strategy,
+                                        Some(MatchingStrategy::Regex)
+                                    ) {
+                                        let re = Regex::new(&entry.identifier.id)?;
+                                        regex_identifiers.insert(entry.identifier.id.clone(), re);
+                                    }
+                                }
                             }
                         }
                     }
@@ -551,7 +748,7 @@ impl StaticConfig {
     #[allow(clippy::too_many_lines)]
     pub fn preload(
         path: &PathBuf,
-        incoming: Receiver<WindowManagerEvent>,
+        incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>,
     ) -> Result<WindowManager> {
         let content = std::fs::read_to_string(path)?;
         let mut value: Self = serde_json::from_str(&content)?;
@@ -578,6 +775,12 @@ impl StaticConfig {
             incoming_events: incoming,
             command_listener: listener,
             is_paused: false,
+            invisible_borders: value.invisible_borders.unwrap_or(Rect {
+                left: 7,
+                top: 0,
+                right: 14,
+                bottom: 7,
+            }),
             virtual_desktop_id: current_virtual_desktop(),
             work_area_offset: value.global_work_area_offset,
             window_container_behaviour: value
@@ -608,10 +811,10 @@ impl StaticConfig {
 
         let bytes = SocketMessage::ReloadStaticConfiguration(path.clone()).as_bytes()?;
 
-        wm.hotwatch.watch(path, move |event| match event.kind {
+        wm.hotwatch.watch(path, move |event| match event {
             // Editing in Notepad sends a NoticeWrite while editing in (Neo)Vim sends
             // a NoticeRemove, presumably because of the use of swap files?
-            EventKind::Modify(_) | EventKind::Remove(_) => {
+            DebouncedEvent::NoticeWrite(_) | DebouncedEvent::NoticeRemove(_) => {
                 let socket = DATA_DIR.join("komorebi.sock");
                 let mut stream =
                     UnixStream::connect(socket).expect("could not connect to komorebi.sock");
@@ -724,6 +927,10 @@ impl StaticConfig {
             wm.hide_border()?;
         }
 
+        if let Some(val) = value.invisible_borders {
+            wm.invisible_borders = val;
+        }
+
         if let Some(val) = value.window_container_behaviour {
             wm.window_container_behaviour = val;
         }
@@ -756,76 +963,6 @@ impl StaticConfig {
 
         wm.focus_follows_mouse = value.focus_follows_mouse;
 
-        let monitor_count = wm.monitors().len();
-
-        for i in 0..monitor_count {
-            wm.update_focused_workspace_by_monitor_idx(i)?;
-        }
-
         Ok(())
     }
 }
-
-fn populate_option(
-    entry: &mut ApplicationConfiguration,
-    identifiers: &mut Vec<MatchingRule>,
-    regex_identifiers: &mut HashMap<String, Regex>,
-) -> Result<()> {
-    if entry.identifier.matching_strategy.is_none() {
-        entry.identifier.matching_strategy = Option::from(MatchingStrategy::Legacy);
-    }
-
-    let rule = MatchingRule::Simple(entry.identifier.clone());
-
-    if !identifiers.contains(&rule) {
-        identifiers.push(rule);
-
-        if matches!(
-            entry.identifier.matching_strategy,
-            Some(MatchingStrategy::Regex)
-        ) {
-            let re = Regex::new(&entry.identifier.id)?;
-            regex_identifiers.insert(entry.identifier.id.clone(), re);
-        }
-    }
-
-    Ok(())
-}
-
-fn populate_rules(
-    matching_rules: &mut Vec<MatchingRule>,
-    identifiers: &mut Vec<MatchingRule>,
-    regex_identifiers: &mut HashMap<String, Regex>,
-) -> Result<()> {
-    for matching_rule in matching_rules {
-        if !identifiers.contains(matching_rule) {
-            match matching_rule {
-                MatchingRule::Simple(simple) => {
-                    if simple.matching_strategy.is_none() {
-                        simple.matching_strategy = Option::from(MatchingStrategy::Legacy);
-                    }
-
-                    if matches!(simple.matching_strategy, Some(MatchingStrategy::Regex)) {
-                        let re = Regex::new(&simple.id)?;
-                        regex_identifiers.insert(simple.id.clone(), re);
-                    }
-                }
-                MatchingRule::Composite(composite) => {
-                    for rule in composite {
-                        if rule.matching_strategy.is_none() {
-                            rule.matching_strategy = Option::from(MatchingStrategy::Legacy);
-                        }
-
-                        if matches!(rule.matching_strategy, Some(MatchingStrategy::Regex)) {
-                            let re = Regex::new(&rule.id)?;
-                            regex_identifiers.insert(rule.id.clone(), re);
-                        }
-                    }
-                }
-            }
-            identifiers.push(matching_rule.clone());
-        }
-    }
-
-    Ok(())
-}

komorebi/src/window.rs

@@ -4,13 +4,12 @@ use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::fmt::Write as _;
-use std::time::Duration;
+use std::sync::atomic::Ordering;
 
 use color_eyre::eyre;
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use komorebi_core::config_generation::IdWithIdentifier;
-use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use regex::Regex;
 use schemars::JsonSchema;
@@ -20,6 +19,9 @@ use serde::Deserialize;
 use serde::Serialize;
 use serde::Serializer;
 use windows::Win32::Foundation::HWND;
+use winput::press;
+use winput::release;
+use winput::Vk;
 
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
@@ -29,6 +31,8 @@ use crate::styles::ExtendedWindowStyle;
 use crate::styles::WindowStyle;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
+use crate::ALT_FOCUS_HACK;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::FLOAT_IDENTIFIERS;
 use crate::HIDDEN_HWNDS;
 use crate::HIDING_BEHAVIOUR;
@@ -125,7 +129,7 @@ impl Window {
         HWND(self.hwnd)
     }
 
-    pub fn center(&mut self, work_area: &Rect) -> Result<()> {
+    pub fn center(&mut self, work_area: &Rect, invisible_borders: &Rect) -> Result<()> {
         let half_width = work_area.right / 2;
         let half_weight = work_area.bottom / 2;
 
@@ -136,23 +140,45 @@ impl Window {
                 right: half_width,
                 bottom: half_weight,
             },
+            invisible_borders,
             true,
         )
     }
 
-    pub fn set_position(&mut self, layout: &Rect, top: bool) -> Result<()> {
-        let rect = *layout;
+    pub fn set_position(
+        &mut self,
+        layout: &Rect,
+        invisible_borders: &Rect,
+        top: bool,
+    ) -> Result<()> {
+        let mut rect = *layout;
+
+        let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
+        let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
+        let title = &self.title()?;
+        let class = &self.class()?;
+        let exe_name = &self.exe()?;
+
+        let should_remove_border = !should_act(
+            title,
+            exe_name,
+            class,
+            &border_overflows,
+            &regex_identifiers,
+        );
+
+        if should_remove_border {
+            // Remove the invisible borders
+            rect.left -= invisible_borders.left;
+            rect.top -= invisible_borders.top;
+            rect.right += invisible_borders.right;
+            rect.bottom += invisible_borders.bottom;
+        }
+
         WindowsApi::position_window(self.hwnd(), &rect, top)
     }
 
-    pub fn is_maximized(self) -> bool {
-        WindowsApi::is_zoomed(self.hwnd())
-    }
-
-    pub fn is_miminized(self) -> bool {
-        WindowsApi::is_iconic(self.hwnd())
-    }
-
     pub fn hide(self) {
         let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
         if !programmatically_hidden_hwnds.contains(&self.hwnd) {
@@ -217,6 +243,57 @@ impl Window {
         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();
+
+        // 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 raise(): {}",
+                    error
+                );
+            }
+        };
+
+        // This isn't really needed when the above command works as expected via AHK
+        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());
@@ -240,7 +317,12 @@ impl Window {
         let mut tried_resetting_foreground_access = false;
         let mut max_attempts = 10;
 
+        let hotkey_uses_alt = WindowsApi::alt_is_pressed();
         while !foregrounded && max_attempts > 0 {
+            if ALT_FOCUS_HACK.load(Ordering::SeqCst) {
+                press(Vk::Alt);
+            }
+
             match WindowsApi::set_foreground_window(self.hwnd()) {
                 Ok(()) => {
                     foregrounded = true;
@@ -261,6 +343,10 @@ impl Window {
                     }
                 }
             };
+
+            if ALT_FOCUS_HACK.load(Ordering::SeqCst) && !hotkey_uses_alt {
+                release(Vk::Alt);
+            }
         }
 
         // Center cursor in Window
@@ -328,14 +414,6 @@ impl Window {
         WindowsApi::window_text_w(self.hwnd())
     }
 
-    pub fn path(self) -> Result<String> {
-        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd());
-        let handle = WindowsApi::process_handle(process_id)?;
-        let path = WindowsApi::exe_path(handle);
-        WindowsApi::close_process(handle)?;
-        path
-    }
-
     pub fn exe(self) -> Result<String> {
         let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd());
         let handle = WindowsApi::process_handle(process_id)?;
@@ -399,8 +477,8 @@ impl Window {
             (true, _) |
             // 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), Ok(path)) = (self.title(), self.exe(), self.class(), self.path()) {
-                    return Ok(window_is_eligible(&title, &exe_name, &class, &path, &self.style()?, &self.ex_style()?, event));
+                if let (Ok(title), Ok(exe_name), Ok(class)) = (self.title(), self.exe(), self.class()) {
+                    return Ok(window_is_eligible(&title, &exe_name, &class, &self.style()?, &self.ex_style()?, event));
                 }
             }
             _ => {}
@@ -414,7 +492,6 @@ fn window_is_eligible(
     title: &String,
     exe_name: &String,
     class: &String,
-    path: &str,
     style: &WindowStyle,
     ex_style: &ExtendedWindowStyle,
     event: Option<WindowManagerEvent>,
@@ -433,7 +510,6 @@ fn window_is_eligible(
         title,
         exe_name,
         class,
-        path,
         &float_identifiers,
         &regex_identifiers,
     );
@@ -443,7 +519,6 @@ fn window_is_eligible(
         title,
         exe_name,
         class,
-        path,
         &manage_identifiers,
         &regex_identifiers,
     );
@@ -457,7 +532,6 @@ fn window_is_eligible(
         title,
         exe_name,
         class,
-        path,
         &layered_whitelist,
         &regex_identifiers,
     );
@@ -475,10 +549,6 @@ fn window_is_eligible(
         titlebars_removed.contains(exe_name)
     };
 
-    if exe_name.contains("firefox") {
-        std::thread::sleep(Duration::from_millis(10));
-    }
-
     if (allow_wsl2_gui || allow_titlebar_removed || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))
                         && !ex_style.contains(ExtendedWindowStyle::DLGMODALFRAME)
                         // Get a lot of dupe events coming through that make the redrawing go crazy
@@ -489,13 +559,8 @@ fn window_is_eligible(
         || managed_override
     {
         return true;
-    } else if let Some(event) = event {
-        tracing::debug!(
-            "ignoring (exe: {}, title: {}, event: {})",
-            exe_name,
-            title,
-            event
-        );
+    } else if event.is_some() {
+        tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
     }
 
     false
@@ -506,204 +571,125 @@ pub fn should_act(
     title: &str,
     exe_name: &str,
     class: &str,
-    path: &str,
-    identifiers: &[MatchingRule],
+    identifiers: &[IdWithIdentifier],
     regex_identifiers: &HashMap<String, Regex>,
 ) -> bool {
     let mut should_act = false;
     for identifier in identifiers {
-        match identifier {
-            MatchingRule::Simple(identifier) => {
-                if should_act_individual(
-                    title,
-                    exe_name,
-                    class,
-                    path,
-                    identifier,
-                    regex_identifiers,
-                ) {
-                    should_act = true
-                };
+        match identifier.matching_strategy {
+            None => {
+                panic!("there is no matching strategy identified for this rule");
             }
-            MatchingRule::Composite(identifiers) => {
-                let mut composite_results = vec![];
-                for identifier in identifiers {
-                    composite_results.push(should_act_individual(
-                        title,
-                        exe_name,
-                        class,
-                        path,
-                        identifier,
-                        regex_identifiers,
-                    ));
+            Some(MatchingStrategy::Legacy) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.starts_with(&identifier.id) || title.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
                 }
-
-                if composite_results.iter().all(|&x| x) {
-                    should_act = true;
+                ApplicationIdentifier::Class => {
+                    if class.starts_with(&identifier.id) || class.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
                 }
-            }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::Equals) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.eq(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::StartsWith) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.starts_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.starts_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.starts_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::EndsWith) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.ends_with(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::Contains) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if title.contains(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if class.contains(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if exe_name.contains(&identifier.id) {
+                        should_act = true;
+                    }
+                }
+            },
+            Some(MatchingStrategy::Regex) => match identifier.kind {
+                ApplicationIdentifier::Title => {
+                    if let Some(re) = regex_identifiers.get(&identifier.id) {
+                        if re.is_match(title) {
+                            should_act = true;
+                        }
+                    }
+                }
+                ApplicationIdentifier::Class => {
+                    if let Some(re) = regex_identifiers.get(&identifier.id) {
+                        if re.is_match(class) {
+                            should_act = true;
+                        }
+                    }
+                }
+                ApplicationIdentifier::Exe => {
+                    if let Some(re) = regex_identifiers.get(&identifier.id) {
+                        if re.is_match(exe_name) {
+                            should_act = true;
+                        }
+                    }
+                }
+            },
         }
     }
 
     should_act
 }
-
-#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
-pub fn should_act_individual(
-    title: &str,
-    exe_name: &str,
-    class: &str,
-    path: &str,
-    identifier: &IdWithIdentifier,
-    regex_identifiers: &HashMap<String, Regex>,
-) -> bool {
-    let mut should_act = false;
-
-    match identifier.matching_strategy {
-        None => {
-            panic!("there is no matching strategy identified for this rule");
-        }
-        Some(MatchingStrategy::Legacy) => match identifier.kind {
-            ApplicationIdentifier::Title => {
-                if title.starts_with(&identifier.id) || title.ends_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Class => {
-                if class.starts_with(&identifier.id) || class.ends_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Exe => {
-                if exe_name.eq(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Path => {
-                if path.eq(&identifier.id) {
-                    should_act = true;
-                }
-            }
-        },
-        Some(MatchingStrategy::Equals) => match identifier.kind {
-            ApplicationIdentifier::Title => {
-                if title.eq(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Class => {
-                if class.eq(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Exe => {
-                if exe_name.eq(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Path => {
-                if path.eq(&identifier.id) {
-                    should_act = true;
-                }
-            }
-        },
-        Some(MatchingStrategy::StartsWith) => match identifier.kind {
-            ApplicationIdentifier::Title => {
-                if title.starts_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Class => {
-                if class.starts_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Exe => {
-                if exe_name.starts_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Path => {
-                if path.starts_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-        },
-        Some(MatchingStrategy::EndsWith) => match identifier.kind {
-            ApplicationIdentifier::Title => {
-                if title.ends_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Class => {
-                if class.ends_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Exe => {
-                if exe_name.ends_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Path => {
-                if path.ends_with(&identifier.id) {
-                    should_act = true;
-                }
-            }
-        },
-        Some(MatchingStrategy::Contains) => match identifier.kind {
-            ApplicationIdentifier::Title => {
-                if title.contains(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Class => {
-                if class.contains(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Exe => {
-                if exe_name.contains(&identifier.id) {
-                    should_act = true;
-                }
-            }
-            ApplicationIdentifier::Path => {
-                if path.contains(&identifier.id) {
-                    should_act = true;
-                }
-            }
-        },
-        Some(MatchingStrategy::Regex) => match identifier.kind {
-            ApplicationIdentifier::Title => {
-                if let Some(re) = regex_identifiers.get(&identifier.id) {
-                    if re.is_match(title) {
-                        should_act = true;
-                    }
-                }
-            }
-            ApplicationIdentifier::Class => {
-                if let Some(re) = regex_identifiers.get(&identifier.id) {
-                    if re.is_match(class) {
-                        should_act = true;
-                    }
-                }
-            }
-            ApplicationIdentifier::Exe => {
-                if let Some(re) = regex_identifiers.get(&identifier.id) {
-                    if re.is_match(exe_name) {
-                        should_act = true;
-                    }
-                }
-            }
-            ApplicationIdentifier::Path => {
-                if let Some(re) = regex_identifiers.get(&identifier.id) {
-                    if re.is_match(path) {
-                        should_act = true;
-                    }
-                }
-            }
-        },
-    }
-
-    should_act
-}

komorebi/src/window_manager.rs

@@ -12,8 +12,7 @@ use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
-use hotwatch::notify::ErrorKind as NotifyErrorKind;
-use hotwatch::EventKind;
+use hotwatch::notify::DebouncedEvent;
 use hotwatch::Hotwatch;
 use parking_lot::Mutex;
 use schemars::JsonSchema;
@@ -21,7 +20,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use uds_windows::UnixListener;
 
-use komorebi_core::config_generation::MatchingRule;
+use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::custom_layout::CustomLayout;
 use komorebi_core::Arrangement;
 use komorebi_core::Axis;
@@ -46,7 +45,7 @@ use crate::static_config::StaticConfig;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::winevent_listener;
+use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
 use crate::workspace::Workspace;
 use crate::BORDER_HWND;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
@@ -67,9 +66,10 @@ use crate::WORKSPACE_RULES;
 pub struct WindowManager {
     pub monitors: Ring<Monitor>,
     pub monitor_cache: HashMap<usize, Monitor>,
-    pub incoming_events: Receiver<WindowManagerEvent>,
+    pub incoming_events: Arc<Mutex<Receiver<WindowManagerEvent>>>,
     pub command_listener: UnixListener,
     pub is_paused: bool,
+    pub invisible_borders: Rect,
     pub work_area_offset: Option<Rect>,
     pub resize_delta: i32,
     pub window_container_behaviour: WindowContainerBehaviour,
@@ -89,6 +89,7 @@ pub struct WindowManager {
 pub struct State {
     pub monitors: Ring<Monitor>,
     pub is_paused: bool,
+    pub invisible_borders: Rect,
     pub resize_delta: i32,
     pub new_window_behaviour: WindowContainerBehaviour,
     pub cross_monitor_move_behaviour: MoveBehaviour,
@@ -97,12 +98,12 @@ pub struct State {
     pub mouse_follows_focus: bool,
     pub has_pending_raise_op: bool,
     pub remove_titlebars: bool,
-    pub float_identifiers: Vec<MatchingRule>,
-    pub manage_identifiers: Vec<MatchingRule>,
-    pub layered_whitelist: Vec<MatchingRule>,
-    pub tray_and_multi_window_identifiers: Vec<MatchingRule>,
-    pub border_overflow_identifiers: Vec<MatchingRule>,
-    pub name_change_on_launch_identifiers: Vec<MatchingRule>,
+    pub float_identifiers: Vec<IdWithIdentifier>,
+    pub manage_identifiers: Vec<IdWithIdentifier>,
+    pub layered_whitelist: Vec<IdWithIdentifier>,
+    pub tray_and_multi_window_identifiers: Vec<IdWithIdentifier>,
+    pub border_overflow_identifiers: Vec<IdWithIdentifier>,
+    pub name_change_on_launch_identifiers: Vec<IdWithIdentifier>,
     pub monitor_index_preferences: HashMap<usize, Rect>,
     pub display_index_preferences: HashMap<usize, String>,
 }
@@ -118,6 +119,7 @@ impl From<&WindowManager> for State {
         Self {
             monitors: wm.monitors.clone(),
             is_paused: wm.is_paused,
+            invisible_borders: wm.invisible_borders,
             work_area_offset: wm.work_area_offset,
             resize_delta: wm.resize_delta,
             new_window_behaviour: wm.window_container_behaviour,
@@ -166,7 +168,7 @@ impl EnforceWorkspaceRuleOp {
 
 impl WindowManager {
     #[tracing::instrument]
-    pub fn new(incoming: Receiver<WindowManagerEvent>) -> Result<Self> {
+    pub fn new(incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>) -> Result<Self> {
         let socket = DATA_DIR.join("komorebi.sock");
 
         match std::fs::remove_file(&socket) {
@@ -188,6 +190,12 @@ impl WindowManager {
             incoming_events: incoming,
             command_listener: listener,
             is_paused: false,
+            invisible_borders: Rect {
+                left: 7,
+                top: 0,
+                right: 14,
+                bottom: 7,
+            },
             virtual_desktop_id: current_virtual_desktop(),
             work_area_offset: None,
             window_container_behaviour: WindowContainerBehaviour::Create,
@@ -212,16 +220,15 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn show_border(&self) -> Result<()> {
-        if self.focused_container().is_ok() {
-            let foreground = WindowsApi::foreground_window()?;
-            let foreground_window = Window { hwnd: foreground };
+        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, true)?;
-            WindowsApi::invalidate_border_rect()?;
-        }
-
-        Ok(())
+        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))]
@@ -266,18 +273,18 @@ impl WindowManager {
             match self.hotwatch.unwatch(&config) {
                 Ok(()) => {}
                 Err(error) => match error {
-                    hotwatch::Error::Notify(ref notify_error) => match notify_error.kind {
-                        NotifyErrorKind::WatchNotFound => {}
-                        _ => return Err(error.into()),
+                    hotwatch::Error::Notify(error) => match error {
+                        hotwatch::notify::Error::WatchNotFound => {}
+                        error => return Err(error.into()),
                     },
                     error @ hotwatch::Error::Io(_) => return Err(error.into()),
                 },
             }
 
-            self.hotwatch.watch(config, |event| match event.kind {
+            self.hotwatch.watch(config, |event| match event {
                 // Editing in Notepad sends a NoticeWrite while editing in (Neo)Vim sends
                 // a NoticeRemove, presumably because of the use of swap files?
-                EventKind::Modify(_) | EventKind::Remove(_) => {
+                DebouncedEvent::NoticeWrite(_) | DebouncedEvent::NoticeRemove(_) => {
                     std::thread::spawn(|| {
                         load_configuration().expect("could not load configuration");
                     });
@@ -396,6 +403,7 @@ impl WindowManager {
             }
         }
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
 
         for monitor in self.monitors_mut() {
@@ -426,7 +434,7 @@ impl WindowManager {
             }
 
             if should_update {
-                monitor.update_focused_workspace(offset)?;
+                monitor.update_focused_workspace(offset, &invisible_borders)?;
             }
         }
 
@@ -628,6 +636,7 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn retile_all(&mut self, preserve_resize_dimensions: bool) -> Result<()> {
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
 
         for monitor in self.monitors_mut() {
@@ -649,7 +658,7 @@ impl WindowManager {
                 }
             }
 
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, &invisible_borders)?;
         }
 
         Ok(())
@@ -659,56 +668,75 @@ impl WindowManager {
     pub fn manage_focused_window(&mut self) -> Result<()> {
         let hwnd = WindowsApi::foreground_window()?;
         let event = WindowManagerEvent::Manage(Window { hwnd });
-        Ok(winevent_listener::event_tx().send(event)?)
+        Ok(WINEVENT_CALLBACK_CHANNEL.lock().0.send(event)?)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn unmanage_focused_window(&mut self) -> Result<()> {
         let hwnd = WindowsApi::foreground_window()?;
         let event = WindowManagerEvent::Unmanage(Window { hwnd });
-        Ok(winevent_listener::event_tx().send(event)?)
+        Ok(WINEVENT_CALLBACK_CHANNEL.lock().0.send(event)?)
     }
 
     #[tracing::instrument(skip(self))]
     pub fn raise_window_at_cursor_pos(&mut self) -> Result<()> {
-        let mut hwnd = None;
+        let mut hwnd = WindowsApi::window_at_cursor_pos()?;
 
-        for monitor in self.monitors() {
-            for workspace in monitor.workspaces() {
-                if let Some(container_idx) = workspace.container_idx_from_current_point() {
-                    if let Some(container) = workspace.containers().get(container_idx) {
-                        if let Some(window) = container.focused_window() {
-                            hwnd = Some(window.hwnd);
+        if self.has_pending_raise_op
+            || self.focused_window()?.hwnd == hwnd
+            // Sometimes we need this check, because the focus may have been given by a click
+            // to a non-window such as the taskbar or system tray, and komorebi doesn't know that
+            // the focused window of the workspace is not actually focused by the OS at that point
+            || WindowsApi::foreground_window()? == hwnd
+        {
+            Ok(())
+        } else {
+            let mut known_hwnd = false;
+            for monitor in self.monitors() {
+                for workspace in monitor.workspaces() {
+                    if workspace.contains_window(hwnd) {
+                        known_hwnd = true;
+                    }
+                }
+            }
+
+            // TODO: Not sure if this needs to be made configurable just yet...
+            let overlay_classes = [
+                // Chromium/Electron
+                "Chrome_RenderWidgetHostHWND".to_string(),
+                // Explorer
+                "DirectUIHWND".to_string(),
+                "SysTreeView32".to_string(),
+                "ToolbarWindow32".to_string(),
+                "NetUIHWND".to_string(),
+            ];
+
+            if !known_hwnd {
+                let class = Window { hwnd }.class()?;
+                // Some applications (Electron/Chromium-based, explorer) have (invisible?) overlays
+                // windows that we need to look beyond to find the actual window to raise
+                if overlay_classes.contains(&class) {
+                    for monitor in self.monitors() {
+                        for workspace in monitor.workspaces() {
+                            if let Some(exe_hwnd) = workspace.hwnd_from_exe(&Window { hwnd }.exe()?)
+                            {
+                                hwnd = exe_hwnd;
+                                known_hwnd = true;
+                            }
                         }
                     }
                 }
             }
-        }
 
-        if let Some(hwnd) = hwnd {
-            if self.has_pending_raise_op
-                    || self.focused_window()?.hwnd == hwnd
-                    // Sometimes we need this check, because the focus may have been given by a click
-                    // to a non-window such as the taskbar or system tray, and komorebi doesn't know that
-                    // the focused window of the workspace is not actually focused by the OS at that point
-                    || WindowsApi::foreground_window()? == hwnd
-            {
-                return Ok(());
+            if known_hwnd {
+                let event = WindowManagerEvent::Raise(Window { hwnd });
+                self.has_pending_raise_op = true;
+                Ok(WINEVENT_CALLBACK_CHANNEL.lock().0.send(event)?)
+            } else {
+                tracing::debug!("not raising unknown window: {}", Window { hwnd });
+                Ok(())
             }
-
-            let event = WindowManagerEvent::Raise(Window { hwnd });
-            self.has_pending_raise_op = true;
-            winevent_listener::event_tx().send(event)?;
-        } else {
-            tracing::debug!(
-                "not raising unknown window: {}",
-                Window {
-                    hwnd: WindowsApi::window_at_cursor_pos()?
-                }
-            );
         }
-
-        Ok(())
     }
 
     #[tracing::instrument(skip(self))]
@@ -802,11 +830,12 @@ impl WindowManager {
     pub fn update_focused_workspace(&mut self, follow_focus: bool) -> Result<()> {
         tracing::info!("updating");
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
 
         self.focused_monitor_mut()
             .ok_or_else(|| anyhow!("there is no monitor"))?
-            .update_focused_workspace(offset)?;
+            .update_focused_workspace(offset, &invisible_borders)?;
 
         if follow_focus {
             if let Some(window) = self.focused_workspace()?.maximized_window() {
@@ -837,30 +866,6 @@ impl WindowManager {
             }
         }
 
-        // if we passed false for follow_focus and there is a container on the workspace
-        if !follow_focus && self.focused_container_mut().is_ok() {
-            // and we have a stack with >1 windows
-            if self.focused_container_mut()?.windows().len() > 1
-            // and we don't have a maxed window 
-            && self.focused_workspace()?.maximized_window().is_none()
-            // and we don't have a monocle container
-            && self.focused_workspace()?.monocle_container().is_none()
-            {
-                if let Ok(window) = self.focused_window_mut() {
-                    window.focus(self.mouse_follows_focus)?;
-                }
-            }
-        };
-
-        // This is to correctly restore and focus when switching to a workspace which
-        // contains a managed maximized window
-        if !follow_focus {
-            if let Some(window) = self.focused_workspace()?.maximized_window() {
-                window.restore();
-                window.focus(self.mouse_follows_focus)?;
-            }
-        }
-
         Ok(())
     }
 
@@ -995,12 +1000,13 @@ impl WindowManager {
     }
 
     pub fn update_focused_workspace_by_monitor_idx(&mut self, idx: usize) -> Result<()> {
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
 
         self.monitors_mut()
             .get_mut(idx)
             .ok_or_else(|| anyhow!("there is no monitor"))?
-            .update_focused_workspace(offset)
+            .update_focused_workspace(offset, &invisible_borders)
     }
 
     #[tracing::instrument(skip(self))]
@@ -1090,6 +1096,7 @@ impl WindowManager {
 
         tracing::info!("moving container");
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
         let mouse_follows_focus = self.mouse_follows_focus;
 
@@ -1108,7 +1115,7 @@ impl WindowManager {
             .remove_focused_container()
             .ok_or_else(|| anyhow!("there is no container"))?;
 
-        monitor.update_focused_workspace(offset)?;
+        monitor.update_focused_workspace(offset, &invisible_borders)?;
 
         let target_monitor = self
             .monitors_mut()
@@ -1117,7 +1124,7 @@ impl WindowManager {
 
         target_monitor.add_container(container, workspace_idx)?;
         target_monitor.load_focused_workspace(mouse_follows_focus)?;
-        target_monitor.update_focused_workspace(offset)?;
+        target_monitor.update_focused_workspace(offset, &invisible_borders)?;
 
         if follow {
             self.focus_monitor(monitor_idx)?;
@@ -1299,11 +1306,12 @@ impl WindowManager {
                 // 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)?;
+                    .update_focused_workspace(offset, &invisible_borders)?;
 
                 let a = self
                     .focused_monitor()
@@ -1436,9 +1444,7 @@ impl WindowManager {
                 anyhow!("this is not a valid direction from the current position")
             })?;
 
-            let adjusted_new_index = if new_idx > current_container_idx
-                && !matches!(workspace.layout(), Layout::Default(DefaultLayout::Grid))
-            {
+            let adjusted_new_index = if new_idx > current_container_idx {
                 new_idx - 1
             } else {
                 new_idx
@@ -1455,15 +1461,9 @@ impl WindowManager {
     pub fn promote_container_to_front(&mut self) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
 
-        let workspace = self.focused_workspace_mut()?;
-
-        if matches!(workspace.layout(), Layout::Default(DefaultLayout::Grid)) {
-            tracing::debug!("ignoring promote command for grid layout");
-            return Ok(());
-        }
-
         tracing::info!("promoting container");
 
+        let workspace = self.focused_workspace_mut()?;
         workspace.promote_container()?;
         self.update_focused_workspace(self.mouse_follows_focus)
     }
@@ -1472,15 +1472,9 @@ impl WindowManager {
     pub fn promote_focus_to_front(&mut self) -> Result<()> {
         self.handle_unmanaged_window_behaviour()?;
 
-        let workspace = self.focused_workspace_mut()?;
-
-        if matches!(workspace.layout(), Layout::Default(DefaultLayout::Grid)) {
-            tracing::info!("ignoring promote focus command for grid layout");
-            return Ok(());
-        }
-
         tracing::info!("promoting focus");
 
+        let workspace = self.focused_workspace_mut()?;
         let target_idx = match workspace.layout() {
             Layout::Default(_) => 0,
             Layout::Custom(custom) => custom
@@ -1541,6 +1535,7 @@ impl WindowManager {
         tracing::info!("floating window");
 
         let work_area = self.focused_monitor_work_area()?;
+        let invisible_borders = self.invisible_borders;
 
         let workspace = self.focused_workspace_mut()?;
         workspace.new_floating_window()?;
@@ -1550,7 +1545,7 @@ impl WindowManager {
             .last_mut()
             .ok_or_else(|| anyhow!("there is no floating window"))?;
 
-        window.center(&work_area)?;
+        window.center(&work_area, &invisible_borders)?;
         window.focus(self.mouse_follows_focus)?;
 
         Ok(())
@@ -1626,10 +1621,10 @@ impl WindowManager {
 
     #[tracing::instrument(skip(self))]
     pub fn flip_layout(&mut self, layout_flip: Axis) -> Result<()> {
-        let workspace = self.focused_workspace_mut()?;
-
         tracing::info!("flipping layout");
 
+        let workspace = self.focused_workspace_mut()?;
+
         #[allow(clippy::match_same_arms)]
         match workspace.layout_flip() {
             None => {
@@ -1807,6 +1802,7 @@ impl WindowManager {
     ) -> Result<()> {
         tracing::info!("setting workspace layout");
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
         let focused_monitor_idx = self.focused_monitor_idx();
 
@@ -1835,7 +1831,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, &invisible_borders)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false)?)
@@ -1855,6 +1851,7 @@ impl WindowManager {
     {
         tracing::info!("setting workspace layout");
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
         let focused_monitor_idx = self.focused_monitor_idx();
 
@@ -1885,7 +1882,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, &invisible_borders)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false)?)
@@ -1900,6 +1897,7 @@ impl WindowManager {
     ) -> Result<()> {
         tracing::info!("setting workspace layout");
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
         let focused_monitor_idx = self.focused_monitor_idx();
 
@@ -1926,7 +1924,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, &invisible_borders)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false)?)
@@ -1942,6 +1940,7 @@ impl WindowManager {
     ) -> Result<()> {
         tracing::info!("setting workspace layout");
 
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
         let focused_monitor_idx = self.focused_monitor_idx();
 
@@ -1967,7 +1966,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, &invisible_borders)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false)?)
@@ -1986,6 +1985,7 @@ impl WindowManager {
     {
         tracing::info!("setting workspace layout");
         let layout = CustomLayout::from_path(path)?;
+        let invisible_borders = self.invisible_borders;
         let offset = self.work_area_offset;
         let focused_monitor_idx = self.focused_monitor_idx();
 
@@ -2012,7 +2012,7 @@ impl WindowManager {
 
         // If this is the focused workspace on a non-focused screen, let's update it
         if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset)?;
+            workspace.update(&work_area, offset, &invisible_borders)?;
             Ok(())
         } else {
             Ok(self.update_focused_workspace(false)?)

komorebi/src/window_manager_event.rs

@@ -139,13 +139,11 @@ impl WindowManagerEvent {
                 let title = &window.title().ok()?;
                 let exe_name = &window.exe().ok()?;
                 let class = &window.class().ok()?;
-                let path = &window.path().ok()?;
 
                 let should_trigger = should_act(
                     title,
                     exe_name,
                     class,
-                    path,
                     &object_name_change_on_launch,
                     &regex_identifiers,
                 );

komorebi/src/windows_api.rs

@@ -22,7 +22,6 @@ use windows::Win32::Foundation::WPARAM;
 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;
@@ -83,7 +82,6 @@ use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 use windows::Win32::UI::WindowsAndMessaging::IsIconic;
 use windows::Win32::UI::WindowsAndMessaging::IsWindow;
 use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
-use windows::Win32::UI::WindowsAndMessaging::IsZoomed;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
@@ -102,7 +100,7 @@ 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_TOP;
+use windows::Win32::UI::WindowsAndMessaging::HWND_TOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
 use windows::Win32::UI::WindowsAndMessaging::LWA_COLORKEY;
 use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
@@ -127,7 +125,8 @@ use windows::Win32::UI::WindowsAndMessaging::WS_DISABLED;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_LAYERED;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
-use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOPMOST;
+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;
 
@@ -340,25 +339,14 @@ impl WindowsApi {
         unsafe { MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST) }.0
     }
 
-    /// position window resizes the target window to the given layout, adjusting
-    /// the layout to account for any window shadow borders (the window painted
-    /// region will match layout on completion).
     pub fn position_window(hwnd: HWND, layout: &Rect, top: bool) -> Result<()> {
         let flags = SetWindowPosition::NO_ACTIVATE
             | SetWindowPosition::NO_SEND_CHANGING
             | SetWindowPosition::NO_COPY_BITS
             | SetWindowPosition::FRAME_CHANGED;
 
-        let shadow_rect = Self::shadow_rect(hwnd)?;
-        let rect = Rect {
-            left: layout.left + shadow_rect.left,
-            top: layout.top + shadow_rect.top,
-            right: layout.right + shadow_rect.right,
-            bottom: layout.bottom + shadow_rect.bottom,
-        };
-
-        let position = if top { HWND_TOP } else { HWND_NOTOPMOST };
-        Self::set_window_pos(hwnd, &rect, position, flags.bits())
+        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<()> {
@@ -368,7 +356,7 @@ impl WindowsApi {
     pub fn raise_window(hwnd: HWND) -> Result<()> {
         let flags = SetWindowPosition::NO_MOVE;
 
-        let position = HWND_TOP;
+        let position = HWND_TOPMOST;
         Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
     }
 
@@ -379,18 +367,6 @@ impl WindowsApi {
             SetWindowPosition::NO_ACTIVATE
         };
 
-        // TODO(raggi): This leaves the window behind the active window, which
-        // can result e.g. single pixel window borders being invisible in the
-        // case of opaque window borders (e.g. EPIC Games Launcher). Ideally
-        // we'd be able to pass a parent window to place ourselves just in front
-        // of, however the SetWindowPos API explicitly ignores that parameter
-        // unless the window being positioned is being activated - and we don't
-        // want to activate the border window here. We can hopefully find a
-        // better workaround in the future.
-        // The trade-off chosen prevents the border window from sitting over the
-        // top of other pop-up dialogs such as a file picker dialog from
-        // Firefox. When adjusting this in the future, it's important to check
-        // those dialog cases.
         let position = HWND_NOTOPMOST;
         Self::set_window_pos(hwnd, layout, position, flags.bits())
     }
@@ -402,8 +378,7 @@ impl WindowsApi {
         Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
     }
 
-    /// set_window_pos calls SetWindowPos without any accounting for Window decorations.
-    fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> Result<()> {
+    pub fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> Result<()> {
         unsafe {
             SetWindowPos(
                 hwnd,
@@ -495,36 +470,9 @@ impl WindowsApi {
 
     pub fn window_rect(hwnd: HWND) -> Result<Rect> {
         let mut rect = unsafe { std::mem::zeroed() };
+        unsafe { GetWindowRect(hwnd, &mut rect) }.process()?;
 
-        if Self::dwm_get_window_attribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &mut rect).is_ok() {
-            // TODO(raggi): once we declare DPI awareness, we will need to scale the rect.
-            // let window_scale = unsafe { GetDpiForWindow(hwnd) };
-            // let system_scale = unsafe { GetDpiForSystem() };
-            // Ok(Rect::from(rect).scale(system_scale.try_into()?, window_scale.try_into()?))
-            Ok(Rect::from(rect))
-        } else {
-            unsafe { GetWindowRect(hwnd, &mut rect) }.process()?;
-            Ok(Rect::from(rect))
-        }
-    }
-
-    /// shadow_rect computes the offset of the shadow position of the window to
-    /// the window painted region. The four values in the returned Rect can be
-    /// added to a position rect to compute a size for set_window_pos that will
-    /// fill the target area, ignoring shadows.
-    fn shadow_rect(hwnd: HWND) -> Result<Rect> {
-        let window_rect = Self::window_rect(hwnd)?;
-
-        let mut srect = Default::default();
-        unsafe { GetWindowRect(hwnd, &mut srect) }.process()?;
-        let shadow_rect = Rect::from(srect);
-
-        Ok(Rect {
-            left: shadow_rect.left - window_rect.left,
-            top: shadow_rect.top - window_rect.top,
-            right: shadow_rect.right - window_rect.right,
-            bottom: shadow_rect.bottom - window_rect.bottom,
-        })
+        Ok(Rect::from(rect))
     }
 
     fn set_cursor_pos(x: i32, y: i32) -> Result<()> {
@@ -729,10 +677,6 @@ impl WindowsApi {
         unsafe { IsIconic(hwnd) }.into()
     }
 
-    pub fn is_zoomed(hwnd: HWND) -> bool {
-        unsafe { IsZoomed(hwnd) }.into()
-    }
-
     pub fn monitor_info_w(hmonitor: HMONITOR) -> Result<MONITORINFOEXW> {
         let mut ex_info = MONITORINFOEXW::default();
         ex_info.monitorInfo.cbSize = u32::try_from(std::mem::size_of::<MONITORINFOEXW>())?;
@@ -900,10 +844,10 @@ impl WindowsApi {
     pub fn create_border_window(name: PCWSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             let hwnd = CreateWindowExW(
-                WS_EX_TOOLWINDOW | WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_NOACTIVATE,
+                WS_EX_TOOLWINDOW | WS_EX_LAYERED,
                 name,
                 name,
-                WS_POPUP | WS_SYSMENU,
+                WS_POPUP | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,

komorebi/src/windows_callbacks.rs

@@ -13,13 +13,11 @@ 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::RoundRect;
 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_INSIDEFRAME;
 use windows::Win32::Graphics::Gdi::PS_SOLID;
 use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
@@ -39,15 +37,13 @@ use crate::ring::Ring;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::winevent::WinEvent;
-use crate::winevent_listener;
+use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
 use crate::BORDER_COLOUR_CURRENT;
 use crate::BORDER_RECT;
 use crate::BORDER_WIDTH;
 use crate::DISPLAY_INDEX_PREFERENCES;
 use crate::MONITOR_INDEX_PREFERENCES;
 use crate::TRANSPARENCY_COLOUR;
-use crate::WINDOWS_11;
 
 pub extern "system" fn valid_display_monitors(
     hmonitor: HMONITOR,
@@ -150,17 +146,12 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let is_visible = WindowsApi::is_window_visible(hwnd);
     let is_window = WindowsApi::is_window(hwnd);
     let is_minimized = WindowsApi::is_iconic(hwnd);
-    let is_maximized = WindowsApi::is_zoomed(hwnd);
 
     if is_visible && is_window && !is_minimized {
         let window = Window { hwnd: hwnd.0 };
 
         if let Ok(should_manage) = window.should_manage(None) {
             if should_manage {
-                if is_maximized {
-                    WindowsApi::restore_window(hwnd);
-                }
-
                 let mut container = Container::default();
                 container.windows_mut().push_back(window);
                 containers.push_back(container);
@@ -187,10 +178,7 @@ pub extern "system" fn win_event_hook(
 
     let window = Window { hwnd: hwnd.0 };
 
-    let winevent = match WinEvent::try_from(event) {
-        Ok(event) => event,
-        Err(_) => return,
-    };
+    let winevent = unsafe { ::std::mem::transmute(event) };
     let event_type = match WindowManagerEvent::from_win_event(winevent, window) {
         None => return,
         Some(event) => event,
@@ -198,9 +186,11 @@ pub extern "system" fn win_event_hook(
 
     if let Ok(should_manage) = window.should_manage(Option::from(event_type)) {
         if should_manage {
-            winevent_listener::event_tx()
+            WINEVENT_CALLBACK_CHANNEL
+                .lock()
+                .0
                 .send(event_type)
-                .expect("could not send message on winevent_listener::event_tx");
+                .expect("could not send message on WINEVENT_CALLBACK_CHANNEL");
         }
     }
 }
@@ -218,7 +208,7 @@ pub extern "system" fn border_window(
                 let mut ps = PAINTSTRUCT::default();
                 let hdc = BeginPaint(window, &mut ps);
                 let hpen = CreatePen(
-                    PS_SOLID | PS_INSIDEFRAME,
+                    PS_SOLID,
                     BORDER_WIDTH.load(Ordering::SeqCst),
                     COLORREF(BORDER_COLOUR_CURRENT.load(Ordering::SeqCst)),
                 );
@@ -226,17 +216,7 @@ pub extern "system" fn border_window(
 
                 SelectObject(hdc, hpen);
                 SelectObject(hdc, hbrush);
-                // TODO(raggi): this is approximately the correct curvature for
-                // the top left of a Windows 11 window (DWMWCP_DEFAULT), but
-                // often the bottom right has a different shape. Furthermore if
-                // the window was made with DWMWCP_ROUNDSMALL then this is the
-                // wrong size.  In the future we should read the DWM properties
-                // of windows and attempt to match appropriately.
-                if *WINDOWS_11 {
-                    RoundRect(hdc, 0, 0, border_rect.right, border_rect.bottom, 20, 20);
-                } else {
-                    Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
-                }
+                Rectangle(hdc, 0, 0, border_rect.right, border_rect.bottom);
                 EndPaint(window, &ps);
                 ValidateRect(window, None);
 
@@ -261,9 +241,11 @@ pub extern "system" fn hidden_window(
         match message {
             WM_DISPLAYCHANGE => {
                 let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
-                winevent_listener::event_tx()
+                WINEVENT_CALLBACK_CHANNEL
+                    .lock()
+                    .0
                     .send(event_type)
-                    .expect("could not send message on winevent_listener::event_tx");
+                    .expect("could not send message on WINEVENT_CALLBACK_CHANNEL");
 
                 LRESULT(0)
             }
@@ -274,9 +256,11 @@ pub extern "system" fn hidden_window(
                     || wparam.0 as u32 == SPI_ICONVERTICALSPACING.0
                 {
                     let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
-                    winevent_listener::event_tx()
+                    WINEVENT_CALLBACK_CHANNEL
+                        .lock()
+                        .0
                         .send(event_type)
-                        .expect("could not send message on winevent_listener::event_tx");
+                        .expect("could not send message on WINEVENT_CALLBACK_CHANNEL");
                 }
                 LRESULT(0)
             }
@@ -285,9 +269,11 @@ pub extern "system" fn hidden_window(
                 #[allow(clippy::cast_possible_truncation)]
                 if wparam.0 as u32 == DBT_DEVNODES_CHANGED {
                     let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
-                    winevent_listener::event_tx()
+                    WINEVENT_CALLBACK_CHANNEL
+                        .lock()
+                        .0
                         .send(event_type)
-                        .expect("could not send message on winevent_listener::event_tx");
+                        .expect("could not send message on WINEVENT_CALLBACK_CHANNEL");
                 }
                 LRESULT(0)
             }

komorebi/src/winevent.rs

@@ -178,100 +178,3 @@ pub enum WinEvent {
     UiaPropIdSEnd = EVENT_UIA_PROPID_END,
     UiaPropIdStart = EVENT_UIA_PROPID_START,
 }
-
-impl TryFrom<u32> for WinEvent {
-    type Error = ();
-
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
-        match value {
-            EVENT_AIA_END => Ok(Self::AiaEnd),
-            EVENT_AIA_START => Ok(Self::AiaStart),
-            EVENT_CONSOLE_CARET => Ok(Self::ConsoleCaret),
-            EVENT_CONSOLE_END => Ok(Self::ConsoleEnd),
-            EVENT_CONSOLE_END_APPLICATION => Ok(Self::ConsoleEndApplication),
-            EVENT_CONSOLE_LAYOUT => Ok(Self::ConsoleLayout),
-            EVENT_CONSOLE_START_APPLICATION => Ok(Self::ConsoleStartApplication),
-            EVENT_CONSOLE_UPDATE_REGION => Ok(Self::ConsoleUpdateRegion),
-            EVENT_CONSOLE_UPDATE_SCROLL => Ok(Self::ConsoleUpdateScroll),
-            EVENT_CONSOLE_UPDATE_SIMPLE => Ok(Self::ConsoleUpdateSimple),
-            EVENT_OBJECT_ACCELERATORCHANGE => Ok(Self::ObjectAcceleratorChange),
-            EVENT_OBJECT_CLOAKED => Ok(Self::ObjectCloaked),
-            EVENT_OBJECT_CONTENTSCROLLED => Ok(Self::ObjectContentScrolled),
-            EVENT_OBJECT_CREATE => Ok(Self::ObjectCreate),
-            EVENT_OBJECT_DEFACTIONCHANGE => Ok(Self::ObjectDefActionChange),
-            EVENT_OBJECT_DESCRIPTIONCHANGE => Ok(Self::ObjectDescriptionChange),
-            EVENT_OBJECT_DESTROY => Ok(Self::ObjectDestroy),
-            EVENT_OBJECT_DRAGCANCEL => Ok(Self::ObjectDragCancel),
-            EVENT_OBJECT_DRAGCOMPLETE => Ok(Self::ObjectDragComplete),
-            EVENT_OBJECT_DRAGDROPPED => Ok(Self::ObjectDragDropped),
-            EVENT_OBJECT_DRAGENTER => Ok(Self::ObjectDragEnter),
-            EVENT_OBJECT_DRAGLEAVE => Ok(Self::ObjectDragLeave),
-            EVENT_OBJECT_DRAGSTART => Ok(Self::ObjectDragStart),
-            EVENT_OBJECT_END => Ok(Self::ObjectEnd),
-            EVENT_OBJECT_FOCUS => Ok(Self::ObjectFocus),
-            EVENT_OBJECT_HELPCHANGE => Ok(Self::ObjectHelpChange),
-            EVENT_OBJECT_HIDE => Ok(Self::ObjectHide),
-            EVENT_OBJECT_HOSTEDOBJECTSINVALIDATED => Ok(Self::ObjectHostedObjectsInvalidated),
-            EVENT_OBJECT_IME_CHANGE => Ok(Self::ObjectImeChange),
-            EVENT_OBJECT_IME_HIDE => Ok(Self::ObjectImeHide),
-            EVENT_OBJECT_IME_SHOW => Ok(Self::ObjectImeShow),
-            EVENT_OBJECT_INVOKED => Ok(Self::ObjectInvoked),
-            EVENT_OBJECT_LIVEREGIONCHANGED => Ok(Self::ObjectLiveRegionChanged),
-            EVENT_OBJECT_LOCATIONCHANGE => Ok(Self::ObjectLocationChange),
-            EVENT_OBJECT_NAMECHANGE => Ok(Self::ObjectNameChange),
-            EVENT_OBJECT_PARENTCHANGE => Ok(Self::ObjectParentChange),
-            EVENT_OBJECT_REORDER => Ok(Self::ObjectReorder),
-            EVENT_OBJECT_SELECTION => Ok(Self::ObjectSelection),
-            EVENT_OBJECT_SELECTIONADD => Ok(Self::ObjectSelectionAdd),
-            EVENT_OBJECT_SELECTIONREMOVE => Ok(Self::ObjectSelectionRemove),
-            EVENT_OBJECT_SELECTIONWITHIN => Ok(Self::ObjectSelectionWithin),
-            EVENT_OBJECT_SHOW => Ok(Self::ObjectShow),
-            EVENT_OBJECT_STATECHANGE => Ok(Self::ObjectStateChange),
-            EVENT_OBJECT_TEXTEDIT_CONVERSIONTARGETCHANGED => {
-                Ok(Self::ObjectTextEditConversionTargetChanged)
-            }
-            EVENT_OBJECT_TEXTSELECTIONCHANGED => Ok(Self::ObjectTextSelectionChanged),
-            EVENT_OBJECT_UNCLOAKED => Ok(Self::ObjectUncloaked),
-            EVENT_OBJECT_VALUECHANGE => Ok(Self::ObjectValueChange),
-            EVENT_OEM_DEFINED_END => Ok(Self::OemDefinedEnd),
-            EVENT_OEM_DEFINED_START => Ok(Self::OemDefinedStart),
-            EVENT_SYSTEM_ALERT => Ok(Self::SystemAlert),
-            EVENT_SYSTEM_ARRANGMENTPREVIEW => Ok(Self::SystemArrangementPreview),
-            EVENT_SYSTEM_CAPTUREEND => Ok(Self::SystemCaptureEnd),
-            EVENT_SYSTEM_CAPTURESTART => Ok(Self::SystemCaptureStart),
-            EVENT_SYSTEM_CONTEXTHELPEND => Ok(Self::SystemContextHelpEnd),
-            EVENT_SYSTEM_CONTEXTHELPSTART => Ok(Self::SystemContextHelpStart),
-            EVENT_SYSTEM_DESKTOPSWITCH => Ok(Self::SystemDesktopSwitch),
-            EVENT_SYSTEM_DIALOGEND => Ok(Self::SystemDialogEnd),
-            EVENT_SYSTEM_DIALOGSTART => Ok(Self::SystemDialogStart),
-            EVENT_SYSTEM_DRAGDROPEND => Ok(Self::SystemDragDropEnd),
-            EVENT_SYSTEM_DRAGDROPSTART => Ok(Self::SystemDragDropStart),
-            EVENT_SYSTEM_END => Ok(Self::SystemEnd),
-            EVENT_SYSTEM_FOREGROUND => Ok(Self::SystemForeground),
-            EVENT_SYSTEM_IME_KEY_NOTIFICATION => Ok(Self::SystemImeKeyNotification),
-            EVENT_SYSTEM_MENUEND => Ok(Self::SystemMenuEnd),
-            EVENT_SYSTEM_MENUPOPUPEND => Ok(Self::SystemMenuPopupEnd),
-            EVENT_SYSTEM_MENUPOPUPSTART => Ok(Self::SystemMenuPopupStart),
-            EVENT_SYSTEM_MENUSTART => Ok(Self::SystemMenuStart),
-            EVENT_SYSTEM_MINIMIZEEND => Ok(Self::SystemMinimizeEnd),
-            EVENT_SYSTEM_MINIMIZESTART => Ok(Self::SystemMinimizeStart),
-            EVENT_SYSTEM_MOVESIZEEND => Ok(Self::SystemMoveSizeEnd),
-            EVENT_SYSTEM_MOVESIZESTART => Ok(Self::SystemMoveSizeStart),
-            EVENT_SYSTEM_SCROLLINGEND => Ok(Self::SystemScrollingEnd),
-            EVENT_SYSTEM_SCROLLINGSTART => Ok(Self::SystemScrollingStart),
-            EVENT_SYSTEM_SOUND => Ok(Self::SystemSound),
-            EVENT_SYSTEM_SWITCHEND => Ok(Self::SystemSwitchEnd),
-            EVENT_SYSTEM_SWITCHER_APPDROPPED => Ok(Self::SystemSwitcherAppDropped),
-            EVENT_SYSTEM_SWITCHER_APPGRABBED => Ok(Self::SystemSwitcherAppGrabbed),
-            EVENT_SYSTEM_SWITCHER_APPOVERTARGET => Ok(Self::SystemSwitcherAppOverTarget),
-            EVENT_SYSTEM_SWITCHER_CANCELLED => Ok(Self::SystemSwitcherCancelled),
-            EVENT_SYSTEM_SWITCHSTART => Ok(Self::SystemSwitchStart),
-            EVENT_UIA_EVENTID_END => Ok(Self::UiaEventIdSEnd),
-            EVENT_UIA_EVENTID_START => Ok(Self::UiaEventIdStart),
-            EVENT_UIA_PROPID_END => Ok(Self::UiaPropIdSEnd),
-            EVENT_UIA_PROPID_START => Ok(Self::UiaPropIdStart),
-
-            _ => Err(()),
-        }
-    }
-}

komorebi/src/winevent_listener.rs

@@ -1,62 +1,105 @@
-use std::sync::OnceLock;
+use std::sync::atomic::AtomicIsize;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::time::Duration;
 
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
+use lazy_static::lazy_static;
+use parking_lot::Mutex;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::UI::Accessibility::SetWinEventHook;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::PeekMessageW;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_MAX;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_MIN;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::PM_REMOVE;
 
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_callbacks;
 
-static CHANNEL: OnceLock<(Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>)> =
-    OnceLock::new();
+lazy_static! {
+    pub static ref WINEVENT_CALLBACK_CHANNEL: Arc<Mutex<(Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>)>> =
+        Arc::new(Mutex::new(crossbeam_channel::unbounded()));
+}
 
-static EVENT_PUMP: OnceLock<std::thread::JoinHandle<()>> = OnceLock::new();
+#[derive(Debug, Clone)]
+pub struct WinEventListener {
+    hook: Arc<AtomicIsize>,
+    outgoing_events: Arc<Mutex<Sender<WindowManagerEvent>>>,
+}
 
-pub fn start() {
-    EVENT_PUMP.get_or_init(|| {
-        std::thread::spawn(move || {
+pub fn new(outgoing: Arc<Mutex<Sender<WindowManagerEvent>>>) -> WinEventListener {
+    WinEventListener {
+        hook: Arc::new(AtomicIsize::new(0)),
+        outgoing_events: outgoing,
+    }
+}
+
+impl WinEventListener {
+    pub fn start(self) {
+        let hook = self.hook.clone();
+        let outgoing = self.outgoing_events.lock().clone();
+
+        std::thread::spawn(move || unsafe {
+            let hook_ref = SetWinEventHook(
+                EVENT_MIN,
+                EVENT_MAX,
+                None,
+                Some(windows_callbacks::win_event_hook),
+                0,
+                0,
+                0,
+            );
+
+            hook.store(hook_ref.0, Ordering::SeqCst);
+
+            // The code in the callback doesn't work in its own loop, needs to be within
+            // the MessageLoop callback for the winevent callback to even fire
+            MessageLoop::start(10, |_msg| {
+                if let Ok(event) = WINEVENT_CALLBACK_CHANNEL.lock().1.try_recv() {
+                    match outgoing.send(event) {
+                        Ok(()) => {}
+                        Err(error) => {
+                            tracing::error!("{}", error);
+                        }
+                    }
+                }
+
+                true
+            });
+        });
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct MessageLoop;
+
+impl MessageLoop {
+    pub fn start(sleep: u64, cb: impl Fn(Option<MSG>) -> bool) {
+        Self::start_with_sleep(sleep, cb);
+    }
+
+    fn start_with_sleep(sleep: u64, cb: impl Fn(Option<MSG>) -> bool) {
+        let mut msg: MSG = MSG::default();
+        loop {
+            let mut value: Option<MSG> = None;
             unsafe {
-                SetWinEventHook(
-                    EVENT_MIN,
-                    EVENT_MAX,
-                    None,
-                    Some(windows_callbacks::win_event_hook),
-                    0,
-                    0,
-                    0,
-                )
-            };
-
-            loop {
-                let mut msg: MSG = MSG::default();
-                unsafe {
-                    if !GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {
-                        tracing::info!("windows event processing shutdown");
-                        break;
-                    };
+                if !bool::from(!PeekMessageW(&mut msg, HWND(0), 0, 0, PM_REMOVE)) {
                     TranslateMessage(&msg);
                     DispatchMessageW(&msg);
+
+                    value = Some(msg);
                 }
             }
-        })
-    });
-}
 
-fn channel() -> &'static (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) {
-    CHANNEL.get_or_init(crossbeam_channel::unbounded)
-}
+            std::thread::sleep(Duration::from_millis(sleep));
 
-pub fn event_tx() -> Sender<WindowManagerEvent> {
-    channel().0.clone()
-}
-
-pub fn event_rx() -> Receiver<WindowManagerEvent> {
-    channel().1.clone()
+            if !cb(value) {
+                break;
+            }
+        }
+    }
 }

komorebi/src/workspace.rs

@@ -26,8 +26,6 @@ use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::window::WindowDetails;
 use crate::windows_api::WindowsApi;
-use crate::BORDER_OFFSET;
-use crate::BORDER_WIDTH;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::INITIAL_CONFIGURATION_LOADED;
@@ -203,7 +201,12 @@ impl Workspace {
         Ok(())
     }
 
-    pub fn update(&mut self, work_area: &Rect, offset: Option<Rect>) -> Result<()> {
+    pub fn update(
+        &mut self,
+        work_area: &Rect,
+        offset: Option<Rect>,
+        invisible_borders: &Rect,
+    ) -> Result<()> {
         if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
             return Ok(());
         }
@@ -222,7 +225,7 @@ impl Workspace {
             },
         );
 
-        adjusted_work_area.add_padding(self.workspace_padding().unwrap_or_default());
+        adjusted_work_area.add_padding(self.workspace_padding());
 
         self.enforce_resize_constraints();
 
@@ -244,19 +247,11 @@ impl Workspace {
             }
         }
 
-        let managed_maximized_window = self.maximized_window().is_some();
-
         if *self.tile() {
             if let Some(container) = self.monocle_container_mut() {
                 if let Some(window) = container.focused_window_mut() {
-                    adjusted_work_area.add_padding(container_padding.unwrap_or_default());
-                    {
-                        let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
-                        adjusted_work_area.add_padding(border_offset);
-                        let width = BORDER_WIDTH.load(Ordering::SeqCst);
-                        adjusted_work_area.add_padding(width);
-                    }
-                    window.set_position(&adjusted_work_area, true)?;
+                    adjusted_work_area.add_padding(container_padding);
+                    window.set_position(&adjusted_work_area, invisible_borders, true)?;
                 };
             } else if let Some(window) = self.maximized_window_mut() {
                 window.maximize();
@@ -285,22 +280,7 @@ impl Workspace {
                             window.add_title_bar()?;
                         }
 
-                        // If a window has been unmaximized via toggle-maximize, this block
-                        // will make sure that it is unmaximized via restore_window
-                        if window.is_maximized() && !managed_maximized_window {
-                            WindowsApi::restore_window(window.hwnd());
-                        }
-
-                        let mut rect = *layout;
-                        {
-                            let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
-                            rect.add_padding(border_offset);
-
-                            let width = BORDER_WIDTH.load(Ordering::SeqCst);
-                            rect.add_padding(width);
-                        }
-
-                        window.set_position(&rect, false)?;
+                        window.set_position(layout, invisible_borders, false)?;
                     }
                 }
 

komorebic-no-console/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.23-dev.0"
+version = "0.1.22-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.23-dev.0"
+version = "0.1.22-dev.0"
 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,15 +21,15 @@ dunce = { workspace = true }
 fs-tail = "0.1"
 heck = "0.4"
 lazy_static = "1"
-miette = { version = "7", features = ["fancy"] }
+miette = { version = "5", features = ["fancy"] }
 paste = "1"
 powershell_script = "1.0"
 reqwest = { version = "0.11", features = ["blocking"] }
 serde = { version = "1", features = ["derive"] }
-serde_json = { workspace = true }
+serde_json = "1"
 serde_yaml = "0.9"
 sysinfo = "0.30"
 thiserror = "1"
 uds_windows = "1"
-which = "6"
+which = "5"
 windows = { workspace = true }

komorebic/src/main.rs

@@ -114,7 +114,7 @@ trait AhkFunction {
 struct ConfigurationError {
     message: String,
     #[source_code]
-    src: NamedSource<String>,
+    src: NamedSource,
     #[label("This bit here")]
     bad_bit: SourceSpan,
 }
@@ -805,14 +805,8 @@ enum SubCommand {
     Start(Start),
     /// Stop the komorebi.exe process and restore all hidden windows
     Stop(Stop),
-    /// Check komorebi configuration and related files for common errors
+    /// Output various important komorebi-related environment values
     Check,
-    /// Show the path to komorebi.json
-    #[clap(alias = "config")]
-    Configuration,
-    /// Show the path to whkdrc
-    #[clap(alias = "whkd")]
-    Whkdrc,
     /// Show a JSON representation of the current window manager state
     State,
     /// Show a JSON representation of visible windows
@@ -1077,9 +1071,8 @@ enum SubCommand {
     WatchConfiguration(WatchConfiguration),
     /// Signal that the final configuration option has been sent
     CompleteConfiguration,
-    /// DEPRECATED since v0.1.22
+    /// Enable or disable a hack simulating ALT key presses to ensure focus changes succeed
     #[clap(arg_required_else_help = true)]
-    #[clap(hide = true)]
     AltFocusHack(AltFocusHack),
     /// Set the window behaviour when switching workspaces / cycling stacks
     #[clap(arg_required_else_help = true)]
@@ -1188,9 +1181,15 @@ enum SubCommand {
 pub fn send_message(bytes: &[u8]) -> Result<()> {
     let socket = DATA_DIR.join("komorebi.sock");
 
-    let mut stream = UnixStream::connect(socket)?;
-    stream.write_all(bytes)?;
-    Ok(stream.shutdown(Shutdown::Write)?)
+    let mut connected = false;
+    while !connected {
+        if let Ok(mut stream) = UnixStream::connect(&socket) {
+            connected = true;
+            stream.write_all(bytes)?;
+        }
+    }
+
+    Ok(())
 }
 
 pub fn send_query(bytes: &[u8]) -> Result<String> {
@@ -1367,7 +1366,7 @@ fn main() -> Result<()> {
                     let diagnostic = ConfigurationError {
                         message: msgs[0].to_string(),
                         src: NamedSource::new("komorebi.json", config_source.clone()),
-                        bad_bit: SourceSpan::new(offset, 2),
+                        bad_bit: SourceSpan::new(offset, 2.into()),
                     };
 
                     println!("{:?}", Report::new(diagnostic));
@@ -1421,20 +1420,6 @@ fn main() -> Result<()> {
                 println!("If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration\n");
             }
         }
-        SubCommand::Configuration => {
-            let static_config = HOME_DIR.join("komorebi.json");
-
-            if static_config.exists() {
-                println!("{}", static_config.display());
-            }
-        }
-        SubCommand::Whkdrc => {
-            let whkdrc = WHKD_CONFIG_DIR.join("whkdrc");
-
-            if whkdrc.exists() {
-                println!("{}", whkdrc.display());
-            }
-        }
         SubCommand::AhkLibrary => {
             let library = HOME_DIR.join("komorebic.lib.ahk");
             let mut file = OpenOptions::new()

mkdocs.yml

@@ -62,23 +62,17 @@ nav:
     - common-workflows/custom-layouts.md
     - common-workflows/dynamic-layout-switching.md
 #    - common-workflows/autohotkey.md
-  - Release notes:
-    - release/v0-1-22.md
   - Configuration reference: https://komorebi.lgug2z.com/schema
   - CLI reference:
     - cli/quickstart.md
     - cli/start.md
     - cli/stop.md
     - cli/check.md
-    - cli/configuration.md
-    - cli/whkdrc.md
     - cli/state.md
     - cli/visible-windows.md
     - cli/query.md
-    - cli/subscribe-socket.md
-    - cli/unsubscribe-socket.md
-    - cli/subscribe-pipe.md
-    - cli/unsubscribe-pipe.md
+    - cli/subscribe.md
+    - cli/unsubscribe.md
     - cli/log.md
     - cli/quick-save-resize.md
     - cli/quick-load-resize.md
@@ -166,6 +160,7 @@ nav:
     - cli/reload-configuration.md
     - cli/watch-configuration.md
     - cli/complete-configuration.md
+    - cli/alt-focus-hack.md
     - cli/window-hiding-behaviour.md
     - cli/cross-monitor-move-behaviour.md
     - cli/toggle-cross-monitor-move-behaviour.md

schema.asc.json

@@ -44,8 +44,7 @@
       "enum": [
         "Exe",
         "Class",
-        "Title",
-        "Path"
+        "Title"
       ]
     },
     "ApplicationOptions": {

schema.json

@@ -19,129 +19,107 @@
       "properties": {
         "monocle": {
           "description": "Border colour when the container is in monocle mode",
-          "anyOf": [
-            {
-              "description": "Colour represented as RGB",
-              "type": "object",
-              "required": [
-                "b",
-                "g",
-                "r"
-              ],
-              "properties": {
-                "b": {
-                  "description": "Blue",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "g": {
-                  "description": "Green",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "r": {
-                  "description": "Red",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                }
-              }
+          "type": "object",
+          "required": [
+            "b",
+            "g",
+            "r"
+          ],
+          "properties": {
+            "b": {
+              "description": "Blue",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
             },
-            {
-              "description": "Colour represented as Hex",
-              "type": "string"
+            "g": {
+              "description": "Green",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
+            },
+            "r": {
+              "description": "Red",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
             }
-          ]
+          }
         },
         "single": {
           "description": "Border colour when the container contains a single window",
-          "anyOf": [
-            {
-              "description": "Colour represented as RGB",
-              "type": "object",
-              "required": [
-                "b",
-                "g",
-                "r"
-              ],
-              "properties": {
-                "b": {
-                  "description": "Blue",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "g": {
-                  "description": "Green",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "r": {
-                  "description": "Red",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                }
-              }
+          "type": "object",
+          "required": [
+            "b",
+            "g",
+            "r"
+          ],
+          "properties": {
+            "b": {
+              "description": "Blue",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
             },
-            {
-              "description": "Colour represented as Hex",
-              "type": "string"
+            "g": {
+              "description": "Green",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
+            },
+            "r": {
+              "description": "Red",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
             }
-          ]
+          }
         },
         "stack": {
           "description": "Border colour when the container contains multiple windows",
-          "anyOf": [
-            {
-              "description": "Colour represented as RGB",
-              "type": "object",
-              "required": [
-                "b",
-                "g",
-                "r"
-              ],
-              "properties": {
-                "b": {
-                  "description": "Blue",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "g": {
-                  "description": "Green",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "r": {
-                  "description": "Red",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                }
-              }
+          "type": "object",
+          "required": [
+            "b",
+            "g",
+            "r"
+          ],
+          "properties": {
+            "b": {
+              "description": "Blue",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
             },
-            {
-              "description": "Colour represented as Hex",
-              "type": "string"
+            "g": {
+              "description": "Green",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
+            },
+            "r": {
+              "description": "Red",
+              "type": "integer",
+              "format": "uint32",
+              "minimum": 0.0
             }
-          ]
+          }
         }
       }
     },
+    "active_window_border_offset": {
+      "description": "Offset of the active window border (default: None)",
+      "type": "integer",
+      "format": "int32"
+    },
+    "active_window_border_width": {
+      "description": "Width of the active window border (default: 20)",
+      "type": "integer",
+      "format": "int32"
+    },
     "app_specific_configuration_path": {
       "description": "Path to applications.yaml from komorebi-application-specific-configurations (default: None)",
       "type": "string"
     },
-    "border_offset": {
-      "description": "Offset of the window border (default: -1)",
-      "type": "integer",
-      "format": "int32"
-    },
     "border_overflow_applications": {
       "description": "Identify border overflow applications",
       "type": "array",
@@ -160,8 +138,7 @@
             "enum": [
               "Exe",
               "Class",
-              "Title",
-              "Path"
+              "Title"
             ]
           },
           "matching_strategy": {
@@ -178,11 +155,6 @@
         }
       }
     },
-    "border_width": {
-      "description": "Width of the window border (default: 8)",
-      "type": "integer",
-      "format": "int32"
-    },
     "cross_monitor_move_behaviour": {
       "description": "Determine what happens when a window is moved across a monitor boundary (default: Swap)",
       "oneOf": [
@@ -237,8 +209,7 @@
             "enum": [
               "Exe",
               "Class",
-              "Title",
-              "Path"
+              "Title"
             ]
           },
           "matching_strategy": {
@@ -307,7 +278,7 @@
       }
     },
     "invisible_borders": {
-      "description": "DEPRECATED from v0.1.22: no longer required",
+      "description": "Dimensions of Windows' own invisible borders; don't set these yourself unless you are told to",
       "type": "object",
       "required": [
         "bottom",
@@ -356,8 +327,7 @@
             "enum": [
               "Exe",
               "Class",
-              "Title",
-              "Path"
+              "Title"
             ]
           },
           "matching_strategy": {
@@ -392,8 +362,7 @@
             "enum": [
               "Exe",
               "Class",
-              "Title",
-              "Path"
+              "Title"
             ]
           },
           "matching_strategy": {
@@ -529,8 +498,7 @@
                         "enum": [
                           "Exe",
                           "Class",
-                          "Title",
-                          "Path"
+                          "Title"
                         ]
                       },
                       "matching_strategy": {
@@ -556,8 +524,7 @@
                     "Rows",
                     "VerticalStack",
                     "HorizontalStack",
-                    "UltrawideVerticalStack",
-                    "Grid"
+                    "UltrawideVerticalStack"
                   ]
                 },
                 "layout_rules": {
@@ -571,8 +538,7 @@
                       "Rows",
                       "VerticalStack",
                       "HorizontalStack",
-                      "UltrawideVerticalStack",
-                      "Grid"
+                      "UltrawideVerticalStack"
                     ]
                   }
                 },
@@ -603,8 +569,7 @@
                         "enum": [
                           "Exe",
                           "Class",
-                          "Title",
-                          "Path"
+                          "Title"
                         ]
                       },
                       "matching_strategy": {
@@ -649,8 +614,7 @@
             "enum": [
               "Exe",
               "Class",
-              "Title",
-              "Path"
+              "Title"
             ]
           },
           "matching_strategy": {
@@ -672,143 +636,6 @@
       "type": "integer",
       "format": "int32"
     },
-    "stackbar": {
-      "type": "object",
-      "properties": {
-        "height": {
-          "type": "integer",
-          "format": "int32"
-        },
-        "mode": {
-          "type": "string",
-          "enum": [
-            "Always",
-            "Never",
-            "OnStack"
-          ]
-        },
-        "tabs": {
-          "type": "object",
-          "properties": {
-            "background": {
-              "anyOf": [
-                {
-                  "description": "Colour represented as RGB",
-                  "type": "object",
-                  "required": [
-                    "b",
-                    "g",
-                    "r"
-                  ],
-                  "properties": {
-                    "b": {
-                      "description": "Blue",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    },
-                    "g": {
-                      "description": "Green",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    },
-                    "r": {
-                      "description": "Red",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    }
-                  }
-                },
-                {
-                  "description": "Colour represented as Hex",
-                  "type": "string"
-                }
-              ]
-            },
-            "focused_text": {
-              "anyOf": [
-                {
-                  "description": "Colour represented as RGB",
-                  "type": "object",
-                  "required": [
-                    "b",
-                    "g",
-                    "r"
-                  ],
-                  "properties": {
-                    "b": {
-                      "description": "Blue",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    },
-                    "g": {
-                      "description": "Green",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    },
-                    "r": {
-                      "description": "Red",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    }
-                  }
-                },
-                {
-                  "description": "Colour represented as Hex",
-                  "type": "string"
-                }
-              ]
-            },
-            "unfocused_text": {
-              "anyOf": [
-                {
-                  "description": "Colour represented as RGB",
-                  "type": "object",
-                  "required": [
-                    "b",
-                    "g",
-                    "r"
-                  ],
-                  "properties": {
-                    "b": {
-                      "description": "Blue",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    },
-                    "g": {
-                      "description": "Green",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    },
-                    "r": {
-                      "description": "Red",
-                      "type": "integer",
-                      "format": "uint32",
-                      "minimum": 0.0
-                    }
-                  }
-                },
-                {
-                  "description": "Colour represented as Hex",
-                  "type": "string"
-                }
-              ]
-            },
-            "width": {
-              "type": "integer",
-              "format": "int32"
-            }
-          }
-        }
-      }
-    },
     "tray_and_multi_window_applications": {
       "description": "Identify tray and multi-window applications",
       "type": "array",
@@ -827,8 +654,7 @@
             "enum": [
               "Exe",
               "Class",
-              "Title",
-              "Path"
+              "Title"
             ]
           },
           "matching_strategy": {