perf(cargo): make schemars derives optional

This commit makes all schemars::JsonSchema derives optional. After
analyzing the output of cargo build timings and llvm-lines, it was clear
that the majority of the 2m+ incremental dev build times was taken up by
codegen, and the majority of it by schemars.

Developers can now run cargo commands with --no-default-features to
disable schemars::JsonSchema codegen, and all justfile commands have
been updated to take this flag by default, with the exception of the
jsonschema target, which will compile with all derives required to
export the various jsonschema files.

Incremental dev build times for komorebi.exe on my machine are now at
around ~18s, while clean dev build times for the entire workspace are at
around ~1m.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,6 +1,6 @@
 name: Bug report
 description: File a bug report
-labels: [ bug ]
+labels: [bug]
 title: "[BUG]: "
 body:
   - type: markdown
@@ -8,9 +8,9 @@ body:
       value: |
         Please **do not** open an issue for applications with invisible windows leaving ghost tiles.
 
-        You can run `komorebic visible-windows` when the ghost tile is present on your workspace to retrieve the invisible window's exe, class name and title, and then use that to [ignore the window](https://lgug2z.github.io/komorebi/common-workflows/ignore-windows.html) responsible for the ghost tile.
+        You can run `komorebic visible-windows` when the ghost tile is present on your workspace to retrieve the invisible window's exe, class name and title, and then use that information to [ignore the window](https://lgug2z.github.io/komorebi/common-workflows/ignore-windows.html) responsible for the ghost tile.
 
-        If it is not possible to uniquely identify the invisible window resulting in a ghost tile through a mixture of exe, title and class identifiers , then this is not a bug with komorebi but a bug with the application you are using, and should open an issue with the developer(s) of that application.
+        If it is not possible to uniquely identify the invisible window resulting in a ghost tile through a mixture of exe, title and class identifiers, then this is not a bug with komorebi but a bug with the application you are using, and you should open an issue with the developer(s) of that application.
   - type: textarea
     validations:
       required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,21 +1,21 @@
 name: Feature request
-description: Suggest a new feature (Sponsors only)
+description: Suggest a new feature (Limited to Sponsors, Commercial License Holders, and Collaborators)
 labels: [enhancement]
 title: "[FEAT]: "
 body:
   - type: dropdown
-    id: Sponsors
+    id: Eligibility
     attributes:
-      label: Sponsorship Information
+      label: Eligibility
       description: >
-        Feature requests are considered from individuals who are $5+ monthly sponsors to the project.
+        Feature requests are considered from individuals who are current $5+ monthly sponsors to the project, individual commercial use license holders, and approved collaborators.
 
         Please specify the platform you use to sponsor the project.
       options:
-        - GitHub Sponsors
-        - Ko-fi
-        - Discord
-        - YouTube
+        - Individual Commercial Use License
+        - GitHub Sponsor
+        - Ko-fi Sponsor
+        - Approved Collaborator
       default: 0
     validations:
       required: true

.github/workflows/feature-check.yaml

@@ -0,0 +1,47 @@
+name: Feature Issue Check
+
+on:
+  issues:
+    types: [ opened ]
+
+jobs:
+  auto-close:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+
+    steps:
+      - name: Check and close feature issues
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const issue = context.payload.issue;
+            
+            if (issue.title.startsWith('[FEAT]: ')) {
+              const message = `
+                Feature requests on this repository are only open to current [GitHub sponsors](https://github.com/sponsors/LGUG2Z) on the $5/month tier and above, people with a valid [individual commercial use license](https://lgug2z.com/software/komorebi), and approved contributors. 
+            
+                This issue has been automatically closed until one of those pre-requisites can be validated.
+              `.replace(/^\s+/gm, ''); 
+            
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                body: message,
+              });
+
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                state: 'closed'
+              });
+
+              await github.rest.issues.lock({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                state: 'resolved'
+              });
+            }

.github/workflows/sponsor-check.yaml

@@ -1,125 +0,0 @@
-name: Feature Request Sponsor Check
-
-on:
-  issues:
-    types: [opened]
-  workflow_dispatch:
-    inputs:
-      test_username:
-        description: "Test username to check sponsorship for"
-        required: true
-        default: "octocat"
-      test_title:
-        description: "Test issue title"
-        required: true
-        default: "[FEAT] Test Feature Request"
-      test_sponsor_platform:
-        description: "Selected sponsor platform"
-        required: true
-        type: choice
-        options:
-          - "GitHub Sponsors"
-          - "Ko-fi"
-          - "Discord"
-          - "YouTube"
-
-jobs:
-  check-sponsor:
-    runs-on: ubuntu-latest
-    if: |
-      (github.event_name == 'workflow_dispatch') || (github.event_name == 'issues' &&
-       startsWith(github.event.issue.title, '[FEAT]') &&
-       github.event.issue.user.login != 'LGUG2Z' &&
-       fromJSON(github.event.issue.body).Sponsors == 'GitHub Sponsors')
-
-    steps:
-      - name: Get Issue Details
-        id: issue-details
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "username=${{ github.event.inputs.test_username }}" >> $GITHUB_OUTPUT
-            echo "title=${{ github.event.inputs.test_title }}" >> $GITHUB_OUTPUT
-            echo "sponsor_platform=${{ github.event.inputs.test_sponsor_platform }}" >> $GITHUB_OUTPUT
-          else
-            echo "username=${{ github.event.issue.user.login }}" >> $GITHUB_OUTPUT
-            echo "title=${{ github.event.issue.title }}" >> $GITHUB_OUTPUT
-            echo "sponsor_platform=$(jq -r '.Sponsors' <<< '${{ github.event.issue.body }}')" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Get Sponsorship Status
-        id: sponsorship
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.PAT }}
-          script: |
-            const username = '${{ steps.issue-details.outputs.username }}';
-            const sponsorPlatform = '${{ steps.issue-details.outputs.sponsor_platform }}';
-
-            if (sponsorPlatform !== 'GitHub Sponsors') {
-              console.log('Sponsor platform is not GitHub Sponsors, skipping check');
-              return true;
-            }
-
-            const sponsorshipQuery = `query($user: String!) {
-              user(login: $user) {
-                ... on Sponsorable {
-                  sponsorshipForViewerAsSponsorable {
-                    tier {
-                      name
-                      monthlyPriceInDollars
-                    }
-                  }
-                }
-              }
-            }`;
-
-            try {
-              const result = await github.graphql(sponsorshipQuery, {
-                user: username
-              });
-
-              console.log(result);
-              const sponsorship = result.user.sponsorshipForViewerAsSponsorable;
-              console.log(sponsorship);
-              const amount = sponsorship?.tier?.monthlyPriceInDollars || 0;
-
-              console.log(`Sponsorship amount for ${username}: $${amount}/month`);
-              return amount >= 5;
-            } catch (error) {
-              console.log(`Error checking sponsorship: ${error.message}`);
-              return false;
-            }
-
-      - name: Print Test Results
-        if: github.event_name == 'workflow_dispatch'
-        run: |
-          echo "Test Results for ${{ steps.issue-details.outputs.username }}:"
-          echo "Title: ${{ steps.issue-details.outputs.title }}"
-          echo "Platform: ${{ steps.issue-details.outputs.sponsor_platform }}"
-          echo "Would close issue: ${{ steps.sponsorship.outputs.result == 'false' }}"
-
-      - name: Close Issue If Not Sponsor
-        if: |
-          github.event_name == 'issues' && 
-          steps.sponsorship.outputs.result == 'false'
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const issueNumber = context.issue.number;
-            const owner = context.repo.owner;
-            const repo = context.repo.repo;
-
-            await github.rest.issues.createComment({
-              owner,
-              repo,
-              issue_number: issueNumber,
-              body: 'Thank you for your feature request! This repository requires a GitHub sponsorship of at least $5/month to submit feature requests. Please consider becoming a sponsor at https://github.com/sponsors/LGUG2Z'
-            });
-
-            await github.rest.issues.update({
-              owner,
-              repo,
-              issue_number: issueNumber,
-              state: 'closed'
-            });

.github/workflows/windows.yaml

@@ -47,7 +47,8 @@ jobs:
           key: ${{ matrix.platform.target }}
       - run: cargo +nightly fmt --check
       - run: cargo clippy
-      - uses: houseabsolute/actions-rust-cross@v0
+      - run: cargo test --package komorebi --test compat
+      - uses: houseabsolute/actions-rust-cross@v1
         with:
           command: "build"
           target: ${{ matrix.platform.target }}
@@ -199,7 +200,7 @@ jobs:
     needs: release
     if: startsWith(github.ref, 'refs/tags/v')
     steps:
-      - uses: vedantmgoyal2009/winget-releaser@v2
+      - uses: vedantmgoyal2009/winget-releaser@main
         with:
           identifier: LGUG2Z.komorebi
           token: ${{ secrets.WINGET_TOKEN }}

Cargo.toml

@@ -17,9 +17,9 @@ chrono = "0.4"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 color-eyre = "0.6"
-eframe = "0.29"
-egui_extras = "0.29"
-dirs = "5"
+eframe = "0.31"
+egui_extras = "0.31"
+dirs = "6"
 dunce = "1"
 hotwatch = "0.5"
 schemars = "0.8"
@@ -27,33 +27,38 @@ lazy_static = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = { package = "serde_json_lenient", version = "0.2" }
 serde_yaml = "0.9"
+strum = { version = "0.27", features = ["derive"] }
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 paste = "1"
-sysinfo = "0.31"
+sysinfo = "0.33"
 uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "dd65e3f22d0521b78fcddde11abc2a3e9dcc32a8" }
-windows-implement = { version = "0.58" }
-windows-interface = { version = "0.58" }
-windows-core = { version = "0.58" }
-shadow-rs = "0.35"
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "55cebdebfbd68dbd14945a1ba90f6b05b7be2893" }
+windows-numerics = { version = "0.1" }
+windows-implement = { version = "0.59" }
+windows-interface = { version = "0.59" }
+windows-core = { version = "0.60" }
+shadow-rs = "1"
 which = "7"
 
 [workspace.dependencies.windows]
-version = "0.58"
+version = "0.60"
 features = [
-    "implement",
     "Foundation_Numerics",
+    "Win32_Devices",
+    "Win32_Devices_Display",
     "Win32_System_Com",
     "Win32_UI_Shell_Common", # for IObjectArray
     "Win32_Foundation",
+    "Win32_Globalization",
     "Win32_Graphics_Dwm",
     "Win32_Graphics_Gdi",
     "Win32_Graphics_Direct2D",
     "Win32_Graphics_Direct2D_Common",
     "Win32_Graphics_Dxgi_Common",
     "Win32_System_LibraryLoader",
+    "Win32_System_Power",
     "Win32_System_RemoteDesktop",
     "Win32_System_Threading",
     "Win32_UI_Accessibility",
@@ -66,4 +71,4 @@ features = [
     "Win32_System_WindowsProgramming",
     "Media",
     "Media_Control"
-]
+]

README.md

@@ -7,9 +7,9 @@ Tiling Window Management for Windows.
     <img alt="Tech for Palestine" src="https://badge.techforpalestine.org/default">
   </a>
   <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/LGUG2Z/komorebi/.github/workflows/windows.yaml">
-  <img alt="GitHub" src="https://img.shields.io/github/license/LGUG2Z/komorebi">
   <img alt="GitHub all releases" src="https://img.shields.io/github/downloads/LGUG2Z/komorebi/total">
   <img alt="GitHub commits since latest release (by date) for a branch" src="https://img.shields.io/github/commits-since/LGUG2Z/komorebi/latest">
+  <img alt="Active Individual Commercial Use Licenses" src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Flgug2z-ecstaticmagentacheetah.web.val.run&query=%24.&label=active%20individual%20commercial%20use%20licenses&cacheSeconds=3600&link=https%3A%2F%2Flgug2z.com%2Fsoftware%2Fkomorebi">
   <a href="https://discord.gg/mGkn66PHkx">
     <img alt="Discord" src="https://img.shields.io/discord/898554690126630914">
   </a>
@@ -29,6 +29,8 @@ Tiling Window Management for Windows.
 
 ![screenshot](https://user-images.githubusercontent.com/13164844/184027064-f5a6cec2-2865-4d65-a549-a1f1da589abf.png)
 
+## Overview
+
 _komorebi_ is a tiling window manager that works as an extension to Microsoft's
 [Desktop Window
 Manager](https://docs.microsoft.com/en-us/windows/win32/dwm/dwm-overview) in
@@ -50,6 +52,8 @@ _komorebi_, [common workflows](https://lgug2z.github.io/komorebi/common-workflow
 [configuration schema reference](https://komorebi.lgug2z.com/schema) and a
 complete [CLI reference](https://lgug2z.github.io/komorebi/cli/quickstart.html).
 
+## Community
+
 There is a [Discord server](https://discord.gg/mGkn66PHkx) available for
 _komorebi_-related discussion, help, troubleshooting etc. If you have any
 specific feature requests or bugs to report, please create an issue in this
@@ -57,28 +61,62 @@ repository.
 
 There is a [YouTube
 channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
-_komorebi_ development videos. If you would like to be notified of upcoming
-videos please subscribe and turn on notifications.
+_komorebi_ development videos, feature previews and release overviews. Subscribing
+to the channel (which is monetized as part of the YouTube Partner Program) and
+watching videos is a really simple and passive way to contribute financially to
+the development and maintenance of _komorebi_.
 
 There is an [Awesome List](https://github.com/LGUG2Z/awesome-komorebi) which
 showcases the many awesome projects that exist in the _komorebi_ ecosystem.
 
-_komorebi_ is a free and source-available project, and one that encourages you to
-make charitable donations if you find the software to be useful and have the
+## Licensing for Personal Use
+
+`komorebi` is licensed under the [Komorebi 1.0.0
+license](https://github.com/LGUG2Z/komorebi-license), which is a fork of the
+[PolyForm Strict 1.0.0
+license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
+this means that you are free to do whatever you want with `komorebi` for
+personal use other than redistribution, or distribution of new works (i.e.
+hard-forks) based on the software.
+
+Anyone is free to make their own fork of `komorebi` with changes intended either
+for personal use or for integration back upstream via pull requests.
+
+The [Komorebi 1.0.0 License](https://github.com/LGUG2Z/komorebi-license) does
+not permit any kind of commercial use (i.e. using `komorebi` at work).
+
+## Sponsorship for Personal Use
+
+_komorebi_ is a free and educational source project, and one that encourages you
+to make charitable donations if you find the software to be useful and have the
 financial means.
 
 I encourage you to make a charitable donation to the [Palestine Children's
-Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) or contributing
+Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) or to contribute
 to a [Gaza Funds campaign](https://gazafunds.com) before you consider sponsoring
 me on GitHub.
 
 [GitHub Sponsors is enabled for this
-project](https://github.com/sponsors/LGUG2Z). Unfortunately I don't have
-anything specific to offer besides my gratitude and shout outs at the end of
-_komorebi_ live development videos and tutorials.
+project](https://github.com/sponsors/LGUG2Z). Sponsors can claim custom roles on
+the Discord server, get shout outs at the end of _komorebi_-related videos on
+YouTube, and gain the ability to submit feature requests on the issue tracker.
 
 If you would like to tip or sponsor the project but are unable to use GitHub
-Sponsors, you may also sponsor through [Ko-fi](https://ko-fi.com/lgug2z).
+Sponsors, you may also sponsor through [Ko-fi](https://ko-fi.com/lgug2z), or
+make an anonymous Bitcoin donation to `bc1qv73wzspc77k46uty4vp85x8sdp24mphvm58f6q`.
+
+## Licensing for Commercial Use
+
+A dedicated Individual Commercial Use License is available for those who want to
+use `komorebi` at work.
+
+The Individual Commerical Use License adds “Commercial Use” as a “Permitted Use”
+for the licensed individual only, for the duration of a valid paid license
+subscription only. All provisions and restrictions enumerated in the [Komorebi
+License](https://github.com/LGUG2Z/komorebi-license) continue to apply.
+
+More information, pricing and purchase links for Individual Commercial Use
+Licenses [can be found here](https://lgug2z.com/software/komorebi).
 
 # Installation
 
@@ -125,7 +163,11 @@ https://user-images.githubusercontent.com/13164844/163496414-a9cde3d1-b8a7-4a7a-
 
 # Contribution Guidelines
 
-If you would like to contribute to `komorebi` please take the time to carefully read the guidelines below.
+If you would like to contribute to `komorebi` please take the time to carefully
+read the guidelines below.
+
+Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about how
+code contributions to `komorebi` are licensed.
 
 ## Commit hygiene
 
@@ -135,8 +177,8 @@ If you would like to contribute to `komorebi` please take the time to carefully
 - 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
-  changes being committed
+- 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
 
@@ -175,7 +217,8 @@ 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)
+- 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
@@ -191,27 +234,6 @@ ability for users to specify colours in `komorebi.json` in Hex format alongside
 There is also a process in place for graceful, non-breaking, deprecation of configuration options that are no longer
 required.
 
-## License
-
-`komorebi` is licensed under the [Komorebi 1.0.0 license](./LICENSE.md), which
-is a fork of the [PolyForm Strict 1.0.0
-license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
-this means that you are free to do whatever you want with `komorebi` for
-personal use other than redistribution, or distribution of new works (ie.
-hard-forks) based on the software.
-
-Anyone is free to make their own fork of `komorebi` with changes intended
-either for personal use or for integration back upstream via pull requests.
-
-The [Komorebi 1.0.0 License](./LICENSE.md) does not permit any kind of
-commercial use.
-
-A dedicated license and EULA will be introduced in 2025 for both commercial and
-noncommercial organizations.
-
-Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about how
-code contributions to `komorebi` are licensed.
-
 # Development
 
 If you use IntelliJ, you should enable the following settings to ensure that code generated by macros is recognised by
@@ -220,13 +242,13 @@ the IDE for completions and navigation:
 - Set `Expand declarative macros`
   to `Use new engine` under "Settings > Langauges & Frameworks > Rust"
 - Enable the following experimental features:
-  - `org.rust.cargo.evaluate.build.scripts`
-  - `org.rust.macros.proc`
+    - `org.rust.cargo.evaluate.build.scripts`
+    - `org.rust.macros.proc`
 
 # Logs and Debugging
 
-Logs from `komorebi` will be appended to `%LOCALAPPDATA%/komorebi/komorebi.log`; this file is never rotated or overwritten, so it will keep
-growing until it is deleted by the user.
+Logs from `komorebi` will be appended to `%LOCALAPPDATA%/komorebi/komorebi.log`; this file is never rotated or
+overwritten, so it will keep growing until it is deleted by the user.
 
 Whenever running the `komorebic stop` command or sending a Ctrl-C signal to `komorebi` directly, the `komorebi` process
 ensures that all hidden windows are restored before termination.
@@ -367,7 +389,7 @@ every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust c
 Below is a simple example of how to use `komorebi-client` in a basic Rust application.
 
 ```rust
-// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.30"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.34"}
 
 use anyhow::Result;
 use komorebi_client::Notification;
@@ -442,12 +464,17 @@ programming languages.
 
 # Appreciations
 
-- First and foremost, thank you to my wife, both for naming this project and for her patience throughout its never-ending development
+- First and foremost, thank you to my wife, both for naming this project and for her patience throughout its
+  never-ending development
 
-- Thank you to [@sitiom](https://github.com/sitiom) for being [an exemplary open source community leader](https://jeezy.substack.com/p/the-open-source-contributions-i-appreciate)
+- Thank you to [@sitiom](https://github.com/sitiom) for
+  being [an exemplary open source community leader](https://jeezy.substack.com/p/the-open-source-contributions-i-appreciate)
 
-- Thank you to the developers of [nog](https://github.com/TimUntersberger/nog) who came before me and whose work taught me more than I can ever hope to repay
+- Thank you to the developers of [nog](https://github.com/TimUntersberger/nog) who came before me and whose work taught
+  me more than I can ever hope to repay
 
-- Thank you to the developers of [GlazeWM](https://github.com/lars-berger/GlazeWM) for pushing the boundaries of tiling window management on Windows with me and having an excellent spirit of collaboration
+- Thank you to the developers of [GlazeWM](https://github.com/lars-berger/GlazeWM) for pushing the boundaries of tiling
+  window management on Windows with me and having an excellent spirit of collaboration
 
-- Thank you to [@Ciantic](https://github.com/Ciantic) for helping me bring the [hidden Virtual Desktops cloaking function](https://github.com/Ciantic/AltTabAccessor/issues/1) to `komorebi`
+- Thank you to [@Ciantic](https://github.com/Ciantic) for helping me bring
+  the [hidden Virtual Desktops cloaking function](https://github.com/Ciantic/AltTabAccessor/issues/1) to `komorebi`

docs/cli/animation-duration.md

@@ -3,13 +3,18 @@
 ```
 Set the duration for movement animations in ms
 
-Usage: komorebic.exe animation-duration <DURATION>
+Usage: komorebic.exe animation-duration [OPTIONS] <DURATION>
 
 Arguments:
   <DURATION>
           Desired animation durations in ms
 
 Options:
+  -a, --animation-type <ANIMATION_TYPE>
+          Animation type to apply the duration to. If not specified, sets global duration
+          
+          [possible values: movement, transparency]
+
   -h, --help
           Print help
 

docs/cli/animation-style.md

@@ -10,8 +10,14 @@ Options:
           Desired ease function for animation
           
           [default: linear]
-          [possible values: linear, ease-in-sine, ease-out-sine, ease-in-out-sine, ease-in-quad, ease-out-quad, ease-in-out-quad, ease-in-cubic, ease-in-out-cubic, ease-in-quart, ease-out-quart, ease-in-out-quart, ease-in-quint, ease-out-quint, ease-in-out-quint, ease-in-expo, ease-out-expo,
-          ease-in-out-expo, ease-in-circ, ease-out-circ, ease-in-out-circ, ease-in-back, ease-out-back, ease-in-out-back, ease-in-elastic, ease-out-elastic, ease-in-out-elastic, ease-in-bounce, ease-out-bounce, ease-in-out-bounce]
+          [possible values: linear, ease-in-sine, ease-out-sine, ease-in-out-sine, ease-in-quad, ease-out-quad, ease-in-out-quad, ease-in-cubic, ease-in-out-cubic, ease-in-quart,
+          ease-out-quart, ease-in-out-quart, ease-in-quint, ease-out-quint, ease-in-out-quint, ease-in-expo, ease-out-expo, ease-in-out-expo, ease-in-circ, ease-out-circ, ease-in-out-circ,
+          ease-in-back, ease-out-back, ease-in-out-back, ease-in-elastic, ease-out-elastic, ease-in-out-elastic, ease-in-bounce, ease-out-bounce, ease-in-out-bounce]
+
+  -a, --animation-type <ANIMATION_TYPE>
+          Animation type to apply the style to. If not specified, sets global style
+          
+          [possible values: movement, transparency]
 
   -h, --help
           Print help

docs/cli/animation.md

@@ -3,13 +3,18 @@
 ```
 Enable or disable movement animations
 
-Usage: komorebic.exe animation <BOOLEAN_STATE>
+Usage: komorebic.exe animation [OPTIONS] <BOOLEAN_STATE>
 
 Arguments:
   <BOOLEAN_STATE>
           [possible values: enable, disable]
 
 Options:
+  -a, --animation-type <ANIMATION_TYPE>
+          Animation type to apply the state to. If not specified, sets global state
+          
+          [possible values: movement, transparency]
+
   -h, --help
           Print help
 

docs/cli/check.md

@@ -3,9 +3,12 @@
 ```
 Check komorebi configuration and related files for common errors
 
-Usage: komorebic.exe check
+Usage: komorebic.exe check [OPTIONS]
 
 Options:
+  -k, --komorebi-config <KOMOREBI_CONFIG>
+          Path to a static configuration JSON file
+
   -h, --help
           Print help
 

docs/cli/close-workspace.md

@@ -0,0 +1,12 @@
+# close-workspace
+
+```
+Close the focused workspace (must be empty and unnamed)
+
+Usage: komorebic.exe close-workspace
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/cycle-stack-index.md

@@ -0,0 +1,16 @@
+# cycle-stack-index
+
+```
+Cycle the index of the focused window in the focused stack in the specified cycle direction
+
+Usage: komorebic.exe cycle-stack-index <CYCLE_DIRECTION>
+
+Arguments:
+  <CYCLE_DIRECTION>
+          [possible values: previous, next]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/eager-focus.md

@@ -0,0 +1,16 @@
+# eager-focus
+
+```
+Focus the first managed window matching the given exe
+
+Usage: komorebic.exe eager-focus <EXE>
+
+Arguments:
+  <EXE>
+          Case-sensitive exe identifier
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/enable-autostart.md

@@ -18,6 +18,9 @@ Options:
       --bar
           Enable autostart of komorebi-bar
 
+      --masir
+          Enable autostart of masir
+
   -h, --help
           Print help
 

docs/cli/enforce-workspace-rules.md

@@ -0,0 +1,12 @@
+# enforce-workspace-rules
+
+```
+Enforce all workspace rules, including initial workspace rules that have already been applied
+
+Usage: komorebic.exe enforce-workspace-rules
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/flip-layout.md

@@ -1,7 +1,7 @@
 # flip-layout
 
 ```
-Flip the layout on the focused workspace (BSP only)
+Flip the layout on the focused workspace
 
 Usage: komorebic.exe flip-layout <AXIS>
 

docs/cli/focus-monitor-at-cursor.md

@@ -0,0 +1,12 @@
+# focus-monitor-at-cursor
+
+```
+Focus the monitor at the current cursor location
+
+Usage: komorebic.exe focus-monitor-at-cursor
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/kill.md

@@ -0,0 +1,24 @@
+# kill
+
+```
+Kill background processes started by komorebic
+
+Usage: komorebic.exe kill [OPTIONS]
+
+Options:
+      --whkd
+          Kill whkd if it is running as a background process
+
+      --ahk
+          Kill ahk if it is running as a background process
+
+      --bar
+          Kill komorebi-bar if it is running as a background process
+
+      --masir
+          Kill masir if it is running as a background process
+
+  -h, --help
+          Print help
+
+```

docs/cli/query.md

@@ -7,7 +7,7 @@ Usage: komorebic.exe query <STATE_QUERY>
 
 Arguments:
   <STATE_QUERY>
-          [possible values: focused-monitor-index, focused-workspace-index, focused-container-index, focused-window-index]
+          [possible values: focused-monitor-index, focused-workspace-index, focused-container-index, focused-window-index, focused-workspace-name]
 
 Options:
   -h, --help

docs/cli/stackbar-mode.md

@@ -0,0 +1,18 @@
+# stackbar-mode
+
+```
+Set the stackbar mode
+
+Usage: komorebic.exe stackbar-mode <MODE>
+
+Arguments:
+  <MODE>
+          Desired stackbar mode
+          
+          [possible values: always, never, on-stack]
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/start.md

@@ -24,6 +24,12 @@ Options:
       --bar
           Start komorebi-bar in a background process
 
+      --masir
+          Start masir in a background process for focus-follows-mouse
+
+      --clean-state
+          Do not attempt to auto-apply a dumped state temp file from a previously running instance of komorebi
+
   -h, --help
           Print help
 

docs/cli/stop.md

@@ -15,6 +15,9 @@ Options:
       --bar
           Stop komorebi-bar if it is running as a background process
 
+      --masir
+          Stop masir if it is running as a background process
+
   -h, --help
           Print help
 

docs/cli/toggle-window-based-work-area-offset.md

@@ -0,0 +1,12 @@
+# toggle-window-based-work-area-offset
+
+```
+Toggle application of the window-based work area offset for the focused workspace
+
+Usage: komorebic.exe toggle-window-based-work-area-offset
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/toggle-workspace-float-override.md

@@ -1,7 +1,8 @@
 # toggle-workspace-float-override
 
 ```
-Enable or disable float override, which makes it so every new window opens in floating mode, for the currently focused workspace. If there was no override value set for the workspace previously it takes the opposite of the global value
+Enable or disable float override, which makes it so every new window opens in floating mode, for the currently focused workspace. If there was no override value set for the workspace
+previously it takes the opposite of the global value
 
 Usage: komorebic.exe toggle-workspace-float-override
 

docs/cli/toggle-workspace-layer.md

@@ -0,0 +1,12 @@
+# toggle-workspace-layer
+
+```
+Toggle between the Tiling and Floating layers on the focused workspace
+
+Usage: komorebic.exe toggle-workspace-layer
+
+Options:
+  -h, --help
+          Print help
+
+```

docs/cli/toggle-workspace-window-container-behaviour.md

@@ -1,7 +1,8 @@
 # toggle-workspace-window-container-behaviour
 
 ```
-Toggle the behaviour for new windows (stacking or dynamic tiling) for currently focused workspace. If there was no behaviour set for the workspace previously it takes the opposite of the global value
+Toggle the behaviour for new windows (stacking or dynamic tiling) for currently focused workspace. If there was no behaviour set for the workspace previously it takes the opposite of the
+global value
 
 Usage: komorebic.exe toggle-workspace-window-container-behaviour
 

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

@@ -26,5 +26,15 @@ 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.
 
+After setting `$Env:KOMOREBI_CONFIG_HOME`, make sure to update the path in komorebi.json:
+
+```json
+{
+  "app_specific_configuration_path": "$Env:KOMOREBI_CONFIG_HOME/applications.json"
+}
+```
+
+This ensures that komorebi can locate all configuration files correctly.
+
 [![Watch the tutorial
 video](https://img.youtube.com/vi/C_KWUqQ6kko/hqdefault.jpg)](https://www.youtube.com/watch?v=C_KWUqQ6kko)

docs/example-configurations.md

@@ -75,7 +75,7 @@ solo developer.
 
 If you choose to use the active window border, you can set different colours to
 give you visual queues when you are focused on a single window, a stack of
-windows, or a window that is in monocole mode.
+windows, or a window that is in monocle mode.
 
 The example colours given are blue single, green for stack and pink for
 monocle.
@@ -181,10 +181,10 @@ The `grid` layout does not support resizing windows tiles.
 key bindings go to the left of the colon, and shell commands go to the right of the
 colon.
 
-Please remember that `whkd` does not support overriding Microsoft's limitations
-on hotkey bindings that include the `Windows` key. If this is important to you,
-I recommend using [AutoHotKey](https://autohotkey.com) to set up your key
-bindings for `komorebic` commands instead.
+As of [`v0.2.4`](https://github.com/LGUG2Z/whkd/releases/tag/v0.2.4), `whkd` can override most of Microsoft's
+limitations on hotkey bindings that include the `win` key. However, you will still need
+to [modify the registry](https://superuser.com/questions/1059511/how-to-disable-winl-in-windows-10) to prevent
+`win + l` from locking the operating system.
 
 ```
 {% include "./whkdrc.sample" %}
@@ -203,7 +203,7 @@ It is also possible to change a hotkey behavior depending on which application h
 alt + n [
     # ProcessName as shown by `Get-Process`
     Firefox       : echo "hello firefox"
-    
+
     # Spaces are fine, no quotes required
     Google Chrome : echo "hello chrome"
 ]
@@ -254,5 +254,5 @@ stackbars as well as the status bar.
 If set in `komorebi.bar.json`, the theme will only be applied to the status bar.
 
 All [Catppuccin palette variants](https://catppuccin.com/)
-and [most Base16 palette variants](https://tinted-theming.github.io/base16-gallery/)
+and [most Base16 palette variants](https://tinted-theming.github.io/tinted-gallery/)
 are available as themes.

docs/index.md

@@ -1,5 +1,7 @@
 ![screenshot](https://user-images.githubusercontent.com/13164844/184027064-f5a6cec2-2865-4d65-a549-a1f1da589abf.png)
 
+## Overview
+
 `komorebi` is a tiling window manager that works as an extension to Microsoft's
 [Desktop Window
 Manager](https://docs.microsoft.com/en-us/windows/win32/dwm/dwm-overview) in
@@ -15,12 +17,63 @@ system and desktop environment by default. Users are free to make such
 modifications in their own configuration files for `komorebi`, but these will
 always remain opt-in and off-by-default.
 
+## Community
+
 There is a [Discord server](https://discord.gg/mGkn66PHkx) available for
-`komorebi`-related discussion, help, troubleshooting etc. If you have any
-specific feature requests or bugs to report, please create an issue on
-[GitHub](https://github.com/LGUG2Z/komorebi).
+`komorebi`-related discussion, help, troubleshooting etc.
 
+There is a [YouTube
+channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
+`komorebi` development videos, feature previews and release overviews. Subscribing
+to the channel (which is monetized as part of the YouTube Partner Program) and
+watching videos is a really simple and passive way to contribute financially to
+the development and maintenance of `komorebi`.
 
-There is also a [YouTube
-channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg?sub_confirmation=1)
-where I share `komorebi` live programming videos and tutorial videos.
+There is an [Awesome List](https://github.com/LGUG2Z/awesome-komorebi) which
+showcases the many awesome projects that exist in the `komorebi` ecosystem.
+
+## Licensing for Personal Use
+
+`komorebi` is licensed under the [Komorebi 1.0.0 license](https://github.com/LGUG2Z/komorebi-license), which is a fork
+of the [PolyForm Strict 1.0.0 license](https://polyformproject.org/licenses/strict/1.0.0). On a high level this means
+that you are free to do whatever you want with `komorebi` for personal use other than redistribution, or distribution of
+new works (i.e. hard-forks) based on the software.
+
+Anyone is free to make their own fork of `komorebi` with changes intended either for personal use or for integration
+back upstream via pull requests.
+
+The [Komorebi 1.0.0 License](https://github.com/LGUG2Z/komorebi-license) does not permit any kind of commercial use (
+i.e. using `komorebi` at work).
+
+## Sponsorship for Personal Use
+
+`komorebi` is a free and educational source project, and one that encourages you
+to make charitable donations if you find the software to be useful and have the
+financial means.
+
+I encourage you to make a charitable donation to the [Palestine Children's
+Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) or to contribute
+to a [Gaza Funds campaign](https://gazafunds.com) before you consider sponsoring
+me on GitHub.
+
+[GitHub Sponsors is enabled for this
+project](https://github.com/sponsors/LGUG2Z). Sponsors can claim custom roles on
+the Discord server, get shout-outs at the end of _komorebi_-related videos on
+YouTube, and gain the ability to submit feature requests on the issue tracker.
+
+If you would like to tip or sponsor the project but are unable to use GitHub
+Sponsors, you may also sponsor through [Ko-fi](https://ko-fi.com/lgug2z), or
+make an anonymous Bitcoin donation to `bc1qv73wzspc77k46uty4vp85x8sdp24mphvm58f6q`.
+
+## Licensing for Commercial Use
+
+A dedicated Individual Commercial Use License is available for those who want to
+use `komorebi` at work.
+
+The Individual Commerical Use License adds “Commercial Use” as a “Permitted Use”
+for the licensed individual only, for the duration of a valid paid license
+subscription only. All provisions and restrictions enumerated in the [Komorebi
+License](https://github.com/LGUG2Z/komorebi-license) continue to apply.
+
+More information, pricing and purchase links for Individual Commercial Use
+Licenses [can be found here](https://lgug2z.com/software/komorebi).

docs/komorebi.bar.example.json

@@ -1,14 +1,6 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.30/schema.bar.json",
-  "monitor": {
-    "index": 0,
-    "work_area_offset": {
-      "left": 0,
-      "top": 40,
-      "right": 0,
-      "bottom": 40
-    }
-  },
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.34/schema.bar.json",
+  "monitor": 0,
   "font_family": "JetBrains Mono",
   "theme": {
     "palette": "Base16",
@@ -33,6 +25,11 @@
     }
   ],
   "right_widgets": [
+    {
+      "Update": {
+        "enable": true
+      }
+    },
     {
       "Media": {
         "enable": true
@@ -73,4 +70,4 @@
       }
     }
   ]
-}
+}

docs/komorebi.example.json

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

justfile

@@ -1,4 +1,5 @@
 set windows-shell := ["pwsh.exe", "-NoLogo", "-Command"]
+
 export RUST_BACKTRACE := "full"
 
 clean:
@@ -18,13 +19,43 @@ install-targets *targets:
     "{{ targets }}" -split ' ' | ForEach-Object { just install-target $_ }
 
 install-target target:
+    cargo +stable install --path {{ target }} --locked --no-default-features
+
+install-targets-with-jsonschema *targets:
+    "{{ targets }}" -split ' ' | ForEach-Object { just install-target-with-jsonschema $_ }
+
+install-target-with-jsonschema target:
     cargo +stable install --path {{ target }} --locked
 
 install:
     just install-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
 
+install-with-jsonschema:
+    just install-targets-with-jsonschema komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
+
+build-targets *targets:
+    "{{ targets }}" -split ' ' | ForEach-Object { just build-target $_ }
+
+build-target target:
+    cargo +stable build --package {{ target }} --locked --release --no-default-features
+
+build:
+    just build-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
+
+copy-target target:
+    cp .\target\release\{{ target }}.exe $Env:USERPROFILE\.cargo\bin
+
+copy-targets *targets:
+    "{{ targets }}" -split ' ' | ForEach-Object { just copy-target $_ }
+
+wpm target:
+    just build-target {{ target }} && wpmctl stop {{ target }}; just copy-target {{ target }} && wpmctl start {{ target }}
+
+copy:
+    just copy-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
+
 run target:
-    cargo +stable run --bin {{ target }} --locked
+    cargo +stable run --bin {{ target }} --locked --no-default-features
 
 warn target $RUST_LOG="warn":
     just run {{ target }}
@@ -39,19 +70,21 @@ trace target $RUST_LOG="trace":
     just run {{ target }}
 
 deadlock $RUST_LOG="trace":
-    cargo +stable run --bin komorebi --locked --features deadlock_detection
+    cargo +stable run --bin komorebi --locked --no-default-features --features deadlock_detection
 
 docgen:
     cargo run --package komorebic -- docgen
     Get-ChildItem -Path "docs/cli" -Recurse -File | ForEach-Object { (Get-Content $_.FullName) -replace 'Usage: ', 'Usage: komorebic.exe ' | Set-Content $_.FullName }
 
-schemagen:
+jsonschema:
     cargo run --package komorebic -- static-config-schema > schema.json
     cargo run --package komorebic -- application-specific-configuration-schema > schema.asc.json
     cargo run --package komorebi-bar -- --schema > schema.bar.json
-    generate-schema-doc .\schema.json --config template_name=js_offline --config minify=false .\static-config-docs\
 
-    generate-schema-doc .\schema.bar.json --config template_name=js_offline --config minify=false .\bar-config-docs\
-
-    rm -Force .\bar-config-docs\schema.html
-    mv .\bar-config-docs\schema.bar.html .\bar-config-docs\schema.html
+# this part is run in a nix shell because python is a nightmare
+schemagen:
+    rm -rf static-config-docs bar-config-docs
+    mkdir -p static-config-docs bar-config-docs
+    generate-schema-doc ./schema.json --config template_name=js_offline --config minify=false ./static-config-docs/
+    generate-schema-doc ./schema.bar.json --config template_name=js_offline --config minify=false ./bar-config-docs/
+    mv ./bar-config-docs/schema.bar.html ./bar-config-docs/schema.html

komorebi-bar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.31"
+version = "0.1.35"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -16,16 +16,17 @@ crossbeam-channel = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 eframe = { workspace = true }
-egui-phosphor = "0.7"
+egui-phosphor = "0.9"
 font-loader = "0.11"
 hotwatch = { workspace = true }
 image = "0.25"
-netdev = "0.31"
+netdev = "0.32"
 num = "0.4"
 num-derive = "0.4"
 num-traits = "0.2"
 random_word = { version = "0.4", features = ["en"] }
-schemars = { workspace = true }
+reqwest = { version = "0.12", features = ["blocking"] }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 starship-battery = "0.10"
@@ -33,4 +34,9 @@ sysinfo = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 windows = { workspace = true }
-windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }
+windows-core = { workspace = true }
+windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }
+
+[features]
+default = ["schemars"]
+schemars = ["dep:schemars"]

komorebi-bar/src/battery.rs

@@ -1,27 +1,29 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use starship_battery::units::ratio::percent;
 use starship_battery::Manager;
 use starship_battery::State;
+use std::process::Command;
 use std::time::Duration;
 use std::time::Instant;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct BatteryConfig {
     /// Enable the Battery widget
     pub enable: bool,
+    /// Hide the widget if the battery is at full charge
+    pub hide_on_full_charge: Option<bool>,
     /// Data refresh interval (default: 10 seconds)
     pub data_refresh_interval: Option<u64>,
     /// Display label prefix
@@ -30,37 +32,19 @@ pub struct BatteryConfig {
 
 impl From<BatteryConfig> for Battery {
     fn from(value: BatteryConfig) -> Self {
-        let manager = Manager::new().unwrap();
-        let mut last_state = String::new();
-        let mut state = None;
-        let prefix = value.label_prefix.unwrap_or(LabelPrefix::Icon);
-
-        if let Ok(mut batteries) = manager.batteries() {
-            if let Some(Ok(first)) = batteries.nth(0) {
-                let percentage = first.state_of_charge().get::<percent>();
-                match first.state() {
-                    State::Charging => state = Some(BatteryState::Charging),
-                    State::Discharging => state = Some(BatteryState::Discharging),
-                    _ => {}
-                }
-
-                last_state = match prefix {
-                    LabelPrefix::Text | LabelPrefix::IconAndText => {
-                        format!("BAT: {percentage:.0}%")
-                    }
-                    LabelPrefix::None | LabelPrefix::Icon => format!("{percentage:.0}%"),
-                }
-            }
-        }
+        let data_refresh_interval = value.data_refresh_interval.unwrap_or(10);
 
         Self {
             enable: value.enable,
-            manager,
-            last_state,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            label_prefix: prefix,
-            state: state.unwrap_or(BatteryState::Discharging),
-            last_updated: Instant::now(),
+            hide_on_full_charge: value.hide_on_full_charge.unwrap_or(false),
+            manager: Manager::new().unwrap(),
+            last_state: String::new(),
+            data_refresh_interval,
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
+            state: BatteryState::Discharging,
+            last_updated: Instant::now()
+                .checked_sub(Duration::from_secs(data_refresh_interval))
+                .unwrap(),
         }
     }
 }
@@ -72,6 +56,7 @@ pub enum BatteryState {
 
 pub struct Battery {
     pub enable: bool,
+    hide_on_full_charge: bool,
     manager: Manager,
     pub state: BatteryState,
     data_refresh_interval: u64,
@@ -91,17 +76,22 @@ impl Battery {
             if let Ok(mut batteries) = self.manager.batteries() {
                 if let Some(Ok(first)) = batteries.nth(0) {
                     let percentage = first.state_of_charge().get::<percent>();
-                    match first.state() {
-                        State::Charging => self.state = BatteryState::Charging,
-                        State::Discharging => self.state = BatteryState::Discharging,
-                        _ => {}
-                    }
 
-                    output = match self.label_prefix {
-                        LabelPrefix::Text | LabelPrefix::IconAndText => {
-                            format!("BAT: {percentage:.0}%")
+                    if percentage == 100.0 && self.hide_on_full_charge {
+                        output = String::new()
+                    } else {
+                        match first.state() {
+                            State::Charging => self.state = BatteryState::Charging,
+                            State::Discharging => self.state = BatteryState::Discharging,
+                            _ => {}
+                        }
+
+                        output = match self.label_prefix {
+                            LabelPrefix::Text | LabelPrefix::IconAndText => {
+                                format!("BAT: {percentage:.0}%")
+                            }
+                            LabelPrefix::None | LabelPrefix::Icon => format!("{percentage:.0}%"),
                         }
-                        LabelPrefix::None | LabelPrefix::Icon => format!("{percentage:.0}%"),
                     }
                 }
             }
@@ -124,19 +114,12 @@ impl BarWidget for Battery {
                     BatteryState::Discharging => egui_phosphor::regular::BATTERY_FULL,
                 };
 
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
                         LabelPrefix::Icon | LabelPrefix::IconAndText => emoji.to_string(),
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -144,15 +127,26 @@ impl BarWidget for Battery {
                 layout_job.append(
                     &output,
                     10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
                 );
 
-                config.apply_on_widget(true, ui, |ui| {
-                    ui.add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    );
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
+                        .clicked()
+                    {
+                        if let Err(error) = Command::new("cmd.exe")
+                            .args(["/C", "start", "ms-settings:batterysaver"])
+                            .spawn()
+                        {
+                            eprintln!("{}", error)
+                        }
+                    }
                 });
             }
         }

komorebi-bar/src/config.rs

@@ -1,30 +1,85 @@
 use crate::render::Grouping;
 use crate::widget::WidgetConfig;
+use crate::DEFAULT_PADDING;
 use eframe::egui::Pos2;
 use eframe::egui::TextBuffer;
 use eframe::egui::Vec2;
 use komorebi_client::KomorebiTheme;
 use komorebi_client::Rect;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::path::PathBuf;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.31`
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+/// The `komorebi.bar.json` configuration file reference for `v0.1.35`
 pub struct KomobarConfig {
+    /// Bar height (default: 50)
+    pub height: Option<f32>,
+    /// Bar padding. Use one value for all sides or use a grouped padding for horizontal and/or
+    /// vertical definition which can each take a single value for a symmetric padding or two
+    /// values for each side, i.e.:
+    /// ```json
+    /// "padding": {
+    ///     "horizontal": 10
+    /// }
+    /// ```
+    /// or:
+    /// ```json
+    /// "padding": {
+    ///     "horizontal": [left, right]
+    /// }
+    /// ```
+    /// You can also set individual padding on each side like this:
+    /// ```json
+    /// "padding": {
+    ///     "top": 10,
+    ///     "bottom": 10,
+    ///     "left": 10,
+    ///     "right": 10,
+    /// }
+    /// ```
+    /// By default, padding is set to 10 on all sides.
+    pub padding: Option<Padding>,
+    /// Bar margin. Use one value for all sides or use a grouped margin for horizontal and/or
+    /// vertical definition which can each take a single value for a symmetric margin or two
+    /// values for each side, i.e.:
+    /// ```json
+    /// "margin": {
+    ///     "horizontal": 10
+    /// }
+    /// ```
+    /// or:
+    /// ```json
+    /// "margin": {
+    ///     "vertical": [top, bottom]
+    /// }
+    /// ```
+    /// You can also set individual margin on each side like this:
+    /// ```json
+    /// "margin": {
+    ///     "top": 10,
+    ///     "bottom": 10,
+    ///     "left": 10,
+    ///     "right": 10,
+    /// }
+    /// ```
+    /// By default, margin is set to 0 on all sides.
+    pub margin: Option<Margin>,
     /// Bar positioning options
     #[serde(alias = "viewport")]
     pub position: Option<PositionConfig>,
     /// Frame options (see: https://docs.rs/egui/latest/egui/containers/frame/struct.Frame.html)
     pub frame: Option<FrameConfig>,
-    /// Monitor options
-    pub monitor: MonitorConfig,
+    /// The monitor index or the full monitor options
+    pub monitor: MonitorConfigOrIndex,
     /// Font family
     pub font_family: Option<String>,
     /// Font size (default: 12.5)
     pub font_size: Option<f32>,
+    /// Scale of the icons relative to the font_size [[1.0-2.0]]. (default: 1.4)
+    pub icon_scale: Option<f32>,
     /// Max label width before text truncation (default: 400.0)
     pub max_label_width: Option<f32>,
     /// Theme
@@ -70,9 +125,19 @@ impl KomobarConfig {
             }
         }
     }
+
+    pub fn show_all_icons_on_komorebi_workspace(widgets: &[WidgetConfig]) -> bool {
+        widgets
+            .iter()
+            .any(|w| matches!(w, WidgetConfig::Komorebi(config) if config.workspaces.is_some_and(|w| w.enable && w.display.is_some_and(|s| matches!(s,
+            WorkspacesDisplayFormat::AllIcons
+            | WorkspacesDisplayFormat::AllIconsAndText
+            | WorkspacesDisplayFormat::AllIconsAndTextOnSelected)))))
+    }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct PositionConfig {
     /// The desired starting position of the bar (0,0 = top left of the screen)
     #[serde(alias = "position")]
@@ -82,13 +147,25 @@ pub struct PositionConfig {
     pub end: Option<Position>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct FrameConfig {
     /// Margin inside the painted frame
     pub inner_margin: Position,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+pub enum MonitorConfigOrIndex {
+    /// The monitor index where you want the bar to show
+    Index(usize),
+    /// The full monitor options with the index and an optional work_area_offset
+    MonitorConfig(MonitorConfig),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MonitorConfig {
     /// Komorebi monitor index of the monitor on which to render the bar
     pub index: usize,
@@ -96,6 +173,158 @@ pub struct MonitorConfig {
     pub work_area_offset: Option<Rect>,
 }
 
+pub type Padding = SpacingKind;
+pub type Margin = SpacingKind;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+// WARNING: To any developer messing with this code in the future: The order here matters!
+// `Grouped` needs to come last, otherwise serde might mistaken an `IndividualSpacingConfig` for a
+// `GroupedSpacingConfig` with both `vertical` and `horizontal` set to `None` ignoring the
+// individual values.
+pub enum SpacingKind {
+    All(f32),
+    Individual(IndividualSpacingConfig),
+    Grouped(GroupedSpacingConfig),
+}
+
+impl SpacingKind {
+    pub fn to_individual(&self, default: f32) -> IndividualSpacingConfig {
+        match self {
+            SpacingKind::All(m) => IndividualSpacingConfig::all(*m),
+            SpacingKind::Grouped(grouped_spacing_config) => {
+                let vm = grouped_spacing_config.vertical.as_ref().map_or(
+                    IndividualSpacingConfig::vertical(default),
+                    |vm| match vm {
+                        GroupedSpacingOptions::Symmetrical(m) => {
+                            IndividualSpacingConfig::vertical(*m)
+                        }
+                        GroupedSpacingOptions::Split(tm, bm) => {
+                            IndividualSpacingConfig::vertical(*tm).bottom(*bm)
+                        }
+                    },
+                );
+                let hm = grouped_spacing_config.horizontal.as_ref().map_or(
+                    IndividualSpacingConfig::horizontal(default),
+                    |hm| match hm {
+                        GroupedSpacingOptions::Symmetrical(m) => {
+                            IndividualSpacingConfig::horizontal(*m)
+                        }
+                        GroupedSpacingOptions::Split(lm, rm) => {
+                            IndividualSpacingConfig::horizontal(*lm).right(*rm)
+                        }
+                    },
+                );
+                IndividualSpacingConfig {
+                    top: vm.top,
+                    bottom: vm.bottom,
+                    left: hm.left,
+                    right: hm.right,
+                }
+            }
+            SpacingKind::Individual(m) => *m,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct GroupedSpacingConfig {
+    pub vertical: Option<GroupedSpacingOptions>,
+    pub horizontal: Option<GroupedSpacingOptions>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+pub enum GroupedSpacingOptions {
+    Symmetrical(f32),
+    Split(f32, f32),
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct IndividualSpacingConfig {
+    pub top: f32,
+    pub bottom: f32,
+    pub left: f32,
+    pub right: f32,
+}
+
+#[allow(dead_code)]
+impl IndividualSpacingConfig {
+    pub const ZERO: Self = IndividualSpacingConfig {
+        top: 0.0,
+        bottom: 0.0,
+        left: 0.0,
+        right: 0.0,
+    };
+
+    pub fn all(value: f32) -> Self {
+        IndividualSpacingConfig {
+            top: value,
+            bottom: value,
+            left: value,
+            right: value,
+        }
+    }
+
+    pub fn horizontal(value: f32) -> Self {
+        IndividualSpacingConfig {
+            top: 0.0,
+            bottom: 0.0,
+            left: value,
+            right: value,
+        }
+    }
+
+    pub fn vertical(value: f32) -> Self {
+        IndividualSpacingConfig {
+            top: value,
+            bottom: value,
+            left: 0.0,
+            right: 0.0,
+        }
+    }
+
+    pub fn top(self, value: f32) -> Self {
+        IndividualSpacingConfig { top: value, ..self }
+    }
+
+    pub fn bottom(self, value: f32) -> Self {
+        IndividualSpacingConfig {
+            bottom: value,
+            ..self
+        }
+    }
+
+    pub fn left(self, value: f32) -> Self {
+        IndividualSpacingConfig {
+            left: value,
+            ..self
+        }
+    }
+
+    pub fn right(self, value: f32) -> Self {
+        IndividualSpacingConfig {
+            right: value,
+            ..self
+        }
+    }
+}
+
+pub fn get_individual_spacing(
+    default: f32,
+    spacing: &Option<SpacingKind>,
+) -> IndividualSpacingConfig {
+    spacing
+        .as_ref()
+        .map_or(IndividualSpacingConfig::all(default), |s| {
+            s.to_individual(default)
+        })
+}
+
 impl KomobarConfig {
     pub fn read(path: &PathBuf) -> color_eyre::Result<Self> {
         let content = std::fs::read_to_string(path)?;
@@ -106,7 +335,10 @@ impl KomobarConfig {
 
         if value.frame.is_none() {
             value.frame = Some(FrameConfig {
-                inner_margin: Position { x: 10.0, y: 10.0 },
+                inner_margin: Position {
+                    x: DEFAULT_PADDING,
+                    y: DEFAULT_PADDING,
+                },
             });
         }
 
@@ -114,7 +346,8 @@ impl KomobarConfig {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Position {
     /// X coordinate
     pub x: f32,
@@ -140,7 +373,8 @@ impl From<Position> for Pos2 {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "palette")]
 pub enum KomobarTheme {
     /// A theme from catppuccin-egui
@@ -151,7 +385,7 @@ pub enum KomobarTheme {
     },
     /// A theme from base16-egui-themes
     Base16 {
-        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)
+        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)
         name: komorebi_themes::Base16,
         accent: Option<komorebi_themes::Base16Value>,
     },
@@ -176,7 +410,8 @@ impl From<KomorebiTheme> for KomobarTheme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum LabelPrefix {
     /// Show no prefix
     None,
@@ -188,12 +423,104 @@ pub enum LabelPrefix {
     IconAndText,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum DisplayFormat {
     /// Show only icon
     Icon,
     /// Show only text
     Text,
+    /// Show an icon and text for the selected element, and text on the rest
+    TextAndIconOnSelected,
     /// Show both icon and text
     IconAndText,
+    /// Show an icon and text for the selected element, and icons on the rest
+    IconAndTextOnSelected,
+}
+
+macro_rules! extend_enum {
+    ($existing_enum:ident, $new_enum:ident, { $($(#[$meta:meta])* $variant:ident),* $(,)? }) => {
+        #[derive(Copy, Clone, Debug, serde::Serialize, serde::Deserialize, PartialEq)]
+        #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+        pub enum $new_enum {
+            // Add new variants
+            $(
+                $(#[$meta])*
+                $variant,
+            )*
+            // Include a variant that wraps the existing enum and flatten it when deserializing
+            #[serde(untagged)]
+            Existing($existing_enum),
+        }
+
+        // Implement From for the existing enum
+        impl From<$existing_enum> for $new_enum {
+            fn from(value: $existing_enum) -> Self {
+                $new_enum::Existing(value)
+            }
+        }
+    };
+}
+
+extend_enum!(DisplayFormat, WorkspacesDisplayFormat, {
+    /// Show all icons only
+    AllIcons,
+    /// Show both all icons and text
+    AllIconsAndText,
+    /// Show all icons and text for the selected element, and all icons on the rest
+    AllIconsAndTextOnSelected,
+});
+
+#[cfg(test)]
+mod tests {
+    use serde::Deserialize;
+    use serde::Serialize;
+    use serde_json::json;
+
+    #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
+    pub enum OriginalDisplayFormat {
+        /// Show None Of The Things
+        NoneOfTheThings,
+    }
+
+    extend_enum!(OriginalDisplayFormat, ExtendedDisplayFormat, {
+        /// Show Some Of The Things
+        SomeOfTheThings,
+    });
+
+    #[derive(serde::Deserialize)]
+    struct ExampleConfig {
+        #[allow(unused)]
+        format: ExtendedDisplayFormat,
+    }
+
+    #[test]
+    pub fn extend_new_variant() {
+        let raw = json!({
+            "format": "SomeOfTheThings",
+        })
+        .to_string();
+
+        assert!(serde_json::from_str::<ExampleConfig>(&raw).is_ok())
+    }
+
+    #[test]
+    pub fn extend_existing_variant() {
+        let raw = json!({
+            "format": "NoneOfTheThings",
+        })
+        .to_string();
+
+        assert!(serde_json::from_str::<ExampleConfig>(&raw).is_ok())
+    }
+
+    #[test]
+    pub fn extend_invalid_variant() {
+        let raw = json!({
+            "format": "ALLOFTHETHINGS",
+        })
+        .to_string();
+
+        assert!(serde_json::from_str::<ExampleConfig>(&raw).is_err())
+    }
 }

komorebi-bar/src/cpu.rs

@@ -1,15 +1,13 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -18,7 +16,8 @@ use std::time::Instant;
 use sysinfo::RefreshKind;
 use sysinfo::System;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct CpuConfig {
     /// Enable the Cpu widget
     pub enable: bool,
@@ -30,17 +29,18 @@ pub struct CpuConfig {
 
 impl From<CpuConfig> for Cpu {
     fn from(value: CpuConfig) -> Self {
-        let mut system =
-            System::new_with_specifics(RefreshKind::default().without_memory().without_processes());
-
-        system.refresh_cpu_usage();
+        let data_refresh_interval = value.data_refresh_interval.unwrap_or(10);
 
         Self {
             enable: value.enable,
-            system,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            system: System::new_with_specifics(
+                RefreshKind::default().without_memory().without_processes(),
+            ),
+            data_refresh_interval,
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
-            last_updated: Instant::now(),
+            last_updated: Instant::now()
+                .checked_sub(Duration::from_secs(data_refresh_interval))
+                .unwrap(),
         }
     }
 }
@@ -74,13 +74,6 @@ impl BarWidget for Cpu {
         if self.enable {
             let output = self.output();
             if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
                         LabelPrefix::Icon | LabelPrefix::IconAndText => {
@@ -88,7 +81,7 @@ impl BarWidget for Cpu {
                         }
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -96,16 +89,17 @@ impl BarWidget for Cpu {
                 layout_job.append(
                     &output,
                     10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
                 );
 
-                config.apply_on_widget(true, ui, |ui| {
-                    if ui
-                        .add(
-                            Label::new(layout_job)
-                                .selectable(false)
-                                .sense(Sense::click()),
-                        )
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
                     {
                         if let Err(error) =

komorebi-bar/src/date.rs

@@ -1,20 +1,62 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
 use eframe::egui::WidgetText;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+/// Custom format with additive modifiers for integer format specifiers
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct CustomModifiers {
+    /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    format: String,
+    /// Additive modifiers for integer format specifiers (e.g. { "%U": 1 } to increment the zero-indexed week number by 1)
+    modifiers: std::collections::HashMap<String, i32>,
+}
+
+impl CustomModifiers {
+    fn apply(&self, output: &str) -> String {
+        let int_formatters = vec![
+            "%Y", "%C", "%y", "%m", "%d", "%e", "%w", "%u", "%U", "%W", "%G", "%g", "%V", "%j",
+            "%H", "%k", "%I", "%l", "%M", "%S", "%f",
+        ];
+
+        let mut modified_output = output.to_string();
+
+        for (modifier, value) in &self.modifiers {
+            // check if formatter is integer type
+            if !int_formatters.contains(&modifier.as_str()) {
+                continue;
+            }
+
+            // get the strftime value of modifier
+            let formatted_modifier = chrono::Local::now().format(modifier).to_string();
+
+            // find the gotten value in the original output
+            if let Some(pos) = modified_output.find(&formatted_modifier) {
+                let start = pos;
+                let end = start + formatted_modifier.len();
+                // replace that value with the modified value
+                if let Ok(num) = formatted_modifier.parse::<i32>() {
+                    modified_output.replace_range(start..end, &(num + value).to_string());
+                }
+            }
+        }
+
+        modified_output
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct DateConfig {
     /// Enable the Date widget
     pub enable: bool,
@@ -34,7 +76,8 @@ impl From<DateConfig> for Date {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum DateFormat {
     /// Month/Date/Year format (09/08/24)
     MonthDateYear,
@@ -46,6 +89,8 @@ pub enum DateFormat {
     DayDateMonthYear,
     /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
     Custom(String),
+    /// Custom format with modifiers
+    CustomModifiers(CustomModifiers),
 }
 
 impl DateFormat {
@@ -59,13 +104,14 @@ impl DateFormat {
         };
     }
 
-    fn fmt_string(&self) -> String {
+    pub fn fmt_string(&self) -> String {
         match self {
             DateFormat::MonthDateYear => String::from("%D"),
             DateFormat::YearMonthDate => String::from("%F"),
             DateFormat::DateMonthYear => String::from("%v"),
             DateFormat::DayDateMonthYear => String::from("%A %e %B %Y"),
             DateFormat::Custom(custom) => custom.to_string(),
+            DateFormat::CustomModifiers(custom) => custom.format.clone(),
         }
     }
 }
@@ -79,9 +125,15 @@ pub struct Date {
 
 impl Date {
     fn output(&mut self) -> String {
-        chrono::Local::now()
+        let formatted = chrono::Local::now()
             .format(&self.format.fmt_string())
-            .to_string()
+            .to_string();
+
+        // if custom modifiers are used, apply them
+        match &self.format {
+            DateFormat::CustomModifiers(custom) => custom.apply(&formatted),
+            _ => formatted,
+        }
     }
 }
 
@@ -90,13 +142,6 @@ impl BarWidget for Date {
         if self.enable {
             let mut output = self.output();
             if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
                         LabelPrefix::Icon | LabelPrefix::IconAndText => {
@@ -104,7 +149,7 @@ impl BarWidget for Date {
                         }
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -116,16 +161,22 @@ impl BarWidget for Date {
                 layout_job.append(
                     &output,
                     10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
                 );
 
-                config.apply_on_widget(true, ui, |ui| {
-                    if ui
-                        .add(
-                            Label::new(WidgetText::LayoutJob(layout_job.clone()))
-                                .selectable(false)
-                                .sense(Sense::click()),
-                        )
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| {
+                            ui.add(
+                                Label::new(WidgetText::LayoutJob(layout_job.clone()))
+                                    .selectable(false),
+                            )
+                        })
                         .clicked()
                     {
                         self.format.next()

komorebi-bar/src/keyboard.rs

@@ -0,0 +1,177 @@
+use crate::config::LabelPrefix;
+use crate::render::RenderConfig;
+use crate::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
+use eframe::egui::Context;
+use eframe::egui::Label;
+use eframe::egui::TextFormat;
+use eframe::egui::Ui;
+use eframe::egui::WidgetText;
+use serde::Deserialize;
+use serde::Serialize;
+use std::time::Duration;
+use std::time::Instant;
+use windows::Win32::Globalization::LCIDToLocaleName;
+use windows::Win32::Globalization::LOCALE_ALLOW_NEUTRAL_NAMES;
+use windows::Win32::System::SystemServices::LOCALE_NAME_MAX_LENGTH;
+use windows::Win32::UI::Input::KeyboardAndMouse::GetKeyboardLayout;
+use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
+
+const DEFAULT_DATA_REFRESH_INTERVAL: u64 = 1;
+const ERROR_TEXT: &str = "Error";
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct KeyboardConfig {
+    /// Enable the Input widget
+    pub enable: bool,
+    /// Data refresh interval (default: 1 second)
+    pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
+}
+
+impl From<KeyboardConfig> for Keyboard {
+    fn from(value: KeyboardConfig) -> Self {
+        let data_refresh_interval = value
+            .data_refresh_interval
+            .unwrap_or(DEFAULT_DATA_REFRESH_INTERVAL);
+
+        Self {
+            enable: value.enable,
+            data_refresh_interval,
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
+            last_updated: Instant::now(),
+            lang_name: get_lang(),
+        }
+    }
+}
+
+pub struct Keyboard {
+    pub enable: bool,
+    data_refresh_interval: u64,
+    label_prefix: LabelPrefix,
+    last_updated: Instant,
+    lang_name: String,
+}
+
+/// Retrieves the name of the active keyboard layout for the current foreground window.
+///
+/// This function determines the active keyboard layout by querying the system for the
+/// foreground window's thread ID and its associated keyboard layout. It then attempts
+/// to retrieve the locale name corresponding to the keyboard layout.
+///
+/// # Failure Cases
+///
+/// This function can fail in two distinct scenarios:
+///
+/// 1. **Failure to Retrieve the Locale Name**:
+///    If the system fails to retrieve the locale name (e.g., due to an invalid or unsupported
+///    language identifier), the function will return `Err(())`.
+///
+/// 2. **Invalid UTF-16 Characters in the Locale Name**:
+///    If the retrieved locale name contains invalid UTF-16 sequences, the conversion to a Rust
+///    `String` will fail, and the function will return `Err(())`.
+///
+/// # Returns
+///
+/// - `Ok(String)`: The name of the active keyboard layout as a valid UTF-8 string.
+/// - `Err(())`: Indicates that the function failed to retrieve the locale name or encountered
+///   invalid UTF-16 characters during conversion.
+fn get_active_keyboard_layout() -> Result<String, ()> {
+    let foreground_window_tid = unsafe { GetWindowThreadProcessId(GetForegroundWindow(), None) };
+    let lcid = unsafe { GetKeyboardLayout(foreground_window_tid) };
+
+    // Extract the low word (language identifier) from the keyboard layout handle.
+    let lang_id = (lcid.0 as u32) & 0xFFFF;
+    let mut locale_name_buffer = [0; LOCALE_NAME_MAX_LENGTH as usize];
+    let char_count = unsafe {
+        LCIDToLocaleName(
+            lang_id,
+            Some(&mut locale_name_buffer),
+            LOCALE_ALLOW_NEUTRAL_NAMES,
+        )
+    };
+
+    match char_count {
+        0 => Err(()),
+        _ => String::from_utf16(&locale_name_buffer[..char_count as usize]).map_err(|_| ()),
+    }
+}
+
+/// Retrieves the name of the active keyboard layout or a fallback error message.
+///
+/// # Behavior
+///
+/// - **Success Case**:
+///   If [`get_active_keyboard_layout`] succeeds, this function returns the retrieved keyboard
+///   layout name as a `String`.
+///
+/// - **Failure Case**:
+///   If [`get_active_keyboard_layout`] fails, this function returns the value of `ERROR_TEXT`
+///   as a fallback message. This ensures that the function always returns a valid `String`,
+///   even in error scenarios.
+///
+/// # Returns
+///
+/// A `String` representing either:
+/// - The name of the active keyboard layout, or
+/// - The fallback error message (`ERROR_TEXT`) if the layout name cannot be retrieved.
+fn get_lang() -> String {
+    get_active_keyboard_layout()
+        .map(|l| l.trim_end_matches('\0').to_string())
+        .unwrap_or_else(|_| ERROR_TEXT.to_string())
+}
+
+impl Keyboard {
+    fn output(&mut self) -> String {
+        let now = Instant::now();
+        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
+            self.last_updated = now;
+            self.lang_name = get_lang();
+        }
+
+        match self.label_prefix {
+            LabelPrefix::Text | LabelPrefix::IconAndText => format!("KB: {}", self.lang_name),
+            LabelPrefix::None | LabelPrefix::Icon => self.lang_name.clone(),
+        }
+    }
+}
+
+impl BarWidget for Keyboard {
+    fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
+        if self.enable {
+            let output = self.output();
+            if !output.is_empty() {
+                let mut layout_job = LayoutJob::simple(
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::KEYBOARD.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
+                    config.icon_font_id.clone(),
+                    ctx.style().visuals.selection.stroke.color,
+                    100.0,
+                );
+
+                layout_job.append(
+                    &output,
+                    10.0,
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
+                );
+
+                config.apply_on_widget(true, ui, |ui| {
+                    ui.add(Label::new(WidgetText::LayoutJob(layout_job.clone())).selectable(false))
+                });
+            }
+        }
+    }
+}

komorebi-bar/src/komorebi.rs

@@ -1,28 +1,29 @@
 use crate::bar::apply_theme;
 use crate::config::DisplayFormat;
 use crate::config::KomobarTheme;
+use crate::config::WorkspacesDisplayFormat;
 use crate::komorebi_layout::KomorebiLayout;
+use crate::render::Grouping;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
 use crate::widget::BarWidget;
+use crate::ICON_CACHE;
 use crate::MAX_LABEL_WIDTH;
 use crate::MONITOR_INDEX;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::TryRecvError;
 use eframe::egui::vec2;
 use eframe::egui::Color32;
 use eframe::egui::ColorImage;
 use eframe::egui::Context;
-use eframe::egui::FontId;
+use eframe::egui::CornerRadius;
 use eframe::egui::Frame;
 use eframe::egui::Image;
 use eframe::egui::Label;
 use eframe::egui::Margin;
-use eframe::egui::Rounding;
+use eframe::egui::RichText;
 use eframe::egui::Sense;
 use eframe::egui::Stroke;
-use eframe::egui::TextStyle;
+use eframe::egui::StrokeKind;
 use eframe::egui::TextureHandle;
 use eframe::egui::TextureOptions;
 use eframe::egui::Ui;
@@ -30,42 +31,49 @@ use eframe::egui::Vec2;
 use image::RgbaImage;
 use komorebi_client::Container;
 use komorebi_client::NotificationEvent;
+use komorebi_client::PathExt;
 use komorebi_client::Rect;
 use komorebi_client::SocketMessage;
 use komorebi_client::Window;
 use komorebi_client::Workspace;
-use schemars::JsonSchema;
+use komorebi_client::WorkspaceLayer;
 use serde::Deserialize;
 use serde::Serialize;
 use std::cell::RefCell;
 use std::collections::BTreeMap;
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiConfig {
     /// Configure the Workspaces widget
-    pub workspaces: KomorebiWorkspacesConfig,
+    pub workspaces: Option<KomorebiWorkspacesConfig>,
     /// Configure the Layout widget
     pub layout: Option<KomorebiLayoutConfig>,
+    /// Configure the Workspace Layer widget
+    pub workspace_layer: Option<KomorebiWorkspaceLayerConfig>,
     /// Configure the Focused Window widget
     pub focused_window: Option<KomorebiFocusedWindowConfig>,
     /// Configure the Configuration Switcher widget
     pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiWorkspacesConfig {
     /// Enable the Komorebi Workspaces widget
     pub enable: bool,
     /// Hide workspaces without any windows
     pub hide_empty_workspaces: bool,
     /// Display format of the workspace
-    pub display: Option<DisplayFormat>,
+    pub display: Option<WorkspacesDisplayFormat>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiLayoutConfig {
     /// Enable the Komorebi Layout widget
     pub enable: bool,
@@ -75,7 +83,19 @@ pub struct KomorebiLayoutConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct KomorebiWorkspaceLayerConfig {
+    /// Enable the Komorebi Workspace Layer widget
+    pub enable: bool,
+    /// Display format of the current layer
+    pub display: Option<DisplayFormat>,
+    /// Show the widget event if the layer is Tiling
+    pub show_when_tiling: Option<bool>,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiFocusedWindowConfig {
     /// Enable the Komorebi Focused Window widget
     pub enable: bool,
@@ -85,7 +105,8 @@ pub struct KomorebiFocusedWindowConfig {
     pub display: Option<DisplayFormat>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct KomorebiConfigurationSwitcherConfig {
     /// Enable the Komorebi Configurations widget
     pub enable: bool,
@@ -99,7 +120,7 @@ impl From<&KomorebiConfig> for Komorebi {
             if let Some(configuration_switcher) = &value.configuration_switcher {
                 let mut configuration_switcher = configuration_switcher.clone();
                 for (_, location) in configuration_switcher.configurations.iter_mut() {
-                    *location = dunce::simplified(&PathBuf::from(location.clone()))
+                    *location = dunce::simplified(&PathBuf::from(location.clone()).replace_env())
                         .to_string_lossy()
                         .to_string();
                 }
@@ -113,16 +134,21 @@ impl From<&KomorebiConfig> for Komorebi {
                 selected_workspace: String::new(),
                 layout: KomorebiLayout::Default(komorebi_client::DefaultLayout::BSP),
                 workspaces: vec![],
-                hide_empty_workspaces: value.workspaces.hide_empty_workspaces,
+                hide_empty_workspaces: value
+                    .workspaces
+                    .map(|w| w.hide_empty_workspaces)
+                    .unwrap_or_default(),
                 mouse_follows_focus: true,
                 work_area_offset: None,
                 focused_container_information: KomorebiNotificationStateContainerInformation::EMPTY,
                 stack_accent: None,
                 monitor_index: MONITOR_INDEX.load(Ordering::SeqCst),
+                monitor_usr_idx_map: HashMap::new(),
             })),
             workspaces: value.workspaces,
             layout: value.layout.clone(),
             focused_window: value.focused_window,
+            workspace_layer: value.workspace_layer,
             configuration_switcher,
         }
     }
@@ -131,149 +157,271 @@ impl From<&KomorebiConfig> for Komorebi {
 #[derive(Clone, Debug)]
 pub struct Komorebi {
     pub komorebi_notification_state: Rc<RefCell<KomorebiNotificationState>>,
-    pub workspaces: KomorebiWorkspacesConfig,
+    pub workspaces: Option<KomorebiWorkspacesConfig>,
     pub layout: Option<KomorebiLayoutConfig>,
     pub focused_window: Option<KomorebiFocusedWindowConfig>,
+    pub workspace_layer: Option<KomorebiWorkspaceLayerConfig>,
     pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
 }
 
 impl BarWidget for Komorebi {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
         let mut komorebi_notification_state = self.komorebi_notification_state.borrow_mut();
+        let icon_size = Vec2::splat(config.icon_font_id.size);
+        let text_size = Vec2::splat(config.text_font_id.size);
 
-        if self.workspaces.enable {
-            let mut update = None;
+        if let Some(workspaces) = self.workspaces {
+            if workspaces.enable {
+                let mut update = None;
 
-            if !komorebi_notification_state.workspaces.is_empty() {
-                let format = self.workspaces.display.unwrap_or(DisplayFormat::Text);
+                if !komorebi_notification_state.workspaces.is_empty() {
+                    let format = workspaces.display.unwrap_or(DisplayFormat::Text.into());
 
-                config.apply_on_widget(false, ui, |ui| {
-                    for (i, (ws, container_information)) in
-                        komorebi_notification_state.workspaces.iter().enumerate()
-                    {
-                        if SelectableFrame::new(
-                            komorebi_notification_state.selected_workspace.eq(ws),
-                        )
-                        .show(ui, |ui| {
-                            let mut has_icon = false;
-
-                            if let DisplayFormat::Icon | DisplayFormat::IconAndText = format {
-                                let icons: Vec<_> =
-                                    container_information.icons.iter().flatten().collect();
-
-                                if !icons.is_empty() {
-                                    Frame::none()
-                                        .inner_margin(Margin::same(
-                                            ui.style().spacing.button_padding.y,
-                                        ))
-                                        .show(ui, |ui| {
-                                            for icon in icons {
-                                                ui.add(
-                                                    Image::from(&img_to_texture(ctx, icon))
-                                                        .maintain_aspect_ratio(true)
-                                                        .shrink_to_fit(),
-                                                );
-
-                                                if !has_icon {
-                                                    has_icon = true;
-                                                }
-                                            }
-                                        });
-                                }
-                            }
-
-                            // draw a custom icon when there is no app icon
-                            if match format {
-                                DisplayFormat::Icon => !has_icon,
-                                _ => false,
-                            } {
-                                let font_id = ctx
-                                    .style()
-                                    .text_styles
-                                    .get(&TextStyle::Body)
-                                    .cloned()
-                                    .unwrap_or_else(FontId::default);
-
-                                let (response, painter) =
-                                    ui.allocate_painter(Vec2::splat(font_id.size), Sense::hover());
-                                let stroke =
-                                    Stroke::new(1.0, ctx.style().visuals.selection.stroke.color);
-                                let mut rect = response.rect;
-                                let rounding = Rounding::same(rect.width() * 0.1);
-                                rect = rect.shrink(stroke.width);
-                                let c = rect.center();
-                                let r = rect.width() / 2.0;
-                                painter.rect_stroke(rect, rounding, stroke);
-                                painter.line_segment([c - vec2(r, r), c + vec2(r, r)], stroke);
-
-                                response.on_hover_text(ws.to_string())
-                            } else if match format {
-                                DisplayFormat::Icon => has_icon,
-                                _ => false,
-                            } {
-                                ui.response().on_hover_text(ws.to_string())
-                            } else {
-                                ui.add(Label::new(ws.to_string()).selectable(false))
-                            }
-                        })
-                        .clicked()
+                    config.apply_on_widget(false, ui, |ui| {
+                        for (i, (ws, containers, _)) in
+                            komorebi_notification_state.workspaces.iter().enumerate()
                         {
-                            update = Some(ws.to_string());
-                            let mut proceed = true;
+                            let is_selected = komorebi_notification_state.selected_workspace.eq(ws);
 
-                            if komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                                false,
-                            ))
-                            .is_err()
+                            if SelectableFrame::new(
+                                is_selected,
+                            )
+                            .show(ui, |ui| {
+                                let mut has_icon = false;
+
+                                if format == WorkspacesDisplayFormat::AllIcons
+                                    || format == WorkspacesDisplayFormat::AllIconsAndText
+                                    || format == WorkspacesDisplayFormat::AllIconsAndTextOnSelected
+                                    || format == DisplayFormat::Icon.into()
+                                    || format == DisplayFormat::IconAndText.into()
+                                    || format == DisplayFormat::IconAndTextOnSelected.into()
+                                    || (format == DisplayFormat::TextAndIconOnSelected.into() && is_selected)
+                                {
+                                    has_icon = containers.iter().any(|(_, container_info)| {
+                                        container_info.icons.iter().any(|icon| icon.is_some())
+                                    });
+
+                                    if has_icon {
+                                        Frame::NONE
+                                            .inner_margin(Margin::same(
+                                                ui.style().spacing.button_padding.y as i8,
+                                            ))
+                                            .show(ui, |ui| {
+                                                for (is_focused, container) in containers {
+                                                    for icon in container.icons.iter().flatten().collect::<Vec<_>>() {
+                                                        ui.add(
+                                                            Image::from(&img_to_texture(ctx, icon))
+                                                                .maintain_aspect_ratio(true)
+                                                                .fit_to_exact_size(if *is_focused { icon_size } else { text_size }),
+                                                        );
+                                                    }
+                                                }
+                                            });
+                                    }
+                                }
+
+                                // draw a custom icon when there is no app icon or text
+                                if !has_icon && (matches!(format, WorkspacesDisplayFormat::AllIcons | WorkspacesDisplayFormat::Existing(DisplayFormat::Icon))
+                                || (!is_selected && matches!(format, WorkspacesDisplayFormat::AllIconsAndTextOnSelected | WorkspacesDisplayFormat::Existing(DisplayFormat::IconAndTextOnSelected)))) {
+                                    let (response, painter) =
+                                        ui.allocate_painter(icon_size, Sense::hover());
+                                    let stroke = Stroke::new(
+                                        1.0,
+                                        if is_selected { ctx.style().visuals.selection.stroke.color} else { ui.style().visuals.text_color() },
+                                    );
+                                    let mut rect = response.rect;
+                                    let rounding = CornerRadius::same((rect.width() * 0.1) as u8);
+                                    rect = rect.shrink(stroke.width);
+                                    let c = rect.center();
+                                    let r = rect.width() / 2.0;
+                                    painter.rect_stroke(rect, rounding, stroke, StrokeKind::Outside);
+                                    painter.line_segment([c - vec2(r, r), c + vec2(r, r)], stroke);
+
+                                    response.on_hover_text(ws.to_string())
+                                // add hover text when there are only icons
+                                } else if match format {
+                                    WorkspacesDisplayFormat::AllIcons | WorkspacesDisplayFormat::Existing(DisplayFormat::Icon) => has_icon,
+                                    _ => false,
+                                } {
+                                    ui.response().on_hover_text(ws.to_string())
+                                // add label only
+                                } else if (format != WorkspacesDisplayFormat::AllIconsAndTextOnSelected && format != DisplayFormat::IconAndTextOnSelected.into())
+                                    || (is_selected && matches!(format, WorkspacesDisplayFormat::AllIconsAndTextOnSelected | WorkspacesDisplayFormat::Existing(DisplayFormat::IconAndTextOnSelected)))
+                                {
+                                     if is_selected {
+                                        ui.add(Label::new(RichText::new(ws.to_string()).color(ctx.style().visuals.selection.stroke.color)).selectable(false))
+                                    }
+                                    else {
+                                        ui.add(Label::new(ws.to_string()).selectable(false))
+                                    }
+                                } else {
+                                    ui.response()
+                                }
+                            })
+                            .clicked()
                             {
-                                tracing::error!(
-                                    "could not send message to komorebi: MouseFollowsFocus"
-                                );
-                                proceed = false;
-                            }
+                                update = Some(ws.to_string());
 
-                            if proceed
-                                && komorebi_client::send_message(
-                                    &SocketMessage::FocusMonitorWorkspaceNumber(
+                                if komorebi_notification_state.mouse_follows_focus {
+                                    if komorebi_client::send_batch([
+                                        SocketMessage::MouseFollowsFocus(false),
+                                        SocketMessage::FocusMonitorWorkspaceNumber(
+                                            komorebi_notification_state.monitor_index,
+                                            i,
+                                        ),
+                                        SocketMessage::RetileWithResizeDimensions,
+                                        SocketMessage::MouseFollowsFocus(true),
+                                    ])
+                                        .is_err()
+                                    {
+                                        tracing::error!(
+                                            "could not send the following batch of messages to komorebi:\n
+                                            MouseFollowsFocus(false)\n
+                                            FocusMonitorWorkspaceNumber({}, {})\n
+                                            RetileWithResizeDimensions
+                                            MouseFollowsFocus(true)\n",
+                                            komorebi_notification_state.monitor_index,
+                                            i,
+                                        );
+                                    }
+                                } else if komorebi_client::send_batch([
+                                    SocketMessage::FocusMonitorWorkspaceNumber(
                                         komorebi_notification_state.monitor_index,
                                         i,
                                     ),
-                                )
-                                .is_err()
-                            {
-                                tracing::error!(
-                                    "could not send message to komorebi: FocusWorkspaceNumber"
-                                );
-                                proceed = false;
-                            }
-
-                            if proceed
-                                && komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                                    komorebi_notification_state.mouse_follows_focus,
-                                ))
-                                .is_err()
-                            {
-                                tracing::error!(
-                                    "could not send message to komorebi: MouseFollowsFocus"
-                                );
-                                proceed = false;
-                            }
-
-                            if proceed
-                                && komorebi_client::send_message(
-                                    &SocketMessage::RetileWithResizeDimensions,
-                                )
-                                .is_err()
-                            {
-                                tracing::error!("could not send message to komorebi: Retile");
+                                    SocketMessage::RetileWithResizeDimensions,
+                                ])
+                                    .is_err()
+                                {
+                                    tracing::error!(
+                                        "could not send the following batch of messages to komorebi:\n
+                                        FocusMonitorWorkspaceNumber({}, {})\n
+                                        RetileWithResizeDimensions",
+                                        komorebi_notification_state.monitor_index,
+                                        i,
+                                    );
+                                }
                             }
                         }
-                    }
-                });
-            }
+                    });
+                }
 
-            if let Some(update) = update {
-                komorebi_notification_state.selected_workspace = update;
+                if let Some(update) = update {
+                    komorebi_notification_state.selected_workspace = update;
+                }
+            }
+        }
+
+        if let Some(layer_config) = &self.workspace_layer {
+            if layer_config.enable {
+                let layer = komorebi_notification_state
+                    .workspaces
+                    .iter()
+                    .find(|o| komorebi_notification_state.selected_workspace.eq(&o.0))
+                    .map(|(_, _, layer)| layer);
+
+                if let Some(layer) = layer {
+                    if (layer_config.show_when_tiling.unwrap_or_default()
+                        && matches!(layer, WorkspaceLayer::Tiling))
+                        || matches!(layer, WorkspaceLayer::Floating)
+                    {
+                        let display_format = layer_config.display.unwrap_or(DisplayFormat::Text);
+                        let size = Vec2::splat(config.icon_font_id.size);
+
+                        config.apply_on_widget(false, ui, |ui| {
+                            let layer_frame = SelectableFrame::new(false)
+                                .show(ui, |ui| {
+                                    if display_format != DisplayFormat::Text {
+                                        if matches!(layer, WorkspaceLayer::Tiling) {
+                                            let (response, painter) =
+                                                ui.allocate_painter(size, Sense::hover());
+                                            let color = ui.style().visuals.text_color();
+                                            let stroke = Stroke::new(1.0, color);
+                                            let mut rect = response.rect;
+                                            let corner =
+                                                CornerRadius::same((rect.width() * 0.1) as u8);
+                                            rect = rect.shrink(stroke.width);
+
+                                            // tiling
+                                            let mut rect_left = response.rect;
+                                            rect_left.set_width(rect.width() * 0.48);
+                                            rect_left.set_height(rect.height() * 0.98);
+                                            let mut rect_right = rect_left;
+                                            rect_left = rect_left.translate(Vec2::new(
+                                                rect.width() * 0.01 + stroke.width,
+                                                rect.width() * 0.01 + stroke.width,
+                                            ));
+                                            rect_right = rect_right.translate(Vec2::new(
+                                                rect.width() * 0.51 + stroke.width,
+                                                rect.width() * 0.01 + stroke.width,
+                                            ));
+                                            painter.rect_filled(rect_left, corner, color);
+                                            painter.rect_stroke(
+                                                rect_right,
+                                                corner,
+                                                stroke,
+                                                StrokeKind::Outside,
+                                            );
+                                        } else {
+                                            let (response, painter) =
+                                                ui.allocate_painter(size, Sense::hover());
+                                            let color = ui.style().visuals.text_color();
+                                            let stroke = Stroke::new(1.0, color);
+                                            let mut rect = response.rect;
+                                            let corner =
+                                                CornerRadius::same((rect.width() * 0.1) as u8);
+                                            rect = rect.shrink(stroke.width);
+
+                                            // floating
+                                            let mut rect_left = response.rect;
+                                            rect_left.set_width(rect.width() * 0.65);
+                                            rect_left.set_height(rect.height() * 0.65);
+                                            let mut rect_right = rect_left;
+                                            rect_left = rect_left.translate(Vec2::new(
+                                                rect.width() * 0.01 + stroke.width,
+                                                rect.width() * 0.01 + stroke.width,
+                                            ));
+                                            rect_right = rect_right.translate(Vec2::new(
+                                                rect.width() * 0.34 + stroke.width,
+                                                rect.width() * 0.34 + stroke.width,
+                                            ));
+                                            painter.rect_filled(rect_left, corner, color);
+                                            painter.rect_stroke(
+                                                rect_right,
+                                                corner,
+                                                stroke,
+                                                StrokeKind::Outside,
+                                            );
+                                        }
+                                    }
+
+                                    if display_format != DisplayFormat::Icon {
+                                        ui.add(Label::new(layer.to_string()).selectable(false));
+                                    }
+                                })
+                                .on_hover_text(layer.to_string());
+
+                            if layer_frame.clicked()
+                                && komorebi_client::send_batch([
+                                    SocketMessage::MouseFollowsFocus(false),
+                                    SocketMessage::ToggleWorkspaceLayer,
+                                    SocketMessage::MouseFollowsFocus(
+                                        komorebi_notification_state.mouse_follows_focus,
+                                    ),
+                                ])
+                                .is_err()
+                            {
+                                tracing::error!(
+                                    "could not send the following batch of messages to komorebi:\n\
+                                                MouseFollowsFocus(false),
+                                                ToggleWorkspaceLayer,
+                                                MouseFollowsFocus({})",
+                                    komorebi_notification_state.mouse_follows_focus,
+                                );
+                            }
+                        });
+                    }
+                }
             }
         }
 
@@ -368,9 +516,11 @@ impl BarWidget for Komorebi {
                             .focused_window_idx;
 
                         let iter = titles.iter().zip(icons.iter());
+                        let len = iter.len();
 
                         for (i, (title, icon)) in iter.enumerate() {
-                            let selected = i == focused_window_idx;
+                            let selected = i == focused_window_idx && len != 1;
+                            let text_color = if selected { ctx.style().visuals.selection.stroke.color} else { ui.style().visuals.text_color() };
 
                             if SelectableFrame::new(selected)
                                 .show(ui, |ui| {
@@ -383,18 +533,22 @@ impl BarWidget for Komorebi {
                                         },
                                     );
 
-                                    if let DisplayFormat::Icon | DisplayFormat::IconAndText = format
+                                    if format == DisplayFormat::Icon
+                                        || format == DisplayFormat::IconAndText
+                                        || format == DisplayFormat::IconAndTextOnSelected
+                                        || (format == DisplayFormat::TextAndIconOnSelected
+                                            && i == focused_window_idx)
                                     {
                                         if let Some(img) = icon {
-                                            Frame::none()
+                                            Frame::NONE
                                                 .inner_margin(Margin::same(
-                                                    ui.style().spacing.button_padding.y,
+                                                    ui.style().spacing.button_padding.y as i8,
                                                 ))
                                                 .show(ui, |ui| {
                                                     let response = ui.add(
                                                         Image::from(&img_to_texture(ctx, img))
                                                             .maintain_aspect_ratio(true)
-                                                            .shrink_to_fit(),
+                                                            .fit_to_exact_size(icon_size),
                                                     );
 
                                                     if let DisplayFormat::Icon = format {
@@ -404,7 +558,11 @@ impl BarWidget for Komorebi {
                                         }
                                     }
 
-                                    if let DisplayFormat::Text | DisplayFormat::IconAndText = format
+                                    if format == DisplayFormat::Text
+                                        || format == DisplayFormat::IconAndText
+                                        || format == DisplayFormat::TextAndIconOnSelected
+                                        || (format == DisplayFormat::IconAndTextOnSelected
+                                            && i == focused_window_idx)
                                     {
                                         let available_height = ui.available_height();
                                         let mut custom_ui = CustomUi(ui);
@@ -414,7 +572,7 @@ impl BarWidget for Komorebi {
                                                 MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
                                                 available_height,
                                             ),
-                                            Label::new(title).selectable(false).truncate(),
+                                            Label::new(RichText::new( title).color(text_color)).selectable(false).truncate(),
                                         );
                                     }
                                 })
@@ -424,35 +582,27 @@ impl BarWidget for Komorebi {
                                     return;
                                 }
 
-                                if komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                                    false,
-                                ))
-                                .is_err()
-                                {
-                                    tracing::error!(
-                                        "could not send message to komorebi: MouseFollowsFocus"
-                                    );
-                                }
-
-                                if komorebi_client::send_message(&SocketMessage::FocusStackWindow(
-                                    i,
-                                ))
-                                .is_err()
-                                {
+                                if komorebi_notification_state.mouse_follows_focus {
+                                    if komorebi_client::send_batch([
+                                        SocketMessage::MouseFollowsFocus(false),
+                                        SocketMessage::FocusStackWindow(i),
+                                        SocketMessage::MouseFollowsFocus(true),
+                                    ]).is_err() {
+                                        tracing::error!(
+                                            "could not send the following batch of messages to komorebi:\n
+                                            MouseFollowsFocus(false)\n
+                                            FocusStackWindow({})\n
+                                            MouseFollowsFocus(true)\n",
+                                            i,
+                                        );
+                                    }
+                                } else if komorebi_client::send_message(
+                                    &SocketMessage::FocusStackWindow(i)
+                                ).is_err() {
                                     tracing::error!(
                                         "could not send message to komorebi: FocusStackWindow"
                                     );
                                 }
-
-                                if komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                                    komorebi_notification_state.mouse_follows_focus,
-                                ))
-                                .is_err()
-                                {
-                                    tracing::error!(
-                                        "could not send message to komorebi: MouseFollowsFocus"
-                                    );
-                                }
                             }
                         }
                     });
@@ -469,9 +619,14 @@ fn img_to_texture(ctx: &Context, rgba_image: &RgbaImage) -> TextureHandle {
     ctx.load_texture("icon", color_image, TextureOptions::default())
 }
 
+#[allow(clippy::type_complexity)]
 #[derive(Clone, Debug)]
 pub struct KomorebiNotificationState {
-    pub workspaces: Vec<(String, KomorebiNotificationStateContainerInformation)>,
+    pub workspaces: Vec<(
+        String,
+        Vec<(bool, KomorebiNotificationStateContainerInformation)>,
+        WorkspaceLayer,
+    )>,
     pub selected_workspace: String,
     pub focused_container_information: KomorebiNotificationStateContainerInformation,
     pub layout: KomorebiLayout,
@@ -480,6 +635,7 @@ pub struct KomorebiNotificationState {
     pub work_area_offset: Option<Rect>,
     pub stack_accent: Option<Color32>,
     pub monitor_index: usize,
+    pub monitor_usr_idx_map: HashMap<usize, usize>,
 }
 
 impl KomorebiNotificationState {
@@ -487,97 +643,161 @@ impl KomorebiNotificationState {
         self.hide_empty_workspaces = config.hide_empty_workspaces;
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn handle_notification(
         &mut self,
         ctx: &Context,
-        monitor_index: usize,
-        rx_gui: Receiver<komorebi_client::Notification>,
+        monitor_index: Option<usize>,
+        notification: komorebi_client::Notification,
         bg_color: Rc<RefCell<Color32>>,
+        bg_color_with_alpha: Rc<RefCell<Color32>>,
+        transparency_alpha: Option<u8>,
+        grouping: Option<Grouping>,
+        default_theme: Option<KomobarTheme>,
+        render_config: Rc<RefCell<RenderConfig>>,
     ) {
-        match rx_gui.try_recv() {
-            Err(error) => match error {
-                TryRecvError::Empty => {}
-                TryRecvError::Disconnected => {
-                    tracing::error!(
-                        "failed to receive komorebi notification on gui thread: {error}"
-                    );
-                }
-            },
-            Ok(notification) => {
-                match notification.event {
-                    NotificationEvent::WindowManager(_) => {}
-                    NotificationEvent::Socket(message) => match message {
-                        SocketMessage::ReloadStaticConfiguration(path) => {
-                            if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
-                                if let Some(theme) = config.theme {
-                                    apply_theme(ctx, KomobarTheme::from(theme), bg_color.clone());
-                                    tracing::info!("applied theme from updated komorebi.json");
-                                }
-                            }
+        let show_all_icons = render_config.borrow().show_all_icons;
+
+        match notification.event {
+            NotificationEvent::WindowManager(_) => {}
+            NotificationEvent::Monitor(_) => {}
+            NotificationEvent::Socket(message) => match message {
+                SocketMessage::ReloadStaticConfiguration(path) => {
+                    if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
+                        if let Some(theme) = config.theme {
+                            apply_theme(
+                                ctx,
+                                KomobarTheme::from(theme),
+                                bg_color.clone(),
+                                bg_color_with_alpha.clone(),
+                                transparency_alpha,
+                                grouping,
+                                render_config,
+                            );
+                            tracing::info!("applied theme from updated komorebi.json");
+                        } else if let Some(default_theme) = default_theme {
+                            apply_theme(
+                                ctx,
+                                default_theme,
+                                bg_color.clone(),
+                                bg_color_with_alpha.clone(),
+                                transparency_alpha,
+                                grouping,
+                                render_config,
+                            );
+                            tracing::info!("removed theme from updated komorebi.json and applied default theme");
+                        } else {
+                            tracing::warn!("theme was removed from updated komorebi.json but there was no default theme to apply");
                         }
-                        SocketMessage::Theme(theme) => {
-                            apply_theme(ctx, KomobarTheme::from(theme), bg_color);
-                            tracing::info!("applied theme from komorebi socket message");
-                        }
-                        _ => {}
-                    },
-                }
-
-                self.monitor_index = monitor_index;
-
-                self.mouse_follows_focus = notification.state.mouse_follows_focus;
-
-                let monitor = &notification.state.monitors.elements()[monitor_index];
-                self.work_area_offset =
-                    notification.state.monitors.elements()[monitor_index].work_area_offset();
-
-                let focused_workspace_idx = monitor.focused_workspace_idx();
-
-                let mut workspaces = vec![];
-                self.selected_workspace = monitor.workspaces()[focused_workspace_idx]
-                    .name()
-                    .to_owned()
-                    .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));
-
-                for (i, ws) in monitor.workspaces().iter().enumerate() {
-                    let should_show = if self.hide_empty_workspaces {
-                        focused_workspace_idx == i || !ws.containers().is_empty()
-                    } else {
-                        true
-                    };
-
-                    if should_show {
-                        workspaces.push((
-                            ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)),
-                            ws.into(),
-                        ));
                     }
                 }
-
-                self.workspaces = workspaces;
-
-                if monitor.workspaces()[focused_workspace_idx]
-                    .monocle_container()
-                    .is_some()
-                {
-                    self.layout = KomorebiLayout::Monocle;
-                } else if !*monitor.workspaces()[focused_workspace_idx].tile() {
-                    self.layout = KomorebiLayout::Floating;
-                } else if notification.state.is_paused {
-                    self.layout = KomorebiLayout::Paused;
-                } else {
-                    self.layout = match monitor.workspaces()[focused_workspace_idx].layout() {
-                        komorebi_client::Layout::Default(layout) => {
-                            KomorebiLayout::Default(*layout)
-                        }
-                        komorebi_client::Layout::Custom(_) => KomorebiLayout::Custom,
-                    };
+                SocketMessage::Theme(theme) => {
+                    apply_theme(
+                        ctx,
+                        KomobarTheme::from(theme),
+                        bg_color,
+                        bg_color_with_alpha.clone(),
+                        transparency_alpha,
+                        grouping,
+                        render_config,
+                    );
+                    tracing::info!("applied theme from komorebi socket message");
                 }
+                _ => {}
+            },
+        }
 
-                self.focused_container_information =
-                    (&monitor.workspaces()[focused_workspace_idx]).into();
+        self.monitor_usr_idx_map = notification.state.monitor_usr_idx_map.clone();
+
+        if monitor_index.is_none()
+            || monitor_index.is_some_and(|idx| idx >= notification.state.monitors.elements().len())
+        {
+            // The bar's monitor is diconnected, so the bar is disabled no need to check anything
+            // any further otherwise we'll get `OutOfBounds` panics.
+            return;
+        }
+        let monitor_index = monitor_index.expect("should have a monitor index");
+        self.monitor_index = monitor_index;
+
+        self.mouse_follows_focus = notification.state.mouse_follows_focus;
+
+        let monitor = &notification.state.monitors.elements()[monitor_index];
+        self.work_area_offset =
+            notification.state.monitors.elements()[monitor_index].work_area_offset();
+
+        let focused_workspace_idx = monitor.focused_workspace_idx();
+
+        let mut workspaces = vec![];
+
+        self.selected_workspace = monitor.workspaces()[focused_workspace_idx]
+            .name()
+            .to_owned()
+            .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));
+
+        for (i, ws) in monitor.workspaces().iter().enumerate() {
+            let should_show = if self.hide_empty_workspaces {
+                focused_workspace_idx == i || !ws.is_empty()
+            } else {
+                true
+            };
+
+            if should_show {
+                workspaces.push((
+                    ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)),
+                    if show_all_icons {
+                        let mut containers = vec![];
+                        let mut has_monocle = false;
+
+                        // add monocle container
+                        if let Some(container) = ws.monocle_container() {
+                            containers.push((true, container.into()));
+                            has_monocle = true;
+                        }
+
+                        // add all tiled windows
+                        for (i, container) in ws.containers().iter().enumerate() {
+                            containers.push((
+                                !has_monocle && i == ws.focused_container_idx(),
+                                container.into(),
+                            ));
+                        }
+
+                        // add all floating windows
+                        for floating_window in ws.floating_windows() {
+                            containers.push((
+                                !has_monocle && floating_window.is_focused(),
+                                floating_window.into(),
+                            ));
+                        }
+
+                        containers
+                    } else {
+                        vec![(true, ws.into())]
+                    },
+                    ws.layer().to_owned(),
+                ));
             }
         }
+
+        self.workspaces = workspaces;
+
+        if monitor.workspaces()[focused_workspace_idx]
+            .monocle_container()
+            .is_some()
+        {
+            self.layout = KomorebiLayout::Monocle;
+        } else if !*monitor.workspaces()[focused_workspace_idx].tile() {
+            self.layout = KomorebiLayout::Floating;
+        } else if notification.state.is_paused {
+            self.layout = KomorebiLayout::Paused;
+        } else {
+            self.layout = match monitor.workspaces()[focused_workspace_idx].layout() {
+                komorebi_client::Layout::Default(layout) => KomorebiLayout::Default(*layout),
+                komorebi_client::Layout::Custom(_) => KomorebiLayout::Custom,
+            };
+        }
+
+        self.focused_container_information = (&monitor.workspaces()[focused_workspace_idx]).into();
     }
 }
 
@@ -610,17 +830,38 @@ impl From<&Workspace> for KomorebiNotificationStateContainerInformation {
 
 impl From<&Container> for KomorebiNotificationStateContainerInformation {
     fn from(value: &Container) -> Self {
+        let windows = value.windows().iter().collect::<Vec<_>>();
+        let mut icons = vec![];
+
+        for window in windows {
+            let mut icon_cache = ICON_CACHE.lock().unwrap();
+            let mut update_cache = false;
+            let exe = window.exe().unwrap_or_default();
+
+            match icon_cache.get(&exe) {
+                None => {
+                    icons.push(windows_icons::get_icon_by_process_id(window.process_id()));
+                    update_cache = true;
+                }
+                Some(icon) => {
+                    icons.push(Some(icon.clone()));
+                }
+            }
+
+            if update_cache {
+                if let Some(Some(icon)) = icons.last() {
+                    icon_cache.insert(exe, icon.clone());
+                }
+            }
+        }
+
         Self {
             titles: value
                 .windows()
                 .iter()
                 .map(|w| w.title().unwrap_or_default())
                 .collect::<Vec<_>>(),
-            icons: value
-                .windows()
-                .iter()
-                .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
-                .collect::<Vec<_>>(),
+            icons,
             focused_window_idx: value.focused_window_idx(),
         }
     }
@@ -628,9 +869,30 @@ impl From<&Container> for KomorebiNotificationStateContainerInformation {
 
 impl From<&Window> for KomorebiNotificationStateContainerInformation {
     fn from(value: &Window) -> Self {
+        let mut icon_cache = ICON_CACHE.lock().unwrap();
+        let mut update_cache = false;
+        let mut icons = vec![];
+        let exe = value.exe().unwrap_or_default();
+
+        match icon_cache.get(&exe) {
+            None => {
+                icons.push(windows_icons::get_icon_by_process_id(value.process_id()));
+                update_cache = true;
+            }
+            Some(icon) => {
+                icons.push(Some(icon.clone()));
+            }
+        }
+
+        if update_cache {
+            if let Some(Some(icon)) = icons.last() {
+                icon_cache.insert(exe, icon.clone());
+            }
+        }
+
         Self {
             titles: vec![value.title().unwrap_or_default()],
-            icons: vec![windows_icons::get_icon_by_process_id(value.process_id())],
+            icons,
             focused_window_idx: 0,
         }
     }

komorebi-bar/src/komorebi_layout.rs

@@ -4,17 +4,16 @@ use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use eframe::egui::vec2;
 use eframe::egui::Context;
+use eframe::egui::CornerRadius;
 use eframe::egui::FontId;
 use eframe::egui::Frame;
 use eframe::egui::Label;
-use eframe::egui::Rounding;
 use eframe::egui::Sense;
 use eframe::egui::Stroke;
-use eframe::egui::TextStyle;
+use eframe::egui::StrokeKind;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
 use komorebi_client::SocketMessage;
-use schemars::JsonSchema;
 use serde::de::Error;
 use serde::Deserialize;
 use serde::Deserializer;
@@ -23,7 +22,8 @@ use serde_json::from_str;
 use std::fmt::Display;
 use std::fmt::Formatter;
 
-#[derive(Copy, Clone, Debug, Serialize, JsonSchema, PartialEq)]
+#[derive(Copy, Clone, Debug, Serialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum KomorebiLayout {
     Default(komorebi_client::DefaultLayout),
@@ -123,18 +123,22 @@ impl KomorebiLayout {
         }
     }
 
-    fn show_icon(&mut self, font_id: FontId, ctx: &Context, ui: &mut Ui) {
+    fn show_icon(&mut self, is_selected: bool, font_id: FontId, ctx: &Context, ui: &mut Ui) {
         // paint custom icons for the layout
         let size = Vec2::splat(font_id.size);
         let (response, painter) = ui.allocate_painter(size, Sense::hover());
-        let color = ctx.style().visuals.selection.stroke.color;
+        let color = if is_selected {
+            ctx.style().visuals.selection.stroke.color
+        } else {
+            ui.style().visuals.text_color()
+        };
         let stroke = Stroke::new(1.0, color);
         let mut rect = response.rect;
-        let rounding = Rounding::same(rect.width() * 0.1);
+        let rounding = CornerRadius::same((rect.width() * 0.1) as u8);
         rect = rect.shrink(stroke.width);
         let c = rect.center();
         let r = rect.width() / 2.0;
-        painter.rect_stroke(rect, rounding, stroke);
+        painter.rect_stroke(rect, rounding, stroke, StrokeKind::Outside);
 
         match self {
             KomorebiLayout::Default(layout) => match layout {
@@ -190,7 +194,7 @@ impl KomorebiLayout {
                     rect.width() * 0.35 + stroke.width,
                 ));
                 painter.rect_filled(rect_left, rounding, color);
-                painter.rect_stroke(rect_right, rounding, stroke);
+                painter.rect_stroke(rect_right, rounding, stroke, StrokeKind::Outside);
             }
             KomorebiLayout::Paused => {
                 let mut rect_left = response.rect;
@@ -225,13 +229,7 @@ impl KomorebiLayout {
         workspace_idx: Option<usize>,
     ) {
         let monitor_idx = render_config.monitor_idx;
-        let font_id = ctx
-            .style()
-            .text_styles
-            .get(&TextStyle::Body)
-            .cloned()
-            .unwrap_or_else(FontId::default);
-
+        let font_id = render_config.icon_font_id.clone();
         let mut show_options = RenderConfig::load_show_komorebi_layout_options();
         let format = layout_config.display.unwrap_or(DisplayFormat::IconAndText);
 
@@ -243,7 +241,7 @@ impl KomorebiLayout {
             let layout_frame = SelectableFrame::new(false)
                 .show(ui, |ui| {
                     if let DisplayFormat::Icon | DisplayFormat::IconAndText = format {
-                        self.show_icon(font_id.clone(), ctx, ui);
+                        self.show_icon(false, font_id.clone(), ctx, ui);
                     }
 
                     if let DisplayFormat::Text | DisplayFormat::IconAndText = format {
@@ -258,7 +256,7 @@ impl KomorebiLayout {
 
             if show_options {
                 if let Some(workspace_idx) = workspace_idx {
-                    Frame::none().show(ui, |ui| {
+                    Frame::NONE.show(ui, |ui| {
                         ui.add(
                             Label::new(egui_phosphor::regular::ARROW_FAT_LINES_RIGHT.to_string())
                                 .selectable(false),
@@ -286,8 +284,12 @@ impl KomorebiLayout {
                         ]);
 
                         for layout_option in &mut layout_options {
-                            if SelectableFrame::new(self == layout_option)
-                                .show(ui, |ui| layout_option.show_icon(font_id.clone(), ctx, ui))
+                            let is_selected = self == layout_option;
+
+                            if SelectableFrame::new(is_selected)
+                                .show(ui, |ui| {
+                                    layout_option.show_icon(is_selected, font_id.clone(), ctx, ui)
+                                })
                                 .on_hover_text(match layout_option {
                                     KomorebiLayout::Default(layout) => layout.to_string(),
                                     KomorebiLayout::Monocle => "Toggle monocle".to_string(),

komorebi-bar/src/main.rs

@@ -3,6 +3,7 @@ mod battery;
 mod config;
 mod cpu;
 mod date;
+mod keyboard;
 mod komorebi;
 mod komorebi_layout;
 mod media;
@@ -13,6 +14,7 @@ mod selected_frame;
 mod storage;
 mod time;
 mod ui;
+mod update;
 mod widget;
 
 use crate::bar::Komobar;
@@ -20,23 +22,25 @@ use crate::config::KomobarConfig;
 use crate::config::Position;
 use crate::config::PositionConfig;
 use clap::Parser;
+use config::MonitorConfigOrIndex;
 use eframe::egui::ViewportBuilder;
 use font_loader::system_fonts;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
+use image::RgbaImage;
 use komorebi_client::SocketMessage;
 use komorebi_client::SubscribeOptions;
-use schemars::gen::SchemaSettings;
+use std::collections::HashMap;
 use std::io::BufReader;
 use std::io::Read;
 use std::path::PathBuf;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
-use std::sync::Arc;
+use std::sync::LazyLock;
+use std::sync::Mutex;
 use std::time::Duration;
 use tracing_subscriber::EnvFilter;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::System::Threading::GetCurrentProcessId;
@@ -45,6 +49,7 @@ use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
 use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
+use windows_core::BOOL;
 
 pub static MAX_LABEL_WIDTH: AtomicI32 = AtomicI32::new(400);
 pub static MONITOR_LEFT: AtomicI32 = AtomicI32::new(0);
@@ -52,6 +57,10 @@ pub static MONITOR_TOP: AtomicI32 = AtomicI32::new(0);
 pub static MONITOR_RIGHT: AtomicI32 = AtomicI32::new(0);
 pub static MONITOR_INDEX: AtomicUsize = AtomicUsize::new(0);
 pub static BAR_HEIGHT: f32 = 50.0;
+pub static DEFAULT_PADDING: f32 = 10.0;
+
+pub static ICON_CACHE: LazyLock<Mutex<HashMap<String, RgbaImage>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
 
 #[derive(Parser)]
 #[clap(author, about, version)]
@@ -105,13 +114,19 @@ fn process_hwnd() -> Option<isize> {
     }
 }
 
+pub enum KomorebiEvent {
+    Notification(komorebi_client::Notification),
+    Reconnect,
+}
+
 fn main() -> color_eyre::Result<()> {
     unsafe { SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) }?;
 
     let opts: Opts = Opts::parse();
 
+    #[cfg(feature = "schemars")]
     if opts.schema {
-        let settings = SchemaSettings::default().with(|s| {
+        let settings = schemars::gen::SchemaSettings::default().with(|s| {
             s.option_nullable = false;
             s.option_add_null_type = false;
             s.inline_subschemas = true;
@@ -222,32 +237,43 @@ fn main() -> color_eyre::Result<()> {
         &SocketMessage::State,
     )?)?;
 
+    let (usr_monitor_index, work_area_offset) = match &config.monitor {
+        MonitorConfigOrIndex::MonitorConfig(monitor_config) => {
+            (monitor_config.index, monitor_config.work_area_offset)
+        }
+        MonitorConfigOrIndex::Index(idx) => (*idx, None),
+    };
+    let monitor_index = state
+        .monitor_usr_idx_map
+        .get(&usr_monitor_index)
+        .map_or(usr_monitor_index, |i| *i);
+
     MONITOR_RIGHT.store(
-        state.monitors.elements()[config.monitor.index].size().right,
+        state.monitors.elements()[monitor_index].size().right,
         Ordering::SeqCst,
     );
 
     MONITOR_TOP.store(
-        state.monitors.elements()[config.monitor.index].size().top,
+        state.monitors.elements()[monitor_index].size().top,
         Ordering::SeqCst,
     );
 
-    MONITOR_TOP.store(
-        state.monitors.elements()[config.monitor.index].size().left,
+    MONITOR_LEFT.store(
+        state.monitors.elements()[monitor_index].size().left,
         Ordering::SeqCst,
     );
 
-    MONITOR_INDEX.store(config.monitor.index, Ordering::SeqCst);
+    MONITOR_INDEX.store(monitor_index, Ordering::SeqCst);
 
     match config.position {
         None => {
             config.position = Some(PositionConfig {
                 start: Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().left as f32,
-                    y: state.monitors.elements()[config.monitor.index].size().top as f32,
+                    x: state.monitors.elements()[monitor_index].size().left as f32,
+                    y: state.monitors.elements()[monitor_index].size().top as f32,
                 }),
                 end: Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().right as f32,
+                    x: state.monitors.elements()[monitor_index].size().right as f32,
                     y: 50.0,
                 }),
             })
@@ -255,14 +281,14 @@ fn main() -> color_eyre::Result<()> {
         Some(ref mut position) => {
             if position.start.is_none() {
                 position.start = Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().left as f32,
-                    y: state.monitors.elements()[config.monitor.index].size().top as f32,
+                    x: state.monitors.elements()[monitor_index].size().left as f32,
+                    y: state.monitors.elements()[monitor_index].size().top as f32,
                 });
             }
 
             if position.end.is_none() {
                 position.end = Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().right as f32,
+                    x: state.monitors.elements()[monitor_index].size().right as f32,
                     y: 50.0,
                 })
             }
@@ -279,15 +305,9 @@ fn main() -> color_eyre::Result<()> {
         ..Default::default()
     };
 
-    if let Some(rect) = &config.monitor.work_area_offset {
-        komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(
-            config.monitor.index,
-            *rect,
-        ))?;
-        tracing::info!(
-            "work area offset applied to monitor: {}",
-            config.monitor.index
-        );
+    if let Some(rect) = &work_area_offset {
+        komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(monitor_index, *rect))?;
+        tracing::info!("work area offset applied to monitor: {}", monitor_index);
     }
 
     let (tx_gui, rx_gui) = crossbeam_channel::unbounded();
@@ -317,13 +337,10 @@ fn main() -> color_eyre::Result<()> {
 
     tracing::info!("watching configuration file for changes");
 
-    let config_arc = Arc::new(config);
     eframe::run_native(
         "komorebi-bar",
         native_options,
         Box::new(|cc| {
-            let config_cl = config_arc.clone();
-
             let ctx_repainter = cc.egui_ctx.clone();
             std::thread::spawn(move || loop {
                 std::thread::sleep(Duration::from_secs(1));
@@ -344,6 +361,10 @@ fn main() -> color_eyre::Result<()> {
                 for client in listener.incoming() {
                     match client {
                         Ok(subscription) => {
+                            match subscription.set_read_timeout(Some(Duration::from_secs(1))) {
+                                Ok(()) => {}
+                                Err(error) => tracing::error!("{}", error),
+                            }
                             let mut buffer = Vec::new();
                             let mut reader = BufReader::new(subscription);
 
@@ -362,18 +383,12 @@ fn main() -> color_eyre::Result<()> {
 
                                 tracing::info!("reconnected to komorebi");
 
-                                if let Some(rect) = &config_cl.monitor.work_area_offset {
-                                    while komorebi_client::send_message(
-                                        &SocketMessage::MonitorWorkAreaOffset(
-                                            config_cl.monitor.index,
-                                            *rect,
-                                        ),
-                                    )
-                                    .is_err()
-                                    {
-                                        std::thread::sleep(Duration::from_secs(1));
-                                    }
+                                if let Err(error) = tx_gui.send(KomorebiEvent::Reconnect) {
+                                    tracing::error!("could not send komorebi reconnect event to gui thread: {error}")
                                 }
+
+                                ctx_komorebi.request_repaint();
+                                continue;
                             }
 
                             match String::from_utf8(buffer) {
@@ -384,7 +399,7 @@ fn main() -> color_eyre::Result<()> {
                                         Ok(notification) => {
                                             tracing::debug!("received notification from komorebi");
 
-                                            if let Err(error) = tx_gui.send(notification) {
+                                            if let Err(error) = tx_gui.send(KomorebiEvent::Notification(notification)) {
                                                 tracing::error!("could not send komorebi notification update to gui thread: {error}")
                                             }
 
@@ -409,7 +424,7 @@ fn main() -> color_eyre::Result<()> {
                 }
             });
 
-            Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config_arc)))
+            Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config)))
         }),
     )
     .map_err(|error| color_eyre::eyre::Error::msg(error.to_string()))

komorebi-bar/src/media.rs

@@ -1,23 +1,22 @@
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
 use crate::widget::BarWidget;
 use crate::MAX_LABEL_WIDTH;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::sync::atomic::Ordering;
 use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MediaConfig {
     /// Enable the Media widget
     pub enable: bool,
@@ -82,16 +81,9 @@ impl BarWidget for Media {
         if self.enable {
             let output = self.output();
             if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
                 let mut layout_job = LayoutJob::simple(
                     egui_phosphor::regular::HEADPHONES.to_string(),
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -99,24 +91,28 @@ impl BarWidget for Media {
                 layout_job.append(
                     &output,
                     10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
                 );
 
-                config.apply_on_widget(true, ui, |ui| {
-                    let available_height = ui.available_height();
-                    let mut custom_ui = CustomUi(ui);
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| {
+                            let available_height = ui.available_height();
+                            let mut custom_ui = CustomUi(ui);
 
-                    if custom_ui
-                        .add_sized_left_to_right(
-                            Vec2::new(
-                                MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
-                                available_height,
-                            ),
-                            Label::new(layout_job)
-                                .selectable(false)
-                                .sense(Sense::click())
-                                .truncate(),
-                        )
+                            custom_ui.add_sized_left_to_right(
+                                Vec2::new(
+                                    MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
+                                    available_height,
+                                ),
+                                Label::new(layout_job).selectable(false).truncate(),
+                            )
+                        })
                         .clicked()
                     {
                         self.toggle();

komorebi-bar/src/memory.rs

@@ -1,15 +1,13 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -18,7 +16,8 @@ use std::time::Instant;
 use sysinfo::RefreshKind;
 use sysinfo::System;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MemoryConfig {
     /// Enable the Memory widget
     pub enable: bool,
@@ -30,17 +29,18 @@ pub struct MemoryConfig {
 
 impl From<MemoryConfig> for Memory {
     fn from(value: MemoryConfig) -> Self {
-        let mut system =
-            System::new_with_specifics(RefreshKind::default().without_cpu().without_processes());
-
-        system.refresh_memory();
+        let data_refresh_interval = value.data_refresh_interval.unwrap_or(10);
 
         Self {
             enable: value.enable,
-            system,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            system: System::new_with_specifics(
+                RefreshKind::default().without_cpu().without_processes(),
+            ),
+            data_refresh_interval,
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
-            last_updated: Instant::now(),
+            last_updated: Instant::now()
+                .checked_sub(Duration::from_secs(data_refresh_interval))
+                .unwrap(),
         }
     }
 }
@@ -77,13 +77,6 @@ impl BarWidget for Memory {
         if self.enable {
             let output = self.output();
             if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
                         LabelPrefix::Icon | LabelPrefix::IconAndText => {
@@ -91,7 +84,7 @@ impl BarWidget for Memory {
                         }
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -99,16 +92,17 @@ impl BarWidget for Memory {
                 layout_job.append(
                     &output,
                     10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
                 );
 
-                config.apply_on_widget(true, ui, |ui| {
-                    if ui
-                        .add(
-                            Label::new(layout_job)
-                                .selectable(false)
-                                .sense(Sense::click()),
-                        )
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
                     {
                         if let Err(error) =

komorebi-bar/src/network.rs

@@ -1,16 +1,14 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
 use num_derive::FromPrimitive;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::fmt;
@@ -19,7 +17,8 @@ use std::time::Duration;
 use std::time::Instant;
 use sysinfo::Networks;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct NetworkConfig {
     /// Enable the Network widget
     pub enable: bool,
@@ -27,6 +26,8 @@ pub struct NetworkConfig {
     pub show_total_data_transmitted: bool,
     /// Show network activity
     pub show_network_activity: bool,
+    /// Show default interface
+    pub show_default_interface: Option<bool>,
     /// Characters to reserve for network activity data
     pub network_activity_fill_characters: Option<usize>,
     /// Data refresh interval (default: 10 seconds)
@@ -41,12 +42,13 @@ impl From<NetworkConfig> for Network {
 
         Self {
             enable: value.enable,
+            show_total_activity: value.show_total_data_transmitted,
+            show_activity: value.show_network_activity,
+            show_default_interface: value.show_default_interface.unwrap_or(true),
             networks_network_activity: Networks::new_with_refreshed_list(),
             default_interface: String::new(),
             data_refresh_interval,
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
-            show_total_activity: value.show_total_data_transmitted,
-            show_activity: value.show_network_activity,
             network_activity_fill_characters: value
                 .network_activity_fill_characters
                 .unwrap_or_default(),
@@ -63,6 +65,7 @@ pub struct Network {
     pub enable: bool,
     pub show_total_activity: bool,
     pub show_activity: bool,
+    pub show_default_interface: bool,
     networks_network_activity: Networks,
     data_refresh_interval: u64,
     label_prefix: LabelPrefix,
@@ -97,7 +100,7 @@ impl Network {
                 if let Some(friendly_name) = &interface.friendly_name {
                     self.default_interface.clone_from(friendly_name);
 
-                    self.networks_network_activity.refresh();
+                    self.networks_network_activity.refresh(true);
 
                     for (interface_name, data) in &self.networks_network_activity {
                         if friendly_name.eq(interface_name) {
@@ -135,12 +138,17 @@ impl Network {
         (activity, total_activity)
     }
 
-    fn reading_to_label(&self, ctx: &Context, reading: NetworkReading) -> Label {
+    fn reading_to_label(
+        &self,
+        ctx: &Context,
+        reading: NetworkReading,
+        config: RenderConfig,
+    ) -> Label {
         let (text_down, text_up) = match self.label_prefix {
             LabelPrefix::None | LabelPrefix::Icon => match reading.format {
                 NetworkReadingFormat::Speed => (
                     format!(
-                        "{: >width$}/s | ",
+                        "{: >width$}/s ",
                         reading.received_text,
                         width = self.network_activity_fill_characters
                     ),
@@ -151,14 +159,14 @@ impl Network {
                     ),
                 ),
                 NetworkReadingFormat::Total => (
-                    format!("{} | ", reading.received_text),
+                    format!("{} ", reading.received_text),
                     reading.transmitted_text,
                 ),
             },
             LabelPrefix::Text | LabelPrefix::IconAndText => match reading.format {
                 NetworkReadingFormat::Speed => (
                     format!(
-                        "DOWN: {: >width$}/s | ",
+                        "DOWN: {: >width$}/s ",
                         reading.received_text,
                         width = self.network_activity_fill_characters
                     ),
@@ -169,22 +177,22 @@ impl Network {
                     ),
                 ),
                 NetworkReadingFormat::Total => (
-                    format!("\u{2211}DOWN: {}/s | ", reading.received_text),
+                    format!("\u{2211}DOWN: {}/s ", reading.received_text),
                     format!("\u{2211}UP: {}/s", reading.transmitted_text),
                 ),
             },
         };
 
-        let font_id = ctx
-            .style()
-            .text_styles
-            .get(&TextStyle::Body)
-            .cloned()
-            .unwrap_or_else(FontId::default);
-
-        let icon_format =
-            TextFormat::simple(font_id.clone(), ctx.style().visuals.selection.stroke.color);
-        let text_format = TextFormat::simple(font_id.clone(), ctx.style().visuals.text_color());
+        let icon_format = TextFormat::simple(
+            config.icon_font_id.clone(),
+            ctx.style().visuals.selection.stroke.color,
+        );
+        let text_format = TextFormat {
+            font_id: config.text_font_id.clone(),
+            color: ctx.style().visuals.text_color(),
+            valign: Align::Center,
+            ..Default::default()
+        };
 
         // icon
         let mut layout_job = LayoutJob::simple(
@@ -250,74 +258,77 @@ impl Network {
 
 impl BarWidget for Network {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
-        if self.show_total_activity || self.show_activity {
-            let (activity, total_activity) = self.network_activity();
-
-            if self.show_total_activity {
-                for reading in total_activity {
-                    config.apply_on_widget(true, ui, |ui| {
-                        ui.add(self.reading_to_label(ctx, reading));
-                    });
-                }
-            }
-
-            if self.show_activity {
-                for reading in activity {
-                    config.apply_on_widget(true, ui, |ui| {
-                        ui.add(self.reading_to_label(ctx, reading));
-                    });
-                }
-            }
-        }
-
         if self.enable {
-            self.default_interface();
+            // widget spacing: make sure to use the same config to call the apply_on_widget function
+            let mut render_config = config.clone();
 
-            if !self.default_interface.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
+            if self.show_total_activity || self.show_activity {
+                let (activity, total_activity) = self.network_activity();
 
-                let mut layout_job = LayoutJob::simple(
-                    match self.label_prefix {
-                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
-                            egui_phosphor::regular::WIFI_HIGH.to_string()
-                        }
-                        LabelPrefix::None | LabelPrefix::Text => String::new(),
-                    },
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                if let LabelPrefix::Text | LabelPrefix::IconAndText = self.label_prefix {
-                    self.default_interface.insert_str(0, "NET: ");
+                if self.show_total_activity {
+                    for reading in total_activity {
+                        render_config.apply_on_widget(true, ui, |ui| {
+                            ui.add(self.reading_to_label(ctx, reading, config.clone()));
+                        });
+                    }
                 }
 
-                layout_job.append(
-                    &self.default_interface,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                config.apply_on_widget(true, ui, |ui| {
-                    if ui
-                        .add(
-                            Label::new(layout_job)
-                                .selectable(false)
-                                .sense(Sense::click()),
-                        )
-                        .clicked()
-                    {
-                        if let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn() {
-                            eprintln!("{}", error)
-                        }
+                if self.show_activity {
+                    for reading in activity {
+                        render_config.apply_on_widget(true, ui, |ui| {
+                            ui.add(self.reading_to_label(ctx, reading, config.clone()));
+                        });
                     }
-                });
+                }
             }
+
+            if self.show_default_interface {
+                self.default_interface();
+
+                if !self.default_interface.is_empty() {
+                    let mut layout_job = LayoutJob::simple(
+                        match self.label_prefix {
+                            LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                                egui_phosphor::regular::WIFI_HIGH.to_string()
+                            }
+                            LabelPrefix::None | LabelPrefix::Text => String::new(),
+                        },
+                        config.icon_font_id.clone(),
+                        ctx.style().visuals.selection.stroke.color,
+                        100.0,
+                    );
+
+                    if let LabelPrefix::Text | LabelPrefix::IconAndText = self.label_prefix {
+                        self.default_interface.insert_str(0, "NET: ");
+                    }
+
+                    layout_job.append(
+                        &self.default_interface,
+                        10.0,
+                        TextFormat {
+                            font_id: config.text_font_id.clone(),
+                            color: ctx.style().visuals.text_color(),
+                            valign: Align::Center,
+                            ..Default::default()
+                        },
+                    );
+
+                    render_config.apply_on_widget(false, ui, |ui| {
+                        if SelectableFrame::new(false)
+                            .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
+                            .clicked()
+                        {
+                            if let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn()
+                            {
+                                eprintln!("{}", error)
+                            }
+                        }
+                    });
+                }
+            }
+
+            // widget spacing: pass on the config that was use for calling the apply_on_widget function
+            *config = render_config.clone();
         }
     }
 }

komorebi-bar/src/render.rs

@@ -1,22 +1,26 @@
 use crate::bar::Alignment;
 use crate::config::KomobarConfig;
+use crate::config::MonitorConfigOrIndex;
 use eframe::egui::Color32;
+use eframe::egui::Context;
+use eframe::egui::CornerRadius;
+use eframe::egui::FontId;
 use eframe::egui::Frame;
 use eframe::egui::InnerResponse;
 use eframe::egui::Margin;
-use eframe::egui::Rounding;
 use eframe::egui::Shadow;
+use eframe::egui::TextStyle;
 use eframe::egui::Ui;
-use eframe::egui::Vec2;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 static SHOW_KOMOREBI_LAYOUT_OPTIONS: AtomicUsize = AtomicUsize::new(0);
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "kind")]
 pub enum Grouping {
     /// No grouping is applied
@@ -29,7 +33,7 @@ pub enum Grouping {
     Widget(GroupingConfig),
 }
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct RenderConfig {
     /// Komorebi monitor index of the monitor on which to render the bar
     pub monitor_idx: usize,
@@ -45,22 +49,65 @@ pub struct RenderConfig {
     pub more_inner_margin: bool,
     /// Set to true after the first time the apply_on_widget was called on an alignment
     pub applied_on_widget: bool,
+    /// FontId for text
+    pub text_font_id: FontId,
+    /// FontId for icon (based on scaling the text font id)
+    pub icon_font_id: FontId,
+    /// Show all icons on the workspace section of the Komorebi widget
+    pub show_all_icons: bool,
 }
 
 pub trait RenderExt {
-    fn new_renderconfig(&self, background_color: Color32) -> RenderConfig;
+    fn new_renderconfig(
+        &self,
+        ctx: &Context,
+        background_color: Color32,
+        icon_scale: Option<f32>,
+    ) -> RenderConfig;
 }
 
 impl RenderExt for &KomobarConfig {
-    fn new_renderconfig(&self, background_color: Color32) -> RenderConfig {
+    fn new_renderconfig(
+        &self,
+        ctx: &Context,
+        background_color: Color32,
+        icon_scale: Option<f32>,
+    ) -> RenderConfig {
+        let text_font_id = ctx
+            .style()
+            .text_styles
+            .get(&TextStyle::Body)
+            .cloned()
+            .unwrap_or_else(FontId::default);
+
+        let mut icon_font_id = text_font_id.clone();
+        icon_font_id.size *= icon_scale.unwrap_or(1.4).clamp(1.0, 2.0);
+
+        let monitor_idx = match &self.monitor {
+            MonitorConfigOrIndex::MonitorConfig(monitor_config) => monitor_config.index,
+            MonitorConfigOrIndex::Index(idx) => *idx,
+        };
+
+        // check if any of the alignments have a komorebi widget with the workspace set to show all icons
+        let show_all_icons =
+            KomobarConfig::show_all_icons_on_komorebi_workspace(&self.left_widgets)
+                || self
+                    .center_widgets
+                    .as_ref()
+                    .is_some_and(|list| KomobarConfig::show_all_icons_on_komorebi_workspace(list))
+                || KomobarConfig::show_all_icons_on_komorebi_workspace(&self.right_widgets);
+
         RenderConfig {
-            monitor_idx: self.monitor.index,
+            monitor_idx,
             spacing: self.widget_spacing.unwrap_or(10.0),
             grouping: self.grouping.unwrap_or(Grouping::None),
             background_color,
             alignment: None,
             more_inner_margin: false,
             applied_on_widget: false,
+            text_font_id,
+            icon_font_id,
+            show_all_icons,
         }
     }
 }
@@ -83,21 +130,34 @@ impl RenderConfig {
             alignment: None,
             more_inner_margin: false,
             applied_on_widget: false,
+            text_font_id: FontId::default(),
+            icon_font_id: FontId::default(),
+            show_all_icons: false,
         }
     }
 
-    pub fn apply_on_bar<R>(
+    pub fn change_frame_on_bar(
         &mut self,
-        ui: &mut Ui,
-        add_contents: impl FnOnce(&mut Ui) -> R,
-    ) -> InnerResponse<R> {
+        frame: Frame,
+        ui_style: &Arc<eframe::egui::Style>,
+    ) -> Frame {
         self.alignment = None;
 
         if let Grouping::Bar(config) = self.grouping {
-            return self.define_group(None, config, ui, add_contents);
+            return self.define_group_frame(
+                //TODO: this outer margin can be a config
+                Some(Margin {
+                    left: 10,
+                    right: 10,
+                    top: 6,
+                    bottom: 6,
+                }),
+                config,
+                ui_style,
+            );
         }
 
-        Self::fallback_group(ui, add_contents)
+        frame
     }
 
     pub fn apply_on_alignment<R>(
@@ -143,11 +203,11 @@ impl RenderConfig {
         ui: &mut Ui,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
-        Frame::none()
+        Frame::NONE
             .outer_margin(outer_margin.unwrap_or(Margin::ZERO))
             .inner_margin(match self.more_inner_margin {
-                true => Margin::symmetric(5.0, 0.0),
-                false => Margin::same(0.0),
+                true => Margin::symmetric(5, 0),
+                false => Margin::same(0),
             })
             .show(ui, add_contents)
     }
@@ -159,16 +219,26 @@ impl RenderConfig {
         ui: &mut Ui,
         add_contents: impl FnOnce(&mut Ui) -> R,
     ) -> InnerResponse<R> {
-        Frame::group(ui.style_mut())
+        self.define_group_frame(outer_margin, config, ui.style())
+            .show(ui, add_contents)
+    }
+
+    pub fn define_group_frame(
+        &mut self,
+        outer_margin: Option<Margin>,
+        config: GroupingConfig,
+        ui_style: &Arc<eframe::egui::Style>,
+    ) -> Frame {
+        Frame::group(ui_style)
             .outer_margin(outer_margin.unwrap_or(Margin::ZERO))
             .inner_margin(match self.more_inner_margin {
-                true => Margin::symmetric(8.0, 3.0),
-                false => Margin::symmetric(3.0, 3.0),
+                true => Margin::symmetric(6, 1),
+                false => Margin::symmetric(1, 1),
             })
-            .stroke(ui.style().visuals.widgets.noninteractive.bg_stroke)
-            .rounding(match config.rounding {
+            .stroke(ui_style.visuals.widgets.noninteractive.bg_stroke)
+            .corner_radius(match config.rounding {
                 Some(rounding) => rounding.into(),
-                None => ui.style().visuals.widgets.noninteractive.rounding,
+                None => ui_style.visuals.widgets.noninteractive.corner_radius,
             })
             .fill(
                 self.background_color
@@ -178,24 +248,68 @@ impl RenderConfig {
                 Some(style) => match style {
                     // new styles can be added if needed here
                     GroupingStyle::Default => Shadow::NONE,
-                    GroupingStyle::DefaultWithShadow => Shadow {
-                        blur: 4.0,
-                        offset: Vec2::new(1.0, 1.0),
-                        spread: 3.0,
+                    GroupingStyle::DefaultWithShadowB4O1S3 => Shadow {
+                        blur: 4,
+                        offset: [1, 1],
+                        spread: 3,
                         color: Color32::BLACK.try_apply_alpha(config.transparency_alpha),
                     },
+                    GroupingStyle::DefaultWithShadowB4O0S3 => Shadow {
+                        blur: 4,
+                        offset: [0, 0],
+                        spread: 3,
+                        color: Color32::BLACK.try_apply_alpha(config.transparency_alpha),
+                    },
+                    GroupingStyle::DefaultWithShadowB0O1S3 => Shadow {
+                        blur: 0,
+                        offset: [1, 1],
+                        spread: 3,
+                        color: Color32::BLACK.try_apply_alpha(config.transparency_alpha),
+                    },
+                    GroupingStyle::DefaultWithGlowB3O1S2 => Shadow {
+                        blur: 3,
+                        offset: [1, 1],
+                        spread: 2,
+                        color: ui_style
+                            .visuals
+                            .selection
+                            .stroke
+                            .color
+                            .try_apply_alpha(config.transparency_alpha),
+                    },
+                    GroupingStyle::DefaultWithGlowB3O0S2 => Shadow {
+                        blur: 3,
+                        offset: [0, 0],
+                        spread: 2,
+                        color: ui_style
+                            .visuals
+                            .selection
+                            .stroke
+                            .color
+                            .try_apply_alpha(config.transparency_alpha),
+                    },
+                    GroupingStyle::DefaultWithGlowB0O1S2 => Shadow {
+                        blur: 0,
+                        offset: [1, 1],
+                        spread: 2,
+                        color: ui_style
+                            .visuals
+                            .selection
+                            .stroke
+                            .color
+                            .try_apply_alpha(config.transparency_alpha),
+                    },
                 },
                 None => Shadow::NONE,
             })
-            .show(ui, add_contents)
     }
 
     fn widget_outer_margin(&mut self, ui: &mut Ui) -> Margin {
         let spacing = if self.applied_on_widget {
             // Remove the default item spacing from the margin
-            self.spacing - ui.spacing().item_spacing.x
+            (self.spacing - ui.spacing().item_spacing.x) as i8
         } else {
-            0.0
+            0
         };
 
         if !self.applied_on_widget {
@@ -207,25 +321,26 @@ impl RenderConfig {
                 Some(align) => match align {
                     Alignment::Left => spacing,
                     Alignment::Center => spacing,
-                    Alignment::Right => 0.0,
+                    Alignment::Right => 0,
                 },
-                None => 0.0,
+                None => 0,
             },
             right: match self.alignment {
                 Some(align) => match align {
-                    Alignment::Left => 0.0,
-                    Alignment::Center => 0.0,
+                    Alignment::Left => 0,
+                    Alignment::Center => 0,
                     Alignment::Right => spacing,
                 },
-                None => 0.0,
+                None => 0,
             },
-            top: 0.0,
-            bottom: 0.0,
+            top: 0,
+            bottom: 0,
         }
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct GroupingConfig {
     /// Styles for the grouping
     pub style: Option<GroupingStyle>,
@@ -235,16 +350,29 @@ pub struct GroupingConfig {
     pub rounding: Option<RoundingConfig>,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum GroupingStyle {
     #[serde(alias = "CtByte")]
     Default,
-    /// A black shadow is added under the default group
+    /// A shadow is added under the default group. (blur: 4, offset: x-1 y-1, spread: 3)
     #[serde(alias = "CtByteWithShadow")]
-    DefaultWithShadow,
+    #[serde(alias = "DefaultWithShadow")]
+    DefaultWithShadowB4O1S3,
+    /// A shadow is added under the default group. (blur: 4, offset: x-0 y-0, spread: 3)
+    DefaultWithShadowB4O0S3,
+    /// A shadow is added under the default group. (blur: 0, offset: x-1 y-1, spread: 3)
+    DefaultWithShadowB0O1S3,
+    /// A glow is added under the default group. (blur: 3, offset: x-1 y-1, spread: 2)
+    DefaultWithGlowB3O1S2,
+    /// A glow is added under the default group. (blur: 3, offset: x-0 y-0, spread: 2)
+    DefaultWithGlowB3O0S2,
+    /// A glow is added under the default group. (blur: 0, offset: x-1 y-1, spread: 2)
+    DefaultWithGlowB0O1S2,
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum RoundingConfig {
     /// All 4 corners are the same    
@@ -253,16 +381,19 @@ pub enum RoundingConfig {
     Individual([f32; 4]),
 }
 
-impl From<RoundingConfig> for Rounding {
+impl From<RoundingConfig> for CornerRadius {
     fn from(value: RoundingConfig) -> Self {
         match value {
-            RoundingConfig::Same(value) => Rounding::same(value),
-            RoundingConfig::Individual(values) => Self {
-                nw: values[0],
-                ne: values[1],
-                sw: values[2],
-                se: values[3],
-            },
+            RoundingConfig::Same(value) => Self::same(value as u8),
+            RoundingConfig::Individual(values) => {
+                let values = values.map(|f| f as u8);
+                Self {
+                    nw: values[0],
+                    ne: values[1],
+                    sw: values[2],
+                    se: values[3],
+                }
+            }
         }
     }
 }

komorebi-bar/src/selected_frame.rs

@@ -1,7 +1,10 @@
+use eframe::egui::Color32;
+use eframe::egui::CursorIcon;
 use eframe::egui::Frame;
 use eframe::egui::Margin;
 use eframe::egui::Response;
 use eframe::egui::Sense;
+use eframe::egui::Stroke;
 use eframe::egui::Ui;
 
 /// Same as SelectableLabel, but supports all content
@@ -17,31 +20,39 @@ impl SelectableFrame {
     pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> Response {
         let Self { selected } = self;
 
-        Frame::none()
+        Frame::NONE
             .show(ui, |ui| {
                 let response = ui.interact(ui.max_rect(), ui.unique_id(), Sense::click());
 
                 if ui.is_rect_visible(response.rect) {
+                    // take into account the stroke width
                     let inner_margin = Margin::symmetric(
-                        ui.style().spacing.button_padding.x,
-                        ui.style().spacing.button_padding.y,
+                        ui.style().spacing.button_padding.x as i8 - 1,
+                        ui.style().spacing.button_padding.y as i8 - 1,
                     );
 
-                    if selected
-                        || response.hovered()
-                        || response.highlighted()
-                        || response.has_focus()
-                    {
+                    // since the stroke is drawn inside the frame, we always reserve space for it
+                    if response.hovered() || response.highlighted() || response.has_focus() {
                         let visuals = ui.style().interact_selectable(&response, selected);
 
-                        Frame::none()
-                            .stroke(visuals.bg_stroke)
-                            .rounding(visuals.rounding)
+                        Frame::NONE
+                            .stroke(Stroke::new(1.0, visuals.bg_stroke.color))
+                            .corner_radius(visuals.corner_radius)
+                            .fill(visuals.bg_fill)
+                            .inner_margin(inner_margin)
+                            .show(ui, add_contents);
+                    } else if selected {
+                        let visuals = ui.style().interact_selectable(&response, selected);
+
+                        Frame::NONE
+                            .stroke(Stroke::new(1.0, visuals.bg_fill))
+                            .corner_radius(visuals.corner_radius)
                             .fill(visuals.bg_fill)
                             .inner_margin(inner_margin)
                             .show(ui, add_contents);
                     } else {
-                        Frame::none()
+                        Frame::NONE
+                            .stroke(Stroke::new(1.0, Color32::TRANSPARENT))
                             .inner_margin(inner_margin)
                             .show(ui, add_contents);
                     }
@@ -50,6 +61,6 @@ impl SelectableFrame {
                 response
             })
             .inner
-            .on_hover_cursor(eframe::egui::CursorIcon::PointingHand)
+            .on_hover_cursor(CursorIcon::PointingHand)
     }
 }

komorebi-bar/src/storage.rs

@@ -1,15 +1,13 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
 use eframe::egui::Label;
-use eframe::egui::Sense;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::process::Command;
@@ -17,7 +15,8 @@ use std::time::Duration;
 use std::time::Instant;
 use sysinfo::Disks;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct StorageConfig {
     /// Enable the Storage widget
     pub enable: bool,
@@ -51,7 +50,7 @@ impl Storage {
     fn output(&mut self) -> Vec<String> {
         let now = Instant::now();
         if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            self.disks.refresh();
+            self.disks.refresh(true);
             self.last_updated = now;
         }
 
@@ -81,13 +80,6 @@ impl Storage {
 impl BarWidget for Storage {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
         if self.enable {
-            let font_id = ctx
-                .style()
-                .text_styles
-                .get(&TextStyle::Body)
-                .cloned()
-                .unwrap_or_else(FontId::default);
-
             for output in self.output() {
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
@@ -96,7 +88,7 @@ impl BarWidget for Storage {
                         }
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -104,16 +96,17 @@ impl BarWidget for Storage {
                 layout_job.append(
                     &output,
                     10.0,
-                    TextFormat::simple(font_id.clone(), ctx.style().visuals.text_color()),
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
                 );
 
-                config.apply_on_widget(true, ui, |ui| {
-                    if ui
-                        .add(
-                            Label::new(layout_job)
-                                .selectable(false)
-                                .sense(Sense::click()),
-                        )
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
                         .clicked()
                     {
                         if let Err(error) = Command::new("cmd.exe")

komorebi-bar/src/time.rs

@@ -1,19 +1,24 @@
+use crate::bar::Alignment;
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
 use crate::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
 use eframe::egui::Context;
-use eframe::egui::FontId;
+use eframe::egui::CornerRadius;
 use eframe::egui::Label;
 use eframe::egui::Sense;
+use eframe::egui::Stroke;
 use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
 use eframe::egui::Ui;
-use schemars::JsonSchema;
+use eframe::egui::Vec2;
+use eframe::epaint::StrokeKind;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct TimeConfig {
     /// Enable the Time widget
     pub enable: bool,
@@ -33,12 +38,21 @@ impl From<TimeConfig> for Time {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum TimeFormat {
     /// Twelve-hour format (with seconds)
     TwelveHour,
+    /// Twelve-hour format (without seconds)
+    TwelveHourWithoutSeconds,
     /// Twenty-four-hour format (with seconds)
     TwentyFourHour,
+    /// Twenty-four-hour format (without seconds)
+    TwentyFourHourWithoutSeconds,
+    /// Twenty-four-hour format displayed as a binary clock with circles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)
+    BinaryCircle,
+    /// Twenty-four-hour format displayed as a binary clock with rectangles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)
+    BinaryRectangle,
     /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
     Custom(String),
 }
@@ -46,8 +60,12 @@ pub enum TimeFormat {
 impl TimeFormat {
     pub fn toggle(&mut self) {
         match self {
-            TimeFormat::TwelveHour => *self = TimeFormat::TwentyFourHour,
-            TimeFormat::TwentyFourHour => *self = TimeFormat::TwelveHour,
+            TimeFormat::TwelveHour => *self = TimeFormat::TwelveHourWithoutSeconds,
+            TimeFormat::TwelveHourWithoutSeconds => *self = TimeFormat::TwentyFourHour,
+            TimeFormat::TwentyFourHour => *self = TimeFormat::TwentyFourHourWithoutSeconds,
+            TimeFormat::TwentyFourHourWithoutSeconds => *self = TimeFormat::BinaryCircle,
+            TimeFormat::BinaryCircle => *self = TimeFormat::BinaryRectangle,
+            TimeFormat::BinaryRectangle => *self = TimeFormat::TwelveHour,
             _ => {}
         };
     }
@@ -55,7 +73,11 @@ impl TimeFormat {
     fn fmt_string(&self) -> String {
         match self {
             TimeFormat::TwelveHour => String::from("%l:%M:%S %p"),
+            TimeFormat::TwelveHourWithoutSeconds => String::from("%l:%M %p"),
             TimeFormat::TwentyFourHour => String::from("%T"),
+            TimeFormat::TwentyFourHourWithoutSeconds => String::from("%H:%M"),
+            TimeFormat::BinaryCircle => String::from("c%T"),
+            TimeFormat::BinaryRectangle => String::from("r%T"),
             TimeFormat::Custom(format) => format.to_string(),
         }
     }
@@ -73,6 +95,174 @@ impl Time {
         chrono::Local::now()
             .format(&self.format.fmt_string())
             .to_string()
+            .trim()
+            .to_string()
+    }
+
+    fn paint_binary_circle(
+        &mut self,
+        size: f32,
+        number: u32,
+        max_power: usize,
+        ctx: &Context,
+        ui: &mut Ui,
+    ) {
+        let full_height = size;
+        let height = full_height / 4.0;
+        let width = height;
+
+        let (response, painter) =
+            ui.allocate_painter(Vec2::new(width, full_height), Sense::hover());
+        let color = ctx.style().visuals.text_color();
+
+        let c = response.rect.center();
+        let r = height / 2.0 - 0.5;
+
+        if number == 1 || number == 3 || number == 5 || number == 7 || number == 9 {
+            painter.circle_filled(c + Vec2::new(0.0, height * 1.50), r, color);
+        } else {
+            painter.circle_filled(c + Vec2::new(0.0, height * 1.50), r / 2.5, color);
+        }
+
+        if number == 2 || number == 3 || number == 6 || number == 7 {
+            painter.circle_filled(c + Vec2::new(0.0, height * 0.50), r, color);
+        } else {
+            painter.circle_filled(c + Vec2::new(0.0, height * 0.50), r / 2.5, color);
+        }
+
+        if number == 4 || number == 5 || number == 6 || number == 7 {
+            painter.circle_filled(c + Vec2::new(0.0, -height * 0.50), r, color);
+        } else if max_power > 2 {
+            painter.circle_filled(c + Vec2::new(0.0, -height * 0.50), r / 2.5, color);
+        }
+
+        if number == 8 || number == 9 {
+            painter.circle_filled(c + Vec2::new(0.0, -height * 1.50), r, color);
+        } else if max_power > 3 {
+            painter.circle_filled(c + Vec2::new(0.0, -height * 1.50), r / 2.5, color);
+        }
+    }
+
+    fn paint_binary_rect(
+        &mut self,
+        size: f32,
+        number: u32,
+        max_power: usize,
+        ctx: &Context,
+        ui: &mut Ui,
+    ) {
+        let full_height = size;
+        let height = full_height / 4.0;
+        let width = height * 1.5;
+
+        let (response, painter) =
+            ui.allocate_painter(Vec2::new(width, full_height), Sense::hover());
+        let color = ctx.style().visuals.text_color();
+        let stroke = Stroke::new(1.0, color);
+
+        let round_all = CornerRadius::same((response.rect.width() * 0.1) as u8);
+        let round_top = CornerRadius {
+            nw: round_all.nw,
+            ne: round_all.ne,
+            ..Default::default()
+        };
+        let round_none = CornerRadius::ZERO;
+        let round_bottom = CornerRadius {
+            sw: round_all.nw,
+            se: round_all.ne,
+            ..Default::default()
+        };
+
+        if max_power == 2 {
+            let mut rect = response.rect.shrink(stroke.width);
+            rect.set_height(rect.height() - height * 2.0);
+            rect = rect.translate(Vec2::new(0.0, height * 2.0));
+            painter.rect_stroke(rect, round_all, stroke, StrokeKind::Outside);
+        } else if max_power == 3 {
+            let mut rect = response.rect.shrink(stroke.width);
+            rect.set_height(rect.height() - height);
+            rect = rect.translate(Vec2::new(0.0, height));
+            painter.rect_stroke(rect, round_all, stroke, StrokeKind::Outside);
+        } else {
+            painter.rect_stroke(
+                response.rect.shrink(stroke.width),
+                round_all,
+                stroke,
+                StrokeKind::Outside,
+            );
+        }
+
+        let mut rect_bin = response.rect;
+        rect_bin.set_width(width);
+
+        if number == 1 || number == 5 || number == 9 {
+            rect_bin.set_height(height);
+            painter.rect_filled(
+                rect_bin.translate(Vec2::new(0.0, height * 3.0)),
+                round_bottom,
+                color,
+            );
+        }
+        if number == 2 {
+            rect_bin.set_height(height);
+            painter.rect_filled(
+                rect_bin.translate(Vec2::new(0.0, height * 2.0)),
+                if max_power == 2 {
+                    round_top
+                } else {
+                    round_none
+                },
+                color,
+            );
+        }
+        if number == 3 {
+            rect_bin.set_height(height * 2.0);
+            painter.rect_filled(
+                rect_bin.translate(Vec2::new(0.0, height * 2.0)),
+                round_bottom,
+                color,
+            );
+        }
+        if number == 4 || number == 5 {
+            rect_bin.set_height(height);
+            painter.rect_filled(
+                rect_bin.translate(Vec2::new(0.0, height * 1.0)),
+                if max_power == 3 {
+                    round_top
+                } else {
+                    round_none
+                },
+                color,
+            );
+        }
+        if number == 6 {
+            rect_bin.set_height(height * 2.0);
+            painter.rect_filled(
+                rect_bin.translate(Vec2::new(0.0, height * 1.0)),
+                if max_power == 3 {
+                    round_top
+                } else {
+                    round_none
+                },
+                color,
+            );
+        }
+        if number == 7 {
+            rect_bin.set_height(height * 3.0);
+            painter.rect_filled(
+                rect_bin.translate(Vec2::new(0.0, height)),
+                if max_power == 3 {
+                    round_all
+                } else {
+                    round_bottom
+                },
+                color,
+            );
+        }
+        if number == 8 || number == 9 {
+            rect_bin.set_height(height);
+            painter.rect_filled(rect_bin.translate(Vec2::new(0.0, 0.0)), round_top, color);
+        }
     }
 }
 
@@ -81,12 +271,8 @@ impl BarWidget for Time {
         if self.enable {
             let mut output = self.output();
             if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
+                let use_binary_circle = output.starts_with('c');
+                let use_binary_rectangle = output.starts_with('r');
 
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
@@ -95,7 +281,7 @@ impl BarWidget for Time {
                         }
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
-                    font_id.clone(),
+                    config.icon_font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
@@ -104,19 +290,83 @@ impl BarWidget for Time {
                     output.insert_str(0, "TIME: ");
                 }
 
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
+                if !use_binary_circle && !use_binary_rectangle {
+                    layout_job.append(
+                        &output,
+                        10.0,
+                        TextFormat {
+                            font_id: config.text_font_id.clone(),
+                            color: ctx.style().visuals.text_color(),
+                            valign: Align::Center,
+                            ..Default::default()
+                        },
+                    );
+                }
 
-                config.apply_on_widget(true, ui, |ui| {
-                    if ui
-                        .add(
-                            Label::new(layout_job)
-                                .selectable(false)
-                                .sense(Sense::click()),
-                        )
+                let font_id = config.icon_font_id.clone();
+                let is_reversed = matches!(config.alignment, Some(Alignment::Right));
+
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| {
+                            if !is_reversed {
+                                ui.add(Label::new(layout_job.clone()).selectable(false));
+                            }
+
+                            if use_binary_circle || use_binary_rectangle {
+                                let ordered_output = if is_reversed {
+                                    output.chars().rev().collect()
+                                } else {
+                                    output
+                                };
+
+                                for (section_index, section) in
+                                    ordered_output.split(':').enumerate()
+                                {
+                                    ui.scope(|ui| {
+                                        ui.spacing_mut().item_spacing = Vec2::splat(2.0);
+                                        for (number_index, number_char) in
+                                            section.chars().enumerate()
+                                        {
+                                            if let Some(number) = number_char.to_digit(10) {
+                                                // the hour is the second char in the first section (in reverse, it's in the last section)
+                                                let max_power = match (
+                                                    is_reversed,
+                                                    section_index,
+                                                    number_index,
+                                                ) {
+                                                    (true, 2, 1) | (false, 0, 1) => 2,
+                                                    (true, _, 1) | (false, _, 0) => 3,
+                                                    _ => 4,
+                                                };
+
+                                                if use_binary_circle {
+                                                    self.paint_binary_circle(
+                                                        font_id.size,
+                                                        number,
+                                                        max_power,
+                                                        ctx,
+                                                        ui,
+                                                    );
+                                                } else if use_binary_rectangle {
+                                                    self.paint_binary_rect(
+                                                        font_id.size,
+                                                        number,
+                                                        max_power,
+                                                        ctx,
+                                                        ui,
+                                                    );
+                                                }
+                                            }
+                                        }
+                                    });
+                                }
+                            }
+
+                            if is_reversed {
+                                ui.add(Label::new(layout_job.clone()).selectable(false));
+                            }
+                        })
                         .clicked()
                     {
                         self.format.toggle()

komorebi-bar/src/update.rs

@@ -0,0 +1,158 @@
+use crate::config::LabelPrefix;
+use crate::render::RenderConfig;
+use crate::selected_frame::SelectableFrame;
+use crate::widget::BarWidget;
+use eframe::egui::text::LayoutJob;
+use eframe::egui::Align;
+use eframe::egui::Context;
+use eframe::egui::Label;
+use eframe::egui::TextFormat;
+use eframe::egui::Ui;
+use serde::Deserialize;
+use serde::Serialize;
+use std::process::Command;
+use std::time::Duration;
+use std::time::Instant;
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub struct UpdateConfig {
+    /// Enable the Update widget
+    pub enable: bool,
+    /// Data refresh interval (default: 12 hours)
+    pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
+}
+
+impl From<UpdateConfig> for Update {
+    fn from(value: UpdateConfig) -> Self {
+        let data_refresh_interval = value.data_refresh_interval.unwrap_or(12);
+
+        let mut latest_version = String::new();
+
+        let client = reqwest::blocking::Client::new();
+        if let Ok(response) = client
+            .get("https://api.github.com/repos/LGUG2Z/komorebi/releases/latest")
+            .header("User-Agent", "komorebi-bar-version-checker")
+            .send()
+        {
+            #[derive(Deserialize)]
+            struct Release {
+                tag_name: String,
+            }
+
+            if let Ok(release) =
+                serde_json::from_str::<Release>(&response.text().unwrap_or_default())
+            {
+                let trimmed = release.tag_name.trim_start_matches("v");
+                latest_version = trimmed.to_string();
+            }
+        }
+
+        Self {
+            enable: value.enable,
+            data_refresh_interval,
+            installed_version: env!("CARGO_PKG_VERSION").to_string(),
+            latest_version,
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
+            last_updated: Instant::now()
+                .checked_sub(Duration::from_secs(data_refresh_interval))
+                .unwrap(),
+        }
+    }
+}
+
+pub struct Update {
+    pub enable: bool,
+    data_refresh_interval: u64,
+    installed_version: String,
+    latest_version: String,
+    label_prefix: LabelPrefix,
+    last_updated: Instant,
+}
+
+impl Update {
+    fn output(&mut self) -> String {
+        let now = Instant::now();
+        if now.duration_since(self.last_updated)
+            > Duration::from_secs((self.data_refresh_interval * 60) * 60)
+        {
+            let client = reqwest::blocking::Client::new();
+            if let Ok(response) = client
+                .get("https://api.github.com/repos/LGUG2Z/komorebi/releases/latest")
+                .header("User-Agent", "komorebi-bar-version-checker")
+                .send()
+            {
+                #[derive(Deserialize)]
+                struct Release {
+                    tag_name: String,
+                }
+
+                if let Ok(release) =
+                    serde_json::from_str::<Release>(&response.text().unwrap_or_default())
+                {
+                    let trimmed = release.tag_name.trim_start_matches("v");
+                    self.latest_version = trimmed.to_string();
+                }
+            }
+
+            self.last_updated = now;
+        }
+
+        if self.latest_version > self.installed_version {
+            format!("Update available! v{}", self.latest_version)
+        } else {
+            String::new()
+        }
+    }
+}
+
+impl BarWidget for Update {
+    fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
+        if self.enable {
+            let output = self.output();
+            if !output.is_empty() {
+                let mut layout_job = LayoutJob::simple(
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::ROCKET_LAUNCH.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
+                    config.icon_font_id.clone(),
+                    ctx.style().visuals.selection.stroke.color,
+                    100.0,
+                );
+
+                layout_job.append(
+                    &output,
+                    10.0,
+                    TextFormat {
+                        font_id: config.text_font_id.clone(),
+                        color: ctx.style().visuals.text_color(),
+                        valign: Align::Center,
+                        ..Default::default()
+                    },
+                );
+
+                config.apply_on_widget(false, ui, |ui| {
+                    if SelectableFrame::new(false)
+                        .show(ui, |ui| ui.add(Label::new(layout_job).selectable(false)))
+                        .clicked()
+                    {
+                        if let Err(error) = Command::new("explorer.exe")
+                            .args([format!(
+                                "https://github.com/LGUG2Z/komorebi/releases/v{}",
+                                self.latest_version
+                            )])
+                            .spawn()
+                        {
+                            eprintln!("{}", error)
+                        }
+                    }
+                });
+            }
+        }
+    }
+}

komorebi-bar/src/widget.rs

@@ -4,6 +4,8 @@ use crate::cpu::Cpu;
 use crate::cpu::CpuConfig;
 use crate::date::Date;
 use crate::date::DateConfig;
+use crate::keyboard::Keyboard;
+use crate::keyboard::KeyboardConfig;
 use crate::komorebi::Komorebi;
 use crate::komorebi::KomorebiConfig;
 use crate::media::Media;
@@ -17,9 +19,10 @@ use crate::storage::Storage;
 use crate::storage::StorageConfig;
 use crate::time::Time;
 use crate::time::TimeConfig;
+use crate::update::Update;
+use crate::update::UpdateConfig;
 use eframe::egui::Context;
 use eframe::egui::Ui;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -27,17 +30,20 @@ pub trait BarWidget {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig);
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum WidgetConfig {
     Battery(BatteryConfig),
     Cpu(CpuConfig),
     Date(DateConfig),
+    Keyboard(KeyboardConfig),
     Komorebi(KomorebiConfig),
     Media(MediaConfig),
     Memory(MemoryConfig),
     Network(NetworkConfig),
     Storage(StorageConfig),
     Time(TimeConfig),
+    Update(UpdateConfig),
 }
 
 impl WidgetConfig {
@@ -46,12 +52,38 @@ impl WidgetConfig {
             WidgetConfig::Battery(config) => Box::new(Battery::from(*config)),
             WidgetConfig::Cpu(config) => Box::new(Cpu::from(*config)),
             WidgetConfig::Date(config) => Box::new(Date::from(config.clone())),
+            WidgetConfig::Keyboard(config) => Box::new(Keyboard::from(*config)),
             WidgetConfig::Komorebi(config) => Box::new(Komorebi::from(config)),
             WidgetConfig::Media(config) => Box::new(Media::from(*config)),
             WidgetConfig::Memory(config) => Box::new(Memory::from(*config)),
             WidgetConfig::Network(config) => Box::new(Network::from(*config)),
             WidgetConfig::Storage(config) => Box::new(Storage::from(*config)),
             WidgetConfig::Time(config) => Box::new(Time::from(config.clone())),
+            WidgetConfig::Update(config) => Box::new(Update::from(*config)),
+        }
+    }
+
+    pub fn enabled(&self) -> bool {
+        match self {
+            WidgetConfig::Battery(config) => config.enable,
+            WidgetConfig::Cpu(config) => config.enable,
+            WidgetConfig::Date(config) => config.enable,
+            WidgetConfig::Keyboard(config) => config.enable,
+            WidgetConfig::Komorebi(config) => {
+                config.workspaces.as_ref().is_some_and(|w| w.enable)
+                    || config.layout.as_ref().is_some_and(|w| w.enable)
+                    || config.focused_window.as_ref().is_some_and(|w| w.enable)
+                    || config
+                        .configuration_switcher
+                        .as_ref()
+                        .is_some_and(|w| w.enable)
+            }
+            WidgetConfig::Media(config) => config.enable,
+            WidgetConfig::Memory(config) => config.enable,
+            WidgetConfig::Network(config) => config.enable,
+            WidgetConfig::Storage(config) => config.enable,
+            WidgetConfig::Time(config) => config.enable,
+            WidgetConfig::Update(config) => config.enable,
         }
     }
 }

komorebi-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-client"
-version = "0.1.31"
+version = "0.1.35"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

komorebi-client/src/lib.rs

@@ -2,10 +2,15 @@
 #![allow(clippy::missing_errors_doc)]
 
 pub use komorebi::animation::prefix::AnimationPrefix;
+pub use komorebi::animation::PerAnimationPrefixConfig;
 pub use komorebi::asc::ApplicationSpecificConfiguration;
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;
 pub use komorebi::config_generation::ApplicationConfiguration;
+pub use komorebi::config_generation::IdWithIdentifier;
+pub use komorebi::config_generation::IdWithIdentifierAndComment;
+pub use komorebi::config_generation::MatchingRule;
+pub use komorebi::config_generation::MatchingStrategy;
 pub use komorebi::container::Container;
 pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
 pub use komorebi::core::resolve_home_path;
@@ -15,6 +20,10 @@ pub use komorebi::core::Arrangement;
 pub use komorebi::core::Axis;
 pub use komorebi::core::BorderImplementation;
 pub use komorebi::core::BorderStyle;
+pub use komorebi::core::Column;
+pub use komorebi::core::ColumnSplit;
+pub use komorebi::core::ColumnSplitWithCapacity;
+pub use komorebi::core::ColumnWidth;
 pub use komorebi::core::CustomLayout;
 pub use komorebi::core::CycleDirection;
 pub use komorebi::core::DefaultLayout;
@@ -25,6 +34,7 @@ pub use komorebi::core::Layout;
 pub use komorebi::core::MoveBehaviour;
 pub use komorebi::core::OperationBehaviour;
 pub use komorebi::core::OperationDirection;
+pub use komorebi::core::PathExt;
 pub use komorebi::core::Rect;
 pub use komorebi::core::Sizing;
 pub use komorebi::core::SocketMessage;
@@ -33,21 +43,32 @@ pub use komorebi::core::StackbarMode;
 pub use komorebi::core::StateQuery;
 pub use komorebi::core::WindowKind;
 pub use komorebi::monitor::Monitor;
+pub use komorebi::monitor_reconciliator::MonitorNotification;
 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::workspace::WorkspaceGlobals;
+pub use komorebi::workspace::WorkspaceLayer;
+pub use komorebi::AnimationsConfig;
+pub use komorebi::AspectRatio;
 pub use komorebi::BorderColours;
+pub use komorebi::CrossBoundaryBehaviour;
 pub use komorebi::GlobalState;
 pub use komorebi::KomorebiTheme;
+pub use komorebi::MonitorConfig;
 pub use komorebi::Notification;
 pub use komorebi::NotificationEvent;
+pub use komorebi::PredefinedAspectRatio;
 pub use komorebi::RuleDebug;
 pub use komorebi::StackbarConfig;
 pub use komorebi::State;
 pub use komorebi::StaticConfig;
 pub use komorebi::SubscribeOptions;
 pub use komorebi::TabsConfig;
+pub use komorebi::WindowContainerBehaviour;
+pub use komorebi::WindowsApi;
+pub use komorebi::WorkspaceConfig;
 
 use komorebi::DATA_DIR;
 
@@ -68,6 +89,20 @@ pub fn send_message(message: &SocketMessage) -> std::io::Result<()> {
     stream.write_all(serde_json::to_string(message)?.as_bytes())
 }
 
+pub fn send_batch(messages: impl IntoIterator<Item = SocketMessage>) -> std::io::Result<()> {
+    let socket = DATA_DIR.join(KOMOREBI);
+    let mut stream = UnixStream::connect(socket)?;
+    stream.set_write_timeout(Some(Duration::from_secs(1)))?;
+    let msgs = messages.into_iter().fold(String::new(), |mut s, m| {
+        if let Ok(m_str) = serde_json::to_string(&m) {
+            s.push_str(&m_str);
+            s.push('\n');
+        }
+        s
+    });
+    stream.write_all(msgs.as_bytes())
+}
+
 pub fn send_query(message: &SocketMessage) -> std::io::Result<String> {
     let socket = DATA_DIR.join(KOMOREBI);
 

komorebi-gui/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.31"
+version = "0.1.35"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,6 +10,7 @@ komorebi-client = { path = "../komorebi-client" }
 
 eframe = { workspace = true }
 egui_extras = { workspace = true }
-random_word = { version = "0.4.3", features = ["en"] }
+random_word = { version = "0.4", features = ["en"] }
 serde_json = { workspace = true }
+windows-core = { workspace = true }
 windows = { workspace = true }

komorebi-gui/src/main.rs

@@ -215,7 +215,7 @@ impl KomorebiGui {
 extern "system" fn enum_window(
     hwnd: windows::Win32::Foundation::HWND,
     lparam: windows::Win32::Foundation::LPARAM,
-) -> windows::Win32::Foundation::BOOL {
+) -> windows_core::BOOL {
     let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
     let window = Window::from(hwnd.0 as isize);
 

komorebi-themes/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "komorebi-themes"
-version = "0.1.31"
+version = "0.1.35"
 edition = "2021"
 
 [dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "c11fbe2a3a4681485c5065b899a4c4d85fad3b04" }
-#catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "f579847bf2f552b144361d5a78ed8cf360b55cbb" }
-catppuccin-egui = { version = "5", default-features = false, features = ["egui29"] }
+base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "96f26c88d83781f234d42222293ec73d23a39ad8" }
+catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "bdaff30959512c4f7ee7304117076a48633d777f", default-features = false, features = ["egui31"] }
+#catppuccin-egui = { version = "5", default-features = false, features = ["egui30"] }
 eframe = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_variant = "0.1"
-strum = "0.26"
+strum = { workspace = true }

komorebi-themes/src/lib.rs

@@ -4,6 +4,7 @@
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
+use strum::Display;
 use strum::IntoEnumIterator;
 
 pub use base16_egui_themes::Base16;
@@ -11,7 +12,7 @@ pub use catppuccin_egui;
 pub use eframe::egui::Color32;
 use serde_variant::to_variant_name;
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(tag = "type")]
 pub enum Theme {
     /// A theme from catppuccin-egui
@@ -48,7 +49,7 @@ impl Theme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, Display, PartialEq)]
 pub enum Base16Value {
     Base00,
     Base01,
@@ -92,7 +93,7 @@ impl Base16Value {
     }
 }
 
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, Display, PartialEq)]
 pub enum Catppuccin {
     Frappe,
     Latte,
@@ -117,7 +118,7 @@ impl From<Catppuccin> for catppuccin_egui::Theme {
     }
 }
 
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema, Display, PartialEq)]
 pub enum CatppuccinValue {
     Rosewater,
     Flamingo,

komorebi/Cargo.toml

@@ -1,8 +1,7 @@
 [package]
 name = "komorebi"
-version = "0.1.31"
+version = "0.1.35"
 description = "A tiling window manager for Windows"
-categories = ["tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
 
@@ -26,16 +25,16 @@ lazy_static = { workspace = true }
 miow = "0.6"
 nanoid = "0.4"
 net2 = "0.2"
-os_info = "3.8"
+os_info = "3.10"
 parking_lot = "0.12"
 paste = { workspace = true }
 regex = "1"
-schemars = { workspace = true }
+schemars = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }
 shadow-rs = { workspace = true }
-strum = { version = "0.26", features = ["derive"] }
+strum = { workspace = true }
 sysinfo = { workspace = true }
 tracing = { workspace = true }
 tracing-appender = { workspace = true }
@@ -45,13 +44,19 @@ which = { workspace = true }
 win32-display-data = { workspace = true }
 windows = { workspace = true }
 windows-core = { workspace = true }
+windows-numerics = { workspace = true }
 windows-implement = { workspace = true }
 windows-interface = { workspace = true }
 winput = "0.2"
-winreg = "0.52"
+winreg = "0.55"
 
 [build-dependencies]
 shadow-rs = { workspace = true }
 
+[dev-dependencies]
+reqwest = { version = "0.12", features = ["blocking"] }
+
 [features]
+default = ["schemars"]
 deadlock_detection = ["parking_lot/deadlock_detection"]
+schemars = ["dep:schemars"]

komorebi/build.rs

@@ -1,3 +1,5 @@
+use shadow_rs::ShadowBuilder;
+
 fn main() {
-    shadow_rs::new().unwrap();
+    ShadowBuilder::builder().build().unwrap();
 }

komorebi/src/animation/engine.rs

@@ -1,7 +1,5 @@
 use color_eyre::Result;
 
-use schemars::JsonSchema;
-
 use serde::Deserialize;
 use serde::Serialize;
 use std::sync::atomic::Ordering;
@@ -13,7 +11,8 @@ use super::ANIMATION_DURATION_GLOBAL;
 use super::ANIMATION_FPS;
 use super::ANIMATION_MANAGER;
 
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct AnimationEngine;
 
 impl AnimationEngine {

komorebi/src/animation/mod.rs

@@ -18,11 +18,12 @@ pub mod prefix;
 pub mod render_dispatcher;
 pub use render_dispatcher::RenderDispatcher;
 pub mod style;
-use schemars::JsonSchema;
+
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum PerAnimationPrefixConfig<T> {
     Prefix(HashMap<AnimationPrefix, T>),

komorebi/src/animation/prefix.rs

@@ -1,24 +1,14 @@
 use clap::ValueEnum;
-use schemars::JsonSchema;
+
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    Hash,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
+    Copy, Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize, Display, EnumString, ValueEnum,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum AnimationPrefix {

komorebi/src/border_manager/border.rs

@@ -1,4 +1,5 @@
 use crate::border_manager::window_kind_colour;
+use crate::border_manager::RenderTarget;
 use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
@@ -17,8 +18,6 @@ use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::sync::LazyLock;
 use std::sync::OnceLock;
-use windows::Foundation::Numerics::Matrix3x2;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::FALSE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -32,7 +31,6 @@ use windows::Win32::Graphics::Direct2D::Common::D2D_RECT_F;
 use windows::Win32::Graphics::Direct2D::Common::D2D_SIZE_U;
 use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
 use windows::Win32::Graphics::Direct2D::ID2D1Factory;
-use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
 use windows::Win32::Graphics::Direct2D::ID2D1SolidColorBrush;
 use windows::Win32::Graphics::Direct2D::D2D1_ANTIALIAS_MODE_PER_PRIMITIVE;
 use windows::Win32::Graphics::Direct2D::D2D1_BRUSH_PROPERTIES;
@@ -68,13 +66,29 @@ use windows::Win32::UI::WindowsAndMessaging::WM_CREATE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
+use windows_core::BOOL;
 use windows_core::PCWSTR;
+use windows_numerics::Matrix3x2;
+
+pub struct RenderFactory(ID2D1Factory);
+unsafe impl Sync for RenderFactory {}
+unsafe impl Send for RenderFactory {}
+
+impl Deref for RenderFactory {
+    type Target = ID2D1Factory;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
 
 #[allow(clippy::expect_used)]
-static RENDER_FACTORY: LazyLock<ID2D1Factory> = unsafe {
+static RENDER_FACTORY: LazyLock<RenderFactory> = unsafe {
     LazyLock::new(|| {
-        D2D1CreateFactory::<ID2D1Factory>(D2D1_FACTORY_TYPE_MULTI_THREADED, None)
-            .expect("creating RENDER_FACTORY failed")
+        RenderFactory(
+            D2D1CreateFactory::<ID2D1Factory>(D2D1_FACTORY_TYPE_MULTI_THREADED, None)
+                .expect("creating RENDER_FACTORY failed"),
+        )
     })
 };
 
@@ -100,7 +114,7 @@ pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
 #[derive(Debug, Clone)]
 pub struct Border {
     pub hwnd: isize,
-    pub render_target: OnceLock<ID2D1HwndRenderTarget>,
+    pub render_target: OnceLock<RenderTarget>,
     pub tracking_hwnd: isize,
     pub window_rect: Rect,
     pub window_kind: WindowKind,
@@ -180,7 +194,7 @@ impl Border {
 
             loop {
                 unsafe {
-                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
                         tracing::debug!("border window event processing thread shutdown");
                         break;
                     };
@@ -261,7 +275,11 @@ impl Border {
 
                 render_target.SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
 
-                if border.render_target.set(render_target.clone()).is_err() {
+                if border
+                    .render_target
+                    .set(RenderTarget(render_target.clone()))
+                    .is_err()
+                {
                     return Err(anyhow!("could not store border render target"));
                 }
 
@@ -275,7 +293,7 @@ impl Border {
                 };
 
                 let mut render_targets = RENDER_TARGETS.lock();
-                render_targets.insert(border.hwnd, render_target);
+                render_targets.insert(border.hwnd, RenderTarget(render_target));
                 Ok(border.clone())
             },
             Err(error) => Err(error.into()),
@@ -300,7 +318,7 @@ impl Border {
 
     // this triggers WM_PAINT in the callback below
     pub fn invalidate(&self) {
-        let _ = unsafe { InvalidateRect(self.hwnd(), None, false) };
+        let _ = unsafe { InvalidateRect(Option::from(self.hwnd()), None, false) };
     }
 
     pub extern "system" fn callback(
@@ -425,6 +443,18 @@ impl Border {
                             return LRESULT(0);
                         }
 
+                        let reference_hwnd = (*border_pointer).tracking_hwnd;
+
+                        // Update position to update the ZOrder
+                        let border_window_rect = (*border_pointer).window_rect;
+
+                        tracing::trace!("updating border position");
+                        if let Err(error) =
+                            (*border_pointer).set_position(&border_window_rect, reference_hwnd)
+                        {
+                            tracing::error!("failed to update border position {error}");
+                        }
+
                         if let Some(render_target) = (*border_pointer).render_target.get() {
                             (*border_pointer).width = BORDER_WIDTH.load(Ordering::Relaxed);
                             (*border_pointer).offset = BORDER_OFFSET.load(Ordering::Relaxed);
@@ -445,13 +475,11 @@ impl Border {
                             });
 
                             // Get window kind and color
-
                             (*border_pointer).window_kind = FOCUS_STATE
                                 .lock()
                                 .get(&(window.0 as isize))
                                 .copied()
                                 .unwrap_or(WindowKind::Unfocused);
-
                             let window_kind = (*border_pointer).window_kind;
                             if let Some(brush) = (*border_pointer).brushes.get(&window_kind) {
                                 render_target.BeginDraw();
@@ -496,7 +524,7 @@ impl Border {
                             }
                         }
                     }
-                    let _ = ValidateRect(window, None);
+                    let _ = ValidateRect(Option::from(window), None);
                     LRESULT(0)
                 }
                 WM_DESTROY => {

komorebi/src/border_manager/mod.rs

@@ -5,6 +5,7 @@ use crate::core::BorderImplementation;
 use crate::core::BorderStyle;
 use crate::core::WindowKind;
 use crate::ring::Ring;
+use crate::workspace::WorkspaceLayer;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::Colour;
 use crate::Rgb;
@@ -18,17 +19,18 @@ use crossbeam_utils::atomic::AtomicCell;
 use crossbeam_utils::atomic::AtomicConsume;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::ops::Deref;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
+use strum::Display;
 use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
 
 pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
@@ -56,8 +58,19 @@ lazy_static! {
     static ref BORDER_STATE: Mutex<HashMap<String, Border>> = Mutex::new(HashMap::new());
     static ref WINDOWS_BORDERS: Mutex<HashMap<isize, Border>> = Mutex::new(HashMap::new());
     static ref FOCUS_STATE: Mutex<HashMap<isize, WindowKind>> = Mutex::new(HashMap::new());
-    static ref RENDER_TARGETS: Mutex<HashMap<isize, ID2D1HwndRenderTarget>> =
-        Mutex::new(HashMap::new());
+    static ref RENDER_TARGETS: Mutex<HashMap<isize, RenderTarget>> = Mutex::new(HashMap::new());
+}
+
+#[derive(Debug, Clone)]
+pub struct RenderTarget(pub ID2D1HwndRenderTarget);
+unsafe impl Send for RenderTarget {}
+
+impl Deref for RenderTarget {
+    type Target = ID2D1HwndRenderTarget;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
 }
 
 pub struct Notification(pub Option<isize>);
@@ -99,6 +112,7 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
 
     borders.clear();
     BORDERS_MONITORS.lock().clear();
+    WINDOWS_BORDERS.lock().clear();
     FOCUS_STATE.lock().clear();
     RENDER_TARGETS.lock().clear();
 
@@ -153,6 +167,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
     let mut previous_pending_move_op = None;
     let mut previous_is_paused = false;
     let mut previous_notification: Option<Notification> = None;
+    let mut previous_layer = WorkspaceLayer::default();
 
     'receiver: for notification in receiver {
         // Check the wm state every time we receive a notification
@@ -169,6 +184,10 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
             .iter()
             .map(|w| w.hwnd)
             .collect::<Vec<_>>();
+        let workspace_layer = *state.monitors.elements()[focused_monitor_idx].workspaces()
+            [focused_workspace_idx]
+            .layer();
+        let foreground_window = WindowsApi::foreground_window().unwrap_or_default();
 
         drop(state);
 
@@ -210,6 +229,16 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 .unwrap_or_default()
                                 .set_accent(window_kind_colour(window_kind))?;
                         }
+
+                        for window in ws.floating_windows() {
+                            let mut window_kind = WindowKind::Unfocused;
+
+                            if foreground_window == window.hwnd {
+                                window_kind = WindowKind::Floating;
+                            }
+
+                            window.set_accent(window_kind_colour(window_kind))?;
+                        }
                     }
                 }
             }
@@ -238,10 +267,20 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     should_process_notification = true;
                 }
 
-                // when we switch focus to a floating window
-                if !should_process_notification
-                    && floating_window_hwnds.contains(&notification.0.unwrap_or_default())
-                {
+                // when we switch focus to/from a floating window
+                let switch_focus_to_from_floating_window = floating_window_hwnds.iter().any(|fw| {
+                    // if we switch focus to a floating window
+                    fw == &notification.0.unwrap_or_default() ||
+                    // if there is any floating window with a `WindowKind::Floating` border
+                    // that no longer is the foreground window then we need to update that
+                    // border.
+                    (fw != &foreground_window
+                        && window_border(*fw)
+                        .map(|b| b.window_kind == WindowKind::Floating)
+                        .unwrap_or_default())
+                });
+
+                if !should_process_notification && switch_focus_to_from_floating_window {
                     should_process_notification = true;
                 }
 
@@ -261,6 +300,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 let mut borders = BORDER_STATE.lock();
                 let mut borders_monitors = BORDERS_MONITORS.lock();
                 let mut windows_borders = WINDOWS_BORDERS.lock();
+                let mut focus_state = FOCUS_STATE.lock();
 
                 // If borders are disabled
                 if !BORDER_ENABLED.load_consume()
@@ -275,7 +315,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     }
 
                     borders.clear();
+                    borders_monitors.clear();
                     windows_borders.clear();
+                    focus_state.clear();
 
                     previous_is_paused = is_paused;
                     continue 'receiver;
@@ -286,19 +328,15 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     if let Some(ws) = m.focused_workspace() {
                         // Workspaces with tiling disabled don't have borders
                         if !ws.tile() {
-                            let mut to_remove = vec![];
-                            for (id, border) in borders.iter() {
-                                if borders_monitors.get(id).copied().unwrap_or_default()
-                                    == monitor_idx
-                                {
-                                    border.destroy()?;
-                                    to_remove.push(id.clone());
-                                }
-                            }
-
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
+                            // Remove all borders on this monitor
+                            remove_borders(
+                                &mut borders,
+                                &mut windows_borders,
+                                &mut focus_state,
+                                &mut borders_monitors,
+                                monitor_idx,
+                                |_, _| true,
+                            )?;
 
                             continue 'monitors;
                         }
@@ -321,23 +359,13 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 }
                             };
 
-                            borders_monitors.insert(monocle.id().clone(), monitor_idx);
-                            windows_borders.insert(
-                                monocle.focused_window().cloned().unwrap_or_default().hwnd,
-                                border.clone(),
-                            );
-
-                            {
-                                let mut focus_state = FOCUS_STATE.lock();
-                                focus_state.insert(
-                                    border.hwnd,
-                                    if monitor_idx != focused_monitor_idx {
-                                        WindowKind::Unfocused
-                                    } else {
-                                        WindowKind::Monocle
-                                    },
-                                );
-                            }
+                            let new_focus_state = if monitor_idx != focused_monitor_idx {
+                                WindowKind::Unfocused
+                            } else {
+                                WindowKind::Monocle
+                            };
+                            border.window_kind = new_focus_state;
+                            focus_state.insert(border.hwnd, new_focus_state);
 
                             let reference_hwnd =
                                 monocle.focused_window().copied().unwrap_or_default().hwnd;
@@ -350,21 +378,22 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                             border.invalidate();
 
-                            let border_hwnd = border.hwnd;
-                            let mut to_remove = vec![];
-                            for (id, b) in borders.iter() {
-                                if borders_monitors.get(id).copied().unwrap_or_default()
-                                    == monitor_idx
-                                    && border_hwnd != b.hwnd
-                                {
-                                    b.destroy()?;
-                                    to_remove.push(id.clone());
-                                }
-                            }
+                            borders_monitors.insert(monocle.id().clone(), monitor_idx);
+                            windows_borders.insert(
+                                monocle.focused_window().cloned().unwrap_or_default().hwnd,
+                                border.clone(),
+                            );
 
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
+                            let border_hwnd = border.hwnd;
+                            // Remove all borders on this monitor except monocle
+                            remove_borders(
+                                &mut borders,
+                                &mut windows_borders,
+                                &mut focus_state,
+                                &mut borders_monitors,
+                                monitor_idx,
+                                |_, b| border_hwnd != b.hwnd,
+                            )?;
 
                             continue 'monitors;
                         }
@@ -376,24 +405,20 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             && WindowsApi::is_zoomed(foreground_hwnd);
 
                         if is_maximized {
-                            let mut to_remove = vec![];
-                            for (id, border) in borders.iter() {
-                                if borders_monitors.get(id).copied().unwrap_or_default()
-                                    == monitor_idx
-                                {
-                                    border.destroy()?;
-                                    to_remove.push(id.clone());
-                                }
-                            }
-
-                            for id in &to_remove {
-                                borders.remove(id);
-                            }
+                            // Remove all borders on this monitor
+                            remove_borders(
+                                &mut borders,
+                                &mut windows_borders,
+                                &mut focus_state,
+                                &mut borders_monitors,
+                                monitor_idx,
+                                |_, _| true,
+                            )?;
 
                             continue 'monitors;
                         }
 
-                        // Destroy any borders not associated with the focused workspace
+                        // Collect focused workspace container and floating windows ID's
                         let mut container_and_floating_window_ids = ws
                             .containers()
                             .iter()
@@ -404,30 +429,61 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             container_and_floating_window_ids.push(w.hwnd.to_string());
                         }
 
-                        let mut to_remove = vec![];
-                        for (id, border) in borders.iter() {
-                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                                && !container_and_floating_window_ids.contains(id)
-                            {
-                                border.destroy()?;
-                                to_remove.push(id.clone());
+                        // Remove any borders not associated with the focused workspace
+                        remove_borders(
+                            &mut borders,
+                            &mut windows_borders,
+                            &mut focus_state,
+                            &mut borders_monitors,
+                            monitor_idx,
+                            |id, _| !container_and_floating_window_ids.contains(id),
+                        )?;
+
+                        'containers: for (idx, c) in ws.containers().iter().enumerate() {
+                            // In case this container is a stack we need to check it's
+                            // unfocused windows to remove any attached border
+                            let is_stack = c.windows().len() > 1;
+                            if is_stack {
+                                let focused_window_idx = c.focused_window_idx();
+                                let potential_stacked_border_handles = c
+                                    .windows()
+                                    .iter()
+                                    .enumerate()
+                                    .flat_map(|(i, w)| {
+                                        if i != focused_window_idx {
+                                            windows_borders.get(&w.hwnd).map(|b| b.hwnd)
+                                        } else {
+                                            None
+                                        }
+                                    })
+                                    .collect::<Vec<_>>();
+
+                                if !potential_stacked_border_handles.is_empty() {
+                                    tracing::debug!(
+                                        "purging stacked borders: {:?}",
+                                        potential_stacked_border_handles
+                                    );
+                                    remove_borders(
+                                        &mut borders,
+                                        &mut windows_borders,
+                                        &mut focus_state,
+                                        &mut borders_monitors,
+                                        monitor_idx,
+                                        |_, b| potential_stacked_border_handles.contains(&b.hwnd),
+                                    )?;
+                                }
                             }
-                        }
 
-                        for id in &to_remove {
-                            borders.remove(id);
-                        }
+                            let focused_window_hwnd =
+                                c.focused_window().map(|w| w.hwnd).unwrap_or_default();
 
-                        for (idx, c) in ws.containers().iter().enumerate() {
                             // Get the border entry for this container from the map or create one
                             let mut new_border = false;
                             let border = match borders.entry(c.id().clone()) {
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
-                                    if let Ok(border) = Border::create(
-                                        c.id(),
-                                        c.focused_window().copied().unwrap_or_default().hwnd,
-                                    ) {
+                                    if let Ok(border) = Border::create(c.id(), focused_window_hwnd)
+                                    {
                                         new_border = true;
                                         entry.insert(border)
                                     } else {
@@ -436,17 +492,12 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 }
                             };
 
-                            borders_monitors.insert(c.id().clone(), monitor_idx);
-                            windows_borders.insert(
-                                c.focused_window().cloned().unwrap_or_default().hwnd,
-                                border.clone(),
-                            );
-
                             #[allow(unused_assignments)]
                             let mut last_focus_state = None;
 
                             let new_focus_state = if idx != ws.focused_container_idx()
                                 || monitor_idx != focused_monitor_idx
+                                || focused_window_hwnd != foreground_window
                             {
                                 WindowKind::Unfocused
                             } else if c.windows().len() > 1 {
@@ -454,34 +505,87 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             } else {
                                 WindowKind::Single
                             };
+                            border.window_kind = new_focus_state;
 
-                            // Update the focused state for all containers on this workspace
-                            {
-                                let mut focus_state = FOCUS_STATE.lock();
-                                last_focus_state = focus_state.insert(border.hwnd, new_focus_state);
+                            last_focus_state = focus_state.get(&border.hwnd).copied();
+
+                            // If this container's border was previously tracking a different
+                            // window, then we need to destroy that border and create a new one
+                            // tracking the correct window.
+                            if border.tracking_hwnd != focused_window_hwnd {
+                                // Create new border
+                                if let Ok(b) = Border::create(
+                                    c.id(),
+                                    c.focused_window().copied().unwrap_or_default().hwnd,
+                                ) {
+                                    // Destroy previously stacked border window and remove its hwnd
+                                    // and tracking_hwnd.
+                                    border.destroy()?;
+                                    focus_state.remove(&border.hwnd);
+                                    if let Some(previous) =
+                                        windows_borders.get(&border.tracking_hwnd)
+                                    {
+                                        // Only remove the border from `windows_borders` if it
+                                        // still is the same border, if it isn't then it means it
+                                        // was already updated by another border for that window
+                                        // and in that case we don't want to remove it.
+                                        if previous.hwnd == border.hwnd {
+                                            windows_borders.remove(&border.tracking_hwnd);
+                                        }
+                                    }
+
+                                    // Replace with new border
+                                    new_border = true;
+                                    *border = b;
+                                } else {
+                                    continue 'monitors;
+                                }
                             }
 
-                            let reference_hwnd =
-                                c.focused_window().copied().unwrap_or_default().hwnd;
+                            // avoid getting into a thread restart loop if we try to look up
+                            // rect info for a window that has been destroyed by the time
+                            // we get here
+                            let rect = match WindowsApi::window_rect(focused_window_hwnd) {
+                                Ok(rect) => rect,
+                                Err(_) => {
+                                    remove_border(
+                                        c.id(),
+                                        &mut borders,
+                                        &mut windows_borders,
+                                        &mut focus_state,
+                                        &mut borders_monitors,
+                                    )?;
+                                    continue 'containers;
+                                }
+                            };
 
-                            let rect = WindowsApi::window_rect(reference_hwnd)?;
+                            let layer_changed = previous_layer != workspace_layer;
 
                             let should_invalidate = match last_focus_state {
                                 None => true,
-                                Some(last_focus_state) => last_focus_state != new_focus_state,
+                                Some(last_focus_state) => {
+                                    (last_focus_state != new_focus_state) || layer_changed
+                                }
                             };
 
-                            if new_border {
-                                border.set_position(&rect, reference_hwnd)?;
+                            if new_border || should_invalidate {
+                                border.set_position(&rect, focused_window_hwnd)?;
                             }
 
                             if should_invalidate {
                                 border.invalidate();
                             }
+
+                            borders_monitors.insert(c.id().clone(), monitor_idx);
+                            windows_borders.insert(
+                                c.focused_window().cloned().unwrap_or_default().hwnd,
+                                border.clone(),
+                            );
+                            focus_state.insert(border.hwnd, new_focus_state);
                         }
 
                         {
-                            'windows: for window in ws.floating_windows() {
+                            for window in ws.floating_windows() {
                                 let mut new_border = false;
                                 let border = match borders.entry(window.hwnd.to_string()) {
                                     Entry::Occupied(entry) => entry.into_mut(),
@@ -497,44 +601,26 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     }
                                 };
 
-                                borders_monitors.insert(window.hwnd.to_string(), monitor_idx);
-                                windows_borders.insert(window.hwnd, border.clone());
-
-                                let mut should_destroy = false;
-
-                                if let Some(notification_hwnd) = notification.0 {
-                                    if notification_hwnd != window.hwnd {
-                                        should_destroy = true;
-                                    }
-                                }
-
-                                if WindowsApi::foreground_window().unwrap_or_default()
-                                    != window.hwnd
-                                {
-                                    should_destroy = true;
-                                }
-
-                                if should_destroy {
-                                    border.destroy()?;
-                                    borders.remove(&window.hwnd.to_string());
-                                    borders_monitors.remove(&window.hwnd.to_string());
-                                    continue 'windows;
-                                }
-
                                 #[allow(unused_assignments)]
                                 let mut last_focus_state = None;
-                                let new_focus_state = WindowKind::Floating;
-                                {
-                                    let mut focus_state = FOCUS_STATE.lock();
-                                    last_focus_state =
-                                        focus_state.insert(border.hwnd, new_focus_state);
+                                let mut new_focus_state = WindowKind::Unfocused;
+
+                                if foreground_window == window.hwnd {
+                                    new_focus_state = WindowKind::Floating;
                                 }
 
+                                border.window_kind = new_focus_state;
+                                last_focus_state = focus_state.get(&border.hwnd).copied();
+
                                 let rect = WindowsApi::window_rect(window.hwnd)?;
 
+                                let layer_changed = previous_layer != workspace_layer;
+
                                 let should_invalidate = match last_focus_state {
                                     None => true,
-                                    Some(last_focus_state) => last_focus_state != new_focus_state,
+                                    Some(last_focus_state) => {
+                                        last_focus_state != new_focus_state || layer_changed
+                                    }
                                 };
 
                                 if new_border {
@@ -544,6 +630,10 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 if should_invalidate {
                                     border.invalidate();
                                 }
+
+                                borders_monitors.insert(window.hwnd.to_string(), monitor_idx);
+                                windows_borders.insert(window.hwnd, border.clone());
+                                focus_state.insert(border.hwnd, new_focus_state);
                             }
                         }
                     }
@@ -555,12 +645,60 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
         previous_pending_move_op = pending_move_op;
         previous_is_paused = is_paused;
         previous_notification = Some(notification);
+        previous_layer = workspace_layer;
     }
 
     Ok(())
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+/// Removes all borders from monitor with index `monitor_idx` filtered by
+/// `condition`. This condition is a function that will take a reference to
+/// the container id and the border and returns a bool, if true that border
+/// will be removed.
+fn remove_borders(
+    borders: &mut HashMap<String, Border>,
+    windows_borders: &mut HashMap<isize, Border>,
+    focus_state: &mut HashMap<isize, WindowKind>,
+    borders_monitors: &mut HashMap<String, usize>,
+    monitor_idx: usize,
+    condition: impl Fn(&String, &Border) -> bool,
+) -> color_eyre::Result<()> {
+    let mut to_remove = vec![];
+    for (id, border) in borders.iter() {
+        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+            && condition(id, border)
+        {
+            to_remove.push(id.clone());
+        }
+    }
+
+    for id in &to_remove {
+        remove_border(id, borders, windows_borders, focus_state, borders_monitors)?;
+    }
+
+    Ok(())
+}
+
+/// Removes the border with `id` and all its related info from all maps
+fn remove_border(
+    id: &str,
+    borders: &mut HashMap<String, Border>,
+    windows_borders: &mut HashMap<isize, Border>,
+    focus_state: &mut HashMap<isize, WindowKind>,
+    borders_monitors: &mut HashMap<String, usize>,
+) -> color_eyre::Result<()> {
+    if let Some(removed_border) = borders.remove(id) {
+        removed_border.destroy()?;
+        windows_borders.remove(&removed_border.tracking_hwnd);
+        focus_state.remove(&removed_border.hwnd);
+    }
+    borders_monitors.remove(id);
+
+    Ok(())
+}
+
+#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ZOrder {
     Top,
     NoTopMost,

komorebi/src/colour.rs

@@ -1,14 +1,19 @@
 use hex_color::HexColor;
 use komorebi_themes::Color32;
+#[cfg(feature = "schemars")]
 use schemars::gen::SchemaGenerator;
+#[cfg(feature = "schemars")]
 use schemars::schema::InstanceType;
+#[cfg(feature = "schemars")]
 use schemars::schema::Schema;
+#[cfg(feature = "schemars")]
 use schemars::schema::SchemaObject;
-use schemars::JsonSchema;
+
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum Colour {
     /// Colour represented as RGB
@@ -51,10 +56,11 @@ impl From<Colour> for Color32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Hex(HexColor);
 
-impl JsonSchema for Hex {
+#[cfg(feature = "schemars")]
+impl schemars::JsonSchema for Hex {
     fn schema_name() -> String {
         String::from("Hex")
     }
@@ -78,7 +84,8 @@ impl From<Colour> for u32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Rgb {
     /// Red
     pub r: u32,
@@ -120,8 +127,8 @@ impl From<u32> for Rgb {
     fn from(value: u32) -> Self {
         Self {
             r: value & 0xff,
-            g: value >> 8 & 0xff,
-            b: value >> 16 & 0xff,
+            g: (value >> 8) & 0xff,
+            b: (value >> 16) & 0xff,
         }
     }
 }

komorebi/src/com/interfaces.rs

@@ -13,11 +13,11 @@ use windows::core::HRESULT;
 use windows::core::HSTRING;
 use windows::core::PCWSTR;
 use windows::core::PWSTR;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::SIZE;
 use windows::Win32::UI::Shell::Common::IObjectArray;
+use windows_core::BOOL;
 
 type DesktopID = GUID;
 

komorebi/src/com/mod.rs

@@ -15,7 +15,7 @@ use windows::Win32::System::Com::CoCreateInstance;
 use windows::Win32::System::Com::CoInitializeEx;
 use windows::Win32::System::Com::CoUninitialize;
 use windows::Win32::System::Com::CLSCTX_ALL;
-use windows::Win32::System::Com::COINIT_APARTMENTTHREADED;
+use windows::Win32::System::Com::COINIT_MULTITHREADED;
 use windows_core::Interface;
 
 struct ComInit();
@@ -23,10 +23,7 @@ struct ComInit();
 impl ComInit {
     pub fn new() -> Self {
         unsafe {
-            // Notice: Only COINIT_APARTMENTTHREADED works correctly!
-            //
-            // Not COINIT_MULTITHREADED or CoIncrementMTAUsage, they cause a seldom crashes in threading tests.
-            CoInitializeEx(None, COINIT_APARTMENTTHREADED).unwrap();
+            CoInitializeEx(None, COINIT_MULTITHREADED).unwrap();
         }
         Self()
     }

komorebi/src/container.rs

@@ -2,14 +2,14 @@ use std::collections::VecDeque;
 
 use getset::Getters;
 use nanoid::nanoid;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 use crate::ring::Ring;
 use crate::window::Window;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Container {
     #[getset(get = "pub")]
     id: String,
@@ -75,6 +75,18 @@ impl Container {
         None
     }
 
+    pub fn idx_from_exe(&self, exe: &str) -> Option<usize> {
+        for (idx, window) in self.windows().iter().enumerate() {
+            if let Ok(window_exe) = window.exe() {
+                if exe == window_exe {
+                    return Option::from(idx);
+                }
+            }
+        }
+
+        None
+    }
+
     pub fn contains_window(&self, hwnd: isize) -> bool {
         for window in self.windows() {
             if window.hwnd == hwnd {

komorebi/src/core/animation.rs

@@ -1,13 +1,12 @@
 use clap::ValueEnum;
-use schemars::JsonSchema;
+
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
-#[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum AnimationStyle {
     Linear,
     EaseInSine,

komorebi/src/core/arrangement.rs

@@ -1,7 +1,6 @@
 use std::num::NonZeroUsize;
 
 use clap::ValueEnum;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -603,18 +602,8 @@ impl Arrangement for CustomLayout {
     }
 }
 
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Axis {
     Horizontal,
     Vertical,

komorebi/src/core/asc.rs

@@ -2,7 +2,6 @@ use crate::config_generation::ApplicationConfiguration;
 use crate::config_generation::ApplicationOptions;
 use crate::config_generation::MatchingRule;
 use color_eyre::Result;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::BTreeMap;
@@ -10,10 +9,12 @@ use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::PathBuf;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct ApplicationSpecificConfiguration(pub BTreeMap<String, AscApplicationRulesOrSchema>);
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum AscApplicationRulesOrSchema {
     AscApplicationRules(AscApplicationRules),
@@ -46,7 +47,8 @@ impl ApplicationSpecificConfiguration {
 }
 
 /// Rules that determine how an application is handled
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct AscApplicationRules {
     /// Rules to ignore specific windows
     #[serde(skip_serializing_if = "Option::is_none")]

komorebi/src/core/config_generation.rs

@@ -1,6 +1,5 @@
 use clap::ValueEnum;
 use color_eyre::Result;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -8,9 +7,8 @@ use strum::EnumString;
 
 use super::ApplicationIdentifier;
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum ApplicationOptions {
@@ -52,14 +50,16 @@ impl ApplicationOptions {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum MatchingRule {
     Simple(IdWithIdentifier),
     Composite(Vec<IdWithIdentifier>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WorkspaceMatchingRule {
     pub monitor_index: usize,
     pub workspace_index: usize,
@@ -67,7 +67,8 @@ pub struct WorkspaceMatchingRule {
     pub initial_only: bool,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct IdWithIdentifier {
     pub kind: ApplicationIdentifier,
     pub id: String,
@@ -75,7 +76,8 @@ pub struct IdWithIdentifier {
     pub matching_strategy: Option<MatchingStrategy>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum MatchingStrategy {
     Legacy,
     Equals,
@@ -89,7 +91,8 @@ pub enum MatchingStrategy {
     DoesNotContain,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct IdWithIdentifierAndComment {
     pub kind: ApplicationIdentifier,
     pub id: String,
@@ -109,7 +112,8 @@ impl From<IdWithIdentifierAndComment> for IdWithIdentifier {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct ApplicationConfiguration {
     pub name: String,
     pub identifier: IdWithIdentifier,
@@ -133,7 +137,8 @@ impl ApplicationConfiguration {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct ApplicationConfigurationGenerator;
 
 impl ApplicationConfigurationGenerator {

komorebi/src/core/custom_layout.rs

@@ -8,13 +8,13 @@ use std::path::Path;
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
 use color_eyre::Result;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::Rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct CustomLayout(Vec<Column>);
 
 impl Deref for CustomLayout {
@@ -250,7 +250,8 @@ impl CustomLayout {
     }
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "column", content = "configuration")]
 pub enum Column {
     Primary(Option<ColumnWidth>),
@@ -258,18 +259,21 @@ pub enum Column {
     Tertiary(ColumnSplit),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ColumnWidth {
     WidthPercentage(f32),
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ColumnSplit {
     Horizontal,
     Vertical,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ColumnSplitWithCapacity {
     Horizontal(usize),
     Vertical(usize),

komorebi/src/core/cycle_direction.rs

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

komorebi/src/core/default_layout.rs

@@ -1,5 +1,4 @@
 use clap::ValueEnum;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -10,18 +9,9 @@ use super::Rect;
 use super::Sizing;
 
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    Serialize,
-    Deserialize,
-    Eq,
-    PartialEq,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
+    Clone, Copy, Debug, Serialize, Deserialize, Eq, PartialEq, Display, EnumString, ValueEnum,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum DefaultLayout {
     BSP,
     Columns,
@@ -89,7 +79,6 @@ impl DefaultLayout {
             return None;
         };
 
-        let max_divisor = 1.005;
         let mut r = resize.unwrap_or_default();
 
         let resize_delta = delta;
@@ -108,15 +97,13 @@ impl DefaultLayout {
                     // against this; if people end up in this situation they are better off
                     // just hitting the retile command
                     let diff = ((r.left + -resize_delta) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.right as f32 {
                         r.left += -resize_delta;
                     }
                 }
                 Sizing::Decrease => {
                     let diff = ((r.left - -resize_delta) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.right as f32 {
                         r.left -= -resize_delta;
                     }
                 }
@@ -124,15 +111,13 @@ impl DefaultLayout {
             OperationDirection::Up => match sizing {
                 Sizing::Increase => {
                     let diff = ((r.top + resize_delta) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.bottom as f32 {
                         r.top += -resize_delta;
                     }
                 }
                 Sizing::Decrease => {
                     let diff = ((r.top - resize_delta) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.bottom as f32 {
                         r.top -= -resize_delta;
                     }
                 }
@@ -140,15 +125,13 @@ impl DefaultLayout {
             OperationDirection::Right => match sizing {
                 Sizing::Increase => {
                     let diff = ((r.right + resize_delta) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.right as f32 {
                         r.right += resize_delta;
                     }
                 }
                 Sizing::Decrease => {
                     let diff = ((r.right - resize_delta) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.right as f32 {
                         r.right -= resize_delta;
                     }
                 }
@@ -156,15 +139,13 @@ impl DefaultLayout {
             OperationDirection::Down => match sizing {
                 Sizing::Increase => {
                     let diff = ((r.bottom + resize_delta) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.bottom as f32 {
                         r.bottom += resize_delta;
                     }
                 }
                 Sizing::Decrease => {
                     let diff = ((r.bottom - resize_delta) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
+                    if diff < unaltered.bottom as f32 {
                         r.bottom -= resize_delta;
                     }
                 }

komorebi/src/core/direction.rs

@@ -406,7 +406,7 @@ impl Direction for CustomLayout {
                 }
 
                 let (column_idx, column) = self.column_with_idx(idx);
-                column.map_or(false, |column| match column {
+                column.is_some_and(|column| match column {
                     Column::Secondary(Some(ColumnSplitWithCapacity::Horizontal(_)))
                     | Column::Tertiary(ColumnSplit::Horizontal) => {
                         self.column_for_container_idx(idx - 1) == column_idx
@@ -420,7 +420,7 @@ impl Direction for CustomLayout {
                 }
 
                 let (column_idx, column) = self.column_with_idx(idx);
-                column.map_or(false, |column| match column {
+                column.is_some_and(|column| match column {
                     Column::Secondary(Some(ColumnSplitWithCapacity::Horizontal(_)))
                     | Column::Tertiary(ColumnSplit::Horizontal) => {
                         self.column_for_container_idx(idx + 1) == column_idx

komorebi/src/core/layout.rs

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

komorebi/src/core/mod.rs

@@ -8,7 +8,6 @@ use std::str::FromStr;
 use clap::ValueEnum;
 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -19,12 +18,17 @@ use crate::KomorebiTheme;
 pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
+pub use custom_layout::Column;
+pub use custom_layout::ColumnSplit;
+pub use custom_layout::ColumnSplitWithCapacity;
+pub use custom_layout::ColumnWidth;
 pub use custom_layout::CustomLayout;
 pub use cycle_direction::CycleDirection;
 pub use default_layout::DefaultLayout;
 pub use direction::Direction;
 pub use layout::Layout;
 pub use operation_direction::OperationDirection;
+pub use pathext::PathExt;
 pub use rect::Rect;
 
 pub mod animation;
@@ -37,9 +41,11 @@ pub mod default_layout;
 pub mod direction;
 pub mod layout;
 pub mod operation_direction;
+pub mod pathext;
 pub mod rect;
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, Display)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "type", content = "content")]
 pub enum SocketMessage {
     // Window / Container Commands
@@ -77,6 +83,7 @@ pub enum SocketMessage {
     Promote,
     PromoteFocus,
     PromoteWindow(OperationDirection),
+    EagerFocus(String),
     ToggleFloat,
     ToggleMonocle,
     ToggleMaximize,
@@ -105,6 +112,7 @@ pub enum SocketMessage {
     NewWorkspace,
     ToggleTiling,
     Stop,
+    StopIgnoreRestore,
     TogglePause,
     Retile,
     RetileWithResizeDimensions,
@@ -115,6 +123,7 @@ pub enum SocketMessage {
     CycleFocusMonitor(CycleDirection),
     CycleFocusWorkspace(CycleDirection),
     FocusMonitorNumber(usize),
+    FocusMonitorAtCursor,
     FocusLastWorkspace,
     CloseWorkspace,
     FocusWorkspaceNumber(usize),
@@ -140,6 +149,7 @@ pub enum SocketMessage {
     NamedWorkspaceLayoutCustomRule(String, usize, PathBuf),
     ClearWorkspaceLayoutRules(usize, usize),
     ClearNamedWorkspaceLayoutRules(String),
+    ToggleWorkspaceLayer,
     // Configuration
     ReloadConfiguration,
     ReplaceConfiguration(PathBuf),
@@ -176,6 +186,7 @@ pub enum SocketMessage {
     StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
+    ToggleWindowBasedWorkAreaOffset,
     ResizeDelta(i32),
     InitialWorkspaceRule(ApplicationIdentifier, String, usize, usize),
     InitialNamedWorkspaceRule(ApplicationIdentifier, String, String),
@@ -184,6 +195,7 @@ pub enum SocketMessage {
     ClearWorkspaceRules(usize, usize),
     ClearNamedWorkspaceRules(String),
     ClearAllWorkspaceRules,
+    EnforceWorkspaceRules,
     #[serde(alias = "FloatRule")]
     IgnoreRule(ApplicationIdentifier, String),
     ManageRule(ApplicationIdentifier, String),
@@ -229,22 +241,23 @@ impl FromStr for SocketMessage {
     }
 }
 
-#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct SubscribeOptions {
     /// Only emit notifications when the window manager state has changed
     pub filter_state_changes: bool,
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum StackbarMode {
     Always,
     Never,
     OnStack,
 }
 
-#[derive(
-    Debug, Copy, Default, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
-)]
+#[derive(Debug, Copy, Default, Clone, Eq, PartialEq, Display, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum StackbarLabel {
     #[default]
     Process,
@@ -252,18 +265,9 @@ pub enum StackbarLabel {
 }
 
 #[derive(
-    Default,
-    Copy,
-    Clone,
-    Debug,
-    Eq,
-    PartialEq,
-    Display,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    ValueEnum,
+    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, ValueEnum,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum BorderStyle {
     #[default]
     /// Use the system border style
@@ -275,18 +279,9 @@ pub enum BorderStyle {
 }
 
 #[derive(
-    Default,
-    Copy,
-    Clone,
-    Debug,
-    Eq,
-    PartialEq,
-    Display,
-    Serialize,
-    Deserialize,
-    JsonSchema,
-    ValueEnum,
+    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, ValueEnum,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum BorderImplementation {
     #[default]
     /// Use the adjustable komorebi border implementation
@@ -296,19 +291,9 @@ pub enum BorderImplementation {
 }
 
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
-    Eq,
-    Hash,
+    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq, Eq, Hash,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum WindowKind {
     Single,
     Stack,
@@ -317,29 +302,20 @@ pub enum WindowKind {
     Floating,
 }
 
-#[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum StateQuery {
     FocusedMonitorIndex,
     FocusedWorkspaceIndex,
     FocusedContainerIndex,
     FocusedWindowIndex,
+    FocusedWorkspaceName,
 }
 
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    Eq,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
+    Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum ApplicationIdentifier {
     #[serde(alias = "exe")]
     Exe,
@@ -351,18 +327,8 @@ pub enum ApplicationIdentifier {
     Path,
 }
 
-#[derive(
-    Copy,
-    Clone,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum FocusFollowsMouseImplementation {
     /// A custom FFM implementation (slightly more CPU-intensive)
     Komorebi,
@@ -370,7 +336,8 @@ pub enum FocusFollowsMouseImplementation {
     Windows,
 }
 
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WindowManagementBehaviour {
     /// The current WindowContainerBehaviour to be used
     pub current_behaviour: WindowContainerBehaviour,
@@ -381,18 +348,9 @@ pub struct WindowManagementBehaviour {
 }
 
 #[derive(
-    Clone,
-    Copy,
-    Debug,
-    Default,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-    PartialEq,
+    Clone, Copy, Debug, Default, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum WindowContainerBehaviour {
     /// Create a new container for each new window
     #[default]
@@ -401,18 +359,8 @@ pub enum WindowContainerBehaviour {
     Append,
 }
 
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum MoveBehaviour {
     /// Swap the window container with the window container at the edge of the adjacent monitor
     Swap,
@@ -422,9 +370,8 @@ pub enum MoveBehaviour {
     NoOp,
 }
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum CrossBoundaryBehaviour {
     /// Attempt to perform actions across a workspace boundary
     Workspace,
@@ -432,9 +379,8 @@ pub enum CrossBoundaryBehaviour {
     Monitor,
 }
 
-#[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum HidingBehaviour {
     /// Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)
     Hide,
@@ -444,18 +390,8 @@ pub enum HidingBehaviour {
     Cloak,
 }
 
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    PartialEq,
-    Serialize,
-    Deserialize,
-    Display,
-    EnumString,
-    ValueEnum,
-    JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum OperationBehaviour {
     /// Process komorebic commands on temporarily unmanaged/floated windows
     Op,
@@ -463,9 +399,8 @@ pub enum OperationBehaviour {
     NoOp,
 }
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum Sizing {
     Increase,
     Decrease,

komorebi/src/core/operation_direction.rs

@@ -1,7 +1,6 @@
 use std::num::NonZeroUsize;
 
 use clap::ValueEnum;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -10,9 +9,8 @@ use strum::EnumString;
 use super::direction::Direction;
 use super::Axis;
 
-#[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
-)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum OperationDirection {
     Left,
     Right,

komorebi/src/core/pathext.rs

@@ -0,0 +1,48 @@
+use std::env;
+use std::path::Component;
+use std::path::PathBuf;
+
+pub trait PathExt {
+    fn replace_env(&self) -> PathBuf;
+}
+
+impl PathExt for PathBuf {
+    fn replace_env(&self) -> PathBuf {
+        let mut result = PathBuf::new();
+
+        for component in self.components() {
+            match component {
+                Component::Normal(segment) => {
+                    // Check if it starts with `$` or `$Env:`
+                    if let Some(stripped_segment) = segment.to_string_lossy().strip_prefix('$') {
+                        let var_name = if let Some(env_name) = stripped_segment.strip_prefix("Env:")
+                        {
+                            // Extract the variable name after `$Env:`
+                            env_name
+                        } else if stripped_segment == "HOME" {
+                            // Special case for `$HOME`
+                            "USERPROFILE"
+                        } else {
+                            // Extract the variable name after `$`
+                            stripped_segment
+                        };
+
+                        if let Ok(value) = env::var(var_name) {
+                            result.push(&value); // Replace with the value
+                        } else {
+                            result.push(segment); // Keep as-is if variable is not found
+                        }
+                    } else {
+                        result.push(segment); // Keep as-is if not an environment variable
+                    }
+                }
+                _ => {
+                    // Add other components (e.g., root, parent) as-is
+                    result.push(component.as_os_str());
+                }
+            }
+        }
+
+        result
+    }
+}

komorebi/src/core/rect.rs

@@ -1,9 +1,9 @@
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use windows::Win32::Foundation::RECT;
 
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq, JsonSchema)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Rect {
     /// The left point in a Win32 Rect
     pub left: i32,

komorebi/src/lib.rs

@@ -32,6 +32,7 @@ pub mod workspace;
 pub mod workspace_reconciliator;
 
 use lazy_static::lazy_static;
+use monitor_reconciliator::MonitorNotification;
 use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::fs::File;
@@ -65,7 +66,6 @@ use color_eyre::Result;
 use os_info::Version;
 use parking_lot::Mutex;
 use regex::Regex;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use uds_windows::UnixStream;
@@ -127,6 +127,7 @@ lazy_static! {
             matching_strategy: Option::from(MatchingStrategy::Equals),
         }),
     ]));
+    static ref OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST: Arc<Mutex<Vec<Regex>>> = Arc::new(Mutex::new(Vec::new()));
     static ref TRANSPARENCY_BLACKLIST: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(Vec::new()));
     static ref MONITOR_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, Rect>>> =
         Arc::new(Mutex::new(HashMap::new()));
@@ -180,7 +181,7 @@ lazy_static! {
     static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
-        Arc::new(Mutex::new(HidingBehaviour::Minimize));
+        Arc::new(Mutex::new(HidingBehaviour::Cloak));
     pub static ref HOME_DIR: PathBuf = {
         std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(|_| dirs::home_dir().expect("there is no home directory"), |home_path| {
             let home = PathBuf::from(&home_path);
@@ -215,10 +216,12 @@ lazy_static! {
 
     // Use app-specific titlebar removal options where possible
     // eg. Windows Terminal, IntelliJ IDEA, Firefox
-    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
+    static ref NO_TITLEBAR: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
 
     static ref WINDOWS_BY_BAR_HWNDS: Arc<Mutex<HashMap<isize, VecDeque<isize>>>> =
         Arc::new(Mutex::new(HashMap::new()));
+
+    static ref FLOATING_WINDOW_TOGGLE_ASPECT_RATIO: Arc<Mutex<AspectRatio>> = Arc::new(Mutex::new(AspectRatio::Predefined(PredefinedAspectRatio::Widescreen)));
 }
 
 pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
@@ -276,14 +279,17 @@ pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     current
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum NotificationEvent {
     WindowManager(WindowManagerEvent),
     Socket(SocketMessage),
+    Monitor(MonitorNotification),
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Notification {
     pub event: NotificationEvent,
     pub state: State,
@@ -298,6 +304,7 @@ pub fn notify_subscribers(notification: Notification, state_has_been_modified: b
             | NotificationEvent::Socket(SocketMessage::ReloadStaticConfiguration(_))
             | NotificationEvent::WindowManager(WindowManagerEvent::TitleUpdate(_, _))
             | NotificationEvent::WindowManager(WindowManagerEvent::Show(_, _))
+            | NotificationEvent::WindowManager(WindowManagerEvent::Uncloak(_, _))
     );
 
     let notification = &serde_json::to_string(&notification)?;

komorebi/src/main.rs

@@ -7,6 +7,7 @@
     clippy::doc_markdown
 )]
 
+use std::env::temp_dir;
 use std::net::Shutdown;
 use std::path::PathBuf;
 use std::sync::atomic::Ordering;
@@ -43,6 +44,7 @@ use komorebi::stackbar_manager;
 use komorebi::static_config::StaticConfig;
 use komorebi::theme_manager;
 use komorebi::transparency_manager;
+use komorebi::window_manager::State;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
@@ -156,6 +158,9 @@ struct Opts {
     /// Path to a static configuration JSON file
     #[clap(short, long)]
     config: Option<PathBuf>,
+    /// Do not attempt to auto-apply a dumped state temp file from a previously running instance of komorebi
+    #[clap(long)]
+    clean_state: bool,
 }
 
 #[tracing::instrument]
@@ -171,8 +176,8 @@ fn main() -> Result<()> {
     let session_id = WindowsApi::process_id_to_session_id()?;
     SESSION_ID.store(session_id, Ordering::SeqCst);
 
-    let mut system = sysinfo::System::new_all();
-    system.refresh_processes(ProcessesToUpdate::All);
+    let mut system = sysinfo::System::new();
+    system.refresh_processes(ProcessesToUpdate::All, true);
 
     let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe".as_ref()).collect();
 
@@ -239,16 +244,10 @@ fn main() -> Result<()> {
         StaticConfig::postload(config, &wm)?;
     }
 
-    listen_for_commands(wm.clone());
-
     if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
         INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
     };
 
-    if let Some(port) = opts.tcp_port {
-        listen_for_commands_tcp(wm.clone(), port);
-    }
-
     if static_config.is_none() {
         std::thread::spawn(|| load_configuration().expect("could not load configuration"));
 
@@ -260,23 +259,42 @@ fn main() -> Result<()> {
         }
     }
 
-    wm.lock().retile_all(false)?;
+    let dumped_state = temp_dir().join("komorebi.state.json");
 
-    listen_for_events(wm.clone());
-
-    if CUSTOM_FFM.load(Ordering::SeqCst) {
-        listen_for_movements(wm.clone());
+    if !opts.clean_state && dumped_state.is_file() {
+        if let Ok(state) = serde_json::from_str(&std::fs::read_to_string(&dumped_state)?) {
+            wm.lock().apply_state(state);
+        } else {
+            tracing::warn!(
+                "cannot apply state from {}; state struct is not up to date",
+                dumped_state.display()
+            );
+        }
     }
 
+    wm.lock().retile_all(false)?;
+
     border_manager::listen_for_notifications(wm.clone());
     stackbar_manager::listen_for_notifications(wm.clone());
     transparency_manager::listen_for_notifications(wm.clone());
     workspace_reconciliator::listen_for_notifications(wm.clone());
     monitor_reconciliator::listen_for_notifications(wm.clone())?;
-    reaper::watch_for_orphans(wm.clone());
+    reaper::listen_for_notifications(wm.clone(), wm.lock().known_hwnds.clone());
     focus_manager::listen_for_notifications(wm.clone());
     theme_manager::listen_for_notifications();
 
+    listen_for_commands(wm.clone());
+
+    if let Some(port) = opts.tcp_port {
+        listen_for_commands_tcp(wm.clone(), port);
+    }
+
+    listen_for_events(wm.clone());
+
+    if CUSTOM_FFM.load(Ordering::SeqCst) {
+        listen_for_movements(wm.clone());
+    }
+
     let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
     ctrlc::set_handler(move || {
         ctrlc_sender
@@ -290,9 +308,12 @@ fn main() -> Result<()> {
 
     tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
 
+    let state = State::from(&*wm.lock());
+    std::fs::write(dumped_state, serde_json::to_string_pretty(&state)?)?;
+
     ANIMATION_ENABLED_PER_ANIMATION.lock().clear();
     ANIMATION_ENABLED_GLOBAL.store(false, Ordering::SeqCst);
-    wm.lock().restore_all_windows()?;
+    wm.lock().restore_all_windows(false)?;
     AnimationEngine::wait_for_all_animations();
 
     if WindowsApi::focus_follows_mouse()? {

komorebi/src/monitor.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::collections::VecDeque;
+use std::sync::atomic::Ordering;
 
 use color_eyre::eyre::anyhow;
 use color_eyre::eyre::bail;
@@ -8,7 +9,6 @@ use getset::CopyGetters;
 use getset::Getters;
 use getset::MutGetters;
 use getset::Setters;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -21,48 +21,71 @@ use crate::DefaultLayout;
 use crate::Layout;
 use crate::OperationDirection;
 use crate::WindowsApi;
+use crate::DEFAULT_CONTAINER_PADDING;
+use crate::DEFAULT_WORKSPACE_PADDING;
 
 #[derive(
-    Debug,
-    Clone,
-    Serialize,
-    Deserialize,
-    Getters,
-    CopyGetters,
-    MutGetters,
-    Setters,
-    JsonSchema,
-    PartialEq,
+    Debug, Clone, Serialize, Deserialize, Getters, CopyGetters, MutGetters, Setters, PartialEq,
 )]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Monitor {
     #[getset(get_copy = "pub", set = "pub")]
-    id: isize,
+    pub id: isize,
     #[getset(get = "pub", set = "pub")]
-    name: String,
+    pub name: String,
     #[getset(get = "pub", set = "pub")]
-    device: String,
+    pub device: String,
     #[getset(get = "pub", set = "pub")]
-    device_id: String,
+    pub device_id: String,
     #[getset(get = "pub", set = "pub")]
-    size: Rect,
+    pub serial_number_id: Option<String>,
     #[getset(get = "pub", set = "pub")]
-    work_area_size: Rect,
+    pub size: Rect,
+    #[getset(get = "pub", set = "pub")]
+    pub work_area_size: Rect,
     #[getset(get_copy = "pub", set = "pub")]
-    work_area_offset: Option<Rect>,
+    pub work_area_offset: Option<Rect>,
     #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset: Option<Rect>,
+    pub window_based_work_area_offset: Option<Rect>,
     #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset_limit: isize,
-    workspaces: Ring<Workspace>,
+    pub window_based_work_area_offset_limit: isize,
+    pub workspaces: Ring<Workspace>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get_copy = "pub", set = "pub")]
-    last_focused_workspace: Option<usize>,
+    pub last_focused_workspace: Option<usize>,
     #[getset(get_mut = "pub")]
-    workspace_names: HashMap<usize, String>,
+    pub workspace_names: HashMap<usize, String>,
+    #[getset(get_copy = "pub", set = "pub")]
+    pub container_padding: Option<i32>,
+    #[getset(get_copy = "pub", set = "pub")]
+    pub workspace_padding: Option<i32>,
 }
 
 impl_ring_elements!(Monitor, Workspace);
 
+#[derive(Serialize)]
+pub struct MonitorInformation {
+    pub id: isize,
+    pub name: String,
+    pub device: String,
+    pub device_id: String,
+    pub serial_number_id: Option<String>,
+    pub size: Rect,
+}
+
+impl From<&Monitor> for MonitorInformation {
+    fn from(monitor: &Monitor) -> Self {
+        Self {
+            id: monitor.id,
+            name: monitor.name.clone(),
+            device: monitor.device.clone(),
+            device_id: monitor.device_id.clone(),
+            serial_number_id: monitor.serial_number_id.clone(),
+            size: monitor.size,
+        }
+    }
+}
+
 pub fn new(
     id: isize,
     size: Rect,
@@ -70,6 +93,7 @@ pub fn new(
     name: String,
     device: String,
     device_id: String,
+    serial_number_id: Option<String>,
 ) -> Monitor {
     let mut workspaces = Ring::default();
     workspaces.elements_mut().push_back(Workspace::default());
@@ -79,6 +103,7 @@ pub fn new(
         name,
         device,
         device_id,
+        serial_number_id,
         size,
         work_area_size,
         work_area_offset: None,
@@ -87,16 +112,39 @@ pub fn new(
         workspaces,
         last_focused_workspace: None,
         workspace_names: HashMap::default(),
+        container_padding: None,
+        workspace_padding: None,
     }
 }
 
 impl Monitor {
+    pub fn new(
+        id: isize,
+        size: Rect,
+        work_area_size: Rect,
+        name: String,
+        device: String,
+        device_id: String,
+        serial_number_id: Option<String>,
+    ) -> Self {
+        new(
+            id,
+            size,
+            work_area_size,
+            name,
+            device,
+            device_id,
+            serial_number_id,
+        )
+    }
+
     pub fn placeholder() -> Self {
         Self {
             id: 0,
             name: "PLACEHOLDER".to_string(),
             device: "".to_string(),
             device_id: "".to_string(),
+            serial_number_id: None,
             size: Default::default(),
             work_area_size: Default::default(),
             work_area_offset: None,
@@ -105,8 +153,17 @@ impl Monitor {
             workspaces: Default::default(),
             last_focused_workspace: None,
             workspace_names: Default::default(),
+            container_padding: None,
+            workspace_padding: None,
         }
     }
+
+    pub fn focused_workspace_name(&self) -> Option<String> {
+        self.focused_workspace()
+            .map(|w| w.name().clone())
+            .unwrap_or(None)
+    }
+
     pub fn load_focused_workspace(&mut self, mouse_follows_focus: bool) -> Result<()> {
         let focused_idx = self.focused_workspace_idx();
         for (i, workspace) in self.workspaces_mut().iter_mut().enumerate() {
@@ -120,6 +177,52 @@ impl Monitor {
         Ok(())
     }
 
+    /// Updates the `globals` field of all workspaces
+    pub fn update_workspaces_globals(&mut self, offset: Option<Rect>) {
+        let container_padding = self
+            .container_padding()
+            .or(Some(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)));
+        let workspace_padding = self
+            .workspace_padding()
+            .or(Some(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)));
+        let work_area = *self.work_area_size();
+        let offset = self.work_area_offset.or(offset);
+        let window_based_work_area_offset = self.window_based_work_area_offset();
+        let limit = self.window_based_work_area_offset_limit();
+
+        for workspace in self.workspaces_mut() {
+            workspace.globals_mut().container_padding = container_padding;
+            workspace.globals_mut().workspace_padding = workspace_padding;
+            workspace.globals_mut().work_area = work_area;
+            workspace.globals_mut().work_area_offset = offset;
+            workspace.globals_mut().window_based_work_area_offset = window_based_work_area_offset;
+            workspace.globals_mut().window_based_work_area_offset_limit = limit;
+        }
+    }
+
+    /// Updates the `globals` field of workspace with index `workspace_idx`
+    pub fn update_workspace_globals(&mut self, workspace_idx: usize, offset: Option<Rect>) {
+        let container_padding = self
+            .container_padding()
+            .or(Some(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)));
+        let workspace_padding = self
+            .workspace_padding()
+            .or(Some(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)));
+        let work_area = *self.work_area_size();
+        let offset = self.work_area_offset.or(offset);
+        let window_based_work_area_offset = self.window_based_work_area_offset();
+        let limit = self.window_based_work_area_offset_limit();
+
+        if let Some(workspace) = self.workspaces_mut().get_mut(workspace_idx) {
+            workspace.globals_mut().container_padding = container_padding;
+            workspace.globals_mut().workspace_padding = workspace_padding;
+            workspace.globals_mut().work_area = work_area;
+            workspace.globals_mut().work_area_offset = offset;
+            workspace.globals_mut().window_based_work_area_offset = window_based_work_area_offset;
+            workspace.globals_mut().window_based_work_area_offset_limit = limit;
+        }
+    }
+
     pub fn add_container(
         &mut self,
         container: Container,
@@ -346,21 +449,17 @@ impl Monitor {
     }
 
     pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> Result<()> {
-        let work_area = *self.work_area_size();
-        let window_based_work_area_offset = (
-            self.window_based_work_area_offset_limit(),
-            self.window_based_work_area_offset(),
-        );
-
         let offset = if self.work_area_offset().is_some() {
             self.work_area_offset()
         } else {
             offset
         };
 
+        let focused_workspace_idx = self.focused_workspace_idx();
+        self.update_workspace_globals(focused_workspace_idx, offset);
         self.focused_workspace_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?
-            .update(&work_area, offset, window_based_work_area_offset)?;
+            .update()?;
 
         Ok(())
     }

komorebi/src/monitor_reconciliator/hidden.rs

@@ -2,21 +2,33 @@ use std::sync::mpsc;
 use std::time::Duration;
 
 use windows::core::PCWSTR;
+use windows::Win32::Devices::Display::GUID_DEVINTERFACE_DISPLAY_ADAPTER;
+use windows::Win32::Devices::Display::GUID_DEVINTERFACE_MONITOR;
+use windows::Win32::Devices::Display::GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::LRESULT;
 use windows::Win32::Foundation::WPARAM;
+use windows::Win32::System::Power::POWERBROADCAST_SETTING;
+use windows::Win32::System::SystemServices::GUID_LIDSWITCH_STATE_CHANGE;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
 use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::DBT_CONFIGCHANGED;
+use windows::Win32::UI::WindowsAndMessaging::DBT_DEVICEARRIVAL;
+use windows::Win32::UI::WindowsAndMessaging::DBT_DEVICEREMOVECOMPLETE;
 use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
+use windows::Win32::UI::WindowsAndMessaging::DBT_DEVTYP_DEVICEINTERFACE;
+use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMEAUTOMATIC;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMESUSPEND;
 use windows::Win32::UI::WindowsAndMessaging::PBT_APMSUSPEND;
+use windows::Win32::UI::WindowsAndMessaging::PBT_POWERSETTINGCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
 use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
@@ -75,7 +87,7 @@ impl Hidden {
 
             loop {
                 unsafe {
-                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
                         tracing::debug!("hidden window event processing thread shutdown");
                         break;
                     };
@@ -92,8 +104,57 @@ impl Hidden {
 
         let hwnd = hwnd_receiver.recv()?;
 
+        // Register Session Lock/Unlock events
         WindowsApi::wts_register_session_notification(hwnd)?;
 
+        // Register Laptop lid open/close events
+        WindowsApi::register_power_setting_notification(
+            hwnd,
+            &GUID_LIDSWITCH_STATE_CHANGE,
+            REGISTER_NOTIFICATION_FLAGS(0),
+        )?;
+
+        // Register device interface events for multiple display related devices. Some of this
+        // device interfaces might not be needed but it doesn't hurt to have them in case some user
+        // uses some output device as monitor that falls into one of these device interface class
+        // GUID.
+        let monitor_filter = DEV_BROADCAST_DEVICEINTERFACE_W {
+            dbcc_size: std::mem::size_of::<DEV_BROADCAST_DEVICEINTERFACE_W>() as u32,
+            dbcc_devicetype: DBT_DEVTYP_DEVICEINTERFACE.0,
+            dbcc_reserved: 0,
+            dbcc_classguid: GUID_DEVINTERFACE_MONITOR,
+            dbcc_name: [0; 1],
+        };
+        let display_adapter_filter = DEV_BROADCAST_DEVICEINTERFACE_W {
+            dbcc_size: std::mem::size_of::<DEV_BROADCAST_DEVICEINTERFACE_W>() as u32,
+            dbcc_devicetype: DBT_DEVTYP_DEVICEINTERFACE.0,
+            dbcc_reserved: 0,
+            dbcc_classguid: GUID_DEVINTERFACE_DISPLAY_ADAPTER,
+            dbcc_name: [0; 1],
+        };
+        let video_output_filter = DEV_BROADCAST_DEVICEINTERFACE_W {
+            dbcc_size: std::mem::size_of::<DEV_BROADCAST_DEVICEINTERFACE_W>() as u32,
+            dbcc_devicetype: DBT_DEVTYP_DEVICEINTERFACE.0,
+            dbcc_reserved: 0,
+            dbcc_classguid: GUID_DEVINTERFACE_VIDEO_OUTPUT_ARRIVAL,
+            dbcc_name: [0; 1],
+        };
+        WindowsApi::register_device_notification(
+            hwnd,
+            monitor_filter,
+            REGISTER_NOTIFICATION_FLAGS(0),
+        )?;
+        WindowsApi::register_device_notification(
+            hwnd,
+            display_adapter_filter,
+            REGISTER_NOTIFICATION_FLAGS(0),
+        )?;
+        WindowsApi::register_device_notification(
+            hwnd,
+            video_output_filter,
+            REGISTER_NOTIFICATION_FLAGS(0),
+        )?;
+
         Ok(Self { hwnd })
     }
 
@@ -114,7 +175,7 @@ impl Hidden {
                                 "WM_POWERBROADCAST event received - resume from suspend"
                             );
                             monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::ResumingFromSuspendedState,
+                                monitor_reconciliator::MonitorNotification::ResumingFromSuspendedState,
                             );
                             LRESULT(0)
                         }
@@ -124,10 +185,39 @@ impl Hidden {
                                 "WM_POWERBROADCAST event received - entering suspended state"
                             );
                             monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::EnteringSuspendedState,
+                                monitor_reconciliator::MonitorNotification::EnteringSuspendedState,
                             );
                             LRESULT(0)
                         }
+                        // Monitor change power status
+                        PBT_POWERSETTINGCHANGE => {
+                            if let POWERBROADCAST_SETTING {
+                                PowerSetting: GUID_LIDSWITCH_STATE_CHANGE,
+                                DataLength: _,
+                                Data: [0],
+                            } = *(lparam.0 as *const POWERBROADCAST_SETTING)
+                            {
+                                tracing::debug!(
+                                    "WM_POWERBROADCAST event received - laptop lid closed"
+                                );
+                                monitor_reconciliator::send_notification(
+                                    monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
+                                );
+                            } else if let POWERBROADCAST_SETTING {
+                                PowerSetting: GUID_LIDSWITCH_STATE_CHANGE,
+                                DataLength: _,
+                                Data: [1],
+                            } = *(lparam.0 as *const POWERBROADCAST_SETTING)
+                            {
+                                tracing::debug!(
+                                    "WM_POWERBROADCAST event received - laptop lid opened"
+                                );
+                                monitor_reconciliator::send_notification(
+                                    monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
+                                );
+                            }
+                            LRESULT(0)
+                        }
                         _ => LRESULT(0),
                     }
                 }
@@ -137,14 +227,14 @@ impl Hidden {
                             tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_LOCK - screen locked");
 
                             monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::SessionLocked,
+                                monitor_reconciliator::MonitorNotification::SessionLocked,
                             );
                         }
                         WTS_SESSION_UNLOCK => {
                             tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_UNLOCK - screen unlocked");
 
                             monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::SessionUnlocked,
+                                monitor_reconciliator::MonitorNotification::SessionUnlocked,
                             );
                         }
                         _ => {}
@@ -165,7 +255,7 @@ impl Hidden {
                     );
 
                     monitor_reconciliator::send_notification(
-                        monitor_reconciliator::Notification::ResolutionScalingChanged,
+                        monitor_reconciliator::MonitorNotification::ResolutionScalingChanged,
                     );
                     LRESULT(0)
                 }
@@ -179,7 +269,7 @@ impl Hidden {
                             );
 
                         monitor_reconciliator::send_notification(
-                            monitor_reconciliator::Notification::WorkAreaChanged,
+                            monitor_reconciliator::MonitorNotification::WorkAreaChanged,
                         );
                     }
                     LRESULT(0)
@@ -188,12 +278,17 @@ impl Hidden {
                 // Original idea from https://stackoverflow.com/a/33762334
                 WM_DEVICECHANGE => {
                     #[allow(clippy::cast_possible_truncation)]
-                    if wparam.0 as u32 == DBT_DEVNODES_CHANGED {
+                    let event = wparam.0 as u32;
+                    if event == DBT_DEVNODES_CHANGED
+                        || event == DBT_CONFIGCHANGED
+                        || event == DBT_DEVICEARRIVAL
+                        || event == DBT_DEVICEREMOVECOMPLETE
+                    {
                         tracing::debug!(
-                                "WM_DEVICECHANGE event received with DBT_DEVNODES_CHANGED - display added or removed"
-                            );
+                            "WM_DEVICECHANGE event received with one of [DBT_DEVNODES_CHANGED, DBT_CONFIGCHANGED, DBT_DEVICEARRIVAL, DBT_DEVICEREMOVECOMPLETE] - display added or removed"
+                        );
                         monitor_reconciliator::send_notification(
-                            monitor_reconciliator::Notification::DisplayConnectionChange,
+                            monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
                         );
                     }
 

komorebi/src/monitor_reconciliator/mod.rs

@@ -1,17 +1,24 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
 use crate::border_manager;
+use crate::config_generation::WorkspaceMatchingRule;
 use crate::core::Rect;
 use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator::hidden::Hidden;
-use crate::MonitorConfig;
+use crate::notify_subscribers;
+use crate::Notification;
+use crate::NotificationEvent;
+use crate::State;
 use crate::WindowManager;
 use crate::WindowsApi;
+use crate::WORKSPACE_MATCHING_RULES;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
+use serde::Deserialize;
+use serde::Serialize;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
@@ -20,7 +27,10 @@ use std::sync::OnceLock;
 
 pub mod hidden;
 
-pub enum Notification {
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(tag = "type", content = "content")]
+pub enum MonitorNotification {
     ResolutionScalingChanged,
     WorkAreaChanged,
     DisplayConnectionChange,
@@ -32,34 +42,35 @@ pub enum Notification {
 
 static ACTIVE: AtomicBool = AtomicBool::new(true);
 
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
+static CHANNEL: OnceLock<(Sender<MonitorNotification>, Receiver<MonitorNotification>)> =
+    OnceLock::new();
 
-static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, MonitorConfig>>> = OnceLock::new();
+static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, Monitor>>> = OnceLock::new();
 
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
+pub fn channel() -> &'static (Sender<MonitorNotification>, Receiver<MonitorNotification>) {
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
 }
 
-fn event_tx() -> Sender<Notification> {
+fn event_tx() -> Sender<MonitorNotification> {
     channel().0.clone()
 }
 
-fn event_rx() -> Receiver<Notification> {
+fn event_rx() -> Receiver<MonitorNotification> {
     channel().1.clone()
 }
 
-pub fn send_notification(notification: Notification) {
+pub fn send_notification(notification: MonitorNotification) {
     if event_tx().try_send(notification).is_err() {
         tracing::warn!("channel is full; dropping notification")
     }
 }
 
-pub fn insert_in_monitor_cache(device_id: &str, config: MonitorConfig) {
+pub fn insert_in_monitor_cache(serial_or_device_id: &str, monitor: Monitor) {
     let mut monitor_cache = MONITOR_CACHE
         .get_or_init(|| Mutex::new(HashMap::new()))
         .lock();
 
-    monitor_cache.insert(device_id.to_string(), config);
+    monitor_cache.insert(serial_or_device_id.to_string(), monitor);
 }
 
 pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
@@ -89,10 +100,12 @@ pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
                 name,
                 device,
                 device_id,
+                display.serial_number_id,
             )
         })
         .collect::<Vec<_>>())
 }
+
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
     #[allow(clippy::expect_used)]
     Hidden::create("komorebi-hidden")?;
@@ -116,41 +129,40 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Re
 
     Ok(())
 }
+
 pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
     tracing::info!("listening");
 
     let receiver = event_rx();
 
     'receiver: for notification in receiver {
-        if !ACTIVE.load_consume() {
-            if matches!(
+        if !ACTIVE.load_consume()
+            && matches!(
                 notification,
-                Notification::ResumingFromSuspendedState | Notification::SessionUnlocked
-            ) {
-                tracing::debug!(
-                    "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
-                );
+                MonitorNotification::ResumingFromSuspendedState
+                    | MonitorNotification::SessionUnlocked
+            )
+        {
+            tracing::debug!(
+                "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
+            );
 
-                ACTIVE.store(true, Ordering::SeqCst);
-                border_manager::send_notification(None);
-            }
-
-            continue 'receiver;
+            ACTIVE.store(true, Ordering::SeqCst);
+            border_manager::send_notification(None);
         }
 
         let mut wm = wm.lock();
 
+        let initial_state = State::from(wm.as_ref());
+
         match notification {
-            Notification::EnteringSuspendedState | Notification::SessionLocked => {
+            MonitorNotification::EnteringSuspendedState | MonitorNotification::SessionLocked => {
                 tracing::debug!(
                     "deactivating reconciliator until system resumes from suspended state or session is unlocked"
                 );
                 ACTIVE.store(false, Ordering::SeqCst);
             }
-            Notification::ResumingFromSuspendedState | Notification::SessionUnlocked => {
-                // this is only handled above if the reconciliator is paused
-            }
-            Notification::WorkAreaChanged => {
+            MonitorNotification::WorkAreaChanged => {
                 tracing::debug!("handling work area changed notification");
                 let offset = wm.work_area_offset;
                 for monitor in wm.monitors_mut() {
@@ -182,7 +194,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     }
                 }
             }
-            Notification::ResolutionScalingChanged => {
+            MonitorNotification::ResolutionScalingChanged => {
                 tracing::debug!("handling resolution/scaling changed notification");
                 let offset = wm.work_area_offset;
                 for monitor in wm.monitors_mut() {
@@ -229,7 +241,12 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     }
                 }
             }
-            Notification::DisplayConnectionChange => {
+            // this is handled above if the reconciliator is paused but we should still check if
+            // there were any changes to the connected monitors while the system was
+            // suspended/locked.
+            MonitorNotification::ResumingFromSuspendedState
+            | MonitorNotification::SessionUnlocked
+            | MonitorNotification::DisplayConnectionChange => {
                 tracing::debug!("handling display connection change notification");
                 let mut monitor_cache = MONITOR_CACHE
                     .get_or_init(|| Mutex::new(HashMap::new()))
@@ -243,8 +260,13 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 // Make sure that in our state any attached displays have the latest Win32 data
                 for monitor in wm.monitors_mut() {
                     for attached in &attached_devices {
-                        if attached.device_id().eq(monitor.device_id()) {
+                        if attached.serial_number_id().eq(monitor.serial_number_id())
+                            || attached.device_id().eq(monitor.device_id())
+                        {
                             monitor.set_id(attached.id());
+                            monitor.set_device(attached.device().clone());
+                            monitor.set_device_id(attached.device_id().clone());
+                            monitor.set_serial_number_id(attached.serial_number_id().clone());
                             monitor.set_name(attached.name().clone());
                             monitor.set_size(*attached.size());
                             monitor.set_work_area_size(*attached.work_area_size());
@@ -254,6 +276,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 if initial_monitor_count == attached_devices.len() {
                     tracing::debug!("monitor counts match, reconciliation not required");
+                    drop(wm);
                     continue 'receiver;
                 }
 
@@ -261,6 +284,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     tracing::debug!(
                         "no devices found, skipping reconciliation to avoid breaking state"
                     );
+                    drop(wm);
                     continue 'receiver;
                 }
 
@@ -270,41 +294,108 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         attached_devices.len()
                     );
 
-                    // Gather all the containers that will be orphaned from disconnected and invalid displays
-                    let mut orphaned_containers = vec![];
+                    // Windows to remove from `known_hwnds`
+                    let mut windows_to_remove = Vec::new();
 
                     // Collect the ids in our state which aren't in the current attached display ids
                     // These are monitors that have been removed
                     let mut newly_removed_displays = vec![];
 
-                    for m in wm.monitors().iter() {
-                        if !attached_devices
-                            .iter()
-                            .any(|attached| attached.device_id().eq(m.device_id()))
-                        {
-                            newly_removed_displays.push(m.device_id().clone());
-                            for workspace in m.workspaces() {
-                                for container in workspace.containers() {
-                                    // Save the orphaned containers from the removed monitor
-                                    orphaned_containers.push(container.clone());
+                    for (m_idx, m) in wm.monitors().iter().enumerate() {
+                        if !attached_devices.iter().any(|attached| {
+                            attached.serial_number_id().eq(m.serial_number_id())
+                                || attached.device_id().eq(m.device_id())
+                        }) {
+                            let id = m
+                                .serial_number_id()
+                                .as_ref()
+                                .map_or(m.device_id().clone(), |sn| sn.clone());
+
+                            newly_removed_displays.push(id.clone());
+
+                            let focused_workspace_idx = m.focused_workspace_idx();
+
+                            for (idx, workspace) in m.workspaces().iter().enumerate() {
+                                let is_focused_workspace = idx == focused_workspace_idx;
+                                let focused_container_idx = workspace.focused_container_idx();
+                                for (c_idx, container) in workspace.containers().iter().enumerate()
+                                {
+                                    let focused_window_idx = container.focused_window_idx();
+                                    for (w_idx, window) in container.windows().iter().enumerate() {
+                                        windows_to_remove.push(window.hwnd);
+                                        if is_focused_workspace
+                                            && c_idx == focused_container_idx
+                                            && w_idx == focused_window_idx
+                                        {
+                                            // Minimize the focused window since Windows might try
+                                            // to move it to another monitor if it was focused.
+                                            if window.is_focused() {
+                                                window.minimize();
+                                            }
+                                        }
+                                    }
+                                }
+
+                                if let Some(maximized) = workspace.maximized_window() {
+                                    windows_to_remove.push(maximized.hwnd);
+                                    // Minimize the focused window since Windows might try
+                                    // to move it to another monitor if it was focused.
+                                    if maximized.is_focused() {
+                                        maximized.minimize();
+                                    }
+                                }
+
+                                if let Some(container) = workspace.monocle_container() {
+                                    for window in container.windows() {
+                                        windows_to_remove.push(window.hwnd);
+                                    }
+                                    if let Some(window) = container.focused_window() {
+                                        // Minimize the focused window since Windows might try
+                                        // to move it to another monitor if it was focused.
+                                        if window.is_focused() {
+                                            window.minimize();
+                                        }
+                                    }
+                                }
+
+                                for window in workspace.floating_windows() {
+                                    windows_to_remove.push(window.hwnd);
+                                    // Minimize the focused window since Windows might try
+                                    // to move it to another monitor if it was focused.
+                                    if window.is_focused() {
+                                        window.minimize();
+                                    }
                                 }
                             }
 
+                            // Remove any workspace_rules for this specific monitor
+                            let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
+                            let mut rules_to_remove = Vec::new();
+                            for (i, rule) in workspace_rules.iter().enumerate().rev() {
+                                if rule.monitor_index == m_idx {
+                                    rules_to_remove.push(i);
+                                }
+                            }
+                            for i in rules_to_remove {
+                                workspace_rules.remove(i);
+                            }
+
                             // Let's add their state to the cache for later
-                            monitor_cache.insert(m.device_id().clone(), m.into());
+                            monitor_cache.insert(id, m.clone());
                         }
                     }
 
-                    if !orphaned_containers.is_empty() {
-                        tracing::info!(
-                            "removed orphaned containers from: {newly_removed_displays:?}"
-                        );
-                    }
+                    // Update known_hwnds
+                    wm.known_hwnds.retain(|i, _| !windows_to_remove.contains(i));
 
                     if !newly_removed_displays.is_empty() {
                         // After we have cached them, remove them from our state
-                        wm.monitors_mut()
-                            .retain(|m| !newly_removed_displays.contains(m.device_id()));
+                        wm.monitors_mut().retain(|m| {
+                            !newly_removed_displays.iter().any(|id| {
+                                m.serial_number_id().as_ref().is_some_and(|sn| sn == id)
+                                    || m.device_id() == id
+                            })
+                        });
                     }
 
                     let post_removal_monitor_count = wm.monitors().len();
@@ -313,24 +404,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         wm.focus_monitor(0)?;
                     }
 
-                    if !orphaned_containers.is_empty() {
-                        if let Some(primary) = wm.monitors_mut().front_mut() {
-                            if let Some(focused_ws) = primary.focused_workspace_mut() {
-                                let focused_container_idx = focused_ws.focused_container_idx();
-
-                                // Put the orphaned containers somewhere visible
-                                for container in orphaned_containers {
-                                    focused_ws.add_container_to_back(container);
-                                }
-
-                                // Gotta reset the focus or the movement will feel "off"
-                                if initial_monitor_count != post_removal_monitor_count {
-                                    focused_ws.focus_container(focused_container_idx);
-                                }
-                            }
-                        }
-                    }
-
                     let offset = wm.work_area_offset;
 
                     for monitor in wm.monitors_mut() {
@@ -343,7 +416,11 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 let post_removal_monitor_count = wm.monitors().len();
 
-                // This is the list of device ids after we have removed detached displays
+                // This is the list of device ids after we have removed detached displays. We can
+                // keep this with just the device_ids without the serial numbers since this is used
+                // only to check which one is the newly added monitor below if there is a new
+                // monitor. Everything done after with said new monitor will again consider both
+                // serial number and device ids.
                 let post_removal_device_ids = wm
                     .monitors()
                     .iter()
@@ -353,7 +430,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                 // Check for and add any new monitors that may have been plugged in
                 // Monitor and display index preferences get applied in this function
-                WindowsApi::load_monitor_information(&mut wm.monitors)?;
+                WindowsApi::load_monitor_information(&mut wm)?;
 
                 let post_addition_monitor_count = wm.monitors().len();
 
@@ -362,42 +439,203 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         "monitor count mismatch ({post_removal_monitor_count} vs {post_addition_monitor_count}), adding connected monitors",
                     );
 
+                    let known_hwnds = wm.known_hwnds.clone();
+                    let offset = wm.work_area_offset;
+                    let mouse_follows_focus = wm.mouse_follows_focus;
+                    let focused_monitor_idx = wm.focused_monitor_idx();
+                    let focused_workspace_idx = wm.focused_workspace_idx()?;
+
                     // Look in the updated state for new monitors
-                    for m in wm.monitors_mut() {
-                        let device_id = m.device_id().clone();
+                    for (i, m) in wm.monitors_mut().iter_mut().enumerate() {
+                        let device_id = m.device_id();
                         // We identify a new monitor when we encounter a new device id
-                        if !post_removal_device_ids.contains(&device_id) {
+                        if !post_removal_device_ids.contains(device_id) {
                             let mut cache_hit = false;
+                            let mut cached_id = String::new();
                             // Check if that device id exists in the cache for this session
-                            if let Some(cached) = monitor_cache.get(&device_id) {
+                            if let Some((id, cached)) = monitor_cache.get_key_value(device_id).or(m
+                                .serial_number_id()
+                                .as_ref()
+                                .and_then(|sn| monitor_cache.get_key_value(sn)))
+                            {
                                 cache_hit = true;
+                                cached_id = id.clone();
 
-                                tracing::info!("found monitor and workspace configuration for {device_id} in the monitor cache, applying");
+                                tracing::info!("found monitor and workspace configuration for {id} in the monitor cache, applying");
 
-                                // If it does, load all the monitor settings from the cache entry
-                                m.ensure_workspace_count(cached.workspaces.len());
-                                m.set_work_area_offset(cached.work_area_offset);
-                                m.set_window_based_work_area_offset(
-                                    cached.window_based_work_area_offset,
-                                );
-                                m.set_window_based_work_area_offset_limit(
-                                    cached.window_based_work_area_offset_limit.unwrap_or(1),
-                                );
+                                // If it does, update the cached monitor info with the new one and
+                                // load the cached monitor removing any window that has since been
+                                // closed or moved to another workspace
+                                *m = Monitor {
+                                    // Data that should be the one just read from `win32-display-data`
+                                    id: m.id,
+                                    name: m.name.clone(),
+                                    device: m.device.clone(),
+                                    device_id: m.device_id.clone(),
+                                    serial_number_id: m.serial_number_id.clone(),
+                                    size: m.size,
+                                    work_area_size: m.work_area_size,
 
-                                for (w_idx, workspace) in m.workspaces_mut().iter_mut().enumerate()
-                                {
-                                    if let Some(cached_workspace) = cached.workspaces.get(w_idx) {
-                                        workspace.load_static_config(cached_workspace)?;
+                                    // The rest should come from the cached monitor
+                                    work_area_offset: cached.work_area_offset,
+                                    window_based_work_area_offset: cached
+                                        .window_based_work_area_offset,
+                                    window_based_work_area_offset_limit: cached
+                                        .window_based_work_area_offset_limit,
+                                    workspaces: cached.workspaces.clone(),
+                                    last_focused_workspace: cached.last_focused_workspace,
+                                    workspace_names: cached.workspace_names.clone(),
+                                    container_padding: cached.container_padding,
+                                    workspace_padding: cached.workspace_padding,
+                                };
+
+                                let focused_workspace_idx = m.focused_workspace_idx();
+
+                                for (j, workspace) in m.workspaces_mut().iter_mut().enumerate() {
+                                    // If this is the focused workspace we need to show (restore) all
+                                    // windows that were visible since they were probably minimized by
+                                    // Windows.
+                                    let is_focused_workspace = j == focused_workspace_idx;
+                                    let focused_container_idx = workspace.focused_container_idx();
+
+                                    let mut empty_containers = Vec::new();
+                                    for (idx, container) in
+                                        workspace.containers_mut().iter_mut().enumerate()
+                                    {
+                                        container.windows_mut().retain(|window| {
+                                            window.exe().is_ok()
+                                                && !known_hwnds.contains_key(&window.hwnd)
+                                        });
+
+                                        if container.windows().is_empty() {
+                                            empty_containers.push(idx);
+                                        }
+
+                                        if is_focused_workspace {
+                                            if let Some(window) = container.focused_window() {
+                                                tracing::debug!(
+                                                    "restoring window: {}",
+                                                    window.hwnd
+                                                );
+                                                WindowsApi::restore_window(window.hwnd);
+                                            } else {
+                                                // If the focused window was moved or removed by
+                                                // the user after the disconnect then focus the
+                                                // first window and show that one
+                                                container.focus_window(0);
+
+                                                if let Some(window) = container.focused_window() {
+                                                    WindowsApi::restore_window(window.hwnd);
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    // Remove empty containers
+                                    for empty_idx in empty_containers {
+                                        if empty_idx == focused_container_idx {
+                                            workspace.remove_container(empty_idx);
+                                        } else {
+                                            workspace.remove_container_by_idx(empty_idx);
+                                        }
+                                    }
+
+                                    if let Some(window) = workspace.maximized_window() {
+                                        if window.exe().is_err()
+                                            || known_hwnds.contains_key(&window.hwnd)
+                                        {
+                                            workspace.set_maximized_window(None);
+                                        } else if is_focused_workspace {
+                                            WindowsApi::restore_window(window.hwnd);
+                                        }
+                                    }
+
+                                    if let Some(container) = workspace.monocle_container_mut() {
+                                        container.windows_mut().retain(|window| {
+                                            window.exe().is_ok()
+                                                && !known_hwnds.contains_key(&window.hwnd)
+                                        });
+
+                                        if container.windows().is_empty() {
+                                            workspace.set_monocle_container(None);
+                                        } else if is_focused_workspace {
+                                            if let Some(window) = container.focused_window() {
+                                                WindowsApi::restore_window(window.hwnd);
+                                            } else {
+                                                // If the focused window was moved or removed by
+                                                // the user after the disconnect then focus the
+                                                // first window and show that one
+                                                container.focus_window(0);
+
+                                                if let Some(window) = container.focused_window() {
+                                                    WindowsApi::restore_window(window.hwnd);
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    workspace.floating_windows_mut().retain(|window| {
+                                        window.exe().is_ok()
+                                            && !known_hwnds.contains_key(&window.hwnd)
+                                    });
+
+                                    if is_focused_workspace {
+                                        for window in workspace.floating_windows() {
+                                            WindowsApi::restore_window(window.hwnd);
+                                        }
+                                    }
+
+                                    // Apply workspace rules
+                                    let mut workspace_matching_rules =
+                                        WORKSPACE_MATCHING_RULES.lock();
+                                    if let Some(rules) = workspace
+                                        .workspace_config()
+                                        .as_ref()
+                                        .and_then(|c| c.workspace_rules.as_ref())
+                                    {
+                                        for r in rules {
+                                            workspace_matching_rules.push(WorkspaceMatchingRule {
+                                                monitor_index: i,
+                                                workspace_index: j,
+                                                matching_rule: r.clone(),
+                                                initial_only: false,
+                                            });
+                                        }
+                                    }
+
+                                    if let Some(rules) = workspace
+                                        .workspace_config()
+                                        .as_ref()
+                                        .and_then(|c| c.initial_workspace_rules.as_ref())
+                                    {
+                                        for r in rules {
+                                            workspace_matching_rules.push(WorkspaceMatchingRule {
+                                                monitor_index: i,
+                                                workspace_index: j,
+                                                matching_rule: r.clone(),
+                                                initial_only: true,
+                                            });
+                                        }
                                     }
                                 }
+
+                                // Restore windows from new monitor and update the focused
+                                // workspace
+                                m.load_focused_workspace(mouse_follows_focus)?;
+                                m.update_focused_workspace(offset)?;
                             }
 
                             // Entries in the cache should only be used once; remove the entry there was a cache hit
-                            if cache_hit {
-                                monitor_cache.remove(&device_id);
+                            if cache_hit && !cached_id.is_empty() {
+                                monitor_cache.remove(&cached_id);
                             }
                         }
                     }
+
+                    // Refocus the previously focused monitor since the code above might
+                    // steal the focus away.
+                    wm.focus_monitor(focused_monitor_idx)?;
+                    wm.focus_workspace(focused_workspace_idx)?;
                 }
 
                 let final_count = wm.monitors().len();
@@ -411,6 +649,14 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 }
             }
         }
+
+        notify_subscribers(
+            Notification {
+                event: NotificationEvent::Monitor(notification),
+                state: wm.as_ref().into(),
+            },
+            initial_state.has_been_modified(&wm),
+        )?;
     }
 
     Ok(())

komorebi/src/process_command.rs

@@ -1,10 +1,14 @@
+use color_eyre::eyre::anyhow;
+use color_eyre::Result;
+use miow::pipe::connect;
+use net2::TcpStreamExt;
+use parking_lot::Mutex;
 use std::collections::HashMap;
 use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Read;
-use std::net::Shutdown;
 use std::net::TcpListener;
 use std::net::TcpStream;
 use std::num::NonZeroUsize;
@@ -12,21 +16,11 @@ use std::str::FromStr;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
-
-use color_eyre::eyre::anyhow;
-use color_eyre::Result;
-use miow::pipe::connect;
-use net2::TcpStreamExt;
-use parking_lot::Mutex;
-use schemars::gen::SchemaSettings;
-use schemars::schema_for;
 use uds_windows::UnixStream;
 
-use crate::animation::AnimationEngine;
 use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
 use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
 use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
-use crate::core::config_generation::ApplicationConfiguration;
 use crate::core::config_generation::IdWithIdentifier;
 use crate::core::config_generation::MatchingRule;
 use crate::core::config_generation::MatchingStrategy;
@@ -54,6 +48,7 @@ use crate::border_manager::STYLE;
 use crate::colour::Rgb;
 use crate::config_generation::WorkspaceMatchingRule;
 use crate::current_virtual_desktop;
+use crate::monitor::MonitorInformation;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
 use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
@@ -67,6 +62,8 @@ use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
+use crate::workspace::WorkspaceLayer;
+use crate::workspace::WorkspaceWindowLocation;
 use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
@@ -231,14 +228,97 @@ impl WindowManager {
                 self.focus_container_in_direction(direction)?;
                 self.promote_container_to_front()?
             }
+            SocketMessage::EagerFocus(ref exe) => {
+                let focused_monitor_idx = self.focused_monitor_idx();
+                let focused_workspace_idx = self.focused_workspace_idx()?;
+
+                let mut window_location = None;
+                let mut monitor_workspace_indices = None;
+
+                'search: for (monitor_idx, monitor) in self.monitors().iter().enumerate() {
+                    for (workspace_idx, workspace) in monitor.workspaces().iter().enumerate() {
+                        if let Some(location) = workspace.location_from_exe(exe) {
+                            window_location = Some(location);
+                            monitor_workspace_indices = Some((monitor_idx, workspace_idx));
+                            break 'search;
+                        }
+                    }
+                }
+
+                if let Some((monitor_idx, workspace_idx)) = monitor_workspace_indices {
+                    if monitor_idx != focused_monitor_idx {
+                        self.focus_monitor(monitor_idx)?;
+                    }
+
+                    if workspace_idx != focused_workspace_idx {
+                        self.focus_workspace(workspace_idx)?;
+                    }
+                }
+
+                if let Some(location) = window_location {
+                    match location {
+                        WorkspaceWindowLocation::Monocle(window_idx) => {
+                            self.focus_container_window(window_idx)?;
+                        }
+                        WorkspaceWindowLocation::Maximized => {
+                            if let Some(window) =
+                                self.focused_workspace_mut()?.maximized_window_mut()
+                            {
+                                window.focus(self.mouse_follows_focus)?;
+                            }
+                        }
+                        WorkspaceWindowLocation::Container(container_idx, window_idx) => {
+                            let focused_container_idx = self.focused_container_idx()?;
+                            if container_idx != focused_container_idx {
+                                self.focused_workspace_mut()?.focus_container(container_idx);
+                            }
+
+                            self.focus_container_window(window_idx)?;
+                        }
+                        WorkspaceWindowLocation::Floating(window_idx) => {
+                            if let Some(window) = self
+                                .focused_workspace_mut()?
+                                .floating_windows_mut()
+                                .get_mut(window_idx)
+                            {
+                                window.focus(self.mouse_follows_focus)?;
+                            }
+                        }
+                    }
+                }
+            }
             SocketMessage::FocusWindow(direction) => {
-                self.focus_container_in_direction(direction)?;
+                let focused_workspace = self.focused_workspace()?;
+                match focused_workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        self.focus_container_in_direction(direction)?;
+                    }
+                    WorkspaceLayer::Floating => {
+                        self.focus_floating_window_in_direction(direction)?;
+                    }
+                }
             }
             SocketMessage::MoveWindow(direction) => {
-                self.move_container_in_direction(direction)?;
+                let focused_workspace = self.focused_workspace()?;
+                match focused_workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        self.move_container_in_direction(direction)?;
+                    }
+                    WorkspaceLayer::Floating => {
+                        self.move_floating_window_in_direction(direction)?;
+                    }
+                }
             }
             SocketMessage::CycleFocusWindow(direction) => {
-                self.focus_container_in_cycle_direction(direction)?;
+                let focused_workspace = self.focused_workspace()?;
+                match focused_workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        self.focus_container_in_cycle_direction(direction)?;
+                    }
+                    WorkspaceLayer::Floating => {
+                        self.focus_floating_window_in_cycle_direction(direction)?;
+                    }
+                }
             }
             SocketMessage::CycleMoveWindow(direction) => {
                 self.move_container_in_cycle_direction(direction)?;
@@ -398,6 +478,13 @@ impl WindowManager {
                 let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
                 workspace_rules.clear();
             }
+            SocketMessage::EnforceWorkspaceRules => {
+                {
+                    let mut already_moved = self.already_moved_window_handles.lock();
+                    already_moved.clear();
+                }
+                self.enforce_workspace_rules()?;
+            }
             SocketMessage::ManageRule(identifier, ref id) => {
                 let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
 
@@ -669,6 +756,11 @@ impl WindowManager {
                 self.focus_monitor(monitor_idx)?;
                 self.update_focused_workspace(self.mouse_follows_focus, true)?;
             }
+            SocketMessage::FocusMonitorAtCursor => {
+                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
+                    self.focus_monitor(monitor_idx)?;
+                }
+            }
             SocketMessage::Retile => {
                 border_manager::destroy_all_borders()?;
                 self.retile_all(false)?
@@ -782,7 +874,15 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 let focused_monitor = self
@@ -805,16 +905,22 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 let mut can_close = false;
 
                 if let Some(monitor) = self.focused_monitor_mut() {
                     let focused_workspace_idx = monitor.focused_workspace_idx();
-                    let last_focused_workspace = monitor
-                        .last_focused_workspace()
-                        .unwrap_or(focused_workspace_idx.saturating_sub(1));
+                    let next_focused_workspace_idx = focused_workspace_idx.saturating_sub(1);
 
                     if let Some(workspace) = monitor.focused_workspace() {
                         if monitor.workspaces().len() > 1
@@ -834,7 +940,7 @@ impl WindowManager {
                             .remove(focused_workspace_idx)
                             .is_some()
                     {
-                        self.focus_workspace(last_focused_workspace)?;
+                        self.focus_workspace(next_focused_workspace_idx)?;
                     }
                 }
             }
@@ -843,7 +949,15 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 let idx = self
@@ -866,7 +980,15 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 if self.focused_workspace_idx().unwrap_or_default() != workspace_idx {
@@ -878,7 +1000,15 @@ impl WindowManager {
                 // secondary monitor where the cursor is focused will be used as the target for
                 // the workspace switch op
                 if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 let focused_monitor_idx = self.focused_monitor_idx();
@@ -911,31 +1041,55 @@ impl WindowManager {
                     self.focus_workspace(workspace_idx)?;
                 }
             }
-            SocketMessage::Stop => {
-                tracing::info!(
-                    "received stop command, restoring all hidden windows and terminating process"
-                );
+            SocketMessage::ToggleWorkspaceLayer => {
+                let mouse_follows_focus = self.mouse_follows_focus;
+                let workspace = self.focused_workspace_mut()?;
 
-                ANIMATION_ENABLED_PER_ANIMATION.lock().clear();
-                ANIMATION_ENABLED_GLOBAL.store(false, Ordering::SeqCst);
-                self.restore_all_windows()?;
-                AnimationEngine::wait_for_all_animations();
+                let mut to_focus = None;
+                match workspace.layer() {
+                    WorkspaceLayer::Tiling => {
+                        workspace.set_layer(WorkspaceLayer::Floating);
 
-                if WindowsApi::focus_follows_mouse()? {
-                    WindowsApi::disable_focus_follows_mouse()?;
-                }
+                        for (i, window) in workspace.floating_windows().iter().enumerate() {
+                            if i == 0 {
+                                to_focus = Some(*window);
+                            }
+                            window.raise()?;
+                        }
 
-                let sockets = SUBSCRIPTION_SOCKETS.lock();
-                for path in (*sockets).values() {
-                    if let Ok(stream) = UnixStream::connect(path) {
-                        stream.shutdown(Shutdown::Both)?;
+                        for container in workspace.containers() {
+                            if let Some(window) = container.focused_window() {
+                                window.lower()?;
+                            }
+                        }
                     }
+                    WorkspaceLayer::Floating => {
+                        workspace.set_layer(WorkspaceLayer::Tiling);
+
+                        let focused_container_idx = workspace.focused_container_idx();
+                        for (i, container) in workspace.containers_mut().iter_mut().enumerate() {
+                            if let Some(window) = container.focused_window() {
+                                if i == focused_container_idx {
+                                    to_focus = Some(*window);
+                                }
+                                window.raise()?;
+                            }
+                        }
+
+                        for window in workspace.floating_windows() {
+                            window.lower()?;
+                        }
+                    }
+                };
+                if let Some(window) = to_focus {
+                    window.focus(mouse_follows_focus)?;
                 }
-
-                let socket = DATA_DIR.join("komorebi.sock");
-                let _ = std::fs::remove_file(socket);
-
-                std::process::exit(0)
+            }
+            SocketMessage::Stop => {
+                self.stop(false)?;
+            }
+            SocketMessage::StopIgnoreRestore => {
+                self.stop(true)?;
             }
             SocketMessage::MonitorIndexPreference(index_preference, left, top, right, bottom) => {
                 let mut monitor_index_preferences = MONITOR_INDEX_PREFERENCES.lock();
@@ -1008,9 +1162,9 @@ impl WindowManager {
                 reply.write_all(visible_windows_state.as_bytes())?;
             }
             SocketMessage::MonitorInformation => {
-                let mut monitors = HashMap::new();
+                let mut monitors = vec![];
                 for monitor in self.monitors() {
-                    monitors.insert(monitor.device_id(), monitor.size());
+                    monitors.push(MonitorInformation::from(monitor));
                 }
 
                 let monitors_state = serde_json::to_string_pretty(&monitors)
@@ -1020,19 +1174,29 @@ impl WindowManager {
             }
             SocketMessage::Query(query) => {
                 let response = match query {
-                    StateQuery::FocusedMonitorIndex => self.focused_monitor_idx(),
+                    StateQuery::FocusedMonitorIndex => self.focused_monitor_idx().to_string(),
                     StateQuery::FocusedWorkspaceIndex => self
                         .focused_monitor()
                         .ok_or_else(|| anyhow!("there is no monitor"))?
-                        .focused_workspace_idx(),
-                    StateQuery::FocusedContainerIndex => {
-                        self.focused_workspace()?.focused_container_idx()
-                    }
+                        .focused_workspace_idx()
+                        .to_string(),
+                    StateQuery::FocusedContainerIndex => self
+                        .focused_workspace()?
+                        .focused_container_idx()
+                        .to_string(),
                     StateQuery::FocusedWindowIndex => {
-                        self.focused_container()?.focused_window_idx()
+                        self.focused_container()?.focused_window_idx().to_string()
                     }
-                }
-                .to_string();
+                    StateQuery::FocusedWorkspaceName => {
+                        let focused_monitor = self
+                            .focused_monitor()
+                            .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+                        focused_monitor
+                            .focused_workspace_name()
+                            .unwrap_or_else(|| focused_monitor.focused_workspace_idx().to_string())
+                    }
+                };
 
                 reply.write_all(response.as_bytes())?;
             }
@@ -1250,7 +1414,7 @@ impl WindowManager {
                     // Pause so that restored windows come to the foreground from all workspaces
                     self.is_paused = true;
                     // Bring all windows to the foreground
-                    self.restore_all_windows()?;
+                    self.restore_all_windows(false)?;
 
                     // Create a new wm from the config path
                     let mut wm = StaticConfig::preload(
@@ -1262,6 +1426,8 @@ impl WindowManager {
                     // Initialize the new wm
                     wm.init()?;
 
+                    wm.restore_all_windows(true)?;
+
                     // This is equivalent to StaticConfig::postload for this use case
                     StaticConfig::reload(config, &mut wm)?;
 
@@ -1357,6 +1523,14 @@ impl WindowManager {
                     self.retile_all(false)?;
                 }
             }
+            SocketMessage::ToggleWindowBasedWorkAreaOffset => {
+                let workspace = self.focused_workspace_mut()?;
+                workspace.set_apply_window_based_work_area_offset(
+                    !workspace.apply_window_based_work_area_offset(),
+                );
+
+                self.retile_all(true)?;
+            }
             SocketMessage::QuickSave => {
                 let workspace = self.focused_workspace()?;
                 let resize = workspace.resize_dimensions();
@@ -1619,6 +1793,7 @@ impl WindowManager {
             }
             SocketMessage::StackbarMode(mode) => {
                 STACKBAR_MODE.store(mode);
+                self.retile_all(true)?;
             }
             SocketMessage::StackbarLabel(label) => {
                 STACKBAR_LABEL.store(label);
@@ -1649,45 +1824,73 @@ impl WindowManager {
                 *STACKBAR_FONT_FAMILY.lock() = font_family.clone();
             }
             SocketMessage::ApplicationSpecificConfigurationSchema => {
-                let asc = schema_for!(Vec<ApplicationConfiguration>);
-                let schema = serde_json::to_string_pretty(&asc)?;
+                #[cfg(feature = "schemars")]
+                {
+                    let asc = schemars::schema_for!(
+                        Vec<crate::core::config_generation::ApplicationConfiguration>
+                    );
+                    let schema = serde_json::to_string_pretty(&asc)?;
 
-                reply.write_all(schema.as_bytes())?;
+                    reply.write_all(schema.as_bytes())?;
+                }
             }
             SocketMessage::NotificationSchema => {
-                let notification = schema_for!(Notification);
-                let schema = serde_json::to_string_pretty(&notification)?;
+                #[cfg(feature = "schemars")]
+                {
+                    let notification = schemars::schema_for!(Notification);
+                    let schema = serde_json::to_string_pretty(&notification)?;
 
-                reply.write_all(schema.as_bytes())?;
+                    reply.write_all(schema.as_bytes())?;
+                }
             }
             SocketMessage::SocketSchema => {
-                let socket_message = schema_for!(SocketMessage);
-                let schema = serde_json::to_string_pretty(&socket_message)?;
+                #[cfg(feature = "schemars")]
+                {
+                    let socket_message = schemars::schema_for!(SocketMessage);
+                    let schema = serde_json::to_string_pretty(&socket_message)?;
 
-                reply.write_all(schema.as_bytes())?;
+                    reply.write_all(schema.as_bytes())?;
+                }
             }
             SocketMessage::StaticConfigSchema => {
-                let settings = SchemaSettings::default().with(|s| {
-                    s.option_nullable = false;
-                    s.option_add_null_type = false;
-                    s.inline_subschemas = true;
-                });
+                #[cfg(feature = "schemars")]
+                {
+                    let settings = schemars::gen::SchemaSettings::default().with(|s| {
+                        s.option_nullable = false;
+                        s.option_add_null_type = false;
+                        s.inline_subschemas = true;
+                    });
 
-                let gen = settings.into_generator();
-                let socket_message = gen.into_root_schema_for::<StaticConfig>();
-                let schema = serde_json::to_string_pretty(&socket_message)?;
+                    let gen = settings.into_generator();
+                    let socket_message = gen.into_root_schema_for::<StaticConfig>();
+                    let schema = serde_json::to_string_pretty(&socket_message)?;
 
-                reply.write_all(schema.as_bytes())?;
+                    reply.write_all(schema.as_bytes())?;
+                }
             }
             SocketMessage::GenerateStaticConfig => {
                 let config = serde_json::to_string_pretty(&StaticConfig::from(&*self))?;
 
                 reply.write_all(config.as_bytes())?;
             }
-            SocketMessage::RemoveTitleBar(_, ref id) => {
+            SocketMessage::RemoveTitleBar(identifier, ref id) => {
                 let mut identifiers = NO_TITLEBAR.lock();
-                if !identifiers.contains(id) {
-                    identifiers.push(id.clone());
+
+                let mut should_push = true;
+                for i in &*identifiers {
+                    if let MatchingRule::Simple(i) = i {
+                        if i.id.eq(id) {
+                            should_push = false;
+                        }
+                    }
+                }
+
+                if should_push {
+                    identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                        kind: identifier,
+                        id: id.clone(),
+                        matching_strategy: Option::from(MatchingStrategy::Legacy),
+                    }));
                 }
             }
             SocketMessage::ToggleTitleBars => {
@@ -1711,6 +1914,9 @@ impl WindowManager {
             | SocketMessage::IdentifyBorderOverflowApplication(_, _) => {}
         };
 
+        // Update list of known_hwnds and their monitor/workspace index pair
+        self.update_known_hwnds();
+
         notify_subscribers(
             Notification {
                 event: NotificationEvent::Socket(message.clone()),

komorebi/src/process_event.rs

@@ -1,4 +1,3 @@
-use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
@@ -27,13 +26,13 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
+use crate::workspace::WorkspaceLayer;
 use crate::workspace_reconciliator;
 use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::State;
-use crate::DATA_DIR;
 use crate::FLOATING_APPLICATIONS;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
@@ -93,8 +92,18 @@ impl WindowManager {
                             .map(|w| w.hwnd)
                             .collect::<Vec<_>>();
 
-                        if w.contains_managed_window(event_hwnd)
-                            && !visible_hwnds.contains(&event_hwnd)
+                        let contains_managed_window = w.contains_managed_window(event_hwnd);
+
+                        // this is for an old stackbar clicking fix
+                        if contains_managed_window && !visible_hwnds.contains(&event_hwnd) {
+                            transparency_override = true;
+                        }
+
+                        // but we always want to handle a minimize event when transparency overrides
+                        // are applied
+                        if !transparency_override
+                            && contains_managed_window
+                            && matches!(event, WindowManagerEvent::Minimize(_, _))
                         {
                             transparency_override = true;
                         }
@@ -244,7 +253,12 @@ impl WindowManager {
                 already_moved_window_handles.remove(&window.hwnd);
             }
             WindowManagerEvent::FocusChange(_, window) => {
-                self.update_focused_workspace(self.mouse_follows_focus, false)?;
+                // don't want to trigger the full workspace updates when there are no managed
+                // containers - this makes floating windows on empty workspaces go into very
+                // annoying focus change loops which prevents users from interacting with them
+                if !self.focused_workspace()?.containers().is_empty() {
+                    self.update_focused_workspace(self.mouse_follows_focus, false)?;
+                }
 
                 let workspace = self.focused_workspace_mut()?;
                 let floating_window_idx = workspace
@@ -267,10 +281,12 @@ impl WindowManager {
                         } else {
                             workspace.focus_container_by_window(window.hwnd)?;
                         }
+
+                        workspace.set_layer(WorkspaceLayer::Tiling);
                     }
                     Some(idx) => {
-                        if let Some(window) = workspace.floating_windows().get(idx) {
-                            window.focus(false)?;
+                        if let Some(_window) = workspace.floating_windows().get(idx) {
+                            workspace.set_layer(WorkspaceLayer::Floating);
                         }
                     }
                 }
@@ -292,30 +308,28 @@ impl WindowManager {
 
                     let mut needs_reconciliation = false;
 
-                    for (i, monitors) in self.monitors().iter().enumerate() {
-                        for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                            if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
-                                // At this point we know we are going to send a notification to the workspace reconciliator
-                                // So we get the topmost window returned by EnumWindows, which is almost always the window
-                                // that has been selected by alt-tab
-                                if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                    if let Some(first) =
-                                        alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                    {
-                                        // If our record of this HWND hasn't been updated in over a minute
-                                        let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                        if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                            // Update our record with the HWND we just found
-                                            ALT_TAB_HWND.store(Some(first.hwnd));
-                                            // Update the timestamp of our record
-                                            *instant = Instant::now();
-                                        }
+                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
+                        if focused_pair != (*m_idx, *w_idx) {
+                            // At this point we know we are going to send a notification to the workspace reconciliator
+                            // So we get the topmost window returned by EnumWindows, which is almost always the window
+                            // that has been selected by alt-tab
+                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
+                                if let Some(first) =
+                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
+                                {
+                                    // If our record of this HWND hasn't been updated in over a minute
+                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
+                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
+                                        // Update our record with the HWND we just found
+                                        ALT_TAB_HWND.store(Some(first.hwnd));
+                                        // Update the timestamp of our record
+                                        *instant = Instant::now();
                                     }
                                 }
-
-                                workspace_reconciliator::send_notification(i, j);
-                                needs_reconciliation = true;
                             }
+
+                            workspace_reconciliator::send_notification(*m_idx, *w_idx);
+                            needs_reconciliation = true;
                         }
                     }
 
@@ -326,11 +340,14 @@ impl WindowManager {
                     // duplicates across multiple workspaces, as it results in ghost layout tiles.
                     let mut proceed = true;
 
-                    for (i, monitor) in self.monitors().iter().enumerate() {
-                        for (j, workspace) in monitor.workspaces().iter().enumerate() {
-                            if workspace.contains_window(window.hwnd)
-                                && i != self.focused_monitor_idx()
-                                && j != monitor.focused_workspace_idx()
+                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
+                        if let Some(focused_workspace_idx) = self
+                            .monitors()
+                            .get(*m_idx)
+                            .map(|m| m.focused_workspace_idx())
+                        {
+                            if *m_idx != self.focused_monitor_idx()
+                                && *w_idx != focused_workspace_idx
                             {
                                 tracing::debug!(
                                     "ignoring show event for window already associated with another workspace"
@@ -353,10 +370,11 @@ impl WindowManager {
 
                         if !workspace_contains_window && !needs_reconciliation {
                             let floating_applications = FLOATING_APPLICATIONS.lock();
-                            let regex_identifiers = REGEX_IDENTIFIERS.lock();
                             let mut should_float = false;
 
                             if !floating_applications.is_empty() {
+                                let regex_identifiers = REGEX_IDENTIFIERS.lock();
+
                                 if let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) =
                                     (window.title(), window.exe(), window.class(), window.path())
                                 {
@@ -378,11 +396,13 @@ impl WindowManager {
 
                             if behaviour.float_override {
                                 workspace.floating_windows_mut().push(window);
+                                workspace.set_layer(WorkspaceLayer::Floating);
                                 self.update_focused_workspace(false, false)?;
                             } else {
                                 match behaviour.current_behaviour {
                                     WindowContainerBehaviour::Create => {
                                         workspace.new_container_for_window(window);
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
                                         self.update_focused_workspace(false, false)?;
                                     }
                                     WindowContainerBehaviour::Append => {
@@ -392,6 +412,7 @@ impl WindowManager {
                                                 anyhow!("there is no focused container")
                                             })?
                                             .add_window(window);
+                                        workspace.set_layer(WorkspaceLayer::Tiling);
                                         self.update_focused_workspace(true, false)?;
                                         stackbar_manager::send_notification();
                                     }
@@ -488,15 +509,9 @@ impl WindowManager {
                 // This will be true if we have moved to another monitor
                 let mut moved_across_monitors = false;
 
-                for (i, monitors) in self.monitors().iter().enumerate() {
-                    for workspace in monitors.workspaces() {
-                        if workspace.contains_window(window.hwnd) && i != target_monitor_idx {
-                            moved_across_monitors = true;
-                            break;
-                        }
-                    }
-                    if moved_across_monitors {
-                        break;
+                if let Some((m_idx, _)) = self.known_hwnds.get(&window.hwnd) {
+                    if *m_idx != target_monitor_idx {
+                        moved_across_monitors = true;
                     }
                 }
 
@@ -700,40 +715,8 @@ impl WindowManager {
             window.center(&self.focused_monitor_work_area()?)?;
         }
 
-        tracing::trace!("updating list of known hwnds");
-        let mut known_hwnds = vec![];
-        for monitor in self.monitors() {
-            for workspace in monitor.workspaces() {
-                for container in workspace.containers() {
-                    for window in container.windows() {
-                        known_hwnds.push(window.hwnd);
-                    }
-                }
-
-                for window in workspace.floating_windows() {
-                    known_hwnds.push(window.hwnd);
-                }
-
-                if let Some(window) = workspace.maximized_window() {
-                    known_hwnds.push(window.hwnd);
-                }
-
-                if let Some(container) = workspace.monocle_container() {
-                    for window in container.windows() {
-                        known_hwnds.push(window.hwnd);
-                    }
-                }
-            }
-        }
-
-        let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
-        let file = OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .create(true)
-            .open(hwnd_json)?;
-
-        serde_json::to_writer_pretty(&file, &known_hwnds)?;
+        // Update list of known_hwnds and their monitor/workspace index pair
+        self.update_known_hwnds();
 
         notify_subscribers(
             Notification {

komorebi/src/reaper.rs

@@ -1,14 +1,155 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 
 use crate::border_manager;
+use crate::notify_subscribers;
+use crate::winevent::WinEvent;
+use crate::NotificationEvent;
+use crate::Window;
 use crate::WindowManager;
+use crate::WindowManagerEvent;
+use crate::DATA_DIR;
+
+use crossbeam_channel::Receiver;
+use crossbeam_channel::Sender;
+use lazy_static::lazy_static;
 use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::fs::OpenOptions;
 use std::sync::Arc;
+use std::sync::OnceLock;
 use std::time::Duration;
 
-pub fn watch_for_orphans(wm: Arc<Mutex<WindowManager>>) {
+lazy_static! {
+    pub static ref HWNDS_CACHE: Arc<Mutex<HashMap<isize, (usize, usize)>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+}
+
+pub struct ReaperNotification(pub HashMap<isize, (usize, usize)>);
+
+static CHANNEL: OnceLock<(Sender<ReaperNotification>, Receiver<ReaperNotification>)> =
+    OnceLock::new();
+
+pub fn channel() -> &'static (Sender<ReaperNotification>, Receiver<ReaperNotification>) {
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(50))
+}
+
+fn event_tx() -> Sender<ReaperNotification> {
+    channel().0.clone()
+}
+
+fn event_rx() -> Receiver<ReaperNotification> {
+    channel().1.clone()
+}
+
+pub fn send_notification(hwnds: HashMap<isize, (usize, usize)>) {
+    if event_tx().try_send(ReaperNotification(hwnds)).is_err() {
+        tracing::warn!("channel is full; dropping notification")
+    }
+}
+
+pub fn listen_for_notifications(
+    wm: Arc<Mutex<WindowManager>>,
+    known_hwnds: HashMap<isize, (usize, usize)>,
+) {
+    watch_for_orphans(known_hwnds);
+
     std::thread::spawn(move || loop {
-        match find_orphans(wm.clone()) {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
+            }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
+            }
+        }
+    });
+}
+
+fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
+    tracing::info!("listening");
+
+    let receiver = event_rx();
+
+    for notification in receiver {
+        let orphan_hwnds = notification.0;
+        let mut wm = wm.lock();
+
+        let mut update_borders = false;
+
+        for (hwnd, (m_idx, w_idx)) in orphan_hwnds.iter() {
+            if let Some(monitor) = wm.monitors_mut().get_mut(*m_idx) {
+                let focused_workspace_idx = monitor.focused_workspace_idx();
+
+                if let Some(workspace) = monitor.workspaces_mut().get_mut(*w_idx) {
+                    // Remove orphan window
+                    if let Err(error) = workspace.remove_window(*hwnd) {
+                        tracing::warn!(
+                            "error reaping orphan window ({}) on monitor: {}, workspace: {}. Error: {}",
+                            hwnd,
+                            m_idx,
+                            w_idx,
+                            error,
+                        );
+                    }
+
+                    if focused_workspace_idx == *w_idx {
+                        // If this is not a focused workspace there is no need to update the
+                        // workspace or the borders. That will already be done when the user
+                        // changes to this workspace.
+                        workspace.update()?;
+                        update_borders = true;
+                    }
+                    tracing::info!(
+                        "reaped orphan window ({}) on monitor: {}, workspace: {}",
+                        hwnd,
+                        m_idx,
+                        w_idx,
+                    );
+                }
+            }
+
+            wm.known_hwnds.remove(hwnd);
+
+            let window = Window::from(*hwnd);
+            notify_subscribers(
+                crate::Notification {
+                    event: NotificationEvent::WindowManager(WindowManagerEvent::Destroy(
+                        WinEvent::ObjectDestroy,
+                        window,
+                    )),
+                    state: wm.as_ref().into(),
+                },
+                true,
+            )?;
+        }
+
+        if update_borders {
+            border_manager::send_notification(None);
+        }
+
+        // Save to file
+        let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
+        let file = OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(hwnd_json)?;
+
+        serde_json::to_writer_pretty(&file, &wm.known_hwnds.keys().collect::<Vec<_>>())?;
+    }
+
+    Ok(())
+}
+
+fn watch_for_orphans(known_hwnds: HashMap<isize, (usize, usize)>) {
+    // Cache current hwnds
+    {
+        let mut cache = HWNDS_CACHE.lock();
+        *cache = known_hwnds;
+    }
+
+    std::thread::spawn(move || loop {
+        match find_orphans() {
             Ok(()) => {
                 tracing::warn!("restarting finished thread");
             }
@@ -23,44 +164,37 @@ pub fn watch_for_orphans(wm: Arc<Mutex<WindowManager>>) {
     });
 }
 
-pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
+fn find_orphans() -> color_eyre::Result<()> {
     tracing::info!("watching");
 
-    let arc = wm.clone();
-
     loop {
-        std::thread::sleep(Duration::from_secs(1));
+        std::thread::sleep(Duration::from_millis(20));
 
-        let mut wm = arc.lock();
-        let offset = wm.work_area_offset;
+        let mut cache = HWNDS_CACHE.lock();
+        let mut orphan_hwnds = HashMap::new();
 
-        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
-            let work_area = *monitor.work_area_size();
-            let window_based_work_area_offset = (
-                monitor.window_based_work_area_offset_limit(),
-                monitor.window_based_work_area_offset(),
-            );
+        for (hwnd, (m_idx, w_idx)) in cache.iter() {
+            let window = Window::from(*hwnd);
 
-            let offset = if monitor.work_area_offset().is_some() {
-                monitor.work_area_offset()
-            } else {
-                offset
-            };
-
-            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, window_based_work_area_offset)?;
-                    border_manager::send_notification(None);
-                    tracing::info!(
-                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
-                        reaped_orphans.0,
-                        reaped_orphans.1,
-                        i,
-                        j
-                    );
-                }
+            if !window.is_window()
+                // This one is a hack because WINWORD.EXE is an absolute trainwreck of an app
+                // when multiple docs are open, it keeps open an invisible window, with WS_EX_LAYERED
+                // (A STYLE THAT THE REGULAR WINDOWS NEED IN ORDER TO BE MANAGED!) when one of the
+                // docs is closed
+                //
+                // I hate every single person who worked on Microsoft Office 365, especially Word
+                || !window.is_visible()
+            {
+                orphan_hwnds.insert(window.hwnd, (*m_idx, *w_idx));
             }
         }
+
+        if !orphan_hwnds.is_empty() {
+            // Update reaper cache
+            cache.retain(|h, _| !orphan_hwnds.contains_key(h));
+
+            // Send handles to remove
+            event_tx().send(ReaperNotification(orphan_hwnds))?;
+        }
     }
 }

komorebi/src/ring.rs

@@ -1,10 +1,10 @@
 use std::collections::VecDeque;
 
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Ring<T> {
     elements: VecDeque<T>,
     focused: usize,

komorebi/src/stackbar_manager/stackbar.rs

@@ -123,7 +123,7 @@ impl Stackbar {
                     0,
                     None,
                     None,
-                    HINSTANCE(windows_api::as_ptr!(instance)),
+                    Option::from(HINSTANCE(windows_api::as_ptr!(instance))),
                     None,
                 )?;
 
@@ -133,7 +133,7 @@ impl Stackbar {
                 let mut msg: MSG = MSG::default();
 
                 loop {
-                    if !GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, None, 0, 0).as_bool() {
                         tracing::debug!("stackbar window event processing thread shutdown");
                         break;
                     };
@@ -183,13 +183,13 @@ impl Stackbar {
         WindowsApi::position_window(self.hwnd, &layout, false)?;
 
         unsafe {
-            let hdc = GetDC(self.hwnd());
+            let hdc = GetDC(Option::from(self.hwnd()));
 
             let hpen = CreatePen(PS_SOLID, 0, COLORREF(background));
             let hbrush = CreateSolidBrush(COLORREF(background));
 
-            SelectObject(hdc, hpen);
-            SelectObject(hdc, hbrush);
+            SelectObject(hdc, hpen.into());
+            SelectObject(hdc, hbrush.into());
             SetBkColor(hdc, COLORREF(background));
 
             let mut logfont = LOGFONTW {
@@ -209,14 +209,14 @@ impl Stackbar {
             let logical_height = -MulDiv(
                 STACKBAR_FONT_SIZE.load(Ordering::SeqCst),
                 72,
-                GetDeviceCaps(hdc, LOGPIXELSY),
+                GetDeviceCaps(Option::from(hdc), LOGPIXELSY),
             );
 
             logfont.lfHeight = logical_height;
 
             let hfont = CreateFontIndirectW(&logfont);
 
-            SelectObject(hdc, hfont);
+            SelectObject(hdc, hfont.into());
 
             for (i, window) in container.windows().iter().enumerate() {
                 if window.hwnd == container.focused_window().copied().unwrap_or_default().hwnd {
@@ -283,13 +283,13 @@ impl Stackbar {
                 );
             }
 
-            ReleaseDC(self.hwnd(), hdc);
+            ReleaseDC(Option::from(self.hwnd()), hdc);
             // TODO: error handling
-            let _ = DeleteObject(hpen);
+            let _ = DeleteObject(hpen.into());
             // TODO: error handling
-            let _ = DeleteObject(hbrush);
+            let _ = DeleteObject(hbrush.into());
             // TODO: error handling
-            let _ = DeleteObject(hfont);
+            let _ = DeleteObject(hfont.into());
         }
 
         Ok(())

komorebi/src/static_config.rs

@@ -7,15 +7,37 @@ use crate::animation::ANIMATION_FPS;
 use crate::animation::ANIMATION_STYLE_GLOBAL;
 use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
 use crate::animation::DEFAULT_ANIMATION_FPS;
+use crate::asc::ApplicationSpecificConfiguration;
+use crate::asc::AscApplicationRulesOrSchema;
 use crate::border_manager;
 use crate::border_manager::ZOrder;
 use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
 use crate::colour::Colour;
+use crate::config_generation::WorkspaceMatchingRule;
+use crate::core::config_generation::ApplicationConfiguration;
+use crate::core::config_generation::ApplicationConfigurationGenerator;
+use crate::core::config_generation::ApplicationOptions;
+use crate::core::config_generation::MatchingRule;
+use crate::core::config_generation::MatchingStrategy;
+use crate::core::resolve_home_path;
+use crate::core::AnimationStyle;
 use crate::core::BorderImplementation;
+use crate::core::BorderStyle;
+use crate::core::DefaultLayout;
+use crate::core::FocusFollowsMouseImplementation;
+use crate::core::HidingBehaviour;
+use crate::core::Layout;
+use crate::core::MoveBehaviour;
+use crate::core::OperationBehaviour;
+use crate::core::Rect;
+use crate::core::SocketMessage;
 use crate::core::StackbarLabel;
 use crate::core::StackbarMode;
+use crate::core::WindowContainerBehaviour;
+use crate::core::WindowManagementBehaviour;
 use crate::current_virtual_desktop;
+use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator;
 use crate::ring::Ring;
@@ -35,18 +57,24 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
+use crate::AspectRatio;
+use crate::Axis;
 use crate::CrossBoundaryBehaviour;
+use crate::PredefinedAspectRatio;
 use crate::DATA_DIR;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::DISPLAY_INDEX_PREFERENCES;
 use crate::FLOATING_APPLICATIONS;
+use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
 use crate::HIDING_BEHAVIOUR;
 use crate::IGNORE_IDENTIFIERS;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
+use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST;
 use crate::REGEX_IDENTIFIERS;
 use crate::SLOW_APPLICATION_COMPENSATION_TIME;
 use crate::SLOW_APPLICATION_IDENTIFIERS;
@@ -54,35 +82,12 @@ use crate::TRANSPARENCY_BLACKLIST;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WINDOWS_11;
 use crate::WORKSPACE_MATCHING_RULES;
-
-use crate::asc::ApplicationSpecificConfiguration;
-use crate::asc::AscApplicationRulesOrSchema;
-use crate::config_generation::WorkspaceMatchingRule;
-use crate::core::config_generation::ApplicationConfiguration;
-use crate::core::config_generation::ApplicationConfigurationGenerator;
-use crate::core::config_generation::ApplicationOptions;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
-use crate::core::resolve_home_path;
-use crate::core::AnimationStyle;
-use crate::core::BorderStyle;
-use crate::core::DefaultLayout;
-use crate::core::FocusFollowsMouseImplementation;
-use crate::core::HidingBehaviour;
-use crate::core::Layout;
-use crate::core::MoveBehaviour;
-use crate::core::OperationBehaviour;
-use crate::core::Rect;
-use crate::core::SocketMessage;
-use crate::core::WindowContainerBehaviour;
-use crate::core::WindowManagementBehaviour;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
 use parking_lot::Mutex;
 use regex::Regex;
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
@@ -95,21 +100,28 @@ use std::sync::Arc;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct BorderColours {
     /// Border colour when the container contains a single window
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub single: Option<Colour>,
     /// Border colour when the container contains multiple windows
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub stack: Option<Colour>,
     /// Border colour when the container is in monocle mode
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub monocle: Option<Colour>,
     /// Border colour when the container is in floating mode
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub floating: Option<Colour>,
     /// Border colour when the container is unfocused
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub unfocused: Option<Colour>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WorkspaceConfig {
     /// Name
     pub name: String,
@@ -119,7 +131,7 @@ pub struct WorkspaceConfig {
     /// END OF LIFE FEATURE: Custom Layout (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub custom_layout: Option<PathBuf>,
-    /// Layout rules (default: None)
+    /// Layout rules in the format of threshold => layout (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub layout_rules: Option<HashMap<usize, DefaultLayout>>,
     /// END OF LIFE FEATURE: Custom layout rules (default: None)
@@ -128,7 +140,7 @@ pub struct WorkspaceConfig {
     /// Container padding (default: global)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub container_padding: Option<i32>,
-    /// Container padding (default: global)
+    /// Workspace padding (default: global)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub workspace_padding: Option<i32>,
     /// Initial workspace application rules
@@ -143,10 +155,15 @@ pub struct WorkspaceConfig {
     /// Determine what happens when a new window is opened (default: Create)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_container_behaviour: Option<WindowContainerBehaviour>,
-    /// Enable or disable float override, which makes it so every new window opens in floating mode
-    /// (default: false)
+    /// Window container behaviour rules in the format of threshold => behaviour (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_container_behaviour_rules: Option<HashMap<usize, WindowContainerBehaviour>>,
+    /// Enable or disable float override, which makes it so every new window opens in floating mode (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub float_override: Option<bool>,
+    /// Specify an axis on which to flip the selected layout (default: None)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub layout_flip: Option<Axis>,
 }
 
 impl From<&Workspace> for WorkspaceConfig {
@@ -160,6 +177,12 @@ impl From<&Workspace> for WorkspaceConfig {
                 Layout::Custom(_) => {}
             }
         }
+        let layout_rules = (!layout_rules.is_empty()).then_some(layout_rules);
+
+        let mut window_container_behaviour_rules = HashMap::new();
+        for (threshold, behaviour) in value.window_container_behaviour_rules().iter().flatten() {
+            window_container_behaviour_rules.insert(*threshold, *behaviour);
+        }
 
         let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
         let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
@@ -185,27 +208,43 @@ impl From<&Workspace> for WorkspaceConfig {
                 .name()
                 .clone()
                 .unwrap_or_else(|| String::from("unnamed")),
-            layout: match value.layout() {
-                Layout::Default(layout) => Option::from(*layout),
-                // TODO: figure out how we might resolve file references in the future
-                Layout::Custom(_) => None,
-            },
-            custom_layout: None,
-            layout_rules: Option::from(layout_rules),
-            // TODO: figure out how we might resolve file references in the future
-            custom_layout_rules: None,
+            layout: value
+                .tile()
+                .then_some(match value.layout() {
+                    Layout::Default(layout) => Option::from(*layout),
+                    Layout::Custom(_) => None,
+                })
+                .flatten(),
+            custom_layout: value
+                .workspace_config()
+                .as_ref()
+                .and_then(|c| c.custom_layout.clone()),
+            layout_rules,
+            custom_layout_rules: value
+                .workspace_config()
+                .as_ref()
+                .and_then(|c| c.custom_layout_rules.clone()),
             container_padding,
             workspace_padding,
-            initial_workspace_rules: None,
-            workspace_rules: None,
+            initial_workspace_rules: value
+                .workspace_config()
+                .as_ref()
+                .and_then(|c| c.initial_workspace_rules.clone()),
+            workspace_rules: value
+                .workspace_config()
+                .as_ref()
+                .and_then(|c| c.workspace_rules.clone()),
             apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
             window_container_behaviour: *value.window_container_behaviour(),
+            window_container_behaviour_rules: Option::from(window_container_behaviour_rules),
             float_override: *value.float_override(),
+            layout_flip: value.layout_flip(),
         }
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct MonitorConfig {
     /// Workspace configurations
     pub workspaces: Vec<WorkspaceConfig>,
@@ -218,6 +257,12 @@ pub struct MonitorConfig {
     /// Open window limit after which the window based work area offset will no longer be applied (default: 1)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_based_work_area_offset_limit: Option<isize>,
+    /// Container padding (default: global)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub container_padding: Option<i32>,
+    /// Workspace padding (default: global)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_padding: Option<i32>,
 }
 
 impl From<&Monitor> for MonitorConfig {
@@ -227,17 +272,39 @@ impl From<&Monitor> for MonitorConfig {
             workspaces.push(WorkspaceConfig::from(w));
         }
 
+        let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
+        let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
+
+        let container_padding = value.container_padding().and_then(|container_padding| {
+            if container_padding == default_container_padding {
+                None
+            } else {
+                Option::from(container_padding)
+            }
+        });
+
+        let workspace_padding = value.workspace_padding().and_then(|workspace_padding| {
+            if workspace_padding == default_workspace_padding {
+                None
+            } else {
+                Option::from(workspace_padding)
+            }
+        });
+
         Self {
             workspaces,
             work_area_offset: value.work_area_offset(),
             window_based_work_area_offset: value.window_based_work_area_offset(),
             window_based_work_area_offset_limit: Some(value.window_based_work_area_offset_limit()),
+            container_padding,
+            workspace_padding,
         }
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.31`
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+/// The `komorebi.json` static configuration file reference for `v0.1.35`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -348,6 +415,9 @@ pub struct StaticConfig {
     /// 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>>,
+    /// Do not process EVENT_OBJECT_NAMECHANGE events as Show events for identified applications matching these title regexes
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub object_name_change_title_ignore_list: Option<Vec<String>>,
     /// Set monitor index preferences
     #[serde(skip_serializing_if = "Option::is_none")]
     pub monitor_index_preferences: Option<HashMap<usize, Rect>>,
@@ -370,23 +440,35 @@ pub struct StaticConfig {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub slow_application_compensation_time: Option<u64>,
     /// Komorebi status bar configuration files for multiple instances on different monitors
-    #[serde(skip_serializing_if = "Option::is_none")]
     // this option is a little special because it is only consumed by komorebic
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub bar_configurations: Option<Vec<PathBuf>>,
+    /// HEAVILY DISCOURAGED: Identify applications for which komorebi should forcibly remove title bars
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub remove_titlebar_applications: Option<Vec<MatchingRule>>,
+    /// Aspect ratio to resize with when toggling floating mode for a window
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub floating_window_aspect_ratio: Option<AspectRatio>,
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct AnimationsConfig {
     /// Enable or disable animations (default: false)
-    enabled: PerAnimationPrefixConfig<bool>,
+    pub enabled: PerAnimationPrefixConfig<bool>,
     /// Set the animation duration in ms (default: 250)
-    duration: Option<PerAnimationPrefixConfig<u64>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub duration: Option<PerAnimationPrefixConfig<u64>>,
     /// Set the animation style (default: Linear)
-    style: Option<PerAnimationPrefixConfig<AnimationStyle>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub style: Option<PerAnimationPrefixConfig<AnimationStyle>>,
     /// Set the animation FPS (default: 60)
-    fps: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fps: Option<u64>,
 }
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "palette")]
 pub enum KomorebiTheme {
     /// A theme from catppuccin-egui
@@ -394,45 +476,63 @@ pub enum KomorebiTheme {
         /// Name of the Catppuccin theme (theme previews: https://github.com/catppuccin/catppuccin)
         name: komorebi_themes::Catppuccin,
         /// Border colour when the container contains a single window (default: Blue)
+        #[serde(skip_serializing_if = "Option::is_none")]
         single_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container contains multiple windows (default: Green)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stack_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container is in monocle mode (default: Pink)
+        #[serde(skip_serializing_if = "Option::is_none")]
         monocle_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the window is floating (default: Yellow)
+        #[serde(skip_serializing_if = "Option::is_none")]
         floating_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container is unfocused (default: Base)
+        #[serde(skip_serializing_if = "Option::is_none")]
         unfocused_border: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar focused tab text colour (default: Green)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_focused_text: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar unfocused tab text colour (default: Text)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_unfocused_text: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar tab background colour (default: Base)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_background: Option<komorebi_themes::CatppuccinValue>,
         /// Komorebi status bar accent (default: Blue)
+        #[serde(skip_serializing_if = "Option::is_none")]
         bar_accent: Option<komorebi_themes::CatppuccinValue>,
     },
     /// A theme from base16-egui-themes
     Base16 {
-        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)
+        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)
         name: komorebi_themes::Base16,
         /// Border colour when the container contains a single window (default: Base0D)
+        #[serde(skip_serializing_if = "Option::is_none")]
         single_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container contains multiple windows (default: Base0B)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stack_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container is in monocle mode (default: Base0F)
+        #[serde(skip_serializing_if = "Option::is_none")]
         monocle_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the window is floating (default: Base09)
+        #[serde(skip_serializing_if = "Option::is_none")]
         floating_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container is unfocused (default: Base01)
+        #[serde(skip_serializing_if = "Option::is_none")]
         unfocused_border: Option<komorebi_themes::Base16Value>,
         /// Stackbar focused tab text colour (default: Base0B)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_focused_text: Option<komorebi_themes::Base16Value>,
         /// Stackbar unfocused tab text colour (default: Base05)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_unfocused_text: Option<komorebi_themes::Base16Value>,
         /// Stackbar tab background colour (default: Base01)
+        #[serde(skip_serializing_if = "Option::is_none")]
         stackbar_background: Option<komorebi_themes::Base16Value>,
         /// Komorebi status bar accent (default: Base0D)
+        #[serde(skip_serializing_if = "Option::is_none")]
         bar_accent: Option<komorebi_themes::Base16Value>,
     },
 }
@@ -518,31 +618,43 @@ impl StaticConfig {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct TabsConfig {
     /// Width of a stackbar tab
-    width: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub width: Option<i32>,
     /// Focused tab text colour
-    focused_text: Option<Colour>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub focused_text: Option<Colour>,
     /// Unfocused tab text colour
-    unfocused_text: Option<Colour>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub unfocused_text: Option<Colour>,
     /// Tab background colour
-    background: Option<Colour>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub background: Option<Colour>,
     /// Font family
-    font_family: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub font_family: Option<String>,
     /// Font size
-    font_size: Option<i32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub font_size: Option<i32>,
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct StackbarConfig {
     /// Stackbar height
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub height: Option<i32>,
     /// Stackbar label
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub label: Option<StackbarLabel>,
     /// Stackbar mode
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub mode: Option<StackbarMode>,
     /// Stackbar tab configuration options
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub tabs: Option<TabsConfig>,
 }
 
@@ -616,7 +728,17 @@ impl From<&WindowManager> for StaticConfig {
             border_overflow_applications: None,
             tray_and_multi_window_applications: None,
             layered_applications: None,
-            object_name_change_applications: None,
+            object_name_change_applications: Option::from(
+                OBJECT_NAME_CHANGE_ON_LAUNCH.lock().clone(),
+            ),
+            object_name_change_title_ignore_list: Option::from(
+                OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST
+                    .lock()
+                    .clone()
+                    .iter()
+                    .map(|r| r.to_string())
+                    .collect::<Vec<_>>(),
+            ),
             monitor_index_preferences: Option::from(MONITOR_INDEX_PREFERENCES.lock().clone()),
             display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.lock().clone()),
             stackbar: None,
@@ -627,6 +749,8 @@ impl From<&WindowManager> for StaticConfig {
             ),
             slow_application_identifiers: Option::from(SLOW_APPLICATION_IDENTIFIERS.lock().clone()),
             bar_configurations: None,
+            remove_titlebar_applications: Option::from(NO_TITLEBAR.lock().clone()),
+            floating_window_aspect_ratio: Option::from(*FLOATING_WINDOW_TOGGLE_ASPECT_RATIO.lock()),
         }
     }
 }
@@ -634,6 +758,10 @@ impl From<&WindowManager> for StaticConfig {
 impl StaticConfig {
     #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
     fn apply_globals(&mut self) -> Result<()> {
+        *FLOATING_WINDOW_TOGGLE_ASPECT_RATIO.lock() = self
+            .floating_window_aspect_ratio
+            .unwrap_or(AspectRatio::Predefined(PredefinedAspectRatio::Standard));
+
         if let Some(monitor_index_preferences) = &self.monitor_index_preferences {
             let mut preferences = MONITOR_INDEX_PREFERENCES.lock();
             preferences.clone_from(monitor_index_preferences);
@@ -769,10 +897,12 @@ impl StaticConfig {
         let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
         let mut tray_and_multi_window_identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
         let mut object_name_change_identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+        let mut object_name_change_title_ignore_list = OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST.lock();
         let mut layered_identifiers = LAYERED_WHITELIST.lock();
         let mut transparency_blacklist = TRANSPARENCY_BLACKLIST.lock();
         let mut slow_application_identifiers = SLOW_APPLICATION_IDENTIFIERS.lock();
         let mut floating_applications = FLOATING_APPLICATIONS.lock();
+        let mut no_titlebar_applications = NO_TITLEBAR.lock();
 
         if let Some(rules) = &mut self.ignore_rules {
             populate_rules(rules, &mut ignore_identifiers, &mut regex_identifiers)?;
@@ -794,6 +924,17 @@ impl StaticConfig {
             )?;
         }
 
+        if let Some(regexes) = &mut self.object_name_change_title_ignore_list {
+            let mut updated = vec![];
+            for r in regexes {
+                if let Ok(regex) = Regex::new(r) {
+                    updated.push(regex);
+                }
+            }
+
+            *object_name_change_title_ignore_list = updated;
+        }
+
         if let Some(rules) = &mut self.layered_applications {
             populate_rules(rules, &mut layered_identifiers, &mut regex_identifiers)?;
         }
@@ -818,6 +959,10 @@ impl StaticConfig {
             )?;
         }
 
+        if let Some(rules) = &mut self.remove_titlebar_applications {
+            populate_rules(rules, &mut no_titlebar_applications, &mut regex_identifiers)?;
+        }
+
         if let Some(stackbar) = &self.stackbar {
             if let Some(height) = &stackbar.height {
                 STACKBAR_TAB_HEIGHT.store(*height, Ordering::SeqCst);
@@ -999,6 +1144,10 @@ impl StaticConfig {
         Ok(())
     }
 
+    pub fn read_raw(raw: &str) -> Result<Self> {
+        Ok(serde_json::from_str(raw)?)
+    }
+
     pub fn read(path: &PathBuf) -> Result<Self> {
         let content = std::fs::read_to_string(path)?;
         let mut value: Self = serde_json::from_str(&content)?;
@@ -1063,6 +1212,7 @@ impl StaticConfig {
 
         let mut wm = WindowManager {
             monitors: Ring::default(),
+            monitor_usr_idx_map: HashMap::new(),
             incoming_events: incoming,
             command_listener: listener,
             is_paused: false,
@@ -1091,6 +1241,7 @@ impl StaticConfig {
             pending_move_op: Arc::new(None),
             already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
             uncloack_to_ignore: 0,
+            known_hwnds: HashMap::new(),
         };
 
         match value.focus_follows_mouse {
@@ -1124,32 +1275,82 @@ impl StaticConfig {
         let value = Self::read(path)?;
         let mut wm = wm.lock();
 
-        if let Some(monitors) = value.monitors {
-            for (i, monitor) in monitors.iter().enumerate() {
-                {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                    if let Some(device_id) = display_index_preferences.get(&i) {
-                        monitor_reconciliator::insert_in_monitor_cache(device_id, monitor.clone());
+        let configs_with_preference: Vec<_> =
+            DISPLAY_INDEX_PREFERENCES.lock().keys().copied().collect();
+        let mut configs_used = Vec::new();
+
+        let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+        workspace_matching_rules.clear();
+        drop(workspace_matching_rules);
+
+        let offset = wm.work_area_offset;
+        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
+            let preferred_config_idx = {
+                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
+                    (monitor
+                        .serial_number_id()
+                        .as_ref()
+                        .is_some_and(|sn| sn == id)
+                        || monitor.device_id() == id)
+                        .then_some(*c_idx)
+                });
+                c_idx
+            };
+            let idx = preferred_config_idx.or({
+                // Monitor without preferred config idx.
+                // Get index of first config that is not a preferred config of some other monitor
+                // and that has not been used yet. This might return `None` as well, in that case
+                // this monitor won't have a config tied to it and will use the default values.
+                let m_config_count = value
+                    .monitors
+                    .as_ref()
+                    .map(|ms| ms.len())
+                    .unwrap_or_default();
+                (0..m_config_count)
+                    .find(|i| !configs_with_preference.contains(i) && !configs_used.contains(i))
+            });
+            if let Some(monitor_config) = value
+                .monitors
+                .as_ref()
+                .and_then(|ms| idx.and_then(|i| ms.get(i)))
+            {
+                if let Some(used_config_idx) = idx {
+                    configs_used.push(used_config_idx);
+                }
+
+                monitor.ensure_workspace_count(monitor_config.workspaces.len());
+                monitor.set_work_area_offset(monitor_config.work_area_offset);
+                monitor.set_window_based_work_area_offset(
+                    monitor_config.window_based_work_area_offset,
+                );
+                monitor.set_window_based_work_area_offset_limit(
+                    monitor_config
+                        .window_based_work_area_offset_limit
+                        .unwrap_or(1),
+                );
+                monitor.set_container_padding(monitor_config.container_padding);
+                monitor.set_workspace_padding(monitor_config.workspace_padding);
+
+                monitor.update_workspaces_globals(offset);
+                for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
+                    if let Some(workspace_config) = monitor_config.workspaces.get(j) {
+                        ws.load_static_config(workspace_config)?;
                     }
                 }
 
-                if let Some(m) = wm.monitors_mut().get_mut(i) {
-                    m.ensure_workspace_count(monitor.workspaces.len());
-                    m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );
-
-                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
-                    }
+                // Check if this monitor config is the preferred config for this monitor and store
+                // a copy of the monitor itself on the monitor cache if it is.
+                if idx == preferred_config_idx {
+                    let id = monitor
+                        .serial_number_id()
+                        .as_ref()
+                        .map_or(monitor.device_id(), |sn| sn);
+                    monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
                 }
 
                 let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                for (j, ws) in monitor.workspaces.iter().enumerate() {
+                for (j, ws) in monitor_config.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {
                             workspace_matching_rules.push(WorkspaceMatchingRule {
@@ -1175,6 +1376,60 @@ impl StaticConfig {
             }
         }
 
+        // Check for configs that should be tied to a specific display that isn't loaded right now
+        // and cache a monitor with those configs with the specific `serial_number_id` so that when
+        // those devices are connected later we can use the correct config from the cache.
+        if configs_with_preference.len() > configs_used.len() {
+            for i in configs_with_preference
+                .iter()
+                .filter(|i| !configs_used.contains(i))
+            {
+                let id = {
+                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                    display_index_preferences.get(i).cloned()
+                };
+                if let (Some(id), Some(monitor_config)) =
+                    (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
+                {
+                    // The name, device, device_id and serial_number_id can be empty here since
+                    // once the monitor with this preferred index actually connects the
+                    // `load_monitor_information` function will update these fields.
+                    let mut m = monitor::new(
+                        0,
+                        Rect::default(),
+                        Rect::default(),
+                        "".into(),
+                        "".into(),
+                        "".into(),
+                        None,
+                    );
+
+                    m.ensure_workspace_count(monitor_config.workspaces.len());
+                    m.set_work_area_offset(monitor_config.work_area_offset);
+                    m.set_window_based_work_area_offset(
+                        monitor_config.window_based_work_area_offset,
+                    );
+                    m.set_window_based_work_area_offset_limit(
+                        monitor_config
+                            .window_based_work_area_offset_limit
+                            .unwrap_or(1),
+                    );
+                    m.set_container_padding(monitor_config.container_padding);
+                    m.set_workspace_padding(monitor_config.workspace_padding);
+
+                    m.update_workspaces_globals(offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        if let Some(workspace_config) = monitor_config.workspaces.get(j) {
+                            ws.load_static_config(workspace_config)?;
+                        }
+                    }
+
+                    monitor_reconciliator::insert_in_monitor_cache(&id, m);
+                }
+            }
+        }
+
         wm.enforce_workspace_rules()?;
 
         if value.border == Some(true) {
@@ -1189,28 +1444,85 @@ impl StaticConfig {
 
         value.apply_globals()?;
 
-        if let Some(monitors) = value.monitors {
-            for (i, monitor) in monitors.iter().enumerate() {
-                if let Some(m) = wm.monitors_mut().get_mut(i) {
-                    m.ensure_workspace_count(monitor.workspaces.len());
-                    if m.work_area_offset().is_none() {
-                        m.set_work_area_offset(monitor.work_area_offset);
-                    }
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );
+        let configs_with_preference: Vec<_> =
+            DISPLAY_INDEX_PREFERENCES.lock().keys().copied().collect();
+        let mut configs_used = Vec::new();
 
-                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
+        let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+        workspace_matching_rules.clear();
+        drop(workspace_matching_rules);
+
+        let offset = wm.work_area_offset;
+        for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
+            let preferred_config_idx = {
+                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
+                    (monitor
+                        .serial_number_id()
+                        .as_ref()
+                        .is_some_and(|sn| sn == id)
+                        || monitor.device_id() == id)
+                        .then_some(*c_idx)
+                });
+                c_idx
+            };
+            let idx = preferred_config_idx.or({
+                // Monitor without preferred config idx.
+                // Get index of first config that is not a preferred config of some other monitor
+                // and that has not been used yet. This might return `None` as well, in that case
+                // this monitor won't have a config tied to it and will use the default values.
+                let m_config_count = value
+                    .monitors
+                    .as_ref()
+                    .map(|ms| ms.len())
+                    .unwrap_or_default();
+                (0..m_config_count)
+                    .find(|i| !configs_with_preference.contains(i) && !configs_used.contains(i))
+            });
+            if let Some(monitor_config) = value
+                .monitors
+                .as_ref()
+                .and_then(|ms| idx.and_then(|i| ms.get(i)))
+            {
+                if let Some(used_config_idx) = idx {
+                    configs_used.push(used_config_idx);
+                }
+
+                monitor.ensure_workspace_count(monitor_config.workspaces.len());
+                if monitor.work_area_offset().is_none() {
+                    monitor.set_work_area_offset(monitor_config.work_area_offset);
+                }
+                monitor.set_window_based_work_area_offset(
+                    monitor_config.window_based_work_area_offset,
+                );
+                monitor.set_window_based_work_area_offset_limit(
+                    monitor_config
+                        .window_based_work_area_offset_limit
+                        .unwrap_or(1),
+                );
+                monitor.set_container_padding(monitor_config.container_padding);
+                monitor.set_workspace_padding(monitor_config.workspace_padding);
+
+                monitor.update_workspaces_globals(offset);
+
+                for (j, ws) in monitor.workspaces_mut().iter_mut().enumerate() {
+                    if let Some(workspace_config) = monitor_config.workspaces.get(j) {
+                        ws.load_static_config(workspace_config)?;
                     }
                 }
 
+                // Check if this monitor config is the preferred config for this monitor and store
+                // a copy of the monitor itself on the monitor cache if it is.
+                if idx == preferred_config_idx {
+                    let id = monitor
+                        .serial_number_id()
+                        .as_ref()
+                        .map_or(monitor.device_id(), |sn| sn);
+                    monitor_reconciliator::insert_in_monitor_cache(id, monitor.clone());
+                }
+
                 let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                workspace_matching_rules.clear();
-                for (j, ws) in monitor.workspaces.iter().enumerate() {
+                for (j, ws) in monitor_config.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {
                             workspace_matching_rules.push(WorkspaceMatchingRule {
@@ -1236,6 +1548,60 @@ impl StaticConfig {
             }
         }
 
+        // Check for configs that should be tied to a specific display that isn't loaded right now
+        // and cache a monitor with those configs with the specific `serial_number_id` so that when
+        // those devices are connected later we can use the correct config from the cache.
+        if configs_with_preference.len() > configs_used.len() {
+            for i in configs_with_preference
+                .iter()
+                .filter(|i| !configs_used.contains(i))
+            {
+                let id = {
+                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                    display_index_preferences.get(i).cloned()
+                };
+                if let (Some(id), Some(monitor_config)) =
+                    (id, value.monitors.as_ref().and_then(|ms| ms.get(*i)))
+                {
+                    // The name, device, device_id and serial_number_id can be empty here since
+                    // once the monitor with this preferred index actually connects the
+                    // `load_monitor_information` function will update these fields.
+                    let mut m = monitor::new(
+                        0,
+                        Rect::default(),
+                        Rect::default(),
+                        "".into(),
+                        "".into(),
+                        "".into(),
+                        None,
+                    );
+
+                    m.ensure_workspace_count(monitor_config.workspaces.len());
+                    m.set_work_area_offset(monitor_config.work_area_offset);
+                    m.set_window_based_work_area_offset(
+                        monitor_config.window_based_work_area_offset,
+                    );
+                    m.set_window_based_work_area_offset_limit(
+                        monitor_config
+                            .window_based_work_area_offset_limit
+                            .unwrap_or(1),
+                    );
+                    m.set_container_padding(monitor_config.container_padding);
+                    m.set_workspace_padding(monitor_config.workspace_padding);
+
+                    m.update_workspaces_globals(offset);
+
+                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
+                        if let Some(workspace_config) = monitor_config.workspaces.get(j) {
+                            ws.load_static_config(workspace_config)?;
+                        }
+                    }
+
+                    monitor_reconciliator::insert_in_monitor_cache(&id, m);
+                }
+            }
+        }
+
         wm.enforce_workspace_rules()?;
 
         if let Some(enabled) = value.border {

komorebi/src/window.rs

@@ -11,12 +11,42 @@ use crate::animation::ANIMATION_MANAGER;
 use crate::animation::ANIMATION_STYLE_GLOBAL;
 use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
 use crate::com::SetCloak;
+use crate::core::config_generation::IdWithIdentifier;
+use crate::core::config_generation::MatchingRule;
+use crate::core::config_generation::MatchingStrategy;
+use crate::core::ApplicationIdentifier;
+use crate::core::HidingBehaviour;
+use crate::core::Rect;
 use crate::focus_manager;
 use crate::stackbar_manager;
+use crate::styles::ExtendedWindowStyle;
+use crate::styles::WindowStyle;
+use crate::transparency_manager;
+use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api;
+use crate::windows_api::WindowsApi;
 use crate::AnimationStyle;
+use crate::FLOATING_APPLICATIONS;
+use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
+use crate::HIDDEN_HWNDS;
+use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
+use crate::LAYERED_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;
+use crate::NO_TITLEBAR;
+use crate::PERMAIGNORE_CLASSES;
+use crate::REGEX_IDENTIFIERS;
 use crate::SLOW_APPLICATION_COMPENSATION_TIME;
 use crate::SLOW_APPLICATION_IDENTIFIERS;
+use crate::WSL2_UI_PROCESSES;
+use color_eyre::eyre;
+use color_eyre::Result;
+use crossbeam_utils::atomic::AtomicConsume;
+use regex::Regex;
+use serde::ser::SerializeStruct;
+use serde::Deserialize;
+use serde::Serialize;
+use serde::Serializer;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
@@ -26,45 +56,15 @@ use std::sync::atomic::AtomicI32;
 use std::sync::atomic::Ordering;
 use std::thread;
 use std::time::Duration;
-
-use crate::core::config_generation::IdWithIdentifier;
-use crate::core::config_generation::MatchingRule;
-use crate::core::config_generation::MatchingStrategy;
-use color_eyre::eyre;
-use color_eyre::Result;
-use crossbeam_utils::atomic::AtomicConsume;
-use regex::Regex;
-use schemars::JsonSchema;
-use serde::ser::SerializeStruct;
-use serde::Deserialize;
-use serde::Serialize;
-use serde::Serializer;
+use strum::Display;
+use strum::EnumString;
 use windows::Win32::Foundation::HWND;
 
-use crate::core::ApplicationIdentifier;
-use crate::core::HidingBehaviour;
-use crate::core::Rect;
-
-use crate::styles::ExtendedWindowStyle;
-use crate::styles::WindowStyle;
-use crate::transparency_manager;
-use crate::window_manager_event::WindowManagerEvent;
-use crate::windows_api::WindowsApi;
-use crate::FLOATING_APPLICATIONS;
-use crate::HIDDEN_HWNDS;
-use crate::HIDING_BEHAVIOUR;
-use crate::IGNORE_IDENTIFIERS;
-use crate::LAYERED_WHITELIST;
-use crate::MANAGE_IDENTIFIERS;
-use crate::NO_TITLEBAR;
-use crate::PERMAIGNORE_CLASSES;
-use crate::REGEX_IDENTIFIERS;
-use crate::WSL2_UI_PROCESSES;
-
 pub static MINIMUM_WIDTH: AtomicI32 = AtomicI32::new(0);
 pub static MINIMUM_HEIGHT: AtomicI32 = AtomicI32::new(0);
 
-#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct Window {
     pub hwnd: isize,
 }
@@ -84,7 +84,8 @@ impl From<HWND> for Window {
 }
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, Clone, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub struct WindowDetails {
     pub title: String,
     pub exe: String,
@@ -296,6 +297,47 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
     }
 }
 
+#[derive(Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+pub enum AspectRatio {
+    /// A predefined aspect ratio
+    Predefined(PredefinedAspectRatio),
+    /// A custom W:H aspect ratio
+    Custom(i32, i32),
+}
+
+impl Default for AspectRatio {
+    fn default() -> Self {
+        AspectRatio::Predefined(PredefinedAspectRatio::default())
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default, Display, EnumString, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub enum PredefinedAspectRatio {
+    /// 21:9
+    Ultrawide,
+    /// 16:9
+    Widescreen,
+    /// 4:3
+    #[default]
+    Standard,
+}
+
+impl AspectRatio {
+    pub fn width_and_height(self) -> (i32, i32) {
+        match self {
+            AspectRatio::Predefined(predefined) => match predefined {
+                PredefinedAspectRatio::Ultrawide => (21, 9),
+                PredefinedAspectRatio::Widescreen => (16, 9),
+                PredefinedAspectRatio::Standard => (4, 3),
+            },
+            AspectRatio::Custom(w, h) => (w, h),
+        }
+    }
+}
+
 impl Window {
     pub const fn hwnd(self) -> HWND {
         HWND(windows_api::as_ptr!(self.hwnd))
@@ -369,15 +411,21 @@ impl Window {
     }
 
     pub fn center(&mut self, work_area: &Rect) -> Result<()> {
-        let half_width = work_area.right / 2;
-        let half_weight = work_area.bottom / 2;
+        let (aspect_ratio_width, aspect_ratio_height) = FLOATING_WINDOW_TOGGLE_ASPECT_RATIO
+            .lock()
+            .width_and_height();
+        let target_height = work_area.bottom / 2;
+        let target_width = (target_height * aspect_ratio_width) / aspect_ratio_height;
+
+        let x = work_area.left + ((work_area.right - target_width) / 2);
+        let y = work_area.top + ((work_area.bottom - target_height) / 2);
 
         self.set_position(
             &Rect {
-                left: work_area.left + ((work_area.right - half_width) / 2),
-                top: work_area.top + ((work_area.bottom - half_weight) / 2),
-                right: half_width,
-                bottom: half_weight,
+                left: x,
+                top: y,
+                right: target_width,
+                bottom: target_height,
             },
             true,
         )
@@ -684,6 +732,30 @@ impl Window {
         self.update_style(&style)
     }
 
+    /// Raise the window to the top of the Z order, but do not activate or focus
+    /// it. Use raise_and_focus_window to activate and focus a window.
+    /// It also checks if there is a border attached to this window and if it is
+    /// it raises it as well.
+    pub fn raise(self) -> Result<()> {
+        WindowsApi::raise_window(self.hwnd)?;
+        if let Some(border) = crate::border_manager::window_border(self.hwnd) {
+            WindowsApi::raise_window(border.hwnd)?;
+        }
+        Ok(())
+    }
+
+    /// Lower the window to the bottom of the Z order, but do not activate or focus
+    /// it.
+    /// It also checks if there is a border attached to this window and if it is
+    /// it lowers it as well.
+    pub fn lower(self) -> Result<()> {
+        WindowsApi::lower_window(self.hwnd)?;
+        if let Some(border) = crate::border_manager::window_border(self.hwnd) {
+            WindowsApi::lower_window(border.hwnd)?;
+        }
+        Ok(())
+    }
+
     #[tracing::instrument(fields(exe, title), skip(debug))]
     pub fn should_manage(
         self,
@@ -784,7 +856,7 @@ pub struct RuleDebug {
     pub matches_layered_whitelist: Option<MatchingRule>,
     pub matches_floating_applications: Option<MatchingRule>,
     pub matches_wsl2_gui: Option<String>,
-    pub matches_no_titlebar: Option<String>,
+    pub matches_no_titlebar: Option<MatchingRule>,
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -872,7 +944,11 @@ fn window_is_eligible(
 
     let known_layered_hwnds = transparency_manager::known_hwnds();
 
-    allow_layered = if known_layered_hwnds.contains(&hwnd) {
+    allow_layered = if known_layered_hwnds.contains(&hwnd)
+        // we always want to process hide events for windows with transparency, even on other
+        // monitors, because we don't want to be left with ghost tiles
+        || matches!(event, Some(WindowManagerEvent::Hide(_, _)))
+    {
         debug.allow_layered_transparency = true;
         true
     } else {
@@ -889,9 +965,19 @@ fn window_is_eligible(
         allow
     };
 
-    let allow_titlebar_removed = {
-        let titlebars_removed = NO_TITLEBAR.lock();
-        titlebars_removed.contains(exe_name)
+    let titlebars_removed = NO_TITLEBAR.lock();
+    let allow_titlebar_removed = if let Some(rule) = should_act(
+        title,
+        exe_name,
+        class,
+        path,
+        &titlebars_removed,
+        &regex_identifiers,
+    ) {
+        debug.matches_no_titlebar = Some(rule);
+        true
+    } else {
+        false
     };
 
     {
@@ -914,12 +1000,12 @@ fn window_is_eligible(
     }
 
     if (allow_wsl2_gui || allow_titlebar_removed || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))
-                        && !ex_style.contains(ExtendedWindowStyle::DLGMODALFRAME)
-                        // Get a lot of dupe events coming through that make the redrawing go crazy
-                        // on FocusChange events if I don't filter out this one. But, if we are
-                        // allowing a specific layered window on the whitelist (like Steam), it should
-                        // pass this check
-                        && (allow_layered || !ex_style.contains(ExtendedWindowStyle::LAYERED))
+        && !ex_style.contains(ExtendedWindowStyle::DLGMODALFRAME)
+        // Get a lot of dupe events coming through that make the redrawing go crazy
+        // on FocusChange events if I don't filter out this one. But, if we are
+        // allowing a specific layered window on the whitelist (like Steam), it should
+        // pass this check
+        && (allow_layered || !ex_style.contains(ExtendedWindowStyle::LAYERED))
         || managed_override
     {
         return true;

komorebi/src/window_manager_event.rs

@@ -1,7 +1,6 @@
 use std::fmt::Display;
 use std::fmt::Formatter;
 
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -9,9 +8,11 @@ use crate::window::should_act;
 use crate::window::Window;
 use crate::winevent::WinEvent;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+use crate::OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST;
 use crate::REGEX_IDENTIFIERS;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "type", content = "content")]
 pub enum WindowManagerEvent {
     Destroy(WinEvent, Window),
@@ -176,6 +177,8 @@ impl WindowManagerEvent {
                 // [yatta\src\windows_event.rs:110] event = 32779 ObjectLocationChange
 
                 let object_name_change_on_launch = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+                let object_name_change_title_ignore_list =
+                    OBJECT_NAME_CHANGE_TITLE_IGNORE_LIST.lock();
                 let regex_identifiers = REGEX_IDENTIFIERS.lock();
 
                 let title = &window.title().ok()?;
@@ -183,7 +186,7 @@ impl WindowManagerEvent {
                 let class = &window.class().ok()?;
                 let path = &window.path().ok()?;
 
-                let should_trigger_show = should_act(
+                let mut should_trigger_show = should_act(
                     title,
                     exe_name,
                     class,
@@ -193,6 +196,14 @@ impl WindowManagerEvent {
                 )
                 .is_some();
 
+                if should_trigger_show {
+                    for r in &*object_name_change_title_ignore_list {
+                        if r.is_match(title) {
+                            should_trigger_show = false;
+                        }
+                    }
+                }
+
                 // should not trigger show on minimized windows, for example when firefox sends
                 // this message due to youtube autoplay changing the window title
                 // https://github.com/LGUG2Z/komorebi/issues/941

komorebi/src/windows_api.rs

@@ -1,6 +1,7 @@
+use core::ffi::c_void;
+use std::collections::HashMap;
 use std::collections::VecDeque;
 use std::convert::TryFrom;
-use std::ffi::c_void;
 use std::mem::size_of;
 
 use color_eyre::eyre::anyhow;
@@ -11,7 +12,6 @@ use windows::core::Result as WindowsCrateResult;
 use windows::core::PCWSTR;
 use windows::core::PWSTR;
 use windows::Win32::Foundation::CloseHandle;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HANDLE;
 use windows::Win32::Foundation::HINSTANCE;
@@ -48,6 +48,8 @@ use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
 use windows::Win32::Graphics::Gdi::MONITORINFOEXW;
 use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
 use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::System::Power::RegisterPowerSettingNotification;
+use windows::Win32::System::Power::HPOWERNOTIFY;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
 use windows::Win32::System::RemoteDesktop::WTSRegisterSessionNotification;
 use windows::Win32::System::Threading::GetCurrentProcessId;
@@ -92,6 +94,7 @@ use windows::Win32::UI::WindowsAndMessaging::MoveWindow;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
+use windows::Win32::UI::WindowsAndMessaging::RegisterDeviceNotificationW;
 use windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
 use windows::Win32::UI::WindowsAndMessaging::SetLayeredWindowAttributes;
@@ -101,11 +104,15 @@ use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
 use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
 use windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT;
+use windows::Win32::UI::WindowsAndMessaging::DEV_BROADCAST_DEVICEINTERFACE_W;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
+use windows::Win32::UI::WindowsAndMessaging::HDEVNOTIFY;
+use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
 use windows::Win32::UI::WindowsAndMessaging::HWND_TOP;
 use windows::Win32::UI::WindowsAndMessaging::LWA_ALPHA;
+use windows::Win32::UI::WindowsAndMessaging::REGISTER_NOTIFICATION_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
@@ -133,6 +140,7 @@ use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
 use windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;
+use windows_core::BOOL;
 
 use crate::core::Rect;
 
@@ -143,6 +151,7 @@ use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
 use crate::Window;
+use crate::WindowManager;
 use crate::DISPLAY_INDEX_PREFERENCES;
 use crate::MONITOR_INDEX_PREFERENCES;
 
@@ -228,16 +237,9 @@ impl WindowsApi {
         callback: MONITORENUMPROC,
         callback_data_address: isize,
     ) -> Result<()> {
-        unsafe {
-            EnumDisplayMonitors(
-                HDC(std::ptr::null_mut()),
-                None,
-                callback,
-                LPARAM(callback_data_address),
-            )
-        }
-        .ok()
-        .process()
+        unsafe { EnumDisplayMonitors(None, None, callback, LPARAM(callback_data_address)) }
+            .ok()
+            .process()
     }
 
     pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
@@ -252,7 +254,10 @@ impl WindowsApi {
             .collect::<Vec<_>>())
     }
 
-    pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
+    pub fn load_monitor_information(wm: &mut WindowManager) -> Result<()> {
+        let monitors = &mut wm.monitors;
+        let monitor_usr_idx_map = &mut wm.monitor_usr_idx_map;
+
         'read: for display in win32_display_data::connected_displays_all().flatten() {
             let path = display.device_path.clone();
 
@@ -283,6 +288,7 @@ impl WindowsApi {
                 name,
                 device,
                 device_id,
+                display.serial_number_id,
             );
 
             let mut index_preference = None;
@@ -295,7 +301,8 @@ impl WindowsApi {
 
             let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
             for (index, id) in &*display_index_preferences {
-                if id.eq(m.device_id()) {
+                if m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || id.eq(m.device_id())
+                {
                     index_preference = Option::from(index);
                 }
             }
@@ -324,6 +331,40 @@ impl WindowsApi {
             .elements_mut()
             .retain(|m| m.name().ne("PLACEHOLDER"));
 
+        // Rebuild monitor index map
+        *monitor_usr_idx_map = HashMap::new();
+        let mut added_monitor_idxs = Vec::new();
+        for (index, id) in &*DISPLAY_INDEX_PREFERENCES.lock() {
+            if let Some(m_idx) = monitors.elements().iter().position(|m| {
+                m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || m.device_id() == id
+            }) {
+                monitor_usr_idx_map.insert(*index, m_idx);
+                added_monitor_idxs.push(m_idx);
+            }
+        }
+
+        let max_usr_idx = monitors
+            .elements()
+            .len()
+            .max(monitor_usr_idx_map.keys().max().map_or(0, |v| *v));
+
+        let mut available_usr_idxs = (0..max_usr_idx)
+            .filter(|i| !monitor_usr_idx_map.contains_key(i))
+            .collect::<Vec<_>>();
+
+        let not_added_monitor_idxs = (0..monitors.elements().len())
+            .filter(|i| !added_monitor_idxs.contains(i))
+            .collect::<Vec<_>>();
+
+        for i in not_added_monitor_idxs {
+            if let Some(next_usr_idx) = available_usr_idxs.first() {
+                monitor_usr_idx_map.insert(*next_usr_idx, i);
+                available_usr_idxs.remove(0);
+            } else if let Some(idx) = monitor_usr_idx_map.keys().max() {
+                monitor_usr_idx_map.insert(*idx, i);
+            }
+        }
+
         Ok(())
     }
 
@@ -437,10 +478,13 @@ impl WindowsApi {
         unsafe { BringWindowToTop(HWND(as_ptr!(hwnd))) }.process()
     }
 
-    // Raise the window to the top of the Z order, but do not activate or focus
-    // it. Use raise_and_focus_window to activate and focus a window.
+    /// Raise the window to the top of the Z order, but do not activate or focus
+    /// it. Use raise_and_focus_window to activate and focus a window.
     pub fn raise_window(hwnd: isize) -> Result<()> {
-        let flags = SetWindowPosition::NO_MOVE | SetWindowPosition::NO_ACTIVATE;
+        let flags = SetWindowPosition::NO_MOVE
+            | SetWindowPosition::NO_SIZE
+            | SetWindowPosition::NO_ACTIVATE
+            | SetWindowPosition::SHOW_WINDOW;
 
         let position = HWND_TOP;
         Self::set_window_pos(
@@ -451,6 +495,23 @@ impl WindowsApi {
         )
     }
 
+    /// Lower the window to the bottom of the Z order, but do not activate or focus
+    /// it.
+    pub fn lower_window(hwnd: isize) -> Result<()> {
+        let flags = SetWindowPosition::NO_MOVE
+            | SetWindowPosition::NO_SIZE
+            | SetWindowPosition::NO_ACTIVATE
+            | SetWindowPosition::SHOW_WINDOW;
+
+        let position = HWND_BOTTOM;
+        Self::set_window_pos(
+            HWND(as_ptr!(hwnd)),
+            &Rect::default(),
+            position,
+            flags.bits(),
+        )
+    }
+
     pub fn set_border_pos(hwnd: isize, layout: &Rect, position: isize) -> Result<()> {
         let flags = {
             SetWindowPosition::NO_SEND_CHANGING
@@ -472,7 +533,7 @@ impl WindowsApi {
         unsafe {
             SetWindowPos(
                 hwnd,
-                position,
+                Option::from(position),
                 layout.left,
                 layout.top,
                 layout.right,
@@ -510,7 +571,7 @@ impl WindowsApi {
     }
 
     fn post_message(hwnd: HWND, message: u32, wparam: WPARAM, lparam: LPARAM) -> Result<()> {
-        unsafe { PostMessageW(hwnd, message, wparam, lparam) }.process()
+        unsafe { PostMessageW(Option::from(hwnd), message, wparam, lparam) }.process()
     }
 
     pub fn close_window(hwnd: isize) -> Result<()> {
@@ -553,7 +614,7 @@ impl WindowsApi {
             // Error ignored, as the operation is not always necessary.
             let _ = SetWindowPos(
                 HWND(as_ptr!(hwnd)),
-                HWND_TOP,
+                Option::from(HWND_TOP),
                 0,
                 0,
                 0,
@@ -569,7 +630,7 @@ impl WindowsApi {
 
     #[allow(dead_code)]
     pub fn top_window() -> Result<isize> {
-        unsafe { GetTopWindow(HWND::default())? }.process()
+        unsafe { GetTopWindow(None)? }.process()
     }
 
     pub fn desktop_window() -> Result<isize> {
@@ -885,7 +946,7 @@ impl WindowsApi {
     }
 
     pub fn is_window(hwnd: isize) -> bool {
-        unsafe { IsWindow(HWND(as_ptr!(hwnd))) }.into()
+        unsafe { IsWindow(Option::from(HWND(as_ptr!(hwnd)))) }.into()
     }
 
     pub fn is_window_visible(hwnd: isize) -> bool {
@@ -936,6 +997,7 @@ impl WindowsApi {
                     name,
                     device,
                     device_id,
+                    display.serial_number_id,
                 );
 
                 return Ok(monitor);
@@ -1112,7 +1174,7 @@ impl WindowsApi {
                 CW_USEDEFAULT,
                 None,
                 None,
-                HINSTANCE(as_ptr!(instance)),
+                Option::from(HINSTANCE(as_ptr!(instance))),
                 Some(border as _),
             )?
         }
@@ -1161,16 +1223,35 @@ impl WindowsApi {
                 CW_USEDEFAULT,
                 None,
                 None,
-                HINSTANCE(as_ptr!(instance)),
+                Option::from(HINSTANCE(as_ptr!(instance))),
                 None,
             )?
         }
         .process()
     }
 
+    pub fn register_power_setting_notification(
+        hwnd: isize,
+        guid: &windows_core::GUID,
+        flags: REGISTER_NOTIFICATION_FLAGS,
+    ) -> WindowsCrateResult<HPOWERNOTIFY> {
+        unsafe { RegisterPowerSettingNotification(HANDLE::from(HWND(as_ptr!(hwnd))), guid, flags) }
+    }
+
+    pub fn register_device_notification(
+        hwnd: isize,
+        mut filter: DEV_BROADCAST_DEVICEINTERFACE_W,
+        flags: REGISTER_NOTIFICATION_FLAGS,
+    ) -> WindowsCrateResult<HDEVNOTIFY> {
+        unsafe {
+            let state_ptr: *const c_void = &mut filter as *mut _ as *const c_void;
+            RegisterDeviceNotificationW(HANDLE::from(HWND(as_ptr!(hwnd))), state_ptr, flags)
+        }
+    }
+
     pub fn invalidate_rect(hwnd: isize, rect: Option<&Rect>, erase: bool) -> bool {
         let rect = rect.map(|rect| &rect.rect() as *const RECT);
-        unsafe { InvalidateRect(HWND(as_ptr!(hwnd)), rect, erase) }.as_bool()
+        unsafe { InvalidateRect(Option::from(HWND(as_ptr!(hwnd))), rect, erase) }.as_bool()
     }
 
     pub fn alt_is_pressed() -> bool {

komorebi/src/windows_callbacks.rs

@@ -8,7 +8,6 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::winevent_listener;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::WPARAM;
@@ -21,6 +20,7 @@ use windows::Win32::UI::WindowsAndMessaging::OBJID_WINDOW;
 use windows::Win32::UI::WindowsAndMessaging::WS_CHILD;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_NOACTIVATE;
 use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
+use windows_core::BOOL;
 
 pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let containers = unsafe { &mut *(lparam.0 as *mut VecDeque<Container>) };
@@ -115,6 +115,16 @@ pub extern "system" fn win_event_hook(
         }
     }
 
+    // sometimes the border focus state and colors don't get updated because this event comes too
+    // slow for the value of GetForegroundWindow to be up to date by the time it is inspected in
+    // the border manager to determine if a window show have its border show as "focused"
+    //
+    // so here we can just fire another event at the border manager when the system has finally
+    // registered the new foreground window and this time the correct border colors will be applied
+    if matches!(winevent, WinEvent::SystemForeground) && !has_filtered_style(hwnd) {
+        border_manager::send_notification(Some(hwnd.0 as isize));
+    }
+
     let event_type = match WindowManagerEvent::from_win_event(winevent, window) {
         None => {
             tracing::trace!(

komorebi/src/winevent.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::use_self)]
 
-use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
@@ -89,7 +88,8 @@ use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Display, JsonSchema)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Display)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {