chore(release): v0.1.34

Bumps [os_info](https://github.com/stanislav-tkach/os_info) from 3.9.2 to 3.10.0.
- [Release notes](https://github.com/stanislav-tkach/os_info/releases)
- [Changelog](https://github.com/stanislav-tkach/os_info/blob/master/CHANGELOG.md)
- [Commits](https://github.com/stanislav-tkach/os_info/compare/v3.9.2...v3.10.0)

---
updated-dependencies:
- dependency-name: os_info
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -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,6 +47,7 @@ jobs:
           key: ${{ matrix.platform.target }}
       - run: cargo +nightly fmt --check
       - run: cargo clippy
+      - run: cargo test --package komorebi --test compat
       - uses: houseabsolute/actions-rust-cross@v1
         with:
           command: "build"

Cargo.toml

@@ -19,7 +19,7 @@ crossbeam-utils = "0.8"
 color-eyre = "0.6"
 eframe = "0.30"
 egui_extras = "0.30"
-dirs = "5"
+dirs = "6"
 dunce = "1"
 hotwatch = "0.5"
 schemars = "0.8"
@@ -31,13 +31,13 @@ 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" }
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "75286e77c068a89d12adcd6404c9c4874a60acf5" }
 windows-implement = { version = "0.58" }
 windows-interface = { version = "0.58" }
 windows-core = { version = "0.58" }
-shadow-rs = "0.35"
+shadow-rs = "0.38"
 which = "7"
 
 [workspace.dependencies.windows]
@@ -48,6 +48,7 @@ features = [
     "Win32_System_Com",
     "Win32_UI_Shell_Common", # for IObjectArray
     "Win32_Foundation",
+    "Win32_Globalization",
     "Win32_Graphics_Dwm",
     "Win32_Graphics_Gdi",
     "Win32_Graphics_Direct2D",

README.md

@@ -389,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.31"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.34"}
 
 use anyhow::Result;
 use komorebi_client::Notification;

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-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-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/komorebi.bar.example.json

@@ -1,14 +1,6 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.31/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.31/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

@@ -24,6 +24,15 @@ install-target target:
 install:
     just install-targets 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 --release --package {{ target }} --locked
+
+build:
+    just build-targets komorebic komorebic-no-console komorebi komorebi-bar komorebi-gui
+
 run target:
     cargo +stable run --bin {{ target }} --locked
 

komorebi-bar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.32"
+version = "0.1.34"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -20,11 +20,12 @@ egui-phosphor = "0.8"
 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"] }
+reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

komorebi-bar/src/bar.rs

@@ -1,5 +1,7 @@
+use crate::config::get_individual_spacing;
 use crate::config::KomobarConfig;
 use crate::config::KomobarTheme;
+use crate::config::MonitorConfigOrIndex;
 use crate::config::Position;
 use crate::config::PositionConfig;
 use crate::komorebi::Komorebi;
@@ -11,12 +13,15 @@ use crate::render::RenderConfig;
 use crate::render::RenderExt;
 use crate::widget::BarWidget;
 use crate::widget::WidgetConfig;
+use crate::KomorebiEvent;
 use crate::BAR_HEIGHT;
+use crate::DEFAULT_PADDING;
 use crate::MAX_LABEL_WIDTH;
 use crate::MONITOR_LEFT;
 use crate::MONITOR_RIGHT;
 use crate::MONITOR_TOP;
 use crossbeam_channel::Receiver;
+use crossbeam_channel::TryRecvError;
 use eframe::egui::Align;
 use eframe::egui::Align2;
 use eframe::egui::Area;
@@ -34,33 +39,41 @@ use eframe::egui::Margin;
 use eframe::egui::Rgba;
 use eframe::egui::Style;
 use eframe::egui::TextStyle;
+use eframe::egui::Vec2;
 use eframe::egui::Visuals;
 use font_loader::system_fonts;
 use font_loader::system_fonts::FontPropertyBuilder;
 use komorebi_client::KomorebiTheme;
+use komorebi_client::MonitorNotification;
+use komorebi_client::NotificationEvent;
 use komorebi_client::SocketMessage;
 use komorebi_themes::catppuccin_egui;
 use komorebi_themes::Base16Value;
 use komorebi_themes::Catppuccin;
 use komorebi_themes::CatppuccinValue;
 use std::cell::RefCell;
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
 pub struct Komobar {
+    pub hwnd: Option<isize>,
+    pub monitor_index: usize,
     pub config: Arc<KomobarConfig>,
     pub render_config: Rc<RefCell<RenderConfig>>,
     pub komorebi_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
     pub left_widgets: Vec<Box<dyn BarWidget>>,
     pub center_widgets: Vec<Box<dyn BarWidget>>,
     pub right_widgets: Vec<Box<dyn BarWidget>>,
-    pub rx_gui: Receiver<komorebi_client::Notification>,
+    pub rx_gui: Receiver<KomorebiEvent>,
     pub rx_config: Receiver<KomobarConfig>,
     pub bg_color: Rc<RefCell<Color32>>,
     pub bg_color_with_alpha: Rc<RefCell<Color32>>,
     pub scale_factor: f32,
+    pub size_rect: komorebi_client::Rect,
+    pub work_area_offset: komorebi_client::Rect,
     applied_theme_on_first_frame: bool,
 }
 
@@ -194,49 +207,9 @@ impl Komobar {
             Self::add_custom_font(ctx, font_family);
         }
 
-        let position = config.position.clone().unwrap_or(PositionConfig {
-            start: Some(Position {
-                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
-                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
-            }),
-            end: Some(Position {
-                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
-                y: BAR_HEIGHT,
-            }),
-        });
-
-        if let Some(hwnd) = process_hwnd() {
-            let start = position.start.unwrap_or(Position {
-                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
-                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
-            });
-
-            let end = position.end.unwrap_or(Position {
-                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
-                y: BAR_HEIGHT,
-            });
-
-            if end.y == 0.0 {
-                tracing::warn!("position.end.y is set to 0.0 which will make your bar invisible on a config reload - this is usually set to 50.0 by default")
-            }
-
-            let rect = komorebi_client::Rect {
-                left: start.x as i32,
-                top: start.y as i32,
-                right: end.x as i32,
-                bottom: end.y as i32,
-            };
-
-            let window = komorebi_client::Window::from(hwnd);
-            match window.set_position(&rect, false) {
-                Ok(_) => {
-                    tracing::info!("updated bar position");
-                }
-                Err(error) => {
-                    tracing::error!("{}", error.to_string())
-                }
-            }
-        }
+        // Update the `size_rect` so that the bar position can be changed on the EGUI update
+        // function
+        self.update_size_rect(config);
 
         self.try_apply_theme(config, ctx);
 
@@ -307,7 +280,7 @@ impl Komobar {
                                 Some(widget.komorebi_notification_state.clone());
                         }
                         Some(ref previous) => {
-                            if widget.workspaces.map_or(false, |w| w.enable) {
+                            if widget.workspaces.is_some_and(|w| w.enable) {
                                 previous.borrow_mut().update_from_config(
                                     &widget.komorebi_notification_state.borrow(),
                                 );
@@ -332,23 +305,64 @@ impl Komobar {
         self.center_widgets = center_widgets;
         self.right_widgets = right_widgets;
 
-        if let (Some(prev_rect), Some(new_rect)) = (
-            &self.config.monitor.work_area_offset,
-            &config.monitor.work_area_offset,
-        ) {
+        let (monitor_index, config_work_area_offset) = match &config.monitor {
+            MonitorConfigOrIndex::MonitorConfig(monitor_config) => {
+                (monitor_config.index, monitor_config.work_area_offset)
+            }
+            MonitorConfigOrIndex::Index(idx) => (*idx, None),
+        };
+        self.monitor_index = monitor_index;
+
+        if let (prev_rect, Some(new_rect)) = (&self.work_area_offset, &config_work_area_offset) {
             if new_rect != prev_rect {
+                self.work_area_offset = *new_rect;
                 if let Err(error) = komorebi_client::send_message(
-                    &SocketMessage::MonitorWorkAreaOffset(config.monitor.index, *new_rect),
+                    &SocketMessage::MonitorWorkAreaOffset(self.monitor_index, *new_rect),
                 ) {
                     tracing::error!(
                         "error applying work area offset to monitor '{}': {}",
-                        config.monitor.index,
+                        self.monitor_index,
                         error,
                     );
                 } else {
                     tracing::info!(
                         "work area offset applied to monitor: {}",
-                        config.monitor.index
+                        self.monitor_index
+                    );
+                }
+            }
+        } else if let Some(height) = config.height.or(Some(BAR_HEIGHT)) {
+            // We only add the `bottom_margin` to the work_area_offset since the top margin is
+            // already considered on the `size_rect.top`
+            let bottom_margin = config
+                .margin
+                .as_ref()
+                .map_or(0, |v| v.to_individual(0.0).bottom as i32);
+            let new_rect = komorebi_client::Rect {
+                left: 0,
+                top: (height as i32)
+                    + (self.size_rect.top - MONITOR_TOP.load(Ordering::SeqCst))
+                    + bottom_margin,
+                right: 0,
+                bottom: (height as i32)
+                    + (self.size_rect.top - MONITOR_TOP.load(Ordering::SeqCst))
+                    + bottom_margin,
+            };
+
+            if new_rect != self.work_area_offset {
+                self.work_area_offset = new_rect;
+                if let Err(error) = komorebi_client::send_message(
+                    &SocketMessage::MonitorWorkAreaOffset(self.monitor_index, new_rect),
+                ) {
+                    tracing::error!(
+                        "error applying work area offset to monitor '{}': {}",
+                        self.monitor_index,
+                        error,
+                    );
+                } else {
+                    tracing::info!(
+                        "work area offset applied to monitor: {}",
+                        self.monitor_index
                     );
                 }
             }
@@ -361,6 +375,51 @@ impl Komobar {
         self.config = config.clone().into();
     }
 
+    /// Updates the `size_rect` field. Returns a bool indicating if the field was changed or not
+    fn update_size_rect(&mut self, config: &KomobarConfig) {
+        let position = config.position.clone().unwrap_or(PositionConfig {
+            start: Some(Position {
+                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
+                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
+            }),
+            end: Some(Position {
+                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
+                y: BAR_HEIGHT,
+            }),
+        });
+
+        let mut start = position.start.unwrap_or(Position {
+            x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
+            y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
+        });
+
+        let mut end = position.end.unwrap_or(Position {
+            x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
+            y: BAR_HEIGHT,
+        });
+
+        if let Some(height) = config.height {
+            end.y = height;
+        }
+
+        let margin = get_individual_spacing(0.0, &config.margin);
+
+        start.y += margin.top;
+        start.x += margin.left;
+        end.x -= margin.left + margin.right;
+
+        if end.y == 0.0 {
+            tracing::warn!("position.end.y is set to 0.0 which will make your bar invisible on a config reload - this is usually set to 50.0 by default")
+        }
+
+        self.size_rect = komorebi_client::Rect {
+            left: start.x as i32,
+            top: start.y as i32,
+            right: end.x as i32,
+            bottom: end.y as i32,
+        };
+    }
+
     fn try_apply_theme(&mut self, config: &KomobarConfig, ctx: &Context) {
         match config.theme {
             Some(theme) => {
@@ -449,11 +508,13 @@ impl Komobar {
 
     pub fn new(
         cc: &eframe::CreationContext<'_>,
-        rx_gui: Receiver<komorebi_client::Notification>,
+        rx_gui: Receiver<KomorebiEvent>,
         rx_config: Receiver<KomobarConfig>,
         config: Arc<KomobarConfig>,
     ) -> Self {
         let mut komobar = Self {
+            hwnd: process_hwnd(),
+            monitor_index: 0,
             config: config.clone(),
             render_config: Rc::new(RefCell::new(RenderConfig::new())),
             komorebi_notification_state: None,
@@ -465,6 +526,8 @@ impl Komobar {
             bg_color: Rc::new(RefCell::new(Style::default().visuals.panel_fill)),
             bg_color_with_alpha: Rc::new(RefCell::new(Style::default().visuals.panel_fill)),
             scale_factor: cc.egui_ctx.native_pixels_per_point().unwrap_or(1.0),
+            size_rect: komorebi_client::Rect::default(),
+            work_area_offset: komorebi_client::Rect::default(),
             applied_theme_on_first_frame: false,
         };
 
@@ -504,6 +567,28 @@ impl Komobar {
         let mut fonts = FontDefinitions::default();
         egui_phosphor::add_to_fonts(&mut fonts, egui_phosphor::Variant::Regular);
 
+        let mut fallbacks = HashMap::new();
+
+        fallbacks.insert("Microsoft YaHei", "C:\\Windows\\Fonts\\msyh.ttc"); // chinese
+        fallbacks.insert("Malgun Gothic", "C:\\Windows\\Fonts\\malgun.ttf"); // korean
+        fallbacks.insert("Leelawadee UI", "C:\\Windows\\Fonts\\LeelawUI.ttf"); // thai
+
+        for (name, path) in fallbacks {
+            if let Ok(bytes) = std::fs::read(path) {
+                fonts
+                    .font_data
+                    .insert(name.to_owned(), Arc::from(FontData::from_owned(bytes)));
+
+                for family in [FontFamily::Proportional, FontFamily::Monospace] {
+                    fonts
+                        .families
+                        .entry(family)
+                        .or_default()
+                        .insert(0, name.to_owned());
+                }
+            }
+        }
+
         let property = FontPropertyBuilder::new().family(name).build();
 
         if let Some((font, _)) = system_fonts::get(&property) {
@@ -511,21 +596,17 @@ impl Komobar {
                 .font_data
                 .insert(name.to_owned(), Arc::new(FontData::from_owned(font)));
 
-            fonts
-                .families
-                .entry(FontFamily::Proportional)
-                .or_default()
-                .insert(0, name.to_owned());
-
-            fonts
-                .families
-                .entry(FontFamily::Monospace)
-                .or_default()
-                .push(name.to_owned());
-
-            // Tell egui to use these fonts:
-            ctx.set_fonts(fonts);
+            for family in [FontFamily::Proportional, FontFamily::Monospace] {
+                fonts
+                    .families
+                    .entry(family)
+                    .or_default()
+                    .insert(0, name.to_owned());
+            }
         }
+
+        // Tell egui to use these fonts:
+        ctx.set_fonts(fonts);
     }
 }
 impl eframe::App for Komobar {
@@ -535,6 +616,10 @@ impl eframe::App for Komobar {
     }
 
     fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
+        if self.hwnd.is_none() {
+            self.hwnd = process_hwnd();
+        }
+
         if self.scale_factor != ctx.native_pixels_per_point().unwrap_or(1.0) {
             self.scale_factor = ctx.native_pixels_per_point().unwrap_or(1.0);
             self.apply_config(
@@ -552,20 +637,86 @@ impl eframe::App for Komobar {
             );
         }
 
-        if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
-            komorebi_notification_state
-                .borrow_mut()
-                .handle_notification(
-                    ctx,
-                    self.config.monitor.index,
-                    self.rx_gui.clone(),
-                    self.bg_color.clone(),
-                    self.bg_color_with_alpha.clone(),
-                    self.config.transparency_alpha,
-                    self.config.grouping,
-                    self.config.theme,
-                    self.render_config.clone(),
-                );
+        match self.rx_gui.try_recv() {
+            Err(error) => match error {
+                TryRecvError::Empty => {}
+                TryRecvError::Disconnected => {
+                    tracing::error!(
+                        "failed to receive komorebi notification on gui thread: {error}"
+                    );
+                }
+            },
+            Ok(KomorebiEvent::Notification(notification)) => {
+                let should_apply_config = if matches!(
+                    notification.event,
+                    NotificationEvent::Monitor(MonitorNotification::DisplayConnectionChange)
+                ) {
+                    let state = &notification.state;
+
+                    // Store the monitor coordinates in case they've changed
+                    MONITOR_RIGHT.store(
+                        state.monitors.elements()[self.monitor_index].size().right,
+                        Ordering::SeqCst,
+                    );
+
+                    MONITOR_TOP.store(
+                        state.monitors.elements()[self.monitor_index].size().top,
+                        Ordering::SeqCst,
+                    );
+
+                    MONITOR_LEFT.store(
+                        state.monitors.elements()[self.monitor_index].size().left,
+                        Ordering::SeqCst,
+                    );
+
+                    true
+                } else {
+                    false
+                };
+
+                if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
+                    komorebi_notification_state
+                        .borrow_mut()
+                        .handle_notification(
+                            ctx,
+                            self.monitor_index,
+                            notification,
+                            self.bg_color.clone(),
+                            self.bg_color_with_alpha.clone(),
+                            self.config.transparency_alpha,
+                            self.config.grouping,
+                            self.config.theme,
+                            self.render_config.clone(),
+                        );
+                }
+
+                if should_apply_config {
+                    self.apply_config(
+                        ctx,
+                        &self.config.clone(),
+                        self.komorebi_notification_state.clone(),
+                    );
+                }
+            }
+            Ok(KomorebiEvent::Reconnect) => {
+                if let Err(error) =
+                    komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(
+                        self.monitor_index,
+                        self.work_area_offset,
+                    ))
+                {
+                    tracing::error!(
+                        "error applying work area offset to monitor '{}': {}",
+                        self.monitor_index,
+                        error,
+                    );
+                } else {
+                    tracing::info!(
+                        "work area offset applied to monitor: {}",
+                        self.monitor_index
+                    );
+                }
+            }
         }
 
         if !self.applied_theme_on_first_frame {
@@ -573,40 +724,103 @@ impl eframe::App for Komobar {
             self.applied_theme_on_first_frame = true;
         }
 
-        let frame = if let Some(frame) = &self.config.frame {
-            Frame::none()
-                .inner_margin(Margin::symmetric(
-                    frame.inner_margin.x,
-                    frame.inner_margin.y,
-                ))
-                .fill(*self.bg_color_with_alpha.borrow())
-        } else {
-            Frame::none().fill(*self.bg_color_with_alpha.borrow())
+        // Check if egui's Window size is the expected one, if not, update it
+        if let Some(current_rect) = ctx.input(|i| i.viewport().outer_rect) {
+            // Get the correct size according to scale factor
+            let current_rect = komorebi_client::Rect {
+                left: (current_rect.min.x * self.scale_factor) as i32,
+                top: (current_rect.min.y * self.scale_factor) as i32,
+                right: ((current_rect.max.x - current_rect.min.x) * self.scale_factor) as i32,
+                bottom: ((current_rect.max.y - current_rect.min.y) * self.scale_factor) as i32,
+            };
+
+            if self.size_rect != current_rect {
+                if let Some(hwnd) = self.hwnd {
+                    let window = komorebi_client::Window::from(hwnd);
+                    match window.set_position(&self.size_rect, false) {
+                        Ok(_) => {
+                            tracing::info!("updated bar position");
+                        }
+                        Err(error) => {
+                            tracing::error!("{}", error.to_string())
+                        }
+                    }
+                }
+            }
+        }
+
+        let frame = match &self.config.padding {
+            None => {
+                if let Some(frame) = &self.config.frame {
+                    Frame::none()
+                        .inner_margin(Margin::symmetric(
+                            frame.inner_margin.x,
+                            frame.inner_margin.y,
+                        ))
+                        .fill(*self.bg_color_with_alpha.borrow())
+                } else {
+                    Frame::none()
+                        .inner_margin(Margin::same(0.0))
+                        .fill(*self.bg_color_with_alpha.borrow())
+                }
+            }
+            Some(padding) => {
+                let padding = padding.to_individual(DEFAULT_PADDING);
+                Frame::none()
+                    .inner_margin(Margin {
+                        top: padding.top,
+                        bottom: padding.bottom,
+                        left: padding.left,
+                        right: padding.right,
+                    })
+                    .fill(*self.bg_color_with_alpha.borrow())
+            }
         };
 
         let mut render_config = self.render_config.borrow_mut();
 
         let frame = render_config.change_frame_on_bar(frame, &ctx.style());
 
-        CentralPanel::default().frame(frame).show(ctx, |_| {
+        CentralPanel::default().frame(frame).show(ctx, |ui| {
             // Apply grouping logic for the bar as a whole
             let area_frame = if let Some(frame) = &self.config.frame {
-                Frame::none().inner_margin(Margin::symmetric(0.0, frame.inner_margin.y))
+                Frame::none()
+                    .inner_margin(Margin::symmetric(0.0, frame.inner_margin.y))
+                    .outer_margin(Margin::same(0.0))
             } else {
                 Frame::none()
+                    .inner_margin(Margin::same(0.0))
+                    .outer_margin(Margin::same(0.0))
             };
 
+            let available_height = ui.max_rect().max.y;
+            ctx.style_mut(|style| {
+                style.spacing.interact_size.y = available_height;
+            });
+
             if !self.left_widgets.is_empty() {
                 // Left-aligned widgets layout
                 Area::new(Id::new("left_panel"))
                     .anchor(Align2::LEFT_CENTER, [0.0, 0.0]) // Align in the left center of the window
                     .show(ctx, |ui| {
                         let mut left_area_frame = area_frame;
-                        if let Some(frame) = &self.config.frame {
+                        if let Some(padding) = self
+                            .config
+                            .padding
+                            .as_ref()
+                            .map(|s| s.to_individual(DEFAULT_PADDING))
+                        {
+                            left_area_frame.inner_margin.left = padding.left;
+                            left_area_frame.inner_margin.top = padding.top;
+                            left_area_frame.inner_margin.bottom = padding.bottom;
+                        } else if let Some(frame) = &self.config.frame {
                             left_area_frame.inner_margin.left = frame.inner_margin.x;
+                            left_area_frame.inner_margin.top = frame.inner_margin.y;
+                            left_area_frame.inner_margin.bottom = frame.inner_margin.y;
                         }
+
                         left_area_frame.show(ui, |ui| {
-                            ui.with_layout(Layout::left_to_right(Align::Center), |ui| {
+                            ui.horizontal(|ui| {
                                 let mut render_conf = render_config.clone();
                                 render_conf.alignment = Some(Alignment::Left);
 
@@ -626,20 +840,40 @@ impl eframe::App for Komobar {
                     .anchor(Align2::RIGHT_CENTER, [0.0, 0.0]) // Align in the right center of the window
                     .show(ctx, |ui| {
                         let mut right_area_frame = area_frame;
-                        if let Some(frame) = &self.config.frame {
+                        if let Some(padding) = self
+                            .config
+                            .padding
+                            .as_ref()
+                            .map(|s| s.to_individual(DEFAULT_PADDING))
+                        {
+                            right_area_frame.inner_margin.right = padding.right;
+                            right_area_frame.inner_margin.top = padding.top;
+                            right_area_frame.inner_margin.bottom = padding.bottom;
+                        } else if let Some(frame) = &self.config.frame {
                             right_area_frame.inner_margin.right = frame.inner_margin.x;
+                            right_area_frame.inner_margin.top = frame.inner_margin.y;
+                            right_area_frame.inner_margin.bottom = frame.inner_margin.y;
                         }
-                        right_area_frame.show(ui, |ui| {
-                            ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
-                                let mut render_conf = render_config.clone();
-                                render_conf.alignment = Some(Alignment::Right);
 
-                                render_config.apply_on_alignment(ui, |ui| {
-                                    for w in &mut self.right_widgets {
-                                        w.render(ctx, ui, &mut render_conf);
-                                    }
-                                });
-                            });
+                        right_area_frame.show(ui, |ui| {
+                            let initial_size = Vec2 {
+                                x: ui.available_size_before_wrap().x,
+                                y: ui.spacing().interact_size.y,
+                            };
+                            ui.allocate_ui_with_layout(
+                                initial_size,
+                                Layout::right_to_left(Align::Center),
+                                |ui| {
+                                    let mut render_conf = render_config.clone();
+                                    render_conf.alignment = Some(Alignment::Right);
+
+                                    render_config.apply_on_alignment(ui, |ui| {
+                                        for w in &mut self.right_widgets {
+                                            w.render(ctx, ui, &mut render_conf);
+                                        }
+                                    });
+                                },
+                            );
                         });
                     });
             }
@@ -649,9 +883,22 @@ impl eframe::App for Komobar {
                 Area::new(Id::new("center_panel"))
                     .anchor(Align2::CENTER_CENTER, [0.0, 0.0]) // Align in the center of the window
                     .show(ctx, |ui| {
-                        let center_area_frame = area_frame;
+                        let mut center_area_frame = area_frame;
+                        if let Some(padding) = self
+                            .config
+                            .padding
+                            .as_ref()
+                            .map(|s| s.to_individual(DEFAULT_PADDING))
+                        {
+                            center_area_frame.inner_margin.top = padding.top;
+                            center_area_frame.inner_margin.bottom = padding.bottom;
+                        } else if let Some(frame) = &self.config.frame {
+                            center_area_frame.inner_margin.top = frame.inner_margin.y;
+                            center_area_frame.inner_margin.bottom = frame.inner_margin.y;
+                        }
+
                         center_area_frame.show(ui, |ui| {
-                            ui.with_layout(Layout::left_to_right(Align::Center), |ui| {
+                            ui.horizontal(|ui| {
                                 let mut render_conf = render_config.clone();
                                 render_conf.alignment = Some(Alignment::Center);
 

komorebi-bar/src/battery.rs

@@ -1,11 +1,11 @@
 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::Sense;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
 use schemars::JsonSchema;
@@ -14,6 +14,7 @@ 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;
 
@@ -21,6 +22,8 @@ use std::time::Instant;
 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
@@ -33,6 +36,7 @@ impl From<BatteryConfig> for Battery {
 
         Self {
             enable: value.enable,
+            hide_on_full_charge: value.hide_on_full_charge.unwrap_or(false),
             manager: Manager::new().unwrap(),
             last_state: String::new(),
             data_refresh_interval,
@@ -52,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,
@@ -71,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}%"),
                     }
                 }
             }
@@ -125,12 +135,18 @@ impl BarWidget for Battery {
                     },
                 );
 
-                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,5 +1,6 @@
 use crate::render::Grouping;
 use crate::widget::WidgetConfig;
+use crate::DEFAULT_PADDING;
 use eframe::egui::Pos2;
 use eframe::egui::TextBuffer;
 use eframe::egui::Vec2;
@@ -12,15 +13,67 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.32`
+/// The `komorebi.bar.json` configuration file reference for `v0.1.34`
 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)
@@ -90,6 +143,15 @@ pub struct FrameConfig {
     pub inner_margin: Position,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, 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, JsonSchema)]
 pub struct MonitorConfig {
     /// Komorebi monitor index of the monitor on which to render the bar
@@ -98,6 +160,154 @@ pub struct MonitorConfig {
     pub work_area_offset: Option<Rect>,
 }
 
+pub type Padding = SpacingKind;
+pub type Margin = SpacingKind;
+
+#[derive(Clone, Debug, Serialize, Deserialize, 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, JsonSchema)]
+pub struct GroupedSpacingConfig {
+    pub vertical: Option<GroupedSpacingOptions>,
+    pub horizontal: Option<GroupedSpacingOptions>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(untagged)]
+pub enum GroupedSpacingOptions {
+    Symmetrical(f32),
+    Split(f32, f32),
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, 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)?;
@@ -108,7 +318,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,
+                },
             });
         }
 
@@ -153,7 +366,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>,
     },

komorebi-bar/src/date.rs

@@ -13,6 +13,48 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
+/// Custom format with additive modifiers for integer format specifiers
+#[derive(Clone, Debug, Serialize, Deserialize, 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, JsonSchema)]
 pub struct DateConfig {
     /// Enable the Date widget
@@ -45,6 +87,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 {
@@ -58,13 +102,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(),
         }
     }
 }
@@ -78,9 +123,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,
+        }
     }
 }
 

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 schemars::JsonSchema;
+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, 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

@@ -10,8 +10,6 @@ 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;
@@ -30,6 +28,7 @@ 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;
@@ -99,7 +98,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();
                 }
@@ -496,7 +495,7 @@ impl KomorebiNotificationState {
         &mut self,
         ctx: &Context,
         monitor_index: usize,
-        rx_gui: Receiver<komorebi_client::Notification>,
+        notification: komorebi_client::Notification,
         bg_color: Rc<RefCell<Color32>>,
         bg_color_with_alpha: Rc<RefCell<Color32>>,
         transparency_alpha: Option<u8>,
@@ -504,119 +503,105 @@ impl KomorebiNotificationState {
         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(),
-                                        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) => {
+        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,
+                                bg_color.clone(),
                                 bg_color_with_alpha.clone(),
                                 transparency_alpha,
                                 grouping,
                                 render_config,
                             );
-                            tracing::info!("applied theme from komorebi socket message");
+                            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");
                         }
-                        _ => {}
-                    },
-                }
-
-                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_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)),
+                    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,
+            };
+        }
+
+        self.focused_container_information = (&monitor.workspaces()[focused_workspace_idx]).into();
     }
 }
 

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,6 +22,7 @@ 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;
@@ -56,6 +59,7 @@ 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()));
@@ -112,6 +116,11 @@ 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) }?;
 
@@ -229,32 +238,39 @@ fn main() -> color_eyre::Result<()> {
         &SocketMessage::State,
     )?)?;
 
+    let (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),
+    };
+
     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,
                 }),
             })
@@ -262,14 +278,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,
                 })
             }
@@ -286,15 +302,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();
@@ -329,8 +339,6 @@ fn main() -> color_eyre::Result<()> {
         "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));
@@ -373,18 +381,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) {
@@ -395,7 +397,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}")
                                             }
 

komorebi-bar/src/network.rs

@@ -100,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) {
@@ -148,7 +148,7 @@ impl Network {
             LabelPrefix::None | LabelPrefix::Icon => match reading.format {
                 NetworkReadingFormat::Speed => (
                     format!(
-                        "{: >width$}/s | ",
+                        "{: >width$}/s ",
                         reading.received_text,
                         width = self.network_activity_fill_characters
                     ),
@@ -159,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
                     ),
@@ -177,7 +177,7 @@ 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),
                 ),
             },

komorebi-bar/src/render.rs

@@ -1,5 +1,6 @@
 use crate::bar::Alignment;
 use crate::config::KomobarConfig;
+use crate::config::MonitorConfigOrIndex;
 use eframe::egui::Color32;
 use eframe::egui::Context;
 use eframe::egui::FontId;
@@ -81,8 +82,13 @@ impl RenderExt for &KomobarConfig {
         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,
+        };
+
         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,

komorebi-bar/src/storage.rs

@@ -50,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;
         }
 

komorebi-bar/src/time.rs

@@ -1,3 +1,4 @@
+use crate::bar::Alignment;
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
@@ -6,8 +7,12 @@ use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
 use eframe::egui::Label;
+use eframe::egui::Rounding;
+use eframe::egui::Sense;
+use eframe::egui::Stroke;
 use eframe::egui::TextFormat;
 use eframe::egui::Ui;
+use eframe::egui::Vec2;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
@@ -36,8 +41,16 @@ impl From<TimeConfig> for Time {
 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),
 }
@@ -45,8 +58,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,
             _ => {}
         };
     }
@@ -54,7 +71,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(),
         }
     }
@@ -72,6 +93,169 @@ 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 = Rounding::same(response.rect.width() * 0.1);
+        let round_top = Rounding {
+            nw: round_all.nw,
+            ne: round_all.ne,
+            ..Default::default()
+        };
+        let round_none = Rounding::ZERO;
+        let round_bottom = Rounding {
+            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);
+        } 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);
+        } else {
+            painter.rect_stroke(response.rect.shrink(stroke.width), round_all, stroke);
+        }
+
+        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);
+        }
     }
 }
 
@@ -80,6 +264,9 @@ impl BarWidget for Time {
         if self.enable {
             let mut output = self.output();
             if !output.is_empty() {
+                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 {
                         LabelPrefix::Icon | LabelPrefix::IconAndText => {
@@ -96,20 +283,83 @@ impl BarWidget for Time {
                     output.insert_str(0, "TIME: ");
                 }
 
-                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()
-                    },
-                );
+                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()
+                        },
+                    );
+                }
+
+                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| ui.add(Label::new(layout_job).selectable(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 schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use std::process::Command;
+use std::time::Duration;
+use std::time::Instant;
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, 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,6 +19,8 @@ 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;
@@ -32,12 +36,14 @@ 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,14 @@ 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)),
         }
     }
 
@@ -60,20 +68,22 @@ impl WidgetConfig {
             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().map_or(false, |w| w.enable)
-                    || config.layout.as_ref().map_or(false, |w| w.enable)
-                    || config.focused_window.as_ref().map_or(false, |w| w.enable)
+                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()
-                        .map_or(false, |w| w.enable)
+                        .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.32"
+version = "0.1.34"
 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,29 @@ 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::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::WorkspaceConfig;
 
 use komorebi::DATA_DIR;
 

komorebi-gui/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.32"
+version = "0.1.34"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,6 +10,6 @@ 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 = { workspace = true }

komorebi-themes/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "komorebi-themes"
-version = "0.1.32"
+version = "0.1.34"
 edition = "2021"
 
 [dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "24362c4" }
+base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "911079d" }
 catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "f85cc3c", default-features = false, features = ["egui30"] }
 #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 = "0.26"

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.32"
+version = "0.1.34"
 description = "A tiling window manager for Windows"
-categories = ["tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
 
@@ -26,7 +25,7 @@ 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"
@@ -48,10 +47,13 @@ windows-core = { 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]
 deadlock_detection = ["parking_lot/deadlock_detection"]

komorebi/build.rs

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

komorebi/src/animation/mod.rs

@@ -22,7 +22,7 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(untagged)]
 pub enum PerAnimationPrefixConfig<T> {
     Prefix(HashMap<AnimationPrefix, T>),

komorebi/src/border_manager/mod.rs

@@ -29,6 +29,7 @@ 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);
@@ -211,6 +212,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))?;
+                        }
                     }
                 }
             }
@@ -251,6 +262,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         .map(|b| b.window_kind == WindowKind::Floating)
                         .unwrap_or_default())
                 });
+
                 if !should_process_notification && switch_focus_to_from_floating_window {
                     should_process_notification = true;
                 }
@@ -427,7 +439,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             borders.remove(id);
                         }
 
-                        for (idx, c) in ws.containers().iter().enumerate() {
+                        'containers: 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()) {
@@ -471,14 +483,24 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let reference_hwnd =
                                 c.focused_window().copied().unwrap_or_default().hwnd;
 
-                            let rect = WindowsApi::window_rect(reference_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(reference_hwnd) {
+                                Ok(rect) => rect,
+                                Err(_) => {
+                                    let _ = border.destroy();
+                                    borders.remove(c.id());
+                                    continue 'containers;
+                                }
+                            };
 
                             let should_invalidate = match last_focus_state {
                                 None => true,
                                 Some(last_focus_state) => last_focus_state != new_focus_state,
                             };
 
-                            if new_border {
+                            if new_border || should_invalidate {
                                 border.set_position(&rect, reference_hwnd)?;
                             }
 
@@ -558,7 +580,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
     Ok(())
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Display, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub enum ZOrder {
     Top,
     NoTopMost,

komorebi/src/colour.rs

@@ -8,7 +8,7 @@ use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 #[serde(untagged)]
 pub enum Colour {
     /// Colour represented as RGB
@@ -51,7 +51,7 @@ 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 {
@@ -78,7 +78,7 @@ impl From<Colour> for u32 {
     }
 }
 
-#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema, PartialEq)]
 pub struct Rgb {
     /// Red
     pub r: u32,
@@ -120,8 +120,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/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/core/animation.rs

@@ -6,7 +6,16 @@ use strum::Display;
 use strum::EnumString;
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
 pub enum AnimationStyle {
     Linear,

komorebi/src/core/config_generation.rs

@@ -75,7 +75,7 @@ pub struct IdWithIdentifier {
     pub matching_strategy: Option<MatchingStrategy>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Display, JsonSchema)]
 pub enum MatchingStrategy {
     Legacy,
     Equals,

komorebi/src/core/default_layout.rs

@@ -89,7 +89,6 @@ impl DefaultLayout {
             return None;
         };
 
-        let max_divisor = 1.005;
         let mut r = resize.unwrap_or_default();
 
         let resize_delta = delta;
@@ -108,15 +107,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 +121,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 +135,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 +149,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/mod.rs

@@ -19,12 +19,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,6 +42,7 @@ 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)]
@@ -117,6 +123,7 @@ pub enum SocketMessage {
     CycleFocusMonitor(CycleDirection),
     CycleFocusWorkspace(CycleDirection),
     FocusMonitorNumber(usize),
+    FocusMonitorAtCursor,
     FocusLastWorkspace,
     CloseWorkspace,
     FocusWorkspaceNumber(usize),
@@ -238,7 +245,9 @@ pub struct SubscribeOptions {
     pub filter_state_changes: bool,
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema)]
+#[derive(
+    Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema, ValueEnum,
+)]
 pub enum StackbarMode {
     Always,
     Never,
@@ -328,6 +337,7 @@ pub enum StateQuery {
     FocusedWorkspaceIndex,
     FocusedContainerIndex,
     FocusedWindowIndex,
+    FocusedWorkspaceName,
 }
 
 #[derive(
@@ -426,7 +436,16 @@ pub enum MoveBehaviour {
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Clone,
+    Copy,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
 pub enum CrossBoundaryBehaviour {
     /// Attempt to perform actions across a workspace boundary
@@ -436,7 +455,16 @@ pub enum CrossBoundaryBehaviour {
 }
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Copy,
+    Clone,
+    Debug,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
 pub enum HidingBehaviour {
     /// Use the SW_HIDE flag to hide windows when switching workspaces (has issues with Electron apps)

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/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;
@@ -127,6 +128,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 +182,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);
@@ -219,6 +221,8 @@ lazy_static! {
 
     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);
@@ -281,6 +285,7 @@ pub fn current_virtual_desktop() -> Option<Vec<u8>> {
 pub enum NotificationEvent {
     WindowManager(WindowManagerEvent),
     Socket(SocketMessage),
+    Monitor(MonitorNotification),
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -298,6 +303,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

@@ -176,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();
 

komorebi/src/monitor.rs

@@ -44,6 +44,8 @@ pub struct Monitor {
     #[getset(get = "pub", set = "pub")]
     device_id: String,
     #[getset(get = "pub", set = "pub")]
+    serial_number_id: Option<String>,
+    #[getset(get = "pub", set = "pub")]
     size: Rect,
     #[getset(get = "pub", set = "pub")]
     work_area_size: Rect,
@@ -63,6 +65,29 @@ pub struct Monitor {
 
 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 +95,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 +105,7 @@ pub fn new(
         name,
         device,
         device_id,
+        serial_number_id,
         size,
         work_area_size,
         work_area_offset: None,
@@ -91,12 +118,33 @@ pub fn new(
 }
 
 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,
@@ -107,6 +155,13 @@ impl Monitor {
             workspace_names: Default::default(),
         }
     }
+
+    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() {

komorebi/src/monitor_reconciliator/hidden.rs

@@ -114,7 +114,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,7 +124,7 @@ impl Hidden {
                                 "WM_POWERBROADCAST event received - entering suspended state"
                             );
                             monitor_reconciliator::send_notification(
-                                monitor_reconciliator::Notification::EnteringSuspendedState,
+                                monitor_reconciliator::MonitorNotification::EnteringSuspendedState,
                             );
                             LRESULT(0)
                         }
@@ -137,14 +137,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 +165,7 @@ impl Hidden {
                     );
 
                     monitor_reconciliator::send_notification(
-                        monitor_reconciliator::Notification::ResolutionScalingChanged,
+                        monitor_reconciliator::MonitorNotification::ResolutionScalingChanged,
                     );
                     LRESULT(0)
                 }
@@ -179,7 +179,7 @@ impl Hidden {
                             );
 
                         monitor_reconciliator::send_notification(
-                            monitor_reconciliator::Notification::WorkAreaChanged,
+                            monitor_reconciliator::MonitorNotification::WorkAreaChanged,
                         );
                     }
                     LRESULT(0)
@@ -193,7 +193,7 @@ impl Hidden {
                                 "WM_DEVICECHANGE event received with DBT_DEVNODES_CHANGED - display added or removed"
                             );
                         monitor_reconciliator::send_notification(
-                            monitor_reconciliator::Notification::DisplayConnectionChange,
+                            monitor_reconciliator::MonitorNotification::DisplayConnectionChange,
                         );
                     }
 

komorebi/src/monitor_reconciliator/mod.rs

@@ -5,13 +5,20 @@ use crate::core::Rect;
 use crate::monitor;
 use crate::monitor::Monitor;
 use crate::monitor_reconciliator::hidden::Hidden;
+use crate::notify_subscribers;
 use crate::MonitorConfig;
+use crate::Notification;
+use crate::NotificationEvent;
+use crate::State;
 use crate::WindowManager;
 use crate::WindowsApi;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
 use parking_lot::Mutex;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
@@ -20,7 +27,9 @@ use std::sync::OnceLock;
 
 pub mod hidden;
 
-pub enum Notification {
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(tag = "type", content = "content")]
+pub enum MonitorNotification {
     ResolutionScalingChanged,
     WorkAreaChanged,
     DisplayConnectionChange,
@@ -32,23 +41,24 @@ 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();
 
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
+pub fn channel() -> &'static (Sender<MonitorNotification>, Receiver<MonitorNotification>) {
     CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
 }
 
-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")
     }
@@ -89,10 +99,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,6 +128,7 @@ 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");
 
@@ -125,7 +138,8 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
         if !ACTIVE.load_consume() {
             if matches!(
                 notification,
-                Notification::ResumingFromSuspendedState | Notification::SessionUnlocked
+                MonitorNotification::ResumingFromSuspendedState
+                    | MonitorNotification::SessionUnlocked
             ) {
                 tracing::debug!(
                     "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
@@ -140,17 +154,20 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
         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 => {
+            MonitorNotification::ResumingFromSuspendedState
+            | MonitorNotification::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 +199,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 +246,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     }
                 }
             }
-            Notification::DisplayConnectionChange => {
+            MonitorNotification::DisplayConnectionChange => {
                 tracing::debug!("handling display connection change notification");
                 let mut monitor_cache = MONITOR_CACHE
                     .get_or_init(|| Mutex::new(HashMap::new()))
@@ -411,6 +428,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

@@ -52,6 +52,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;
@@ -734,6 +735,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)?
@@ -847,7 +853,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
@@ -870,7 +884,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 mut can_close = false;
@@ -906,7 +928,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
@@ -929,7 +959,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 {
@@ -941,7 +979,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();
@@ -1051,9 +1097,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)
@@ -1063,19 +1109,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())?;
             }
@@ -1305,6 +1361,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)?;
 
@@ -1662,6 +1720,7 @@ impl WindowManager {
             }
             SocketMessage::StackbarMode(mode) => {
                 STACKBAR_MODE.store(mode);
+                self.retile_all(true)?;
             }
             SocketMessage::StackbarLabel(label) => {
                 STACKBAR_LABEL.store(label);

komorebi/src/process_event.rs

@@ -93,8 +93,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 +254,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

komorebi/src/reaper.rs

@@ -34,6 +34,8 @@ pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
         let mut wm = arc.lock();
         let offset = wm.work_area_offset;
 
+        let mut update_borders = false;
+
         for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
             let work_area = *monitor.work_area_size();
             let window_based_work_area_offset = (
@@ -51,7 +53,7 @@ pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
                 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);
+                    update_borders = true;
                     tracing::info!(
                         "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                         reaped_orphans.0,
@@ -62,5 +64,9 @@ pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
                 }
             }
         }
+
+        if update_borders {
+            border_manager::send_notification(None);
+        }
     }
 }

komorebi/src/static_config.rs

@@ -35,12 +35,16 @@ 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;
@@ -48,6 +52,7 @@ 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;
@@ -96,21 +101,26 @@ use std::sync::Arc;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 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, JsonSchema, PartialEq)]
 pub struct WorkspaceConfig {
     /// Name
     pub name: String,
@@ -120,7 +130,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)
@@ -144,10 +154,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 {
@@ -162,6 +177,11 @@ impl From<&Workspace> for WorkspaceConfig {
             }
         }
 
+        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);
 
@@ -201,12 +221,14 @@ impl From<&Workspace> for WorkspaceConfig {
             workspace_rules: None,
             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, JsonSchema, PartialEq)]
 pub struct MonitorConfig {
     /// Workspace configurations
     pub workspaces: Vec<WorkspaceConfig>,
@@ -237,8 +259,8 @@ impl From<&Monitor> for MonitorConfig {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.32`
+#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
+/// The `komorebi.json` static configuration file reference for `v0.1.34`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -349,6 +371,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>>,
@@ -371,26 +396,33 @@ 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, JsonSchema, PartialEq)]
 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, JsonSchema, PartialEq)]
 #[serde(tag = "palette")]
 pub enum KomorebiTheme {
     /// A theme from catppuccin-egui
@@ -398,45 +430,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>,
     },
 }
@@ -522,31 +572,41 @@ impl StaticConfig {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)]
 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, JsonSchema, PartialEq)]
 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>,
 }
 
@@ -620,7 +680,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,
@@ -632,6 +702,7 @@ 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()),
         }
     }
 }
@@ -639,6 +710,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);
@@ -774,6 +849,7 @@ 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();
@@ -800,6 +876,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)?;
         }
@@ -1009,6 +1096,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)?;
@@ -1200,6 +1291,9 @@ impl StaticConfig {
         value.apply_globals()?;
 
         if let Some(monitors) = value.monitors {
+            let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+            workspace_matching_rules.clear();
+
             for (i, monitor) in monitors.iter().enumerate() {
                 if let Some(m) = wm.monitors_mut().get_mut(i) {
                     m.ensure_workspace_count(monitor.workspaces.len());
@@ -1218,8 +1312,6 @@ impl StaticConfig {
                     }
                 }
 
-                let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                workspace_matching_rules.clear();
                 for (j, ws) in monitor.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {

komorebi/src/window.rs

@@ -15,6 +15,7 @@ use crate::focus_manager;
 use crate::stackbar_manager;
 use crate::windows_api;
 use crate::AnimationStyle;
+use crate::FLOATING_WINDOW_TOGGLE_ASPECT_RATIO;
 use crate::SLOW_APPLICATION_COMPENSATION_TIME;
 use crate::SLOW_APPLICATION_IDENTIFIERS;
 use std::collections::HashMap;
@@ -39,6 +40,8 @@ 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;
@@ -296,6 +299,49 @@ impl RenderDispatcher for TransparencyRenderDispatcher {
     }
 }
 
+#[derive(
+    Copy, Clone, Debug, Display, EnumString, Serialize, Deserialize, JsonSchema, PartialEq,
+)]
+#[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, JsonSchema, PartialEq,
+)]
+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 +415,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,
         )
@@ -872,7 +924,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 {
@@ -924,12 +980,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.rs

@@ -435,13 +435,22 @@ impl WindowManager {
                     if let Some(state_monitor) = state.monitors.elements().get(monitor_idx) {
                         if let Some(state_workspace) = state_monitor.workspaces().get(workspace_idx)
                         {
+                            // to make sure padding changes get applied for users after a quick restart
+                            let container_padding = workspace.container_padding();
+                            let workspace_padding = workspace.workspace_padding();
+
                             *workspace = state_workspace.clone();
+
+                            workspace.set_container_padding(container_padding);
+                            workspace.set_workspace_padding(workspace_padding);
+
                             if state_monitor.focused_workspace_idx() == workspace_idx {
                                 focused_workspace = workspace_idx;
                             }
                         }
                     }
                 }
+
                 if let Err(error) = monitor.focus_workspace(focused_workspace) {
                     tracing::warn!(
                         "cannot focus workspace '{focused_workspace}' on monitor '{monitor_idx}' from {}: {}",
@@ -449,6 +458,7 @@ impl WindowManager {
                         error,
                     );
                 }
+
                 if let Err(error) = monitor.load_focused_workspace(mouse_follows_focus) {
                     tracing::warn!(
                         "cannot load focused workspace '{focused_workspace}' on monitor '{monitor_idx}' from {}: {}",
@@ -456,6 +466,7 @@ impl WindowManager {
                         error,
                     );
                 }
+
                 if let Err(error) = monitor.update_focused_workspace(offset) {
                     tracing::warn!(
                         "cannot update workspace '{focused_workspace}' on monitor '{monitor_idx}' from {}: {}",
@@ -720,75 +731,80 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor with that index"))?
             .focused_workspace_idx();
 
-        let workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-        let regex_identifiers = REGEX_IDENTIFIERS.lock();
-        // Go through all the monitors and workspaces
-        for (i, monitor) in self.monitors().iter().enumerate() {
-            for (j, workspace) in monitor.workspaces().iter().enumerate() {
-                // And all the visible windows (at the top of a container)
-                for window in workspace.visible_windows().into_iter().flatten() {
-                    let mut already_moved_window_handles = self.already_moved_window_handles.lock();
-                    let exe_name = window.exe()?;
-                    let title = window.title()?;
-                    let class = window.class()?;
-                    let path = window.path()?;
+        // scope mutex locks to avoid deadlock if should_update_focused_workspace evaluates to true
+        // at the end of this function
+        {
+            let workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
+            let regex_identifiers = REGEX_IDENTIFIERS.lock();
+            // Go through all the monitors and workspaces
+            for (i, monitor) in self.monitors().iter().enumerate() {
+                for (j, workspace) in monitor.workspaces().iter().enumerate() {
+                    // And all the visible windows (at the top of a container)
+                    for window in workspace.visible_windows().into_iter().flatten() {
+                        let mut already_moved_window_handles =
+                            self.already_moved_window_handles.lock();
 
-                    for rule in &*workspace_matching_rules {
-                        let matched = match &rule.matching_rule {
-                            MatchingRule::Simple(r) => should_act_individual(
-                                &title,
-                                &exe_name,
-                                &class,
-                                &path,
-                                r,
-                                &regex_identifiers,
-                            ),
-                            MatchingRule::Composite(r) => {
-                                let mut composite_results = vec![];
-                                for identifier in r {
-                                    composite_results.push(should_act_individual(
+                        if let (Ok(exe_name), Ok(title), Ok(class), Ok(path)) =
+                            (window.exe(), window.title(), window.class(), window.path())
+                        {
+                            for rule in &*workspace_matching_rules {
+                                let matched = match &rule.matching_rule {
+                                    MatchingRule::Simple(r) => should_act_individual(
                                         &title,
                                         &exe_name,
                                         &class,
                                         &path,
-                                        identifier,
+                                        r,
                                         &regex_identifiers,
-                                    ));
+                                    ),
+                                    MatchingRule::Composite(r) => {
+                                        let mut composite_results = vec![];
+                                        for identifier in r {
+                                            composite_results.push(should_act_individual(
+                                                &title,
+                                                &exe_name,
+                                                &class,
+                                                &path,
+                                                identifier,
+                                                &regex_identifiers,
+                                            ));
+                                        }
+
+                                        composite_results.iter().all(|&x| x)
+                                    }
+                                };
+
+                                if matched {
+                                    let floating = workspace.floating_windows().contains(window);
+
+                                    if rule.initial_only {
+                                        if !already_moved_window_handles.contains(&window.hwnd) {
+                                            already_moved_window_handles.insert(window.hwnd);
+
+                                            self.add_window_handle_to_move_based_on_workspace_rule(
+                                                &window.title()?,
+                                                window.hwnd,
+                                                i,
+                                                j,
+                                                rule.monitor_index,
+                                                rule.workspace_index,
+                                                floating,
+                                                &mut to_move,
+                                            );
+                                        }
+                                    } else {
+                                        self.add_window_handle_to_move_based_on_workspace_rule(
+                                            &window.title()?,
+                                            window.hwnd,
+                                            i,
+                                            j,
+                                            rule.monitor_index,
+                                            rule.workspace_index,
+                                            floating,
+                                            &mut to_move,
+                                        );
+                                    }
                                 }
-
-                                composite_results.iter().all(|&x| x)
-                            }
-                        };
-
-                        if matched {
-                            let floating = workspace.floating_windows().contains(window);
-
-                            if rule.initial_only {
-                                if !already_moved_window_handles.contains(&window.hwnd) {
-                                    already_moved_window_handles.insert(window.hwnd);
-
-                                    self.add_window_handle_to_move_based_on_workspace_rule(
-                                        &window.title()?,
-                                        window.hwnd,
-                                        i,
-                                        j,
-                                        rule.monitor_index,
-                                        rule.workspace_index,
-                                        floating,
-                                        &mut to_move,
-                                    );
-                                }
-                            } else {
-                                self.add_window_handle_to_move_based_on_workspace_rule(
-                                    &window.title()?,
-                                    window.hwnd,
-                                    i,
-                                    j,
-                                    rule.monitor_index,
-                                    rule.workspace_index,
-                                    floating,
-                                    &mut to_move,
-                                );
                             }
                         }
                     }
@@ -1872,21 +1888,10 @@ impl WindowManager {
                 if let Ok(focused_workspace) = self.focused_workspace_mut() {
                     if let Some(window) = focused_workspace.maximized_window() {
                         window.focus(mouse_follows_focus)?;
-                        // (alex-ds13): @LGUG2Z Why was this being done below on the monocle?
-                        // Should it really be done?
-                        //
-                        // WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(
-                        //     window.hwnd,
-                        // )?)?;
-
                         cross_monitor_monocle_or_max = true;
                     } else if let Some(monocle) = focused_workspace.monocle_container() {
                         if let Some(window) = monocle.focused_window() {
                             window.focus(mouse_follows_focus)?;
-                            WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(
-                                window.hwnd,
-                            )?)?;
-
                             cross_monitor_monocle_or_max = true;
                         }
                     } else {

komorebi/src/window_manager_event.rs

@@ -9,6 +9,7 @@ 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)]
@@ -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

@@ -283,6 +283,7 @@ impl WindowsApi {
                 name,
                 device,
                 device_id,
+                display.serial_number_id,
             );
 
             let mut index_preference = None;
@@ -936,6 +937,7 @@ impl WindowsApi {
                     name,
                     device,
                     device_id,
+                    display.serial_number_id,
                 );
 
                 return Ok(monitor);

komorebi/src/windows_callbacks.rs

@@ -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/workspace.rs

@@ -89,6 +89,8 @@ pub struct Workspace {
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
     window_container_behaviour: Option<WindowContainerBehaviour>,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    window_container_behaviour_rules: Option<Vec<(usize, WindowContainerBehaviour)>>,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
     float_override: Option<bool>,
 }
 
@@ -114,6 +116,7 @@ impl Default for Workspace {
             tile: true,
             apply_window_based_work_area_offset: true,
             window_container_behaviour: None,
+            window_container_behaviour_rules: None,
             float_override: None,
         }
     }
@@ -133,10 +136,14 @@ impl Workspace {
 
         if config.container_padding.is_some() {
             self.set_container_padding(config.container_padding);
+        } else {
+            self.set_container_padding(Some(DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst)));
         }
 
         if config.workspace_padding.is_some() {
             self.set_workspace_padding(config.workspace_padding);
+        } else {
+            self.set_container_padding(Some(DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst)));
         }
 
         if let Some(layout) = &config.layout {
@@ -154,38 +161,53 @@ impl Workspace {
             self.tile = false;
         }
 
+        let mut all_layout_rules = vec![];
         if let Some(layout_rules) = &config.layout_rules {
-            let mut all_rules = vec![];
             for (count, rule) in layout_rules {
-                all_rules.push((*count, Layout::Default(*rule)));
+                all_layout_rules.push((*count, Layout::Default(*rule)));
             }
 
-            self.set_layout_rules(all_rules);
-
+            all_layout_rules.sort_by_key(|(i, _)| *i);
             self.tile = true;
         }
 
+        self.set_layout_rules(all_layout_rules.clone());
+
         if let Some(layout_rules) = &config.custom_layout_rules {
-            let rules = self.layout_rules_mut();
             for (count, pathbuf) in layout_rules {
                 let rule = CustomLayout::from_path(pathbuf)?;
-                rules.push((*count, Layout::Custom(rule)));
+                all_layout_rules.push((*count, Layout::Custom(rule)));
             }
 
+            all_layout_rules.sort_by_key(|(i, _)| *i);
             self.tile = true;
+            self.set_layout_rules(all_layout_rules);
         }
 
         self.set_apply_window_based_work_area_offset(
             config.apply_window_based_work_area_offset.unwrap_or(true),
         );
 
-        if config.window_container_behaviour.is_some() {
-            self.set_window_container_behaviour(config.window_container_behaviour);
+        self.set_window_container_behaviour(config.window_container_behaviour);
+
+        if let Some(window_container_behaviour_rules) = &config.window_container_behaviour_rules {
+            if window_container_behaviour_rules.is_empty() {
+                self.set_window_container_behaviour_rules(None);
+            } else {
+                let mut all_rules = vec![];
+                for (count, behaviour) in window_container_behaviour_rules {
+                    all_rules.push((*count, *behaviour));
+                }
+
+                all_rules.sort_by_key(|(i, _)| *i);
+                self.set_window_container_behaviour_rules(Some(all_rules));
+            }
+        } else {
+            self.set_window_container_behaviour_rules(None);
         }
 
-        if config.float_override.is_some() {
-            self.set_float_override(config.float_override);
-        }
+        self.set_float_override(config.float_override);
+        self.set_layout_flip(config.layout_flip);
 
         Ok(())
     }
@@ -318,21 +340,28 @@ impl Workspace {
         if !self.layout_rules().is_empty() {
             let mut updated_layout = None;
 
-            for rule in self.layout_rules() {
-                if self.containers().len() >= rule.0 {
-                    updated_layout = Option::from(rule.1.clone());
+            for (threshold, layout) in self.layout_rules() {
+                if self.containers().len() >= *threshold {
+                    updated_layout = Option::from(layout.clone());
                 }
             }
 
             if let Some(updated_layout) = updated_layout {
-                if !matches!(updated_layout, Layout::Default(DefaultLayout::BSP)) {
-                    self.set_layout_flip(None);
-                }
-
                 self.set_layout(updated_layout);
             }
         }
 
+        if let Some(window_container_behaviour_rules) = self.window_container_behaviour_rules() {
+            let mut updated_behaviour = None;
+            for (threshold, behaviour) in window_container_behaviour_rules {
+                if self.containers().len() >= *threshold {
+                    updated_behaviour = Option::from(*behaviour);
+                }
+            }
+
+            self.set_window_container_behaviour(updated_behaviour);
+        }
+
         let managed_maximized_window = self.maximized_window().is_some();
 
         if *self.tile() {
@@ -429,7 +458,16 @@ impl Workspace {
         // number of layouts / containers. This should never actually truncate as the remove_window
         // function takes care of cleaning up resize dimensions when destroying empty containers
         let container_count = self.containers().len();
-        self.resize_dimensions_mut().resize(container_count, None);
+
+        // since monocle is a toggle, we never want to truncate the resize dimensions since it will
+        // almost always be toggled off and the container will be reintegrated into layout
+        //
+        // without this check, if there are exactly two containers, when one is toggled to monocle
+        // the resize dimensions will be truncated to len == 1, and when it is reintegrated, if it
+        // had a resize adjustment before, that will have been lost
+        if self.monocle_container().is_none() {
+            self.resize_dimensions_mut().resize(container_count, None);
+        }
 
         Ok(())
     }
@@ -461,7 +499,15 @@ impl Workspace {
         }
 
         for window in self.visible_windows().into_iter().flatten() {
-            if !window.is_window() {
+            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()
+            {
                 hwnds.push(window.hwnd);
             }
         }

komorebi/tests/compat.rs

@@ -0,0 +1,29 @@
+use komorebi::StaticConfig;
+
+#[test]
+fn backwards_compat() {
+    let root = vec!["0.1.17", "0.1.18", "0.1.19"];
+    let docs = vec![
+        "0.1.20", "0.1.21", "0.1.22", "0.1.23", "0.1.24", "0.1.25", "0.1.26", "0.1.27", "0.1.28",
+        "0.1.29", "0.1.30", "0.1.31", "0.1.32", "0.1.33",
+    ];
+
+    let mut versions = vec![];
+
+    let client = reqwest::blocking::Client::new();
+
+    for version in root {
+        let request = client.get(format!("https://raw.githubusercontent.com/LGUG2Z/komorebi/refs/tags/v{version}/komorebi.example.json")).header("User-Agent", "komorebi-backwards-compat-test").build().unwrap();
+        versions.push((version, client.execute(request).unwrap().text().unwrap()));
+    }
+
+    for version in docs {
+        let request = client.get(format!("https://raw.githubusercontent.com/LGUG2Z/komorebi/refs/tags/v{version}/docs/komorebi.example.json")).header("User-Agent", "komorebi-backwards-compat-test").build().unwrap();
+        versions.push((version, client.execute(request).unwrap().text().unwrap()));
+    }
+
+    for (version, config) in versions {
+        println!("{version}");
+        StaticConfig::read_raw(&config).unwrap();
+    }
+}

komorebic-no-console/Cargo.toml

@@ -1,8 +1,7 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.32"
+version = "0.1.34"
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
-categories = ["cli", "tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
 

komorebic/Cargo.toml

@@ -1,8 +1,7 @@
 [package]
 name = "komorebic"
-version = "0.1.32"
+version = "0.1.34"
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
-categories = ["cli", "tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
 
@@ -25,13 +24,10 @@ reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-serde_yaml = "0.9"
 shadow-rs = { workspace = true }
 sysinfo = { workspace = true }
 thiserror = "2"
-uds_windows = { workspace = true }
 which = { workspace = true }
-win32-display-data = { workspace = true }
 windows = { workspace = true }
 
 [build-dependencies]

komorebic/build.rs

@@ -1,3 +1,5 @@
+use shadow_rs::ShadowBuilder;
+
 fn main() {
     if std::fs::metadata("applications.json").is_err() {
         let applications_json = reqwest::blocking::get(
@@ -6,5 +8,5 @@ fn main() {
         std::fs::write("applications.json", applications_json).unwrap();
     }
 
-    shadow_rs::new().unwrap();
+    ShadowBuilder::builder().build().unwrap();
 }

komorebic/src/main.rs

@@ -35,6 +35,7 @@ use miette::SourceSpan;
 use paste::paste;
 use schemars::gen::SchemaSettings;
 use schemars::schema_for;
+use serde::Deserialize;
 use sysinfo::ProcessesToUpdate;
 use which::which;
 use windows::Win32::Foundation::HWND;
@@ -720,6 +721,13 @@ struct BorderImplementation {
     style: komorebi_client::BorderImplementation,
 }
 
+#[derive(Parser)]
+struct StackbarMode {
+    /// Desired stackbar mode
+    #[clap(value_enum)]
+    mode: komorebi_client::StackbarMode,
+}
+
 #[derive(Parser)]
 struct Animation {
     #[clap(value_enum)]
@@ -921,6 +929,13 @@ struct EnableAutostart {
     masir: bool,
 }
 
+#[derive(Parser)]
+struct Check {
+    /// Path to a static configuration JSON file
+    #[clap(action, short, long)]
+    komorebi_config: Option<PathBuf>,
+}
+
 #[derive(Parser)]
 struct ReplaceConfiguration {
     /// Static configuration JSON file from which the configuration should be loaded
@@ -953,7 +968,7 @@ enum SubCommand {
     /// Kill background processes started by komorebic
     Kill(Kill),
     /// Check komorebi configuration and related files for common errors
-    Check,
+    Check(Check),
     /// Show the path to komorebi.json
     #[clap(alias = "config")]
     Configuration,
@@ -1093,6 +1108,8 @@ enum SubCommand {
     /// Focus the specified monitor
     #[clap(arg_required_else_help = true)]
     FocusMonitor(FocusMonitor),
+    /// Focus the monitor at the current cursor location
+    FocusMonitorAtCursor,
     /// Focus the last focused workspace on the focused monitor
     FocusLastWorkspace,
     /// Focus the specified workspace on the focused monitor
@@ -1160,7 +1177,7 @@ enum SubCommand {
     #[clap(hide = true)]
     #[clap(arg_required_else_help = true)]
     LoadCustomLayout(LoadCustomLayout),
-    /// Flip the layout on the focused workspace (BSP only)
+    /// Flip the layout on the focused workspace
     #[clap(arg_required_else_help = true)]
     FlipLayout(FlipLayout),
     /// Promote the focused window to the top of the tree
@@ -1360,6 +1377,9 @@ enum SubCommand {
     /// Set the border implementation
     #[clap(arg_required_else_help = true)]
     BorderImplementation(BorderImplementation),
+    /// Set the stackbar mode
+    #[clap(arg_required_else_help = true)]
+    StackbarMode(StackbarMode),
     /// Enable or disable transparency for unfocused windows
     #[clap(arg_required_else_help = true)]
     Transparency(Transparency),
@@ -1575,7 +1595,7 @@ fn main() -> Result<()> {
                 std::fs::remove_file(shortcut_file)?;
             }
         }
-        SubCommand::Check => {
+        SubCommand::Check(args) => {
             let home_display = HOME_DIR.display();
             if HAS_CUSTOM_CONFIG_HOME.load(Ordering::SeqCst) {
                 println!("KOMOREBI_CONFIG_HOME detected: {home_display}\n");
@@ -1590,7 +1610,15 @@ fn main() -> Result<()> {
 
             println!("Looking for configuration files in {home_display}\n");
 
-            let static_config = HOME_DIR.join("komorebi.json");
+            let static_config = if let Some(static_config) = args.komorebi_config {
+                println!(
+                    "Using an arbitrary configuration file passed to --komorebi-config flag\n"
+                );
+                static_config
+            } else {
+                HOME_DIR.join("komorebi.json")
+            };
+
             let config_pwsh = HOME_DIR.join("komorebi.ps1");
             let config_ahk = HOME_DIR.join("komorebi.ahk");
             let config_whkd = WHKD_CONFIG_DIR.join("whkdrc");
@@ -1667,6 +1695,30 @@ fn main() -> Result<()> {
                 println!("No komorebi configuration found in {home_display}\n");
                 println!("If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration\n");
             }
+
+            let client = reqwest::blocking::Client::new();
+
+            if let Ok(response) = client
+                .get("https://api.github.com/repos/LGUG2Z/komorebi/releases/latest")
+                .header("User-Agent", "komorebic-version-checker")
+                .send()
+            {
+                let version = env!("CARGO_PKG_VERSION");
+
+                #[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");
+                    if trimmed > version {
+                        println!("An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}");
+                    }
+                }
+            }
         }
         SubCommand::Configuration => {
             let static_config = HOME_DIR.join("komorebi.json");
@@ -2050,7 +2102,7 @@ fn main() -> Result<()> {
             };
 
             let mut system = sysinfo::System::new_all();
-            system.refresh_processes(ProcessesToUpdate::All);
+            system.refresh_processes(ProcessesToUpdate::All, true);
 
             let mut attempts = 0;
             let mut running = system
@@ -2071,7 +2123,7 @@ fn main() -> Result<()> {
                 print!("Waiting for komorebi.exe to start...");
                 std::thread::sleep(Duration::from_secs(3));
 
-                system.refresh_processes(ProcessesToUpdate::All);
+                system.refresh_processes(ProcessesToUpdate::All, true);
 
                 if system
                     .processes_by_name("komorebi.exe".as_ref())
@@ -2246,6 +2298,30 @@ if (!(Get-Process masir -ErrorAction SilentlyContinue))
                 let stdout = String::from_utf8(output.stdout)?;
                 println!("{stdout}");
             }
+
+            let client = reqwest::blocking::Client::new();
+
+            if let Ok(response) = client
+                .get("https://api.github.com/repos/LGUG2Z/komorebi/releases/latest")
+                .header("User-Agent", "komorebic-version-checker")
+                .send()
+            {
+                let version = env!("CARGO_PKG_VERSION");
+
+                #[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");
+                    if trimmed > version {
+                        println!("An updated version of komorebi is available! https://github.com/LGUG2Z/komorebi/releases/v{trimmed}");
+                    }
+                }
+            }
         }
         SubCommand::Stop(arg) => {
             if arg.whkd {
@@ -2325,7 +2401,7 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
                 send_message(&SocketMessage::Stop)?;
             }
             let mut system = sysinfo::System::new_all();
-            system.refresh_processes(ProcessesToUpdate::All);
+            system.refresh_processes(ProcessesToUpdate::All, true);
 
             if system.processes_by_name("komorebi.exe".as_ref()).count() >= 1 {
                 println!("komorebi is still running, attempting to force-quit");
@@ -2514,6 +2590,9 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
         SubCommand::FocusMonitor(arg) => {
             send_message(&SocketMessage::FocusMonitorNumber(arg.target))?;
         }
+        SubCommand::FocusMonitorAtCursor => {
+            send_message(&SocketMessage::FocusMonitorAtCursor)?;
+        }
         SubCommand::FocusLastWorkspace => {
             send_message(&SocketMessage::FocusLastWorkspace)?;
         }
@@ -2721,6 +2800,9 @@ if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
         SubCommand::BorderImplementation(arg) => {
             send_message(&SocketMessage::BorderImplementation(arg.style))?;
         }
+        SubCommand::StackbarMode(arg) => {
+            send_message(&SocketMessage::StackbarMode(arg.mode))?;
+        }
         SubCommand::Transparency(arg) => {
             send_message(&SocketMessage::Transparency(arg.boolean_state.into()))?;
         }

mkdocs.yml

@@ -77,6 +77,7 @@ nav:
       - cli/quickstart.md
       - cli/start.md
       - cli/stop.md
+      - cli/kill.md
       - cli/check.md
       - cli/configuration.md
       - cli/bar-configuration.md
@@ -103,9 +104,11 @@ nav:
       - cli/force-focus.md
       - cli/cycle-focus.md
       - cli/cycle-move.md
+      - cli/eager-focus.md
       - cli/stack.md
       - cli/unstack.md
       - cli/cycle-stack.md
+      - cli/cycle-stack-index.md
       - cli/focus-stack-window.md
       - cli/stack-all.md
       - cli/unstack-all.md
@@ -124,11 +127,13 @@ nav:
       - cli/send-to-monitor-workspace.md
       - cli/move-to-monitor-workspace.md
       - cli/focus-monitor.md
+      - cli/focus-monitor-at-cursor.md
       - cli/focus-last-workspace.md
       - cli/focus-workspace.md
       - cli/focus-workspaces.md
       - cli/focus-monitor-workspace.md
       - cli/focus-named-workspace.md
+      - cli/close-workspace.md
       - cli/cycle-monitor.md
       - cli/cycle-workspace.md
       - cli/move-workspace-to-monitor.md
@@ -196,6 +201,7 @@ nav:
       - cli/clear-workspace-rules.md
       - cli/clear-named-workspace-rules.md
       - cli/clear-all-workspace-rules.md
+      - cli/enforce-workspace-rules.md
       - cli/identify-object-name-change-application.md
       - cli/identify-tray-application.md
       - cli/identify-layered-application.md
@@ -207,6 +213,7 @@ nav:
       - cli/border-offset.md
       - cli/border-style.md
       - cli/border-implementation.md
+      - cli/stackbar-mode.md
       - cli/transparency.md
       - cli/transparency-alpha.md
       - cli/toggle-transparency.md

schema.bar.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "KomobarConfig",
-  "description": "The `komorebi.bar.json` configuration file reference for `v0.1.32`",
+  "description": "The `komorebi.bar.json` configuration file reference for `v0.1.34`",
   "type": "object",
   "required": [
     "left_widgets",
@@ -36,6 +36,10 @@
                     "description": "Enable the Battery widget",
                     "type": "boolean"
                   },
+                  "hide_on_full_charge": {
+                    "description": "Hide the widget if the battery is at full charge",
+                    "type": "boolean"
+                  },
                   "label_prefix": {
                     "description": "Display label prefix",
                     "oneOf": [
@@ -194,6 +198,38 @@
                           }
                         },
                         "additionalProperties": false
+                      },
+                      {
+                        "description": "Custom format with modifiers",
+                        "type": "object",
+                        "required": [
+                          "CustomModifiers"
+                        ],
+                        "properties": {
+                          "CustomModifiers": {
+                            "description": "Custom format with additive modifiers for integer format specifiers",
+                            "type": "object",
+                            "required": [
+                              "format",
+                              "modifiers"
+                            ],
+                            "properties": {
+                              "format": {
+                                "description": "Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)",
+                                "type": "string"
+                              },
+                              "modifiers": {
+                                "description": "Additive modifiers for integer format specifiers (e.g. { \"%U\": 1 } to increment the zero-indexed week number by 1)",
+                                "type": "object",
+                                "additionalProperties": {
+                                  "type": "integer",
+                                  "format": "int32"
+                                }
+                              }
+                            }
+                          }
+                        },
+                        "additionalProperties": false
                       }
                     ]
                   },
@@ -235,6 +271,66 @@
             },
             "additionalProperties": false
           },
+          {
+            "type": "object",
+            "required": [
+              "Keyboard"
+            ],
+            "properties": {
+              "Keyboard": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 1 second)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Input widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
+          },
           {
             "type": "object",
             "required": [
@@ -719,6 +815,13 @@
                           "TwelveHour"
                         ]
                       },
+                      {
+                        "description": "Twelve-hour format (without seconds)",
+                        "type": "string",
+                        "enum": [
+                          "TwelveHourWithoutSeconds"
+                        ]
+                      },
                       {
                         "description": "Twenty-four-hour format (with seconds)",
                         "type": "string",
@@ -726,6 +829,27 @@
                           "TwentyFourHour"
                         ]
                       },
+                      {
+                        "description": "Twenty-four-hour format (without seconds)",
+                        "type": "string",
+                        "enum": [
+                          "TwentyFourHourWithoutSeconds"
+                        ]
+                      },
+                      {
+                        "description": "Twenty-four-hour format displayed as a binary clock with circles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)",
+                        "type": "string",
+                        "enum": [
+                          "BinaryCircle"
+                        ]
+                      },
+                      {
+                        "description": "Twenty-four-hour format displayed as a binary clock with rectangles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)",
+                        "type": "string",
+                        "enum": [
+                          "BinaryRectangle"
+                        ]
+                      },
                       {
                         "description": "Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)",
                         "type": "object",
@@ -778,6 +902,66 @@
               }
             },
             "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "required": [
+              "Update"
+            ],
+            "properties": {
+              "Update": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 12 hours)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Update widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
           }
         ]
       }
@@ -1122,6 +1306,11 @@
         }
       ]
     },
+    "height": {
+      "description": "Bar height (default: 50)",
+      "type": "number",
+      "format": "float"
+    },
     "icon_scale": {
       "description": "Scale of the icons relative to the font_size [[1.0-2.0]]. (default: 1.4)",
       "type": "number",
@@ -1154,6 +1343,10 @@
                     "description": "Enable the Battery widget",
                     "type": "boolean"
                   },
+                  "hide_on_full_charge": {
+                    "description": "Hide the widget if the battery is at full charge",
+                    "type": "boolean"
+                  },
                   "label_prefix": {
                     "description": "Display label prefix",
                     "oneOf": [
@@ -1312,6 +1505,38 @@
                           }
                         },
                         "additionalProperties": false
+                      },
+                      {
+                        "description": "Custom format with modifiers",
+                        "type": "object",
+                        "required": [
+                          "CustomModifiers"
+                        ],
+                        "properties": {
+                          "CustomModifiers": {
+                            "description": "Custom format with additive modifiers for integer format specifiers",
+                            "type": "object",
+                            "required": [
+                              "format",
+                              "modifiers"
+                            ],
+                            "properties": {
+                              "format": {
+                                "description": "Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)",
+                                "type": "string"
+                              },
+                              "modifiers": {
+                                "description": "Additive modifiers for integer format specifiers (e.g. { \"%U\": 1 } to increment the zero-indexed week number by 1)",
+                                "type": "object",
+                                "additionalProperties": {
+                                  "type": "integer",
+                                  "format": "int32"
+                                }
+                              }
+                            }
+                          }
+                        },
+                        "additionalProperties": false
                       }
                     ]
                   },
@@ -1353,6 +1578,66 @@
             },
             "additionalProperties": false
           },
+          {
+            "type": "object",
+            "required": [
+              "Keyboard"
+            ],
+            "properties": {
+              "Keyboard": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 1 second)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Input widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
+          },
           {
             "type": "object",
             "required": [
@@ -1837,6 +2122,13 @@
                           "TwelveHour"
                         ]
                       },
+                      {
+                        "description": "Twelve-hour format (without seconds)",
+                        "type": "string",
+                        "enum": [
+                          "TwelveHourWithoutSeconds"
+                        ]
+                      },
                       {
                         "description": "Twenty-four-hour format (with seconds)",
                         "type": "string",
@@ -1844,6 +2136,27 @@
                           "TwentyFourHour"
                         ]
                       },
+                      {
+                        "description": "Twenty-four-hour format (without seconds)",
+                        "type": "string",
+                        "enum": [
+                          "TwentyFourHourWithoutSeconds"
+                        ]
+                      },
+                      {
+                        "description": "Twenty-four-hour format displayed as a binary clock with circles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)",
+                        "type": "string",
+                        "enum": [
+                          "BinaryCircle"
+                        ]
+                      },
+                      {
+                        "description": "Twenty-four-hour format displayed as a binary clock with rectangles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)",
+                        "type": "string",
+                        "enum": [
+                          "BinaryRectangle"
+                        ]
+                      },
                       {
                         "description": "Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)",
                         "type": "object",
@@ -1896,30 +2209,78 @@
               }
             },
             "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "required": [
+              "Update"
+            ],
+            "properties": {
+              "Update": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 12 hours)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Update widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
           }
         ]
       }
     },
-    "max_label_width": {
-      "description": "Max label width before text truncation (default: 400.0)",
-      "type": "number",
-      "format": "float"
-    },
-    "monitor": {
-      "description": "Monitor options",
-      "type": "object",
-      "required": [
-        "index"
-      ],
-      "properties": {
-        "index": {
-          "description": "Komorebi monitor index of the monitor on which to render the bar",
-          "type": "integer",
-          "format": "uint",
-          "minimum": 0.0
+    "margin": {
+      "description": "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.",
+      "anyOf": [
+        {
+          "type": "number",
+          "format": "float"
         },
-        "work_area_offset": {
-          "description": "Automatically apply a work area offset for this monitor to accommodate the bar",
+        {
           "type": "object",
           "required": [
             "bottom",
@@ -1929,28 +2290,225 @@
           ],
           "properties": {
             "bottom": {
-              "description": "The bottom point in a Win32 Rect",
-              "type": "integer",
-              "format": "int32"
+              "type": "number",
+              "format": "float"
             },
             "left": {
-              "description": "The left point in a Win32 Rect",
-              "type": "integer",
-              "format": "int32"
+              "type": "number",
+              "format": "float"
             },
             "right": {
-              "description": "The right point in a Win32 Rect",
-              "type": "integer",
-              "format": "int32"
+              "type": "number",
+              "format": "float"
             },
             "top": {
-              "description": "The top point in a Win32 Rect",
-              "type": "integer",
-              "format": "int32"
+              "type": "number",
+              "format": "float"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "properties": {
+            "horizontal": {
+              "anyOf": [
+                {
+                  "type": "number",
+                  "format": "float"
+                },
+                {
+                  "type": "array",
+                  "items": [
+                    {
+                      "type": "number",
+                      "format": "float"
+                    },
+                    {
+                      "type": "number",
+                      "format": "float"
+                    }
+                  ],
+                  "maxItems": 2,
+                  "minItems": 2
+                }
+              ]
+            },
+            "vertical": {
+              "anyOf": [
+                {
+                  "type": "number",
+                  "format": "float"
+                },
+                {
+                  "type": "array",
+                  "items": [
+                    {
+                      "type": "number",
+                      "format": "float"
+                    },
+                    {
+                      "type": "number",
+                      "format": "float"
+                    }
+                  ],
+                  "maxItems": 2,
+                  "minItems": 2
+                }
+              ]
             }
           }
         }
-      }
+      ]
+    },
+    "max_label_width": {
+      "description": "Max label width before text truncation (default: 400.0)",
+      "type": "number",
+      "format": "float"
+    },
+    "monitor": {
+      "description": "The monitor index or the full monitor options",
+      "anyOf": [
+        {
+          "description": "The monitor index where you want the bar to show",
+          "type": "integer",
+          "format": "uint",
+          "minimum": 0.0
+        },
+        {
+          "description": "The full monitor options with the index and an optional work_area_offset",
+          "type": "object",
+          "required": [
+            "index"
+          ],
+          "properties": {
+            "index": {
+              "description": "Komorebi monitor index of the monitor on which to render the bar",
+              "type": "integer",
+              "format": "uint",
+              "minimum": 0.0
+            },
+            "work_area_offset": {
+              "description": "Automatically apply a work area offset for this monitor to accommodate the bar",
+              "type": "object",
+              "required": [
+                "bottom",
+                "left",
+                "right",
+                "top"
+              ],
+              "properties": {
+                "bottom": {
+                  "description": "The bottom point in a Win32 Rect",
+                  "type": "integer",
+                  "format": "int32"
+                },
+                "left": {
+                  "description": "The left point in a Win32 Rect",
+                  "type": "integer",
+                  "format": "int32"
+                },
+                "right": {
+                  "description": "The right point in a Win32 Rect",
+                  "type": "integer",
+                  "format": "int32"
+                },
+                "top": {
+                  "description": "The top point in a Win32 Rect",
+                  "type": "integer",
+                  "format": "int32"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    "padding": {
+      "description": "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.",
+      "anyOf": [
+        {
+          "type": "number",
+          "format": "float"
+        },
+        {
+          "type": "object",
+          "required": [
+            "bottom",
+            "left",
+            "right",
+            "top"
+          ],
+          "properties": {
+            "bottom": {
+              "type": "number",
+              "format": "float"
+            },
+            "left": {
+              "type": "number",
+              "format": "float"
+            },
+            "right": {
+              "type": "number",
+              "format": "float"
+            },
+            "top": {
+              "type": "number",
+              "format": "float"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "properties": {
+            "horizontal": {
+              "anyOf": [
+                {
+                  "type": "number",
+                  "format": "float"
+                },
+                {
+                  "type": "array",
+                  "items": [
+                    {
+                      "type": "number",
+                      "format": "float"
+                    },
+                    {
+                      "type": "number",
+                      "format": "float"
+                    }
+                  ],
+                  "maxItems": 2,
+                  "minItems": 2
+                }
+              ]
+            },
+            "vertical": {
+              "anyOf": [
+                {
+                  "type": "number",
+                  "format": "float"
+                },
+                {
+                  "type": "array",
+                  "items": [
+                    {
+                      "type": "number",
+                      "format": "float"
+                    },
+                    {
+                      "type": "number",
+                      "format": "float"
+                    }
+                  ],
+                  "maxItems": 2,
+                  "minItems": 2
+                }
+              ]
+            }
+          }
+        }
+      ]
     },
     "position": {
       "description": "Bar positioning options",
@@ -2025,6 +2583,10 @@
                     "description": "Enable the Battery widget",
                     "type": "boolean"
                   },
+                  "hide_on_full_charge": {
+                    "description": "Hide the widget if the battery is at full charge",
+                    "type": "boolean"
+                  },
                   "label_prefix": {
                     "description": "Display label prefix",
                     "oneOf": [
@@ -2183,6 +2745,38 @@
                           }
                         },
                         "additionalProperties": false
+                      },
+                      {
+                        "description": "Custom format with modifiers",
+                        "type": "object",
+                        "required": [
+                          "CustomModifiers"
+                        ],
+                        "properties": {
+                          "CustomModifiers": {
+                            "description": "Custom format with additive modifiers for integer format specifiers",
+                            "type": "object",
+                            "required": [
+                              "format",
+                              "modifiers"
+                            ],
+                            "properties": {
+                              "format": {
+                                "description": "Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)",
+                                "type": "string"
+                              },
+                              "modifiers": {
+                                "description": "Additive modifiers for integer format specifiers (e.g. { \"%U\": 1 } to increment the zero-indexed week number by 1)",
+                                "type": "object",
+                                "additionalProperties": {
+                                  "type": "integer",
+                                  "format": "int32"
+                                }
+                              }
+                            }
+                          }
+                        },
+                        "additionalProperties": false
                       }
                     ]
                   },
@@ -2224,6 +2818,66 @@
             },
             "additionalProperties": false
           },
+          {
+            "type": "object",
+            "required": [
+              "Keyboard"
+            ],
+            "properties": {
+              "Keyboard": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 1 second)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Input widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
+          },
           {
             "type": "object",
             "required": [
@@ -2708,6 +3362,13 @@
                           "TwelveHour"
                         ]
                       },
+                      {
+                        "description": "Twelve-hour format (without seconds)",
+                        "type": "string",
+                        "enum": [
+                          "TwelveHourWithoutSeconds"
+                        ]
+                      },
                       {
                         "description": "Twenty-four-hour format (with seconds)",
                         "type": "string",
@@ -2715,6 +3376,27 @@
                           "TwentyFourHour"
                         ]
                       },
+                      {
+                        "description": "Twenty-four-hour format (without seconds)",
+                        "type": "string",
+                        "enum": [
+                          "TwentyFourHourWithoutSeconds"
+                        ]
+                      },
+                      {
+                        "description": "Twenty-four-hour format displayed as a binary clock with circles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)",
+                        "type": "string",
+                        "enum": [
+                          "BinaryCircle"
+                        ]
+                      },
+                      {
+                        "description": "Twenty-four-hour format displayed as a binary clock with rectangles (with seconds) (https://en.wikipedia.org/wiki/Binary_clock)",
+                        "type": "string",
+                        "enum": [
+                          "BinaryRectangle"
+                        ]
+                      },
                       {
                         "description": "Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)",
                         "type": "object",
@@ -2767,6 +3449,66 @@
               }
             },
             "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "required": [
+              "Update"
+            ],
+            "properties": {
+              "Update": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 12 hours)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Update widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
           }
         ]
       }
@@ -2861,7 +3603,7 @@
               ]
             },
             "name": {
-              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)",
+              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)",
               "type": "string",
               "enum": [
                 "3024",

schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "StaticConfig",
-  "description": "The `komorebi.json` static configuration file reference for `v0.1.32`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.34`",
   "type": "object",
   "properties": {
     "animation": {
@@ -642,6 +642,53 @@
         ]
       }
     },
+    "floating_window_aspect_ratio": {
+      "description": "Aspect ratio to resize with when toggling floating mode for a window",
+      "anyOf": [
+        {
+          "description": "A predefined aspect ratio",
+          "oneOf": [
+            {
+              "description": "21:9",
+              "type": "string",
+              "enum": [
+                "Ultrawide"
+              ]
+            },
+            {
+              "description": "16:9",
+              "type": "string",
+              "enum": [
+                "Widescreen"
+              ]
+            },
+            {
+              "description": "4:3",
+              "type": "string",
+              "enum": [
+                "Standard"
+              ]
+            }
+          ]
+        },
+        {
+          "description": "A custom W:H aspect ratio",
+          "type": "array",
+          "items": [
+            {
+              "type": "integer",
+              "format": "int32"
+            },
+            {
+              "type": "integer",
+              "format": "int32"
+            }
+          ],
+          "maxItems": 2,
+          "minItems": 2
+        }
+      ]
+    },
     "focus_follows_mouse": {
       "description": "END OF LIFE FEATURE: Use https://github.com/LGUG2Z/masir instead",
       "oneOf": [
@@ -1227,8 +1274,17 @@
                     "RightMainVerticalStack"
                   ]
                 },
+                "layout_flip": {
+                  "description": "Specify an axis on which to flip the selected layout (default: None)",
+                  "type": "string",
+                  "enum": [
+                    "Horizontal",
+                    "Vertical",
+                    "HorizontalAndVertical"
+                  ]
+                },
                 "layout_rules": {
-                  "description": "Layout rules (default: None)",
+                  "description": "Layout rules in the format of threshold => layout (default: None)",
                   "type": "object",
                   "additionalProperties": {
                     "type": "string",
@@ -1267,6 +1323,28 @@
                     }
                   ]
                 },
+                "window_container_behaviour_rules": {
+                  "description": "Window container behaviour rules in the format of threshold => behaviour (default: None)",
+                  "type": "object",
+                  "additionalProperties": {
+                    "oneOf": [
+                      {
+                        "description": "Create a new container for each new window",
+                        "type": "string",
+                        "enum": [
+                          "Create"
+                        ]
+                      },
+                      {
+                        "description": "Append new windows to the focused window container",
+                        "type": "string",
+                        "enum": [
+                          "Append"
+                        ]
+                      }
+                    ]
+                  }
+                },
                 "workspace_padding": {
                   "description": "Container padding (default: global)",
                   "type": "integer",
@@ -1448,6 +1526,13 @@
         ]
       }
     },
+    "object_name_change_title_ignore_list": {
+      "description": "Do not process EVENT_OBJECT_NAMECHANGE events as Show events for identified applications matching these title regexes",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
     "remove_titlebar_applications": {
       "description": "HEAVILY DISCOURAGED: Identify applications for which komorebi should forcibly remove title bars",
       "type": "array",
@@ -2182,7 +2267,7 @@
               ]
             },
             "name": {
-              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)",
+              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/tinted-gallery/)",
               "type": "string",
               "enum": [
                 "3024",