perf(wm): clone-free locked deque insert/remove

This commit replaces my initial clumsy LockedDeque insert/remove
implementations with Clone-free implementations by @alex-ds13.

Cargo.toml

@@ -13,6 +13,7 @@ members = [
 
 [workspace.dependencies]
 clap = { version = "4", features = ["derive", "wrap_help"] }
+chrono-tz = "0.10"
 chrono = "0.4"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
@@ -34,16 +35,16 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 paste = "1"
 sysinfo = "0.33"
 uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "55cebdebfbd68dbd14945a1ba90f6b05b7be2893" }
-windows-numerics = { version = "0.1" }
-windows-implement = { version = "0.59" }
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "93949750b1f123fb79827ba4d66ffcab68055654" }
+windows-numerics = { version = "0.2" }
+windows-implement = { version = "0.60" }
 windows-interface = { version = "0.59" }
-windows-core = { version = "0.60" }
+windows-core = { version = "0.61" }
 shadow-rs = "1"
 which = "7"
 
 [workspace.dependencies.windows]
-version = "0.60"
+version = "0.61"
 features = [
     "Foundation_Numerics",
     "Win32_Devices",

README.md

@@ -71,6 +71,9 @@ showcases the many awesome projects that exist in the _komorebi_ ecosystem.
 
 ## Licensing for Personal Use
 
+`komorebi` is [educational source
+software](https://lgug2z.com/articles/educational-source-software/).
+
 `komorebi` is licensed under the [Komorebi 1.0.0
 license](https://github.com/LGUG2Z/komorebi-license), which is a fork of the
 [PolyForm Strict 1.0.0
@@ -99,7 +102,8 @@ me on GitHub.
 [GitHub Sponsors is enabled for this
 project](https://github.com/sponsors/LGUG2Z). Sponsors can claim custom roles on
 the Discord server, get shout outs at the end of _komorebi_-related videos on
-YouTube, and gain the ability to submit feature requests on the issue tracker.
+YouTube, gain the ability to submit feature requests on the issue tracker, and
+receive releases of komorebi with "easter eggs" on physical media.
 
 If you would like to tip or sponsor the project but are unable to use GitHub
 Sponsors, you may also sponsor through [Ko-fi](https://ko-fi.com/lgug2z), or
@@ -389,7 +393,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.34"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.35"}
 
 use anyhow::Result;
 use komorebi_client::Notification;

docs/common-workflows/multi-monitor-setup.md

@@ -0,0 +1,412 @@
+# Multi-Monitor Setup
+
+You can set up komorebi to work with multiple monitors. To do so, first you start by setting up multiple monitor
+configurations on your `komorebi.json` config file.
+
+If you've used the [`komorebic quickstart`](../cli/quickstart.md) command you'll already have a `komorebi.json` config
+file with one monitor config setup. Open this file and look for the `"monitors":` line, you should find something like
+this:
+
+```json
+{
+  "monitors": [
+    {
+      "workspaces": [
+        {
+          "name": "I",
+          "layout": "BSP"
+        },
+        {
+          "name": "II",
+          "layout": "VerticalStack"
+        },
+        {
+          "name": "III",
+          "layout": "HorizontalStack"
+        },
+        {
+          "name": "IV",
+          "layout": "UltrawideVerticalStack"
+        },
+        {
+          "name": "V",
+          "layout": "Rows"
+        },
+        {
+          "name": "VI",
+          "layout": "Grid"
+        },
+        {
+          "name": "VII",
+          "layout": "RightMainVerticalStack"
+        }
+      ]
+    }
+  ]
+}
+```
+
+For this example we will remove some workspaces to simplify the config so it is easier to look at, but feel free to
+set up as many workspaces per monitor as you'd like. Here is the same configuration with only 3 workspaces.
+
+```json
+{
+  "monitors": [
+    {
+      "workspaces": [
+        {
+          "name": "I",
+          "layout": "BSP"
+        },
+        {
+          "name": "II",
+          "layout": "VerticalStack"
+        },
+        {
+          "name": "III",
+          "layout": "HorizontalStack"
+        }
+      ]
+    }
+  ]
+}
+```
+
+Let's add another monitor:
+
+```json
+{
+  "monitors": [
+    // monitor 1, index 0
+    {
+      "workspaces": [
+        {
+          "name": "I",
+          "layout": "BSP"
+        },
+        {
+          "name": "II",
+          "layout": "VerticalStack"
+        },
+        {
+          "name": "III",
+          "layout": "HorizontalStack"
+        }
+      ]
+    },
+    // monitor 2, index 1
+    {
+      "workspaces": [
+        {
+          "name": "1",
+          "layout": "BSP"
+        },
+        {
+          "name": "2",
+          "layout": "VerticalStack"
+        },
+        {
+          "name": "3",
+          "layout": "HorizontalStack"
+        }
+      ]
+    }
+  ]
+}
+```
+
+Now have two monitor configurations. We have the first monitor configuration, which is index 0 (*usually
+on programming languages the first item of a list starts with index 0*), this configuration has 3 workspaces with names
+"I", "II" and "III". Then the 2nd monitor configuration, which is index 1, also has 3 workspaces with names "1", "2",
+and "3" (you should always give unique names to your workspaces).
+
+Now if you start komorebi with two monitors connected, the main monitor will use the configuration with index 0 and the
+secondary monitor will use the configuration with index 1.
+
+---
+
+Let's say you have more monitors, or you want to make sure that a certain configuration is always applied to a certain
+monitor. For this you will want to use the `display_index_preferences`.
+
+Open up a terminal and type the following command: [ `komorebic monitor-info`](../cli/monitor-information.md). This
+command will give you the information about your connected monitors, you want to look up the `serial_number_id`. You
+should get something like this:
+
+```
+❯ komorebic monitor-info
+[
+  {
+    "id": 6620935,
+    "name": "DISPLAY1",
+    "device": "BOE0A1C",
+    "device_id": "BOE0A1C-5&a2bea0b&0&UID512",
+    "serial_number_id": "0",
+    "size": {
+      "left": 0,
+      "top": 0,
+      "right": 1920,
+      "bottom": 1080
+    }
+  },
+  {
+    "id": 181932057,
+    "name": "DISPLAY2",
+    "device": "VSC8C31",
+    "device_id": "VSC8C31-5&18560b1f&0&UID4356",
+    "serial_number_id": "UEP174021562",
+    "size": {
+      "left": 0,
+      "top": -1080,
+      "right": 1920,
+      "bottom": 1080
+    }
+  }
+]
+```
+
+In this case the setup is a laptop with a secondary monitor connected. You'll need to figure out which monitor is which,
+usually the display name's number should be similar to the numbers you can find on
+`Windows Settings -> System -> Display`.
+
+If you have trouble with this step you can always jump on Discord and ask for help (create a `Support` thread).
+
+Once you know which monitor is which, you want to look up their `serial_number_id` to use that on
+`display_index_preferences`, you can also use the `device_id`, it accepts both however there have been reported cases
+where the `device_id` changes after a restart while the `serial_number_id` doesn't.
+
+So with the example above, we want the laptop to always use the configuration index 0 and the other monitor to use
+configuration index 1, so we map the configuration index number to the monitor `serial_number_id`/`device_id` like this:
+
+```json
+{
+  "display_index_preferences": {
+    "0": "0",
+    "1": "UEP174021562"
+  }
+}
+```
+
+Again you could also have used the `device_id` like this:
+
+```json
+{
+  "display_index_preferences": {
+    "0": "BOE0A1C-5&a2bea0b&0&UID512",
+    "1": "VSC8C31-5&18560b1f&0&UID4356"
+  }
+}
+```
+
+You should add this `display_index_preferences` option to your `komorebi.json` file. If you find that something is
+not working as expected you can try to use the command `komorebic check`.
+
+> [!IMPORTANT]
+>
+> **When using multiple monitors it is recommended to always set the `display_index_preferences`. If you don't you might
+get some undefined behaviour.**
+
+---
+
+If you would like to run multiple instances of `komorebi-bar` to target different monitors, it is possible to do so
+using the `bar_configurations` array in your `komorebi.json` configuration file. You can refer to the
+[multiple-bar-instances](multiple-bar-instances.md) documentation.
+
+In this case it is important to use `display_index_preferences`, because if you don't, and you have 3 or more monitors,
+disconnecting and reconnecting monitors may result in the bars for the monitors getting shifted around.
+
+Consider this setup with 3 monitors (A, B and C):
+
+```json
+// HOME_MONITOR_1_BAR.json
+{
+  "monitor_index": 0
+  //...
+}
+```
+
+```json
+// HOME_MONITOR_2_BAR.json
+{
+  "monitor_index": 1
+  //...
+}
+```
+
+```json
+// WORK_MONITOR_1_BAR.json
+{
+  "monitor_index": 2
+  //...
+}
+```
+
+```json
+{
+  "display_index_preferences": {
+    "0": "MONITOR_1_ID",
+    "1": "MONITOR_2_ID",
+    "2": "MONITOR_3_ID"
+  },
+  "bar_configurations": [
+    // this bar uses "monitor_index": 0,
+    "path/to/bar_config_1.json",
+    // this bar uses "monitor_index": 1,
+    "path/to/bar_config_2.json",
+    // this bar uses "monitor_index": 2,
+    "path/to/bar_config_3.json"
+  ]
+}
+```
+
+Komorebi uses an internal map to keep track of monitor to config indices, this map is called `monitor_usr_idx_map` it is
+an internal variable to komorebi that you don't need to do anything with, but you can see it with the [
+`komorebic state`](../cli/state.md) command (in case you need to debug something).
+
+At first, komorebi will load all monitors and set the internal index map (`monitor_usr_idx_map`) as:
+
+```json
+{
+  // This is monitor A
+  "0": 0,
+  // This is monitor B
+  "1": 1,
+  // This is monitor C
+  "2": 2
+}
+```
+
+Which kind of seems unnecessary, but imagine that then you disconnect monitor B (or it goes to sleep). Then komorebi
+will only have 2 monitors with index 0 and 1, so the above map will be updated to this:
+
+```jsonc
+[
+  "0": 0, // This is monitor A
+  "2": 1, // This is now monitor C, because monitor B disconnected
+]
+```
+
+So now the bar intended to be for monitor B, which was looking for index "1" on that map, doesn't see it and knows it
+should be disabled. And the bar for monitor C looks at that map and knows that it's index "2" now maps to index 1 so it
+uses that index internally to get all the correct values about the monitor.
+
+If you didn't have the `display_index_preferences` set, then when you disconnected monitor B, komorebi wouldn't know
+how to map the indices and would use default behaviour which would result in a map like this:
+
+```json
+{
+  // This is monitor A 
+  "0": 0,
+  // This is monitor C, because monitor B disconnected. However the bars will think it is monitor B because it has index "1" 
+  "1": 1
+}
+```
+
+# Multiple Monitors on different machines
+
+You can use the same `komorebi.json` to configure two different setups and then synchronize your config across machines.
+However, if you do this it is important to be aware of a few things.
+
+Firstly, using `display_index_preferences` is required in this case.
+
+You will need to get the `serial_number_id` or `device_id` of all the monitors of all your setups. With that information
+you would then set your config like this:
+
+```json
+{
+  "display_index_preferences": {
+    "0": "HOME_MONITOR_1_ID",
+    "1": "HOME_MONITOR_2_ID",
+    "2": "WORK_MONITOR_1_ID",
+    "3": "WORK_MONITOR_2_ID"
+  },
+  "monitors": [
+    // HOME_MONITOR_1
+    {
+      "workspaces": [
+        // ...
+      ]
+    },
+    // HOME_MONITOR_2
+    {
+      "workspaces": [
+        // ...
+      ]
+    },
+    // WORK_MONITOR_1
+    {
+      "workspaces": [
+        // ...
+      ]
+    },
+    // WORK_MONITOR_2
+    {
+      "workspaces": [
+        // ...
+      ]
+    }
+  ]
+}
+```
+
+> [!NOTE]
+>
+> *You can't use the same config on two different monitors, you have to make a duplicated config for each monitor!*
+
+Then on the bar configs you need to set the bar's monitor index like this:
+
+```json
+// HOME_MONITOR_1_BAR.json
+{
+  "monitor_index": 0
+  //...
+}
+```
+
+```json
+// HOME_MONITOR_2_BAR.json
+{
+  "monitor_index": 1
+  //...
+}
+```
+
+```json
+// WORK_MONITOR_1_BAR.json
+{
+  "monitor_index": 2
+  //...
+}
+```
+
+```json
+// WORK_MONITOR_2_BAR.json
+{
+  "monitor_index": 3
+  //...
+}
+```
+
+Although you will only ever have 2 monitors connected at any one time, and they'll always have index 0 and 1, the
+above config will still work on both physical configurations.
+
+This is because komorebi will apply the appropriate config to the loaded monitors and will create a map of the user
+index (the index defined in the user config) to the actual monitor index, and the bar will use that map to know if it
+should be enabled, and where it should be drawn.
+
+### Things to keep in mind
+
+* If you are using a laptop connected to one monitor at work and a different one at home, the work monitor and the home
+  monitor are considered different monitors by komorebi
+* When you disconnect from work, komorebi will keep the work monitor cached
+* You can still use a laptop alone without any monitor and if you need a window that was on the other monitor you can
+  press the taskbar icon or use `alt + tab` to bring it to focus and that window will now be part of the laptop monitor
+* If you then reconnect the work monitor, the cached version will be applied with all its windows (except any window(s)
+  you might have moved to another monitor)
+* If however, instead of reconnecting the work monitor, you connect the home monitor, then the work monitor will still
+  remain cached, and komorebi will load the home monitor from the cache (if it exists)
+* Sometimes when you disconnect/reconnect a monitor the event might be missed by komorebi, meaning that Windows will
+  show you both monitors but komorebi won't know about the existence of one of them
+* If you notice this type of weird behaviour, always run the [
+  `komorebic monitor-info`](../cli/monitor-information.md)
+  command and validate if one of the monitors is missing
+* To fix this you can try disconnecting and reconnecting the monitor again, or restarting komorebi

docs/komorebi.bar.example.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.34/schema.bar.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.35/schema.bar.json",
   "monitor": 0,
   "font_family": "JetBrains Mono",
   "theme": {

docs/komorebi.example.json

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

docs/usage/focusing-windows.md

@@ -0,0 +1,46 @@
+# Focusing Windows
+
+Windows can be focused in a direction (left, down, up, right) using the [`komorebic focus`](../cli/focus.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + h                 : komorebic focus left
+alt + j                 : komorebic focus down
+alt + k                 : komorebic focus up
+alt + l                 : komorebic focus right
+```
+
+Windows can be focused in a cycle direction (previous, next) using the [`komorebic cycle-focus`](../cli/cycle-focus.md)
+command.
+
+```
+# example showing you might bind this command
+
+alt + shift + oem_4     : komorebic cycle-focus previous # oem_4 is [
+alt + shift + oem_6     : komorebic cycle-focus next # oem_6 is ]
+```
+
+It is possible to attempt to focus the first window, on any workspace, matching an exe using the [
+`komorebic eager-focus`](../cli/eager-focus.md) command.
+
+```
+# example showing how you might bind this command
+
+win + 1                 : komorebic eager-focus firefox.exe
+```
+
+The window at the largest tile can be focused using the [`komorebic promote-focus`](../cli/promote-focus.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + return            : komorebic promote-focus
+```
+
+The behaviour when attempting to call `komorebic focus` when at the left or right edge of a monitor is determined by
+the [`cross_boundary_behaviour`](https://komorebi.lgug2z.com/schema#cross_boundary_behaviour) configuration option.
+
+When set to `Workspace`, the next workspace on the same monitor will be focused.
+
+When set to `Monitor`, the focused workspace on the next monitor in the given direction will be focused.

docs/usage/focusing-workspaces.md

@@ -0,0 +1,59 @@
+# Focusing Workspaces
+
+Workspaces on the focused monitor can be focused by their index using the [
+`komorebic focus-workspace`](../cli/focus-workspace.md)  command.
+
+If this command is called with an index for a workspace which does not exist, that workspace, and all workspace indexes
+required to get to that workspace, will be created.
+
+```
+# example showing how you might bind this command
+
+alt + 1                 : komorebic focus-workspace 0
+alt + 2                 : komorebic focus-workspace 1
+alt + 3                 : komorebic focus-workspace 2
+```
+
+Workspaces on the focused monitor can be focused in a cycle direction (previous, next) using the [
+`komorebic cycle-workspace`](../cli/cycle-workspace.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + shift + oem_4     : komorebic cycle-workspace previous # oem_4 is [
+alt + shift + oem_6     : komorebic cycle-workspace next # oem_6 is ]
+```
+
+Workspaces on other monitors can be focused by both the monitor index and the workspace index using the [
+`komorebic focus-monitor-workspace`](../cli/focus-monitor-workspace.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + 1                 : komorebic focus-monitor-workspace 0 0
+alt + 2                 : komorebic focus-monitor-workspace 0 1 
+alt + 3                 : komorebic focus-monitor-workspace 1 0
+```
+
+Workspaces on any monitor can be focused by their name (given that all workspace names across all monitors are unique)
+using the [`komorebic focus-named-workspace`](../cli/focus-named-workspace.md)  command.
+
+```
+# example showing how you might bind this command
+
+alt + c                 : komorebic focus-named-workspace coding
+```
+
+Workspaces on all monitors can be set to the same index (emulating single workspaces which span across all monitors)
+using the [`komorebic focus-workspaces`](../cli/focus-workspaces.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + 1                 : komorebic focus-workspaces 0
+alt + 2                 : komorebic focus-workspaces 1
+alt + 3                 : komorebic focus-workspaces 2
+```
+
+The last focused workspace on the focused monitor can be re-focused using the [
+`komorebic focus-last-workspace`](../cli/focus-last-workspace.md) command.

docs/usage/moving-windows-across-workspaces.md

@@ -0,0 +1,59 @@
+# Moving Windows Across Workspaces
+
+Windows can be moved to another workspace on the focused monitor using the [
+`komorebic move-to-workspace`](../cli/move-to-workspace.md) command. This command will also move your focus to the
+target workspace.
+
+```
+# example showing how you might bind this command
+
+alt + shift + 1         : komorebic move-to-workspace 0
+alt + shift + 2         : komorebic move-to-workspace 1
+alt + shift + 3         : komorebic move-to-workspace 2
+```
+
+Windows can be sent to another workspace on the focused monitor using the [
+`komorebic send-to-workspace`](../cli/send-to-workspace.md) command. This command will keep your focus on the origin
+workspace.
+
+```
+# example showing how you might bind this command
+
+alt + shift + 1         : komorebic send-to-workspace 0
+alt + shift + 2         : komorebic send-to-workspace 1
+alt + shift + 3         : komorebic send-to-workspace 2
+```
+
+Windows can be moved to another workspace on the focused monitor in a cycle direction (previous, next) using the [
+`komorebic cycle-move-to-workspace`](../cli/cycle-move-to-workspace.md) command. This command will also move your focus
+to the target workspace.
+
+```
+# example showing how you might bind this command
+
+alt + shift + oem_4     : komorebic cycle-move-to-workspace previous # oem_4 is [
+alt + shift + oem_6     : komorebic cycle-move-to-workspace next # oem_6 is ]
+```
+
+Windows can be sent to another workspace on the focused monitor in a cycle direction (previous, next) using the [
+`komorebic cycle-move-to-workspace`](../cli/cycle-move-to-workspace.md) command. This command will keep your focus on
+the origin workspace.
+
+```
+# example showing how you might bind this command
+
+alt + shift + oem_4     : komorebic cycle-send-to-workspace previous # oem_4 is [
+alt + shift + oem_6     : komorebic cycle-send-to-workspace next # oem_6 is ]
+```
+
+Windows can be moved or sent to the focused workspace on a another monitor using the [
+`komorebic move-to-monitor`](../cli/move-to-monitor.md) and [`komorebic send-to-monitor`](../cli/send-to-monitor.md)
+commands.
+
+Windows can be moved or sent to the focused workspace on a monitor in a cycle direction (previous, next) using the [
+`komorebic cycle-move-to-monitor`](../cli/cycle-move-to-monitor.md) and [
+`komorebic cycle-send-to-monitor`](../cli/cycle-send-to-monitor.md) commands.
+
+Windows can be moved or sent to a named workspace on any monitor (given that all workspace names across all monitors are
+unique) using the [`komorebic move-to-named-workspace`](../cli/move-to-named-workspace.md) and [
+`komorebic send-to-named-workspace`](../cli/send-to-named-workspace.md) commands

docs/usage/moving-windows.md

@@ -0,0 +1,50 @@
+# Moving Windows
+
+Windows can be moved in a direction (left, down, up, right) using the [`komorebic move`](../cli/move.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + shift + h         : komorebic move left
+alt + shift + j         : komorebic move down
+alt + shift + k         : komorebic move up
+alt + shift + l         : komorebic move right
+```
+
+Windows can be moved in a cycle direction (previous, next) using the [`komorebic cycle-move`](../cli/cycle-move.md)
+command.
+
+```
+# example showing how you might bind this command
+
+alt + shift + oem_4     : komorebic cycle-move previous # oem_4 is [
+alt + shift + oem_6     : komorebic cycle-move next # oem_6 is ]
+```
+
+The focused window can be moved to the largest tile using the [`komorebic promote`](../cli/promote.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + shift + return    : komorebic promote
+```
+
+The behaviour when attempting to call `komorebic move` when at the left or right edge of a monitor is determined by
+the [`cross_boundary_behaviour`](https://komorebi.lgug2z.com/schema#cross_boundary_behaviour) configuration option.
+
+When set to `Workspace`, the focused window will be moved to the next workspace on the focused monitor in the given
+direction
+
+When set to `Monitor`, the focused window will be moved to the focused workspace on the next monitor in the given
+direction.
+
+The behaviour when calling `komorebic move` with `cross_boundary_behaviour` set to `Monitor` can be further refined with
+the [`cross_monitor_move_behaviour`](https://komorebi.lgug2z.com/schema#cross_monitor_move_behaviour) configuration
+option.
+
+When set to `Swap`, the focused window will be swapped with the window at the corresponding edge of the adjacent monitor
+
+When set to `Insert`, the focused window will be inserted into the focused workspace on the adjacent monitor.
+
+When set to `NoOp`, the focused window will not be moved across a monitor boundary, though focusing across monitor
+boundaries will continue to function.

docs/usage/stacking-windows.md

@@ -0,0 +1,52 @@
+# Stacking Windows
+
+Windows can be stacked in a direction (left, down, up, right) using the [`komorebic stack`](../cli/stack.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + left              : komorebic stack left
+alt + down              : komorebic stack down
+alt + up                : komorebic stack up
+alt + right             : komorebic stack right
+```
+
+Windows can be popped from a stack using the [`komorebic unstack`](../cli/unstack.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + oem_1             : komorebic unstack # oem_1 is ;
+```
+
+Windows in a stack can be focused in a cycle direction (previous, next) using the [
+`komorebic cycle-stack`](../cli/cycle-stack.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + oem_4             : komorebic cycle-stack previous # oem_4 is [
+alt + oem_6             : komorebic cycle-stack next # oem_6 is ]
+```
+
+Windows in a stack can have their positions in the stack moved in a cycle direction (previous, next) using the [
+`komorebic cycle-stack-index`](../cli/cycle-stack-index.md) command.
+
+```
+# example showing how you might bind this command
+
+alt + shift + oem_4     : komorebic cycle-stack-index previous # oem_4 is [
+alt + shift + oem_6     : komorebic cycle-stack-index next # oem_6 is ]
+```
+
+Windows in a stack can be focused by their index in the stack using the [
+`komorebic focus-stack-window`](../cli/focus-stack-window.md) command.
+
+All windows on the focused workspace can be combined into a single stack using the [
+`komorebic stack-all`](../cli/stack-all.md) command.
+
+All windows in a focused stack can be popped using the [`komorebic unstack-all`](../cli/unstack-all.md) command.
+
+It is possible to tell the window manager to stack the next opened window on top of the currently focused window by
+using the [
+`komorebic toggle-workspace-window-container-behaviour`](../cli/toggle-workspace-window-container-behaviour.md) command.

komorebi-bar/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.35"
+version = "0.1.36"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -9,6 +9,7 @@ edition = "2021"
 komorebi-client = { path = "../komorebi-client" }
 komorebi-themes = { path = "../komorebi-themes" }
 
+chrono-tz = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
 color-eyre = { workspace = true }
@@ -20,11 +21,12 @@ egui-phosphor = "0.9"
 font-loader = "0.11"
 hotwatch = { workspace = true }
 image = "0.25"
-netdev = "0.32"
+lazy_static = { workspace = true }
+netdev = "0.33"
 num = "0.4"
 num-derive = "0.4"
 num-traits = "0.2"
-random_word = { version = "0.4", features = ["en"] }
+random_word = { version = "0.5", features = ["en"] }
 reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true }

komorebi-bar/src/bar.rs

@@ -4,15 +4,15 @@ use crate::config::KomobarTheme;
 use crate::config::MonitorConfigOrIndex;
 use crate::config::Position;
 use crate::config::PositionConfig;
-use crate::komorebi::Komorebi;
-use crate::komorebi::KomorebiNotificationState;
 use crate::process_hwnd;
 use crate::render::Color32Ext;
 use crate::render::Grouping;
 use crate::render::RenderConfig;
 use crate::render::RenderExt;
-use crate::widget::BarWidget;
-use crate::widget::WidgetConfig;
+use crate::widgets::komorebi::Komorebi;
+use crate::widgets::komorebi::KomorebiNotificationState;
+use crate::widgets::widget::BarWidget;
+use crate::widgets::widget::WidgetConfig;
 use crate::KomorebiEvent;
 use crate::BAR_HEIGHT;
 use crate::DEFAULT_PADDING;

komorebi-bar/src/config.rs

@@ -1,5 +1,5 @@
 use crate::render::Grouping;
-use crate::widget::WidgetConfig;
+use crate::widgets::widget::WidgetConfig;
 use crate::DEFAULT_PADDING;
 use eframe::egui::Pos2;
 use eframe::egui::TextBuffer;
@@ -13,7 +13,7 @@ use std::path::PathBuf;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.35`
+/// The `komorebi.bar.json` configuration file reference for `v0.1.36`
 pub struct KomobarConfig {
     /// Bar height (default: 50)
     pub height: Option<f32>,

komorebi-bar/src/main.rs

@@ -1,21 +1,9 @@
 mod bar;
-mod battery;
 mod config;
-mod cpu;
-mod date;
-mod keyboard;
-mod komorebi;
-mod komorebi_layout;
-mod media;
-mod memory;
-mod network;
 mod render;
 mod selected_frame;
-mod storage;
-mod time;
 mod ui;
-mod update;
-mod widget;
+mod widgets;
 
 use crate::bar::Komobar;
 use crate::config::KomobarConfig;
@@ -349,7 +337,7 @@ fn main() -> color_eyre::Result<()> {
 
             let ctx_komorebi = cc.egui_ctx.clone();
             std::thread::spawn(move || {
-                let subscriber_name = format!("komorebi-bar-{}", random_word::gen(random_word::Lang::En));
+                let subscriber_name = format!("komorebi-bar-{}", random_word::get(random_word::Lang::En));
 
                 let listener = komorebi_client::subscribe_with_options(&subscriber_name, SubscribeOptions {
                     filter_state_changes: true,

komorebi-bar/src/widgets/battery.rs

@@ -1,7 +1,7 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/cpu.rs

@@ -1,7 +1,7 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/date.rs

@@ -1,7 +1,9 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
+use chrono::Local;
+use chrono_tz::Tz;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
@@ -11,6 +13,8 @@ use eframe::egui::Ui;
 use eframe::egui::WidgetText;
 use serde::Deserialize;
 use serde::Serialize;
+use std::time::Duration;
+use std::time::Instant;
 
 /// Custom format with additive modifiers for integer format specifiers
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -38,7 +42,7 @@ impl CustomModifiers {
             }
 
             // get the strftime value of modifier
-            let formatted_modifier = chrono::Local::now().format(modifier).to_string();
+            let formatted_modifier = Local::now().format(modifier).to_string();
 
             // find the gotten value in the original output
             if let Some(pos) = modified_output.find(&formatted_modifier) {
@@ -64,14 +68,35 @@ pub struct DateConfig {
     pub format: DateFormat,
     /// Display label prefix
     pub label_prefix: Option<LabelPrefix>,
+    /// TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)
+    ///
+    /// Use a custom format to display additional information, i.e.:
+    /// ```json
+    /// {
+    ///     "Date": {
+    ///         "enable": true,
+    ///         "format": { "Custom": "%D %Z (Tokyo)" },
+    ///         "timezone": "Asia/Tokyo"
+    ///      }
+    ///}
+    /// ```
+    pub timezone: Option<String>,
 }
 
 impl From<DateConfig> for Date {
     fn from(value: DateConfig) -> Self {
+        let data_refresh_interval = 1;
+
         Self {
             enable: value.enable,
             format: value.format,
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
+            timezone: value.timezone,
+            data_refresh_interval,
+            last_state: String::new(),
+            last_updated: Instant::now()
+                .checked_sub(Duration::from_secs(data_refresh_interval))
+                .unwrap(),
         }
     }
 }
@@ -121,19 +146,46 @@ pub struct Date {
     pub enable: bool,
     pub format: DateFormat,
     label_prefix: LabelPrefix,
+    timezone: Option<String>,
+    data_refresh_interval: u64,
+    last_state: String,
+    last_updated: Instant,
 }
 
 impl Date {
     fn output(&mut self) -> String {
-        let formatted = chrono::Local::now()
-            .format(&self.format.fmt_string())
-            .to_string();
+        let mut output = self.last_state.clone();
+        let now = Instant::now();
 
-        // if custom modifiers are used, apply them
-        match &self.format {
-            DateFormat::CustomModifiers(custom) => custom.apply(&formatted),
-            _ => formatted,
+        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
+            let formatted = match &self.timezone {
+                Some(timezone) => match timezone.parse::<Tz>() {
+                    Ok(tz) => Local::now()
+                        .with_timezone(&tz)
+                        .format(&self.format.fmt_string())
+                        .to_string()
+                        .trim()
+                        .to_string(),
+                    Err(_) => format!("Invalid timezone: {}", timezone),
+                },
+                None => Local::now()
+                    .format(&self.format.fmt_string())
+                    .to_string()
+                    .trim()
+                    .to_string(),
+            };
+
+            // if custom modifiers are used, apply them
+            output = match &self.format {
+                DateFormat::CustomModifiers(custom) => custom.apply(&formatted),
+                _ => formatted,
+            };
+
+            self.last_state.clone_from(&output);
+            self.last_updated = now;
         }
+
+        output
     }
 }
 

komorebi-bar/src/widgets/keyboard.rs

@@ -1,6 +1,6 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/komorebi.rs

@@ -2,12 +2,12 @@ use crate::bar::apply_theme;
 use crate::config::DisplayFormat;
 use crate::config::KomobarTheme;
 use crate::config::WorkspacesDisplayFormat;
-use crate::komorebi_layout::KomorebiLayout;
 use crate::render::Grouping;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
-use crate::widget::BarWidget;
+use crate::widgets::komorebi_layout::KomorebiLayout;
+use crate::widgets::widget::BarWidget;
 use crate::ICON_CACHE;
 use crate::MAX_LABEL_WIDTH;
 use crate::MONITOR_INDEX;
@@ -403,6 +403,7 @@ impl BarWidget for Komorebi {
 
                             if layer_frame.clicked()
                                 && komorebi_client::send_batch([
+                                    SocketMessage::FocusMonitorAtCursor,
                                     SocketMessage::MouseFollowsFocus(false),
                                     SocketMessage::ToggleWorkspaceLayer,
                                     SocketMessage::MouseFollowsFocus(

komorebi-bar/src/widgets/komorebi_layout.rs

@@ -1,7 +1,7 @@
 use crate::config::DisplayFormat;
-use crate::komorebi::KomorebiLayoutConfig;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
+use crate::widgets::komorebi::KomorebiLayoutConfig;
 use eframe::egui::vec2;
 use eframe::egui::Context;
 use eframe::egui::CornerRadius;
@@ -105,12 +105,22 @@ impl KomorebiLayout {
                 }
             }
             KomorebiLayout::Monocle => {
-                if komorebi_client::send_message(&SocketMessage::ToggleMonocle).is_err() {
+                if komorebi_client::send_batch([
+                    SocketMessage::FocusMonitorAtCursor,
+                    SocketMessage::ToggleMonocle,
+                ])
+                .is_err()
+                {
                     tracing::error!("could not send message to komorebi: ToggleMonocle");
                 }
             }
             KomorebiLayout::Floating => {
-                if komorebi_client::send_message(&SocketMessage::ToggleTiling).is_err() {
+                if komorebi_client::send_batch([
+                    SocketMessage::FocusMonitorAtCursor,
+                    SocketMessage::ToggleTiling,
+                ])
+                .is_err()
+                {
                     tracing::error!("could not send message to komorebi: ToggleTiling");
                 }
             }

komorebi-bar/src/widgets/media.rs

@@ -1,7 +1,7 @@
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
 use crate::ui::CustomUi;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use crate::MAX_LABEL_WIDTH;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;

komorebi-bar/src/widgets/memory.rs

@@ -1,7 +1,7 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/mod.rs

@@ -0,0 +1,13 @@
+pub mod battery;
+pub mod cpu;
+pub mod date;
+pub mod keyboard;
+pub mod komorebi;
+mod komorebi_layout;
+pub mod media;
+pub mod memory;
+pub mod network;
+pub mod storage;
+pub mod time;
+pub mod update;
+pub mod widget;

komorebi-bar/src/widgets/network.rs

@@ -1,7 +1,7 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/storage.rs

@@ -1,7 +1,7 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/time.rs

@@ -2,7 +2,10 @@ use crate::bar::Alignment;
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
+use chrono::Local;
+use chrono::NaiveTime;
+use chrono_tz::Tz;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;
@@ -14,8 +17,58 @@ use eframe::egui::TextFormat;
 use eframe::egui::Ui;
 use eframe::egui::Vec2;
 use eframe::epaint::StrokeKind;
+use lazy_static::lazy_static;
 use serde::Deserialize;
 use serde::Serialize;
+use std::time::Duration;
+use std::time::Instant;
+
+lazy_static! {
+    static ref TIME_RANGES: Vec<(&'static str, NaiveTime)> = {
+        vec![
+            (
+                egui_phosphor::regular::MOON,
+                NaiveTime::from_hms_opt(0, 0, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::ALARM,
+                NaiveTime::from_hms_opt(6, 0, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::BREAD,
+                NaiveTime::from_hms_opt(6, 1, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::BARBELL,
+                NaiveTime::from_hms_opt(6, 30, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::COFFEE,
+                NaiveTime::from_hms_opt(8, 0, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::CLOCK,
+                NaiveTime::from_hms_opt(8, 30, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::HAMBURGER,
+                NaiveTime::from_hms_opt(12, 0, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::CLOCK_AFTERNOON,
+                NaiveTime::from_hms_opt(12, 30, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::FORK_KNIFE,
+                NaiveTime::from_hms_opt(18, 0, 0).expect("invalid"),
+            ),
+            (
+                egui_phosphor::regular::MOON_STARS,
+                NaiveTime::from_hms_opt(18, 30, 0).expect("invalid"),
+            ),
+        ]
+    };
+}
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
@@ -26,14 +79,40 @@ pub struct TimeConfig {
     pub format: TimeFormat,
     /// Display label prefix
     pub label_prefix: Option<LabelPrefix>,
+    /// TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)
+    ///
+    /// Use a custom format to display additional information, i.e.:
+    /// ```json
+    /// {
+    ///     "Time": {
+    ///         "enable": true,
+    ///         "format": { "Custom": "%T %Z (Tokyo)" },
+    ///         "timezone": "Asia/Tokyo"
+    ///      }
+    ///}
+    /// ```
+    pub timezone: Option<String>,
+    /// Change the icon depending on the time. The default icon is used between 8:30 and 12:00. (default: false)
+    pub changing_icon: Option<bool>,
 }
 
 impl From<TimeConfig> for Time {
     fn from(value: TimeConfig) -> Self {
+        // using 1 second made the widget look "less accurate" and lagging (especially having multiple with seconds).
+        // This is still better than getting an update every frame
+        let data_refresh_interval = 500;
+
         Self {
             enable: value.enable,
             format: value.format,
             label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
+            timezone: value.timezone,
+            changing_icon: value.changing_icon.unwrap_or_default(),
+            data_refresh_interval_millis: data_refresh_interval,
+            last_state: TimeOutput::new(),
+            last_updated: Instant::now()
+                .checked_sub(Duration::from_millis(data_refresh_interval))
+                .unwrap(),
         }
     }
 }
@@ -83,20 +162,94 @@ impl TimeFormat {
     }
 }
 
+#[derive(Clone, Debug)]
+struct TimeOutput {
+    label: String,
+    icon: String,
+}
+
+impl TimeOutput {
+    fn new() -> Self {
+        Self {
+            label: String::new(),
+            icon: String::new(),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Time {
     pub enable: bool,
     pub format: TimeFormat,
     label_prefix: LabelPrefix,
+    timezone: Option<String>,
+    changing_icon: bool,
+    data_refresh_interval_millis: u64,
+    last_state: TimeOutput,
+    last_updated: Instant,
 }
 
 impl Time {
-    fn output(&mut self) -> String {
-        chrono::Local::now()
-            .format(&self.format.fmt_string())
-            .to_string()
-            .trim()
-            .to_string()
+    fn output(&mut self) -> TimeOutput {
+        let mut output = self.last_state.clone();
+        let now = Instant::now();
+
+        if now.duration_since(self.last_updated)
+            > Duration::from_millis(self.data_refresh_interval_millis)
+        {
+            let (formatted, current_time) = match &self.timezone {
+                Some(timezone) => match timezone.parse::<Tz>() {
+                    Ok(tz) => {
+                        let dt = Local::now().with_timezone(&tz);
+                        (
+                            dt.format(&self.format.fmt_string())
+                                .to_string()
+                                .trim()
+                                .to_string(),
+                            Some(dt.time()),
+                        )
+                    }
+                    Err(_) => (format!("Invalid timezone: {:?}", timezone), None),
+                },
+                None => {
+                    let dt = Local::now();
+                    (
+                        dt.format(&self.format.fmt_string())
+                            .to_string()
+                            .trim()
+                            .to_string(),
+                        Some(dt.time()),
+                    )
+                }
+            };
+
+            if current_time.is_none() {
+                return TimeOutput {
+                    label: formatted,
+                    icon: egui_phosphor::regular::WARNING_CIRCLE.to_string(),
+                };
+            }
+
+            let current_range = match &self.changing_icon {
+                true => TIME_RANGES
+                    .iter()
+                    .rev()
+                    .find(|&(_, start)| current_time.unwrap() > *start)
+                    .cloned(),
+                false => None,
+            }
+            .unwrap_or((egui_phosphor::regular::CLOCK, NaiveTime::default()));
+
+            output = TimeOutput {
+                label: formatted,
+                icon: current_range.0.to_string(),
+            };
+
+            self.last_state.clone_from(&output);
+            self.last_updated = now;
+        }
+
+        output
     }
 
     fn paint_binary_circle(
@@ -279,15 +432,13 @@ impl BarWidget for Time {
     fn render(&mut self, ctx: &Context, ui: &mut Ui, config: &mut RenderConfig) {
         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');
+            if !output.label.is_empty() {
+                let use_binary_circle = output.label.starts_with('c');
+                let use_binary_rectangle = output.label.starts_with('r');
 
                 let mut layout_job = LayoutJob::simple(
                     match self.label_prefix {
-                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
-                            egui_phosphor::regular::CLOCK.to_string()
-                        }
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => output.icon,
                         LabelPrefix::None | LabelPrefix::Text => String::new(),
                     },
                     config.icon_font_id.clone(),
@@ -296,12 +447,12 @@ impl BarWidget for Time {
                 );
 
                 if let LabelPrefix::Text | LabelPrefix::IconAndText = self.label_prefix {
-                    output.insert_str(0, "TIME: ");
+                    output.label.insert_str(0, "TIME: ");
                 }
 
                 if !use_binary_circle && !use_binary_rectangle {
                     layout_job.append(
-                        &output,
+                        &output.label,
                         10.0,
                         TextFormat {
                             font_id: config.text_font_id.clone(),
@@ -324,9 +475,9 @@ impl BarWidget for Time {
 
                             if use_binary_circle || use_binary_rectangle {
                                 let ordered_output = if is_reversed {
-                                    output.chars().rev().collect()
+                                    output.label.chars().rev().collect()
                                 } else {
-                                    output
+                                    output.label
                                 };
 
                                 for (section_index, section) in

komorebi-bar/src/widgets/update.rs

@@ -1,7 +1,7 @@
 use crate::config::LabelPrefix;
 use crate::render::RenderConfig;
 use crate::selected_frame::SelectableFrame;
-use crate::widget::BarWidget;
+use crate::widgets::widget::BarWidget;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Align;
 use eframe::egui::Context;

komorebi-bar/src/widgets/widget.rs

@@ -1,26 +1,26 @@
-use crate::battery::Battery;
-use crate::battery::BatteryConfig;
-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;
-use crate::media::MediaConfig;
-use crate::memory::Memory;
-use crate::memory::MemoryConfig;
-use crate::network::Network;
-use crate::network::NetworkConfig;
 use crate::render::RenderConfig;
-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 crate::widgets::battery::Battery;
+use crate::widgets::battery::BatteryConfig;
+use crate::widgets::cpu::Cpu;
+use crate::widgets::cpu::CpuConfig;
+use crate::widgets::date::Date;
+use crate::widgets::date::DateConfig;
+use crate::widgets::keyboard::Keyboard;
+use crate::widgets::keyboard::KeyboardConfig;
+use crate::widgets::komorebi::Komorebi;
+use crate::widgets::komorebi::KomorebiConfig;
+use crate::widgets::media::Media;
+use crate::widgets::media::MediaConfig;
+use crate::widgets::memory::Memory;
+use crate::widgets::memory::MemoryConfig;
+use crate::widgets::network::Network;
+use crate::widgets::network::NetworkConfig;
+use crate::widgets::storage::Storage;
+use crate::widgets::storage::StorageConfig;
+use crate::widgets::time::Time;
+use crate::widgets::time::TimeConfig;
+use crate::widgets::update::Update;
+use crate::widgets::update::UpdateConfig;
 use eframe::egui::Context;
 use eframe::egui::Ui;
 use serde::Deserialize;

komorebi-client/Cargo.toml

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

komorebi-client/src/lib.rs

@@ -52,6 +52,7 @@ pub use komorebi::workspace::Workspace;
 pub use komorebi::workspace::WorkspaceGlobals;
 pub use komorebi::workspace::WorkspaceLayer;
 pub use komorebi::AnimationsConfig;
+pub use komorebi::AppSpecificConfigurationPath;
 pub use komorebi::AspectRatio;
 pub use komorebi::BorderColours;
 pub use komorebi::CrossBoundaryBehaviour;

komorebi-gui/Cargo.toml

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

komorebi-gui/src/main.rs

@@ -101,7 +101,7 @@ impl From<&komorebi_client::Workspace> for WorkspaceConfig {
         let name = value
             .name()
             .to_owned()
-            .unwrap_or_else(|| random_word::gen(random_word::Lang::En).to_string());
+            .unwrap_or_else(|| random_word::get(random_word::Lang::En).to_string());
 
         Self {
             layout,

komorebi-themes/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-themes"
-version = "0.1.35"
+version = "0.1.36"
 edition = "2021"
 
 [dependencies]

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.35"
+version = "0.1.36"
 description = "A tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"

komorebi/src/border_manager/border.rs

@@ -51,18 +51,22 @@ use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetSystemMetrics;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
+use windows::Win32::UI::WindowsAndMessaging::LoadCursorW;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
+use windows::Win32::UI::WindowsAndMessaging::SetCursor;
 use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
 use windows::Win32::UI::WindowsAndMessaging::CREATESTRUCTW;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_OBJECT_LOCATIONCHANGE;
 use windows::Win32::UI::WindowsAndMessaging::GWLP_USERDATA;
+use windows::Win32::UI::WindowsAndMessaging::IDC_ARROW;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
 use windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN;
 use windows::Win32::UI::WindowsAndMessaging::WM_CREATE;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
+use windows::Win32::UI::WindowsAndMessaging::WM_SETCURSOR;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 use windows_core::BOOL;
 use windows_core::PCWSTR;
@@ -268,6 +272,7 @@ impl Border {
                     WindowKind::Monocle,
                     WindowKind::Unfocused,
                     WindowKind::Floating,
+                    WindowKind::UnfocusedLocked,
                 ] {
                     let color = window_kind_colour(window_kind);
                     let color = D2D1_COLOR_F {
@@ -336,6 +341,16 @@ impl Border {
     ) -> LRESULT {
         unsafe {
             match message {
+                WM_SETCURSOR => match LoadCursorW(None, IDC_ARROW) {
+                    Ok(cursor) => {
+                        SetCursor(Some(cursor));
+                        LRESULT(0)
+                    }
+                    Err(error) => {
+                        tracing::error!("{error}");
+                        LRESULT(1)
+                    }
+                },
                 WM_CREATE => {
                     let mut border_pointer: *mut Border =
                         GetWindowLongPtrW(window, GWLP_USERDATA) as _;

komorebi/src/border_manager/mod.rs

@@ -48,6 +48,8 @@ lazy_static! {
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
     pub static ref UNFOCUSED: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(128, 128, 128))));
+    pub static ref UNFOCUSED_LOCKED: AtomicU32 =
+        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(158, 8, 8))));
     pub static ref MONOCLE: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(255, 51, 153))));
     pub static ref STACK: AtomicU32 = AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(0, 165, 66))));
@@ -149,6 +151,7 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
 fn window_kind_colour(focus_kind: WindowKind) -> u32 {
     match focus_kind {
         WindowKind::Unfocused => UNFOCUSED.load(Ordering::Relaxed),
+        WindowKind::UnfocusedLocked => UNFOCUSED_LOCKED.load(Ordering::Relaxed),
         WindowKind::Single => FOCUSED.load(Ordering::Relaxed),
         WindowKind::Stack => STACK.load(Ordering::Relaxed),
         WindowKind::Monocle => MONOCLE.load(Ordering::Relaxed),
@@ -229,7 +232,11 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             let window_kind = if idx != ws.focused_container_idx()
                                 || monitor_idx != focused_monitor_idx
                             {
-                                WindowKind::Unfocused
+                                if ws.locked_containers().contains(&idx) {
+                                    WindowKind::UnfocusedLocked
+                                } else {
+                                    WindowKind::Unfocused
+                                }
                             } else if c.windows().len() > 1 {
                                 WindowKind::Stack
                             } else {
@@ -403,6 +410,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 }
                             }
 
+                            // Update the border's monitor idx in case it changed
+                            border.monitor_idx = Some(monitor_idx);
+
                             let rect = WindowsApi::window_rect(focused_window_hwnd)?;
                             border.window_rect = rect;
 
@@ -490,7 +500,11 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 || monitor_idx != focused_monitor_idx
                                 || focused_window_hwnd != foreground_window
                             {
-                                WindowKind::Unfocused
+                                if ws.locked_containers().contains(&idx) {
+                                        WindowKind::UnfocusedLocked
+                                    } else {
+                                        WindowKind::Unfocused
+                                    }
                             } else if c.windows().len() > 1 {
                                 WindowKind::Stack
                             } else {
@@ -517,6 +531,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 }
                             }
 
+                            // Update the border's monitor idx in case it changed
+                            border.monitor_idx = Some(monitor_idx);
+
                             // 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
@@ -573,6 +590,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                                 border.window_kind = new_focus_state;
 
+                                // Update the border's monitor idx in case it changed
+                                border.monitor_idx = Some(monitor_idx);
+
                                 let rect = WindowsApi::window_rect(window.hwnd)?;
                                 border.window_rect = rect;
 

komorebi/src/container.rs

@@ -140,3 +140,114 @@ impl Container {
         self.windows.focus(idx);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_contains_window() {
+        let mut container = Container::default();
+
+        for i in 0..3 {
+            container.add_window(Window::from(i));
+        }
+
+        // Should return true for existing windows
+        assert!(container.contains_window(1));
+        assert_eq!(container.idx_for_window(1), Some(1));
+
+        // Should return false since window 4 doesn't exist
+        assert!(!container.contains_window(4));
+        assert_eq!(container.idx_for_window(4), None);
+    }
+
+    #[test]
+    fn test_remove_window_by_idx() {
+        let mut container = Container::default();
+
+        for i in 0..3 {
+            container.add_window(Window::from(i));
+        }
+
+        // Remove window 1
+        container.remove_window_by_idx(1);
+
+        // Should only have 2 windows left
+        assert_eq!(container.windows().len(), 2);
+
+        // Should return false since window 1 was removed
+        assert!(!container.contains_window(1));
+    }
+
+    #[test]
+    fn test_remove_focused_window() {
+        let mut container = Container::default();
+
+        for i in 0..3 {
+            container.add_window(Window::from(i));
+        }
+
+        // Should be focused on the last created window
+        assert_eq!(container.focused_window_idx(), 2);
+
+        // Remove the focused window
+        container.remove_focused_window();
+
+        // Should be focused on the window before the removed one
+        assert_eq!(container.focused_window_idx(), 1);
+
+        // Should only have 2 windows left
+        assert_eq!(container.windows().len(), 2);
+    }
+
+    #[test]
+    fn test_add_window() {
+        let mut container = Container::default();
+
+        container.add_window(Window::from(1));
+
+        assert_eq!(container.windows().len(), 1);
+        assert_eq!(container.focused_window_idx(), 0);
+        assert!(container.contains_window(1));
+    }
+
+    #[test]
+    fn test_focus_window() {
+        let mut container = Container::default();
+
+        for i in 0..3 {
+            container.add_window(Window::from(i));
+        }
+
+        // Should focus on the last created window
+        assert_eq!(container.focused_window_idx(), 2);
+
+        // focus on the window at index 1
+        container.focus_window(1);
+
+        // Should be focused on window 1
+        assert_eq!(container.focused_window_idx(), 1);
+
+        // focus on the window at index 0
+        container.focus_window(0);
+
+        // Should be focused on window 0
+        assert_eq!(container.focused_window_idx(), 0);
+    }
+
+    #[test]
+    fn test_idx_for_window() {
+        let mut container = Container::default();
+
+        for i in 0..3 {
+            container.add_window(Window::from(i));
+        }
+
+        // Should return the index of the window
+        assert_eq!(container.idx_for_window(1), Some(1));
+
+        // Should return None since window 4 doesn't exist
+        assert_eq!(container.idx_for_window(4), None);
+    }
+}

komorebi/src/core/mod.rs

@@ -84,6 +84,9 @@ pub enum SocketMessage {
     PromoteFocus,
     PromoteWindow(OperationDirection),
     EagerFocus(String),
+    LockMonitorWorkspaceContainer(usize, usize, usize),
+    UnlockMonitorWorkspaceContainer(usize, usize, usize),
+    ToggleLock,
     ToggleFloat,
     ToggleMonocle,
     ToggleMaximize,
@@ -312,6 +315,7 @@ pub enum WindowKind {
     Monocle,
     #[default]
     Unfocused,
+    UnfocusedLocked,
     Floating,
 }
 

komorebi/src/lib.rs

@@ -9,6 +9,7 @@ pub mod colour;
 pub mod container;
 pub mod core;
 pub mod focus_manager;
+pub mod locked_deque;
 pub mod monitor;
 pub mod monitor_reconciliator;
 pub mod process_command;
@@ -65,6 +66,7 @@ use crate::core::config_generation::WorkspaceMatchingRule;
 use color_eyre::Result;
 use os_info::Version;
 use parking_lot::Mutex;
+use parking_lot::RwLock;
 use regex::Regex;
 use serde::Deserialize;
 use serde::Serialize;
@@ -131,8 +133,8 @@ lazy_static! {
     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()));
-    static ref DISPLAY_INDEX_PREFERENCES: Arc<Mutex<HashMap<usize, String>>> =
-        Arc::new(Mutex::new(HashMap::new()));
+    static ref DISPLAY_INDEX_PREFERENCES: Arc<RwLock<HashMap<usize, String>>> =
+        Arc::new(RwLock::new(HashMap::new()));
     static ref WORKSPACE_MATCHING_RULES: Arc<Mutex<Vec<WorkspaceMatchingRule>>> =
         Arc::new(Mutex::new(Vec::new()));
     static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
@@ -172,6 +174,8 @@ lazy_static! {
             matching_strategy: Option::from(MatchingStrategy::Equals),
         }),
     ]));
+    static ref DUPLICATE_MONITOR_SERIAL_IDS: Arc<RwLock<Vec<String>>> =
+        Arc::new(RwLock::new(Vec::new()));
     static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
         Arc::new(Mutex::new(HashMap::new()));
     pub static ref SUBSCRIPTION_SOCKETS: Arc<Mutex<HashMap<String, PathBuf>>> =

komorebi/src/locked_deque.rs

@@ -0,0 +1,316 @@
+use std::collections::BTreeSet;
+use std::collections::VecDeque;
+
+pub struct LockedDeque<'a, T> {
+    deque: &'a mut VecDeque<T>,
+    locked_indices: &'a mut BTreeSet<usize>,
+}
+
+impl<'a, T: PartialEq> LockedDeque<'a, T> {
+    pub fn new(deque: &'a mut VecDeque<T>, locked_indices: &'a mut BTreeSet<usize>) -> Self {
+        Self {
+            deque,
+            locked_indices,
+        }
+    }
+
+    pub fn insert(&mut self, index: usize, value: T) -> usize {
+        insert_respecting_locks(self.deque, self.locked_indices, index, value)
+    }
+
+    pub fn remove(&mut self, index: usize) -> Option<T> {
+        remove_respecting_locks(self.deque, self.locked_indices, index)
+    }
+}
+
+pub fn insert_respecting_locks<T>(
+    deque: &mut VecDeque<T>,
+    locked_idx: &mut BTreeSet<usize>,
+    idx: usize,
+    value: T,
+) -> usize {
+    if idx == deque.len() {
+        deque.push_back(value);
+        return idx;
+    }
+
+    let mut new_deque = VecDeque::with_capacity(deque.len() + 1);
+    let mut temp_locked_deque = VecDeque::new();
+    let mut j = 0;
+    let mut corrected_idx = idx;
+
+    for (i, el) in deque.drain(..).enumerate() {
+        if i == idx {
+            corrected_idx = j;
+        }
+        if locked_idx.contains(&i) {
+            temp_locked_deque.push_back(el);
+        } else {
+            new_deque.push_back(el);
+            j += 1;
+        }
+    }
+
+    new_deque.insert(corrected_idx, value);
+
+    for (locked_el, locked_idx) in temp_locked_deque.into_iter().zip(locked_idx.iter()) {
+        new_deque.insert(*locked_idx, locked_el);
+        if *locked_idx <= corrected_idx {
+            corrected_idx += 1;
+        }
+    }
+
+    *deque = new_deque;
+
+    corrected_idx
+}
+
+pub fn remove_respecting_locks<T>(
+    deque: &mut VecDeque<T>,
+    locked_idx: &mut BTreeSet<usize>,
+    idx: usize,
+) -> Option<T> {
+    if idx >= deque.len() {
+        return None;
+    }
+
+    let final_size = deque.len() - 1;
+
+    let mut new_deque = VecDeque::with_capacity(final_size);
+    let mut temp_locked_deque = VecDeque::new();
+    let mut removed = None;
+    let mut removed_locked_idx = None;
+
+    for (i, el) in deque.drain(..).enumerate() {
+        if i == idx {
+            removed = Some(el);
+            removed_locked_idx = locked_idx.contains(&i).then_some(i);
+        } else if locked_idx.contains(&i) {
+            temp_locked_deque.push_back(el);
+        } else {
+            new_deque.push_back(el);
+        }
+    }
+
+    if let Some(i) = removed_locked_idx {
+        let mut above = locked_idx.split_off(&i);
+        above.pop_first();
+        locked_idx.extend(above.into_iter().map(|i| i - 1));
+    }
+
+    while locked_idx.last().is_some_and(|i| *i >= final_size) {
+        locked_idx.pop_last();
+    }
+
+    let extra_invalid_idx = (new_deque.len()
+        ..(new_deque.len() + temp_locked_deque.len() - locked_idx.len()))
+        .collect::<Vec<_>>();
+
+    for (locked_el, locked_idx) in temp_locked_deque
+        .into_iter()
+        .zip(locked_idx.iter().chain(extra_invalid_idx.iter()))
+    {
+        new_deque.insert(*locked_idx, locked_el);
+    }
+
+    *deque = new_deque;
+
+    removed
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeSet;
+    use std::collections::VecDeque;
+
+    #[test]
+    fn test_insert_respecting_locks() {
+        // Test case 1: Basic insertion with locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Insert at index 0, should shift elements while keeping index 2 locked
+            insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(deque, VecDeque::from(vec![99, 0, 2, 1, 3, 4]));
+            // Element '2' remains at index 2, element '1' that was at index 1 is now at index 3
+        }
+
+        // Test case 2: Insert at a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Try to insert at locked index 2, should insert at index 3 instead
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 2, 99);
+            assert_eq!(actual_index, 3);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 99, 3, 4]));
+        }
+
+        // Test case 3: Multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+            locked.insert(3); // Lock index 3
+
+            // Insert at index 0, should maintain locked indices
+            insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(deque, VecDeque::from(vec![99, 1, 0, 3, 2, 4]));
+            // Elements '1' and '3' remain at indices 1 and 3
+        }
+
+        // Test case 4: Insert at end
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Insert at end of deque
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 5, 99);
+            assert_eq!(actual_index, 5);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4, 99]));
+        }
+
+        // Test case 5: Empty deque
+        {
+            let mut deque = VecDeque::new();
+            let mut locked = BTreeSet::new();
+
+            // Insert into empty deque
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(actual_index, 0);
+            assert_eq!(deque, VecDeque::from(vec![99]));
+        }
+
+        // Test case 6: All indices locked
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            for i in 0..5 {
+                locked.insert(i); // Lock all indices
+            }
+
+            // Try to insert at index 2, should insert at the end
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 2, 99);
+            assert_eq!(actual_index, 5);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4, 99]));
+        }
+
+        // Test case 7: Consecutive locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+            locked.insert(3); // Lock index 3
+
+            // Insert at index 1, should maintain consecutive locked indices
+            insert_respecting_locks(&mut deque, &mut locked, 1, 99);
+            assert_eq!(deque, VecDeque::from(vec![0, 99, 2, 3, 1, 4]));
+            // Elements '2' and '3' remain at indices 2 and 3
+        }
+    }
+
+    #[test]
+    fn test_remove_respecting_locks() {
+        // Test case 1: Remove a non-locked index before a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(removed, Some(0));
+            assert_eq!(deque, VecDeque::from(vec![1, 3, 2, 4]));
+            assert!(locked.contains(&2)); // Index 2 should still be locked
+        }
+
+        // Test case 2: Remove a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 2);
+            assert_eq!(removed, Some(2));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 3, 4]));
+            assert!(!locked.contains(&2)); // Index 2 should be unlocked
+        }
+
+        // Test case 3: Remove an index after a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 3);
+            assert_eq!(removed, Some(3));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 4]));
+            assert!(locked.contains(&1)); // Index 1 should still be locked
+        }
+
+        // Test case 4: Multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+            locked.insert(3); // Lock index 3
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(removed, Some(0));
+            assert_eq!(deque, VecDeque::from(vec![2, 1, 4, 3]));
+            assert!(locked.contains(&1) && locked.contains(&3)); // Both indices should still be locked
+        }
+
+        // Test case 5: Remove the last element
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 4);
+            assert_eq!(removed, Some(4));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3]));
+            assert!(locked.contains(&2)); // Index 2 should still be locked
+        }
+
+        // Test case 6: Invalid index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 10);
+            assert_eq!(removed, None);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4])); // Deque unchanged
+            assert!(locked.contains(&2)); // Lock unchanged
+        }
+
+        // Test case 7: Remove enough elements to make a locked index invalid
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(deque, VecDeque::from(vec![1, 2]));
+            assert!(!locked.contains(&2)); // Index 2 should now be invalid
+        }
+
+        // Test case 8: Removing an element before multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4, 5]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+            locked.insert(4); // Lock index 4
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 1);
+            assert_eq!(removed, Some(1));
+            assert_eq!(deque, VecDeque::from(vec![0, 3, 2, 5, 4]));
+            assert!(locked.contains(&2) && locked.contains(&4)); // Both indices should still be locked
+        }
+    }
+}

komorebi/src/monitor.rs

@@ -17,6 +17,7 @@ use crate::core::Rect;
 use crate::container::Container;
 use crate::ring::Ring;
 use crate::workspace::Workspace;
+use crate::workspace::WorkspaceLayer;
 use crate::DefaultLayout;
 use crate::Layout;
 use crate::OperationDirection;
@@ -382,6 +383,7 @@ impl Monitor {
             };
 
             target_workspace.floating_windows_mut().push(window);
+            target_workspace.set_layer(WorkspaceLayer::Floating);
         } else {
             let container = workspace
                 .remove_focused_container()
@@ -398,6 +400,8 @@ impl Monitor {
                 Some(workspace) => workspace,
             };
 
+            target_workspace.set_layer(WorkspaceLayer::Tiling);
+
             if let Some(direction) = direction {
                 self.add_container_with_direction(
                     container,
@@ -464,3 +468,139 @@ impl Monitor {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_add_container() {
+        let mut m = Monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "TestMonitor".to_string(),
+            "TestDevice".to_string(),
+            "TestDeviceID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        // Add container to the default workspace
+        m.add_container(Container::default(), Some(0)).unwrap();
+
+        // Should contain a container in the current focused workspace
+        let workspace = m.focused_workspace_mut().unwrap();
+        assert_eq!(workspace.containers().len(), 1);
+    }
+
+    #[test]
+    fn test_remove_workspace_by_idx() {
+        let mut m = Monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "TestMonitor".to_string(),
+            "TestDevice".to_string(),
+            "TestDeviceID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        let new_workspace_index = m.new_workspace_idx();
+        assert_eq!(new_workspace_index, 1);
+
+        // Create workspace 2
+        m.focus_workspace(new_workspace_index).unwrap();
+
+        // Should have 2 workspaces
+        assert_eq!(m.workspaces().len(), 2);
+
+        // Create workspace 3
+        m.focus_workspace(new_workspace_index + 1).unwrap();
+
+        // Should have 3 workspaces
+        assert_eq!(m.workspaces().len(), 3);
+
+        // Remove workspace 1
+        m.remove_workspace_by_idx(1);
+
+        // Should have only 2 workspaces
+        assert_eq!(m.workspaces().len(), 2);
+    }
+
+    #[test]
+    fn test_remove_workspaces() {
+        let mut m = Monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "TestMonitor".to_string(),
+            "TestDevice".to_string(),
+            "TestDeviceID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        let new_workspace_index = m.new_workspace_idx();
+        assert_eq!(new_workspace_index, 1);
+
+        // Create workspace 2
+        m.focus_workspace(new_workspace_index).unwrap();
+
+        // Should have 2 workspaces
+        assert_eq!(m.workspaces().len(), 2);
+
+        // Create workspace 3
+        m.focus_workspace(new_workspace_index + 1).unwrap();
+
+        // Should have 3 workspaces
+        assert_eq!(m.workspaces().len(), 3);
+
+        // Remove all workspaces
+        m.remove_workspaces();
+
+        // All workspaces should be removed
+        assert_eq!(m.workspaces().len(), 0);
+    }
+
+    #[test]
+    fn test_focus_workspace() {
+        let mut m = Monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "TestMonitor".to_string(),
+            "TestDevice".to_string(),
+            "TestDeviceID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        let new_workspace_index = m.new_workspace_idx();
+        assert_eq!(new_workspace_index, 1);
+
+        // Focus workspace 2
+        m.focus_workspace(new_workspace_index).unwrap();
+
+        // Should have 2 workspaces
+        assert_eq!(m.workspaces().len(), 2);
+
+        // Should be focused on workspace 2
+        assert_eq!(m.focused_workspace_idx(), 1);
+    }
+
+    #[test]
+    fn test_new_workspace_idx() {
+        let m = Monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "TestMonitor".to_string(),
+            "TestDevice".to_string(),
+            "TestDeviceID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        let new_workspace_index = m.new_workspace_idx();
+
+        // Should be the last workspace index: 1
+        assert_eq!(new_workspace_index, 1);
+    }
+}

komorebi/src/monitor_reconciliator/mod.rs

@@ -12,6 +12,8 @@ use crate::NotificationEvent;
 use crate::State;
 use crate::WindowManager;
 use crate::WindowsApi;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::DUPLICATE_MONITOR_SERIAL_IDS;
 use crate::WORKSPACE_MATCHING_RULES;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
@@ -66,17 +68,49 @@ pub fn send_notification(notification: MonitorNotification) {
 }
 
 pub fn insert_in_monitor_cache(serial_or_device_id: &str, monitor: Monitor) {
+    let dip = DISPLAY_INDEX_PREFERENCES.read();
+    let mut dip_ids = dip.values();
+    let preferred_id = if dip_ids.any(|id| id == monitor.device_id()) {
+        monitor.device_id().clone()
+    } else if dip_ids.any(|id| Some(id) == monitor.serial_number_id().as_ref()) {
+        monitor.serial_number_id().clone().unwrap_or_default()
+    } else {
+        serial_or_device_id.to_string()
+    };
     let mut monitor_cache = MONITOR_CACHE
         .get_or_init(|| Mutex::new(HashMap::new()))
         .lock();
 
-    monitor_cache.insert(serial_or_device_id.to_string(), monitor);
+    monitor_cache.insert(preferred_id, monitor);
 }
 
 pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
-    Ok(win32_display_data::connected_displays_all()
+    let all_displays = win32_display_data::connected_displays_all()
         .flatten()
-        .map(|display| {
+        .collect::<Vec<_>>();
+
+    let mut serial_id_map = HashMap::new();
+
+    for d in &all_displays {
+        if let Some(id) = &d.serial_number_id {
+            *serial_id_map.entry(id.clone()).or_insert(0) += 1;
+        }
+    }
+
+    for d in &all_displays {
+        if let Some(id) = &d.serial_number_id {
+            if serial_id_map.get(id).copied().unwrap_or_default() > 1 {
+                let mut dupes = DUPLICATE_MONITOR_SERIAL_IDS.write();
+                if !dupes.contains(id) {
+                    (*dupes).push(id.clone());
+                }
+            }
+        }
+    }
+
+    Ok(all_displays
+        .into_iter()
+        .map(|mut display| {
             let path = display.device_path;
 
             let (device, device_id) = if path.is_empty() {
@@ -93,6 +127,13 @@ pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
             let name = display.device_name.trim_start_matches(r"\\.\").to_string();
             let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
 
+            if let Some(id) = &display.serial_number_id {
+                let dupes = DUPLICATE_MONITOR_SERIAL_IDS.read();
+                if dupes.contains(id) {
+                    display.serial_number_id = None;
+                }
+            }
+
             monitor::new(
                 display.hmonitor,
                 display.size.into(),
@@ -260,9 +301,15 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 // Make sure that in our state any attached displays have the latest Win32 data
                 for monitor in wm.monitors_mut() {
                     for attached in &attached_devices {
-                        if attached.serial_number_id().eq(monitor.serial_number_id())
-                            || attached.device_id().eq(monitor.device_id())
+                        let serial_number_ids_match = if let (Some(attached_snid), Some(m_snid)) =
+                            (attached.serial_number_id(), monitor.serial_number_id())
                         {
+                            attached_snid.eq(m_snid)
+                        } else {
+                            false
+                        };
+
+                        if serial_number_ids_match || attached.device_id().eq(monitor.device_id()) {
                             monitor.set_id(attached.id());
                             monitor.set_device(attached.device().clone());
                             monitor.set_device_id(attached.device_id().clone());
@@ -380,8 +427,18 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 workspace_rules.remove(i);
                             }
 
-                            // Let's add their state to the cache for later
-                            monitor_cache.insert(id, m.clone());
+                            // Let's add their state to the cache for later, make sure to use what
+                            // the user set as preference as the id.
+                            let dip = DISPLAY_INDEX_PREFERENCES.read();
+                            let mut dip_ids = dip.values();
+                            let preferred_id = if dip_ids.any(|id| id == m.device_id()) {
+                                m.device_id().clone()
+                            } else if dip_ids.any(|id| Some(id) == m.serial_number_id().as_ref()) {
+                                m.serial_number_id().clone().unwrap_or_default()
+                            } else {
+                                id
+                            };
+                            monitor_cache.insert(preferred_id, m.clone());
                         }
                     }
 

komorebi/src/process_command.rs

@@ -1,4 +1,5 @@
 use color_eyre::eyre::anyhow;
+use color_eyre::eyre::OptionExt;
 use color_eyre::Result;
 use miow::pipe::connect;
 use net2::TcpStreamExt;
@@ -250,9 +251,11 @@ impl WindowManager {
                 if let Some((monitor_idx, workspace_idx)) = monitor_workspace_indices {
                     if monitor_idx != focused_monitor_idx {
                         self.focus_monitor(monitor_idx)?;
-                    }
-
-                    if workspace_idx != focused_workspace_idx {
+                        let focused_ws_idx = self.focused_workspace_idx()?;
+                        if focused_ws_idx != workspace_idx {
+                            self.focus_workspace(workspace_idx)?;
+                        }
+                    } else if workspace_idx != focused_workspace_idx {
                         self.focus_workspace(workspace_idx)?;
                     }
                 }
@@ -331,11 +334,9 @@ impl WindowManager {
             SocketMessage::UnstackAll => self.unstack_all()?,
             SocketMessage::CycleStack(direction) => {
                 self.cycle_container_window_in_direction(direction)?;
-                self.focused_window()?.focus(self.mouse_follows_focus)?;
             }
             SocketMessage::CycleStackIndex(direction) => {
                 self.cycle_container_window_index_in_direction(direction)?;
-                self.focused_window()?.focus(self.mouse_follows_focus)?;
             }
             SocketMessage::FocusStackWindow(idx) => {
                 // In case you are using this command on a bar on a monitor
@@ -346,7 +347,6 @@ impl WindowManager {
                     self.focus_monitor(monitor_idx)?;
                 }
                 self.focus_container_window(idx)?;
-                self.focused_window()?.focus(self.mouse_follows_focus)?;
             }
             SocketMessage::ForceFocus => {
                 let focused_window = self.focused_window()?;
@@ -360,6 +360,41 @@ impl WindowManager {
             SocketMessage::Minimize => {
                 Window::from(WindowsApi::foreground_window()?).minimize();
             }
+            SocketMessage::LockMonitorWorkspaceContainer(
+                monitor_idx,
+                workspace_idx,
+                container_idx,
+            ) => {
+                let monitor = self
+                    .monitors_mut()
+                    .get_mut(monitor_idx)
+                    .ok_or_eyre("no monitor at the given index")?;
+
+                let workspace = monitor
+                    .workspaces_mut()
+                    .get_mut(workspace_idx)
+                    .ok_or_eyre("no workspace at the given index")?;
+
+                workspace.locked_containers.insert(container_idx);
+            }
+            SocketMessage::UnlockMonitorWorkspaceContainer(
+                monitor_idx,
+                workspace_idx,
+                container_idx,
+            ) => {
+                let monitor = self
+                    .monitors_mut()
+                    .get_mut(monitor_idx)
+                    .ok_or_eyre("no monitor at the given index")?;
+
+                let workspace = monitor
+                    .workspaces_mut()
+                    .get_mut(workspace_idx)
+                    .ok_or_eyre("no workspace at the given index")?;
+
+                workspace.locked_containers.remove(&container_idx);
+            }
+            SocketMessage::ToggleLock => self.toggle_lock()?,
             SocketMessage::ToggleFloat => self.toggle_float()?,
             SocketMessage::ToggleMonocle => self.toggle_monocle()?,
             SocketMessage::ToggleMaximize => self.toggle_maximize()?,
@@ -1155,7 +1190,7 @@ impl WindowManager {
                 );
             }
             SocketMessage::DisplayIndexPreference(index_preference, ref display) => {
-                let mut display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                let mut display_index_preferences = DISPLAY_INDEX_PREFERENCES.write();
                 display_index_preferences.insert(index_preference, display.clone());
             }
             SocketMessage::EnsureWorkspaces(monitor_idx, workspace_count) => {
@@ -1784,6 +1819,10 @@ impl WindowManager {
                 WindowKind::Unfocused => {
                     border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
+                WindowKind::UnfocusedLocked => {
+                    border_manager::UNFOCUSED_LOCKED
+                        .store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                }
                 WindowKind::Floating => {
                     border_manager::FLOATING.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }

komorebi/src/process_event.rs

@@ -395,8 +395,19 @@ impl WindowManager {
                                     && !matches!(event, WindowManagerEvent::Manage(_)));
 
                             if behaviour.float_override {
+                                // Center floating windows if we are already on the `Floating`
+                                // layer and the window doesn't match a `floating_windows` rule and
+                                // the workspace is not a floating workspace
+                                let center_spawned_floats =
+                                    matches!(workspace.layer, WorkspaceLayer::Floating)
+                                        && !should_float
+                                        && workspace.tile;
                                 workspace.floating_windows_mut().push(window);
                                 workspace.set_layer(WorkspaceLayer::Floating);
+                                if center_spawned_floats {
+                                    let mut floating_window = window;
+                                    floating_window.center(&workspace.globals().work_area)?;
+                                }
                                 self.update_focused_workspace(false, false)?;
                             } else {
                                 match behaviour.current_behaviour {

komorebi/src/static_config.rs

@@ -302,9 +302,19 @@ impl From<&Monitor> for MonitorConfig {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[serde(untagged)]
+pub enum AppSpecificConfigurationPath {
+    /// A single applications.json file
+    Single(PathBuf),
+    /// Multiple applications.json files
+    Multiple(Vec<PathBuf>),
+}
+
 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-/// The `komorebi.json` static configuration file reference for `v0.1.35`
+/// The `komorebi.json` static configuration file reference for `v0.1.36`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -342,7 +352,7 @@ pub struct StaticConfig {
     pub mouse_follows_focus: Option<bool>,
     /// Path to applications.json from komorebi-application-specific-configurations (default: None)
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub app_specific_configuration_path: Option<PathBuf>,
+    pub app_specific_configuration_path: Option<AppSpecificConfigurationPath>,
     /// Width of the window border (default: 8)
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(alias = "active_window_border_width")]
@@ -490,6 +500,9 @@ pub enum KomorebiTheme {
         /// Border colour when the container is unfocused (default: Base)
         #[serde(skip_serializing_if = "Option::is_none")]
         unfocused_border: Option<komorebi_themes::CatppuccinValue>,
+        /// Border colour when the container is unfocused and locked (default: Red)
+        #[serde(skip_serializing_if = "Option::is_none")]
+        unfocused_locked_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>,
@@ -522,6 +535,9 @@ pub enum KomorebiTheme {
         /// Border colour when the container is unfocused (default: Base01)
         #[serde(skip_serializing_if = "Option::is_none")]
         unfocused_border: Option<komorebi_themes::Base16Value>,
+        /// Border colour when the container is unfocused and locked (default: Base08)
+        #[serde(skip_serializing_if = "Option::is_none")]
+        unfocused_locked_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>,
@@ -740,7 +756,7 @@ impl From<&WindowManager> for StaticConfig {
                     .collect::<Vec<_>>(),
             ),
             monitor_index_preferences: Option::from(MONITOR_INDEX_PREFERENCES.lock().clone()),
-            display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.lock().clone()),
+            display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.read().clone()),
             stackbar: None,
             animation: None,
             theme: None,
@@ -768,7 +784,7 @@ impl StaticConfig {
         }
 
         if let Some(display_index_preferences) = &self.display_index_preferences {
-            let mut preferences = DISPLAY_INDEX_PREFERENCES.lock();
+            let mut preferences = DISPLAY_INDEX_PREFERENCES.write();
             preferences.clone_from(display_index_preferences);
         }
 
@@ -1004,140 +1020,35 @@ impl StaticConfig {
         }
 
         if let Some(path) = &self.app_specific_configuration_path {
-            match path.extension() {
-                None => {}
-                Some(ext) => match ext.to_string_lossy().to_string().as_str() {
-                    "yaml" => {
-                        tracing::info!("loading applications.yaml from: {}", path.display());
-                        let path = resolve_home_path(path)?;
-                        let content = std::fs::read_to_string(path)?;
-                        let asc = ApplicationConfigurationGenerator::load(&content)?;
-
-                        for mut entry in asc {
-                            if let Some(rules) = &mut entry.ignore_identifiers {
-                                populate_rules(
-                                    rules,
-                                    &mut ignore_identifiers,
-                                    &mut regex_identifiers,
-                                )?;
-                            }
-
-                            if let Some(ref options) = entry.options {
-                                let options = options.clone();
-                                for o in options {
-                                    match o {
-                                        ApplicationOptions::ObjectNameChange => {
-                                            populate_option(
-                                                &mut entry,
-                                                &mut object_name_change_identifiers,
-                                                &mut regex_identifiers,
-                                            )?;
-                                        }
-                                        ApplicationOptions::Layered => {
-                                            populate_option(
-                                                &mut entry,
-                                                &mut layered_identifiers,
-                                                &mut regex_identifiers,
-                                            )?;
-                                        }
-                                        ApplicationOptions::TrayAndMultiWindow => {
-                                            populate_option(
-                                                &mut entry,
-                                                &mut tray_and_multi_window_identifiers,
-                                                &mut regex_identifiers,
-                                            )?;
-                                        }
-                                        ApplicationOptions::Force => {
-                                            populate_option(
-                                                &mut entry,
-                                                &mut manage_identifiers,
-                                                &mut regex_identifiers,
-                                            )?;
-                                        }
-                                        ApplicationOptions::BorderOverflow => {} // deprecated
-                                    }
-                                }
-                            }
-                        }
+            match path {
+                AppSpecificConfigurationPath::Single(path) => handle_asc_file(
+                    path,
+                    &mut ignore_identifiers,
+                    &mut object_name_change_identifiers,
+                    &mut layered_identifiers,
+                    &mut tray_and_multi_window_identifiers,
+                    &mut manage_identifiers,
+                    &mut floating_applications,
+                    &mut transparency_blacklist,
+                    &mut slow_application_identifiers,
+                    &mut regex_identifiers,
+                )?,
+                AppSpecificConfigurationPath::Multiple(paths) => {
+                    for path in paths {
+                        handle_asc_file(
+                            path,
+                            &mut ignore_identifiers,
+                            &mut object_name_change_identifiers,
+                            &mut layered_identifiers,
+                            &mut tray_and_multi_window_identifiers,
+                            &mut manage_identifiers,
+                            &mut floating_applications,
+                            &mut transparency_blacklist,
+                            &mut slow_application_identifiers,
+                            &mut regex_identifiers,
+                        )?
                     }
-                    "json" => {
-                        tracing::info!("loading applications.json from: {}", path.display());
-                        let path = resolve_home_path(path)?;
-                        let mut asc = ApplicationSpecificConfiguration::load(&path)?;
-
-                        for entry in asc.values_mut() {
-                            match entry {
-                                AscApplicationRulesOrSchema::Schema(_) => {}
-                                AscApplicationRulesOrSchema::AscApplicationRules(entry) => {
-                                    if let Some(rules) = &mut entry.ignore {
-                                        populate_rules(
-                                            rules,
-                                            &mut ignore_identifiers,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.manage {
-                                        populate_rules(
-                                            rules,
-                                            &mut manage_identifiers,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.floating {
-                                        populate_rules(
-                                            rules,
-                                            &mut floating_applications,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.transparency_ignore {
-                                        populate_rules(
-                                            rules,
-                                            &mut transparency_blacklist,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.tray_and_multi_window {
-                                        populate_rules(
-                                            rules,
-                                            &mut tray_and_multi_window_identifiers,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.layered {
-                                        populate_rules(
-                                            rules,
-                                            &mut layered_identifiers,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.object_name_change {
-                                        populate_rules(
-                                            rules,
-                                            &mut object_name_change_identifiers,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-
-                                    if let Some(rules) = &mut entry.slow_application {
-                                        populate_rules(
-                                            rules,
-                                            &mut slow_application_identifiers,
-                                            &mut regex_identifiers,
-                                        )?;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    _ => {}
-                },
+                }
             }
         }
 
@@ -1153,7 +1064,16 @@ impl StaticConfig {
         let mut value: Self = serde_json::from_str(&content)?;
 
         if let Some(path) = &mut value.app_specific_configuration_path {
-            *path = resolve_home_path(&*path)?;
+            match path {
+                AppSpecificConfigurationPath::Single(path) => {
+                    *path = resolve_home_path(&*path)?;
+                }
+                AppSpecificConfigurationPath::Multiple(paths) => {
+                    for path in paths {
+                        *path = resolve_home_path(&*path)?;
+                    }
+                }
+            }
         }
 
         if let Some(monitors) = &mut value.monitors {
@@ -1276,7 +1196,7 @@ impl StaticConfig {
         let mut wm = wm.lock();
 
         let configs_with_preference: Vec<_> =
-            DISPLAY_INDEX_PREFERENCES.lock().keys().copied().collect();
+            DISPLAY_INDEX_PREFERENCES.read().keys().copied().collect();
         let mut configs_used = Vec::new();
 
         let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
@@ -1286,7 +1206,7 @@ impl StaticConfig {
         let offset = wm.work_area_offset;
         for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
             let preferred_config_idx = {
-                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
                 let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
                     (monitor
                         .serial_number_id()
@@ -1385,7 +1305,7 @@ impl StaticConfig {
                 .filter(|i| !configs_used.contains(i))
             {
                 let id = {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
                     display_index_preferences.get(i).cloned()
                 };
                 if let (Some(id), Some(monitor_config)) =
@@ -1445,7 +1365,7 @@ impl StaticConfig {
         value.apply_globals()?;
 
         let configs_with_preference: Vec<_> =
-            DISPLAY_INDEX_PREFERENCES.lock().keys().copied().collect();
+            DISPLAY_INDEX_PREFERENCES.read().keys().copied().collect();
         let mut configs_used = Vec::new();
 
         let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
@@ -1455,7 +1375,7 @@ impl StaticConfig {
         let offset = wm.work_area_offset;
         for (i, monitor) in wm.monitors_mut().iter_mut().enumerate() {
             let preferred_config_idx = {
-                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
                 let c_idx = display_index_preferences.iter().find_map(|(c_idx, id)| {
                     (monitor
                         .serial_number_id()
@@ -1557,7 +1477,7 @@ impl StaticConfig {
                 .filter(|i| !configs_used.contains(i))
             {
                 let id = {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
                     display_index_preferences.get(i).cloned()
                 };
                 if let (Some(id), Some(monitor_config)) =
@@ -1722,6 +1642,134 @@ fn populate_rules(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
+fn handle_asc_file(
+    path: &PathBuf,
+    ignore_identifiers: &mut Vec<MatchingRule>,
+    object_name_change_identifiers: &mut Vec<MatchingRule>,
+    layered_identifiers: &mut Vec<MatchingRule>,
+    tray_and_multi_window_identifiers: &mut Vec<MatchingRule>,
+    manage_identifiers: &mut Vec<MatchingRule>,
+    floating_applications: &mut Vec<MatchingRule>,
+    transparency_blacklist: &mut Vec<MatchingRule>,
+    slow_application_identifiers: &mut Vec<MatchingRule>,
+    regex_identifiers: &mut HashMap<String, Regex>,
+) -> Result<()> {
+    match path.extension() {
+        None => {}
+        Some(ext) => match ext.to_string_lossy().to_string().as_str() {
+            "yaml" => {
+                tracing::info!("loading applications.yaml from: {}", path.display());
+                let path = resolve_home_path(path)?;
+                let content = std::fs::read_to_string(path)?;
+                let asc = ApplicationConfigurationGenerator::load(&content)?;
+
+                for mut entry in asc {
+                    if let Some(rules) = &mut entry.ignore_identifiers {
+                        populate_rules(rules, ignore_identifiers, regex_identifiers)?;
+                    }
+
+                    if let Some(ref options) = entry.options {
+                        let options = options.clone();
+                        for o in options {
+                            match o {
+                                ApplicationOptions::ObjectNameChange => {
+                                    populate_option(
+                                        &mut entry,
+                                        object_name_change_identifiers,
+                                        regex_identifiers,
+                                    )?;
+                                }
+                                ApplicationOptions::Layered => {
+                                    populate_option(
+                                        &mut entry,
+                                        layered_identifiers,
+                                        regex_identifiers,
+                                    )?;
+                                }
+                                ApplicationOptions::TrayAndMultiWindow => {
+                                    populate_option(
+                                        &mut entry,
+                                        tray_and_multi_window_identifiers,
+                                        regex_identifiers,
+                                    )?;
+                                }
+                                ApplicationOptions::Force => {
+                                    populate_option(
+                                        &mut entry,
+                                        manage_identifiers,
+                                        regex_identifiers,
+                                    )?;
+                                }
+                                ApplicationOptions::BorderOverflow => {} // deprecated
+                            }
+                        }
+                    }
+                }
+            }
+            "json" => {
+                tracing::info!("loading applications.json from: {}", path.display());
+                let path = resolve_home_path(path)?;
+                let mut asc = ApplicationSpecificConfiguration::load(&path)?;
+
+                for entry in asc.values_mut() {
+                    match entry {
+                        AscApplicationRulesOrSchema::Schema(_) => {}
+                        AscApplicationRulesOrSchema::AscApplicationRules(entry) => {
+                            if let Some(rules) = &mut entry.ignore {
+                                populate_rules(rules, ignore_identifiers, regex_identifiers)?;
+                            }
+
+                            if let Some(rules) = &mut entry.manage {
+                                populate_rules(rules, manage_identifiers, regex_identifiers)?;
+                            }
+
+                            if let Some(rules) = &mut entry.floating {
+                                populate_rules(rules, floating_applications, regex_identifiers)?;
+                            }
+
+                            if let Some(rules) = &mut entry.transparency_ignore {
+                                populate_rules(rules, transparency_blacklist, regex_identifiers)?;
+                            }
+
+                            if let Some(rules) = &mut entry.tray_and_multi_window {
+                                populate_rules(
+                                    rules,
+                                    tray_and_multi_window_identifiers,
+                                    regex_identifiers,
+                                )?;
+                            }
+
+                            if let Some(rules) = &mut entry.layered {
+                                populate_rules(rules, layered_identifiers, regex_identifiers)?;
+                            }
+
+                            if let Some(rules) = &mut entry.object_name_change {
+                                populate_rules(
+                                    rules,
+                                    object_name_change_identifiers,
+                                    regex_identifiers,
+                                )?;
+                            }
+
+                            if let Some(rules) = &mut entry.slow_application {
+                                populate_rules(
+                                    rules,
+                                    slow_application_identifiers,
+                                    regex_identifiers,
+                                )?;
+                            }
+                        }
+                    }
+                }
+            }
+            _ => {}
+        },
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use crate::StaticConfig;

komorebi/src/theme_manager.rs

@@ -76,6 +76,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
             monocle_border,
             floating_border,
             unfocused_border,
+            unfocused_locked_border,
             stackbar_focused_text,
             stackbar_unfocused_text,
             stackbar_background,
@@ -87,6 +88,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                 monocle_border,
                 floating_border,
                 unfocused_border,
+                unfocused_locked_border,
                 stackbar_focused_text,
                 stackbar_unfocused_text,
                 stackbar_background,
@@ -112,6 +114,10 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                     .unwrap_or(komorebi_themes::CatppuccinValue::Base)
                     .color32(name.as_theme());
 
+                let unfocused_locked_border = unfocused_locked_border
+                    .unwrap_or(komorebi_themes::CatppuccinValue::Red)
+                    .color32(name.as_theme());
+
                 let stackbar_focused_text = stackbar_focused_text
                     .unwrap_or(komorebi_themes::CatppuccinValue::Green)
                     .color32(name.as_theme());
@@ -130,6 +136,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                     monocle_border,
                     floating_border,
                     unfocused_border,
+                    unfocused_locked_border,
                     stackbar_focused_text,
                     stackbar_unfocused_text,
                     stackbar_background,
@@ -142,6 +149,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                 monocle_border,
                 floating_border,
                 unfocused_border,
+                unfocused_locked_border,
                 stackbar_focused_text,
                 stackbar_unfocused_text,
                 stackbar_background,
@@ -163,6 +171,10 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                     .unwrap_or(komorebi_themes::Base16Value::Base01)
                     .color32(*name);
 
+                let unfocused_locked_border = unfocused_locked_border
+                    .unwrap_or(komorebi_themes::Base16Value::Base08)
+                    .color32(*name);
+
                 let floating_border = floating_border
                     .unwrap_or(komorebi_themes::Base16Value::Base09)
                     .color32(*name);
@@ -185,6 +197,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                     monocle_border,
                     floating_border,
                     unfocused_border,
+                    unfocused_locked_border,
                     stackbar_focused_text,
                     stackbar_unfocused_text,
                     stackbar_background,
@@ -198,6 +211,10 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
         border_manager::FLOATING.store(u32::from(Colour::from(floating_border)), Ordering::SeqCst);
         border_manager::UNFOCUSED
             .store(u32::from(Colour::from(unfocused_border)), Ordering::SeqCst);
+        border_manager::UNFOCUSED_LOCKED.store(
+            u32::from(Colour::from(unfocused_locked_border)),
+            Ordering::SeqCst,
+        );
 
         STACKBAR_TAB_BACKGROUND_COLOUR.store(
             u32::from(Colour::from(stackbar_background)),

komorebi/src/windows_api.rs

@@ -153,6 +153,7 @@ use crate::windows_callbacks;
 use crate::Window;
 use crate::WindowManager;
 use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::DUPLICATE_MONITOR_SERIAL_IDS;
 use crate::MONITOR_INDEX_PREFERENCES;
 
 macro_rules! as_ptr {
@@ -258,7 +259,30 @@ impl WindowsApi {
         let monitors = &mut wm.monitors;
         let monitor_usr_idx_map = &mut wm.monitor_usr_idx_map;
 
-        'read: for display in win32_display_data::connected_displays_all().flatten() {
+        let all_displays = win32_display_data::connected_displays_all()
+            .flatten()
+            .collect::<Vec<_>>();
+
+        let mut serial_id_map = HashMap::new();
+
+        for d in &all_displays {
+            if let Some(id) = &d.serial_number_id {
+                *serial_id_map.entry(id.clone()).or_insert(0) += 1;
+            }
+        }
+
+        for d in &all_displays {
+            if let Some(id) = &d.serial_number_id {
+                if serial_id_map.get(id).copied().unwrap_or_default() > 1 {
+                    let mut dupes = DUPLICATE_MONITOR_SERIAL_IDS.write();
+                    if !dupes.contains(id) {
+                        (*dupes).push(id.clone());
+                    }
+                }
+            }
+        }
+
+        'read: for mut display in all_displays {
             let path = display.device_path.clone();
 
             let (device, device_id) = if path.is_empty() {
@@ -281,6 +305,13 @@ impl WindowsApi {
                 }
             }
 
+            if let Some(id) = &display.serial_number_id {
+                let dupes = DUPLICATE_MONITOR_SERIAL_IDS.read();
+                if dupes.contains(id) {
+                    display.serial_number_id = None;
+                }
+            }
+
             let m = monitor::new(
                 display.hmonitor,
                 display.size.into(),
@@ -299,7 +330,7 @@ impl WindowsApi {
                 }
             }
 
-            let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+            let display_index_preferences = DISPLAY_INDEX_PREFERENCES.read();
             for (index, id) in &*display_index_preferences {
                 if m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || id.eq(m.device_id())
                 {
@@ -334,7 +365,7 @@ impl WindowsApi {
         // Rebuild monitor index map
         *monitor_usr_idx_map = HashMap::new();
         let mut added_monitor_idxs = Vec::new();
-        for (index, id) in &*DISPLAY_INDEX_PREFERENCES.lock() {
+        for (index, id) in &*DISPLAY_INDEX_PREFERENCES.read() {
             if let Some(m_idx) = monitors.elements().iter().position(|m| {
                 m.serial_number_id().as_ref().is_some_and(|sn| sn == id) || m.device_id() == id
             }) {
@@ -972,7 +1003,7 @@ impl WindowsApi {
     }
 
     pub fn monitor(hmonitor: isize) -> Result<Monitor> {
-        for display in win32_display_data::connected_displays_all().flatten() {
+        for mut display in win32_display_data::connected_displays_all().flatten() {
             if display.hmonitor == hmonitor {
                 let path = display.device_path;
 
@@ -990,6 +1021,13 @@ impl WindowsApi {
                 let name = display.device_name.trim_start_matches(r"\\.\").to_string();
                 let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
 
+                if let Some(id) = &display.serial_number_id {
+                    let dupes = DUPLICATE_MONITOR_SERIAL_IDS.read();
+                    if dupes.contains(id) {
+                        display.serial_number_id = None;
+                    }
+                }
+
                 let monitor = monitor::new(
                     hmonitor,
                     display.size.into(),

komorebi/src/workspace.rs

@@ -1,3 +1,4 @@
+use std::collections::BTreeSet;
 use std::collections::VecDeque;
 use std::fmt::Display;
 use std::fmt::Formatter;
@@ -25,6 +26,7 @@ use crate::core::Rect;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::container::Container;
+use crate::locked_deque::LockedDeque;
 use crate::ring::Ring;
 use crate::should_act;
 use crate::stackbar_manager;
@@ -90,6 +92,8 @@ pub struct Workspace {
     pub globals: WorkspaceGlobals,
     #[getset(get = "pub", get_mut = "pub", set = "pub")]
     pub layer: WorkspaceLayer,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    pub locked_containers: BTreeSet<usize>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[getset(get = "pub", set = "pub")]
     pub workspace_config: Option<WorkspaceConfig>,
@@ -139,6 +143,7 @@ impl Default for Workspace {
             layer: Default::default(),
             globals: Default::default(),
             workspace_config: None,
+            locked_containers: Default::default(),
         }
     }
 }
@@ -282,7 +287,7 @@ impl Workspace {
     }
 
     pub fn restore(&mut self, mouse_follows_focus: bool) -> Result<()> {
-        if let Some(container) = self.monocle_container_mut() {
+        if let Some(container) = self.monocle_container() {
             if let Some(window) = container.focused_window() {
                 container.restore();
                 window.focus(mouse_follows_focus)?;
@@ -318,10 +323,16 @@ impl Workspace {
             if self.maximized_window().is_none() && matches!(self.layer, WorkspaceLayer::Tiling) {
                 window.focus(mouse_follows_focus)?;
             } else if let Some(maximized_window) = self.maximized_window() {
+                maximized_window.restore();
                 maximized_window.focus(mouse_follows_focus)?;
             } else if let Some(floating_window) = self.floating_windows().first() {
                 floating_window.focus(mouse_follows_focus)?;
             }
+        } else if let Some(maximized_window) = self.maximized_window() {
+            maximized_window.restore();
+            maximized_window.focus(mouse_follows_focus)?;
+        } else if let Some(floating_window) = self.floating_windows().first() {
+            floating_window.focus(mouse_follows_focus)?;
         }
 
         Ok(())
@@ -800,9 +811,8 @@ impl Workspace {
             ),
         };
 
-        self.containers_mut().insert(primary_idx, container);
-        self.resize_dimensions_mut().insert(primary_idx, resize);
-
+        let insertion_idx = self.insert_container_at_idx(primary_idx, container);
+        self.resize_dimensions_mut()[insertion_idx] = resize;
         self.focus_container(primary_idx);
 
         Ok(())
@@ -818,21 +828,38 @@ impl Workspace {
         self.focus_first_container();
     }
 
-    pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) {
-        self.containers_mut().insert(idx, container);
-        self.focus_container(idx);
+    // this fn respects locked container indexes - we should use it for pretty much everything
+    // except monocle and maximize toggles
+    pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) -> usize {
+        let mut locked_containers = self.locked_containers().clone();
+        let mut ld = LockedDeque::new(self.containers_mut(), &mut locked_containers);
+        let insertion_idx = ld.insert(idx, container);
+        self.locked_containers = locked_containers;
+
+        if insertion_idx > self.resize_dimensions().len() {
+            self.resize_dimensions_mut().push(None);
+        } else {
+            self.resize_dimensions_mut().insert(insertion_idx, None);
+        }
+
+        self.focus_container(insertion_idx);
+
+        insertion_idx
     }
 
+    // this fn respects locked container indexes - we should use it for pretty much everything
+    // except monocle and maximize toggles
     pub fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
+        let mut locked_containers = self.locked_containers().clone();
+        let mut ld = LockedDeque::new(self.containers_mut(), &mut locked_containers);
+        let container = ld.remove(idx);
+        self.locked_containers = locked_containers;
+
         if idx < self.resize_dimensions().len() {
             self.resize_dimensions_mut().remove(idx);
         }
 
-        if idx < self.containers().len() {
-            return self.containers_mut().remove(idx);
-        }
-
-        None
+        container
     }
 
     fn container_idx_for_window(&self, hwnd: isize) -> Option<usize> {
@@ -906,15 +933,7 @@ impl Workspace {
             .ok_or_else(|| anyhow!("there is no window"))?;
 
         if container.windows().is_empty() {
-            self.containers_mut()
-                .remove(container_idx)
-                .ok_or_else(|| anyhow!("there is no container"))?;
-
-            // Whenever a container is empty, we need to remove any resize dimensions for it too
-            if self.resize_dimensions().get(container_idx).is_some() {
-                self.resize_dimensions_mut().remove(container_idx);
-            }
-
+            self.remove_container_by_idx(container_idx);
             self.focus_previous_container();
         } else {
             container.load_focused_window();
@@ -951,6 +970,7 @@ impl Workspace {
             len,
         )
     }
+
     pub fn new_idx_for_cycle_direction(&self, direction: CycleDirection) -> Option<usize> {
         Option::from(direction.next_idx(
             self.focused_container_idx(),
@@ -958,6 +978,7 @@ impl Workspace {
         ))
     }
 
+    // this is what we use for stacking
     pub fn move_window_to_container(&mut self, target_container_idx: usize) -> Result<()> {
         let focused_idx = self.focused_container_idx();
 
@@ -971,8 +992,7 @@ impl Workspace {
 
         // This is a little messy
         let adjusted_target_container_index = if container.windows().is_empty() {
-            self.containers_mut().remove(focused_idx);
-            self.resize_dimensions_mut().remove(focused_idx);
+            self.remove_container_by_idx(focused_idx);
 
             if focused_idx < target_container_idx {
                 target_container_idx.saturating_sub(1)
@@ -1011,8 +1031,7 @@ impl Workspace {
             .ok_or_else(|| anyhow!("there is no window"))?;
 
         if container.windows().is_empty() {
-            self.containers_mut().remove(focused_container_idx);
-            self.resize_dimensions_mut().remove(focused_container_idx);
+            self.remove_container_by_idx(focused_container_idx);
         } else {
             container.load_focused_window();
         }
@@ -1032,8 +1051,8 @@ impl Workspace {
 
         let mut container = Container::default();
         container.add_window(window);
-        self.containers_mut().insert(focused_idx, container);
-        self.resize_dimensions_mut().insert(focused_idx, None);
+
+        self.insert_container_at_idx(focused_idx, container);
 
         Ok(())
     }
@@ -1048,19 +1067,7 @@ impl Workspace {
         let mut container = Container::default();
         container.add_window(window);
 
-        if next_idx > self.containers().len() {
-            self.containers_mut().push_back(container);
-        } else {
-            self.containers_mut().insert(next_idx, container);
-        }
-
-        if next_idx > self.resize_dimensions().len() {
-            self.resize_dimensions_mut().push(None);
-        } else {
-            self.resize_dimensions_mut().insert(next_idx, None);
-        }
-
-        self.focus_container(next_idx);
+        self.insert_container_at_idx(next_idx, container);
     }
 
     pub fn new_floating_window(&mut self) -> Result<()> {
@@ -1094,8 +1101,7 @@ impl Workspace {
                 .ok_or_else(|| anyhow!("there is no window"))?;
 
             if container.windows().is_empty() {
-                self.containers_mut().remove(focused_idx);
-                self.resize_dimensions_mut().remove(focused_idx);
+                self.remove_container_by_idx(focused_idx);
 
                 if focused_idx == self.containers().len() {
                     self.focus_container(focused_idx.saturating_sub(1));
@@ -1367,6 +1373,10 @@ impl Workspace {
 
     pub fn new_monocle_container(&mut self) -> Result<()> {
         let focused_idx = self.focused_container_idx();
+
+        // we shouldn't use remove_container_by_idx here because it doesn't make sense for
+        // monocle and maximized toggles which take over the whole screen before being reinserted
+        // at the same index to respect locked container indexes
         let container = self
             .containers_mut()
             .remove(focused_idx)
@@ -1404,6 +1414,9 @@ impl Workspace {
                 .resize(restore_idx, Container::default());
         }
 
+        // we shouldn't use insert_container_at_index here because it doesn't make sense for
+        // monocle and maximized toggles which take over the whole screen before being reinserted
+        // at the same index to respect locked container indexes
         self.containers_mut().insert(restore_idx, container);
         self.focus_container(restore_idx);
         self.focused_container_mut()
@@ -1475,6 +1488,9 @@ impl Workspace {
             .ok_or_else(|| anyhow!("there is no window"))?;
 
         if container.windows().is_empty() {
+            // we shouldn't use remove_container_by_idx here because it doesn't make sense for
+            // monocle and maximized toggles which take over the whole screen before being reinserted
+            // at the same index to respect locked container indexes
             self.containers_mut().remove(focused_idx);
             if self.resize_dimensions().get(focused_idx).is_some() {
                 self.resize_dimensions_mut().remove(focused_idx);
@@ -1514,8 +1530,11 @@ impl Workspace {
 
         let mut container = Container::default();
         container.windows_mut().push_back(window);
-        self.containers_mut().insert(restore_idx, container);
 
+        // we shouldn't use insert_container_at_index here because it doesn't make sense for
+        // monocle and maximized toggles which take over the whole screen before being reinserted
+        // at the same index to respect locked container indexes
+        self.containers_mut().insert(restore_idx, container);
         self.focus_container(restore_idx);
 
         self.focused_container_mut()
@@ -1629,3 +1648,626 @@ impl Workspace {
         self.focus_container(0);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::container::Container;
+    use crate::Window;
+    use std::collections::BTreeSet;
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_locked_containers_with_new_window() {
+        let mut ws = Workspace::default();
+
+        let mut state = HashMap::new();
+        let mut locked = BTreeSet::new();
+
+        // add 3 containers
+        for i in 0..4 {
+            let container = Container::default();
+            state.insert(i, container.id().to_string());
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 4);
+
+        // set index 3 locked
+        locked.insert(3);
+        ws.locked_containers = locked;
+
+        // focus container at index 2
+        ws.focus_container(2);
+
+        // simulate a new window being launched on this workspace
+        ws.new_container_for_window(Window::from(123));
+
+        // new length should be 5, with the focus on the new window at index 4
+        assert_eq!(ws.containers().len(), 5);
+        assert_eq!(ws.focused_container_idx(), 4);
+        assert_eq!(
+            ws.focused_container()
+                .unwrap()
+                .focused_window()
+                .unwrap()
+                .hwnd,
+            123
+        );
+
+        // when inserting a new container at index 0, index 3's container should not change
+        ws.focus_container(0);
+        ws.new_container_for_window(Window::from(234));
+        assert_eq!(
+            ws.containers()[3].id().to_string(),
+            state.get(&3).unwrap().to_string()
+        );
+    }
+
+    #[test]
+    fn test_locked_containers_remove_window() {
+        let mut ws = Workspace::default();
+
+        let mut locked = BTreeSet::new();
+
+        // add 4 containers
+        for i in 0..4 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 4);
+
+        // set index 1 locked
+        locked.insert(1);
+        ws.locked_containers = locked;
+
+        ws.remove_window(0).unwrap();
+        assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 2);
+        // index 1 should still be the same
+        assert_eq!(ws.containers()[1].focused_window().unwrap().hwnd, 1);
+        assert_eq!(ws.containers()[2].focused_window().unwrap().hwnd, 3);
+    }
+
+    #[test]
+    fn test_locked_containers_toggle_float() {
+        let mut ws = Workspace::default();
+
+        let mut locked = BTreeSet::new();
+
+        // add 4 containers
+        for i in 0..4 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 4);
+
+        // set index 1 locked
+        locked.insert(1);
+        ws.locked_containers = locked;
+
+        // set index 0 focused
+        ws.focus_container(0);
+
+        // float index 0
+        ws.new_floating_window().unwrap();
+
+        assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 2);
+        // index 1 should still be the same
+        assert_eq!(ws.containers()[1].focused_window().unwrap().hwnd, 1);
+        assert_eq!(ws.containers()[2].focused_window().unwrap().hwnd, 3);
+
+        // unfloat - have to do this semi-manually becuase of calls to WindowsApi in
+        // new_container_for_floating_window which usually handles unfloating
+        let window = ws.floating_windows_mut().pop().unwrap();
+        let mut container = Container::default();
+        container.add_window(window);
+        ws.insert_container_at_idx(ws.focused_container_idx(), container);
+
+        // all indexes should be at their original position
+        for i in 0..4 {
+            assert_eq!(
+                ws.containers()[i].focused_window().unwrap().hwnd,
+                i as isize
+            );
+        }
+    }
+
+    #[test]
+    fn test_locked_containers_stack() {
+        let mut ws = Workspace::default();
+
+        let mut locked = BTreeSet::new();
+
+        // add 6 containers
+        for i in 0..6 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 6);
+
+        // set index 4 locked
+        locked.insert(4);
+        ws.locked_containers = locked;
+
+        // set index 3 focused
+        ws.focus_container(3);
+
+        // stack index 3 on top of index 2
+        ws.move_window_to_container(2).unwrap();
+
+        assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 0);
+        assert_eq!(ws.containers()[1].focused_window().unwrap().hwnd, 1);
+        assert_eq!(ws.containers()[2].windows().len(), 2);
+        assert_eq!(ws.containers()[3].focused_window().unwrap().hwnd, 5);
+        // index 4 should still be the same
+        assert_eq!(ws.containers()[4].focused_window().unwrap().hwnd, 4);
+
+        // unstack
+        ws.new_container_for_focused_window().unwrap();
+
+        // all indexes should be at their original position
+        for i in 0..6 {
+            assert_eq!(
+                ws.containers()[i].focused_window().unwrap().hwnd,
+                i as isize
+            )
+        }
+    }
+
+    #[test]
+    fn test_contains_window() {
+        // Create default workspace
+        let mut workspace = Workspace::default();
+
+        // Add a window to the container
+        let mut container = Container::default();
+        container.windows_mut().push_back(Window::from(0));
+
+        // Add container
+        workspace.add_container_to_back(container);
+
+        // Should be true
+        assert!(workspace.contains_window(0));
+
+        // Should be false
+        assert!(!workspace.is_empty())
+    }
+
+    #[test]
+    fn test_add_container_to_back() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 3 windows
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(1));
+            workspace.add_container_to_back(container);
+        }
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        // Get focused container. Should be the index of the last container added
+        let container = workspace.focused_container_mut().unwrap();
+
+        // Should be focused on the container with 1 window
+        assert_eq!(container.windows().len(), 1);
+    }
+
+    #[test]
+    fn test_add_container_to_front() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(1));
+            workspace.add_container_to_front(container);
+        }
+
+        {
+            // Container with 3 windows
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_front(container);
+        }
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        // Get focused container. Should be the index of the last container added
+        let container = workspace.focused_container_mut().unwrap();
+
+        // Should be focused on the container with 3 windows
+        assert_eq!(container.windows().len(), 3);
+    }
+
+    #[test]
+    fn test_remove_focused_container() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(1));
+            workspace.add_container_to_back(container);
+        }
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(1));
+            workspace.add_container_to_back(container);
+        }
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        // Should be focused on the container at index 1
+        assert_eq!(workspace.focused_container_idx(), 1);
+
+        // Store the container at index 1 before removal
+        let container_to_remove = workspace.containers().get(1).cloned();
+        workspace.remove_focused_container();
+
+        // Should only have 1 container
+        assert_eq!(workspace.containers().len(), 1);
+
+        // Should be focused on the container at index 0
+        assert_eq!(workspace.focused_container_idx(), 0);
+
+        // Ensure the container at index 1 before removal is no longer present
+        assert!(container_to_remove.is_some());
+        assert!(!workspace
+            .containers()
+            .contains(&container_to_remove.unwrap()));
+    }
+
+    #[test]
+    fn test_insert_container_at_idx() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..4 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 4 containers
+        assert_eq!(workspace.containers().len(), 4);
+
+        // Should be focused on the last container
+        assert_eq!(workspace.focused_container_idx(), 3);
+
+        // Insert a container at index 4
+        workspace.insert_container_at_idx(4, Container::default());
+
+        // Should have 5 containers
+        assert_eq!(workspace.containers().len(), 5);
+
+        // Should be focused on the newly inserted container
+        assert_eq!(workspace.focused_container_idx(), 4);
+    }
+
+    #[test]
+    fn test_remove_container_by_idx() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..3 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 3 containers
+        assert_eq!(workspace.containers().len(), 3);
+
+        // Should be focused on the last container
+        assert_eq!(workspace.focused_container_idx(), 2);
+
+        // Store the container at index 1 before removal
+        let container_to_remove = workspace.containers().get(1).cloned();
+
+        // Remove the container at index 1
+        workspace.remove_container_by_idx(1);
+
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        // Ensure the container at index 1 before removal is no longer present
+        assert!(container_to_remove.is_some());
+        assert!(!workspace
+            .containers()
+            .contains(&container_to_remove.unwrap()));
+    }
+
+    #[test]
+    fn test_remove_container() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..3 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 3 containers
+        assert_eq!(workspace.containers().len(), 3);
+
+        // Should be focused on the last container
+        assert_eq!(workspace.focused_container_idx(), 2);
+
+        // Store the container at index 2 before removal
+        let container_to_remove = workspace.containers().get(2).cloned();
+
+        // Remove the container at index 2
+        workspace.remove_container(2);
+
+        // Should be focused on the previous container which is index 1
+        assert_eq!(workspace.focused_container_idx(), 1);
+
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        // Ensure the container at index 1 before removal is no longer present
+        assert!(container_to_remove.is_some());
+        assert!(!workspace
+            .containers()
+            .contains(&container_to_remove.unwrap()));
+    }
+
+    #[test]
+    fn test_focus_container() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..3 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 3 containers
+        assert_eq!(workspace.containers().len(), 3);
+
+        // Should be focused on the last container
+        assert_eq!(workspace.focused_container_idx(), 2);
+
+        // Focus on container 1
+        workspace.focus_container(1);
+        assert_eq!(workspace.focused_container_idx(), 1);
+
+        // Focus on container 0
+        workspace.focus_container(0);
+        assert_eq!(workspace.focused_container_idx(), 0);
+
+        // Focus on container 2
+        workspace.focus_container(2);
+        assert_eq!(workspace.focused_container_idx(), 2);
+    }
+
+    #[test]
+    fn test_focus_previous_container() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..3 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 3 containers
+        assert_eq!(workspace.containers().len(), 3);
+
+        // Should be focused on the last container
+        assert_eq!(workspace.focused_container_idx(), 2);
+
+        // Focus on the previous container
+        workspace.focus_previous_container();
+
+        // Should be focused on container 1
+        assert_eq!(workspace.focused_container_idx(), 1);
+    }
+
+    #[test]
+    fn test_focus_last_container() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..3 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 3 containers
+        assert_eq!(workspace.containers().len(), 3);
+
+        // Change focus to the first container for the test
+        workspace.focus_container(0);
+        assert_eq!(workspace.focused_container_idx(), 0);
+
+        // Focus on the last container
+        workspace.focus_last_container();
+
+        // Should be focused on container 1
+        assert_eq!(workspace.focused_container_idx(), 2);
+    }
+
+    #[test]
+    fn test_focus_first_container() {
+        let mut workspace = Workspace::default();
+
+        for i in 0..3 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 3 containers
+        assert_eq!(workspace.containers().len(), 3);
+
+        // Should be focused on the last container
+        assert_eq!(workspace.focused_container_idx(), 2);
+
+        // Focus on the first container
+        workspace.focus_first_container();
+
+        // Should be focused on container 1
+        assert_eq!(workspace.focused_container_idx(), 0);
+    }
+
+    #[test]
+    fn test_swap_containers() {
+        let mut workspace = Workspace::default();
+
+        {
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(1));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        {
+            // Should be focused on container 1
+            assert_eq!(workspace.focused_container_idx(), 1);
+
+            // Should have 1 window
+            let container = workspace.focused_container_mut().unwrap();
+            assert_eq!(container.windows().len(), 1);
+        }
+
+        // Swap containers 0 and 1
+        workspace.swap_containers(0, 1);
+
+        {
+            // Should be focused on container 0
+            assert_eq!(workspace.focused_container_idx(), 1);
+
+            let container = workspace.focused_container_mut().unwrap();
+            assert_eq!(container.windows().len(), 3);
+        }
+    }
+
+    #[test]
+    fn test_new_container_for_window() {
+        let mut workspace = Workspace::default();
+
+        {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(1));
+            workspace.add_container_to_back(container);
+        }
+
+        // Add new window to container
+        workspace.new_container_for_window(Window::from(2));
+
+        // Container 0 should have 1 window
+        let container = workspace.focused_container_mut().unwrap();
+        assert_eq!(container.windows().len(), 1);
+
+        // Should return true that window 2 exists
+        assert!(workspace.contains_window(2));
+    }
+
+    #[test]
+    fn test_move_window_to_container() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 0 windows
+            let container = Container::default();
+            workspace.add_container_to_back(container);
+        }
+
+        {
+            // Container with 3 windows
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        // Move A Window from container 1 to container 0
+        workspace.move_window_to_container(0).unwrap();
+
+        // Focus on container 0
+        workspace.focus_container(0);
+
+        // Container 0 should have 1 window
+        let container = workspace.focused_container_mut().unwrap();
+        assert_eq!(container.windows().len(), 1);
+    }
+
+    #[test]
+    fn test_remove_window() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        // Remove window 1
+        workspace.remove_window(1).ok();
+
+        // Should have 2 windows
+        let container = workspace.focused_container_mut().unwrap();
+        assert_eq!(container.windows().len(), 2);
+
+        // Check that window 1 is removed
+        assert!(!workspace.contains_window(1));
+    }
+
+    #[test]
+    fn test_new_container_for_focused_window() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        // Add focused window to new container
+        workspace.new_container_for_focused_window().ok();
+
+        // Should have 2 containers
+        assert_eq!(workspace.containers().len(), 2);
+
+        {
+            // Inspect new container. Should contain 1 window. Window name should be 0
+            workspace.focus_container(1);
+            let container = workspace.focused_container_mut().unwrap();
+            assert_eq!(container.windows().len(), 1);
+            assert!(workspace.contains_window(0));
+        }
+    }
+}

komorebic-no-console/Cargo.toml

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

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.35"
+version = "0.1.36"
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"

komorebic/src/main.rs

@@ -25,6 +25,7 @@ use fs_tail::TailedFile;
 use komorebi_client::resolve_home_path;
 use komorebi_client::send_message;
 use komorebi_client::send_query;
+use komorebi_client::AppSpecificConfigurationPath;
 use komorebi_client::ApplicationSpecificConfiguration;
 use lazy_static::lazy_static;
 use miette::NamedSource;
@@ -1282,6 +1283,8 @@ enum SubCommand {
     ToggleMonocle,
     /// Toggle native maximization for the focused window
     ToggleMaximize,
+    /// Toggle a lock for the focused container, ensuring it will not be displaced by any new windows
+    ToggleLock,
     /// Restore all hidden windows (debugging command)
     RestoreWindows,
     /// Force komorebi to manage the focused window
@@ -1660,11 +1663,12 @@ fn main() -> Result<()> {
                         None => {
                             println!("Application specific configuration file path has not been set. Try running 'komorebic fetch-asc'\n");
                         }
-                        Some(path) => {
+                        Some(AppSpecificConfigurationPath::Single(path)) => {
                             if !Path::exists(Path::new(&path)) {
                                 println!("Application specific configuration file path '{}' does not exist. Try running 'komorebic fetch-asc'\n", path.display());
                             }
                         }
+                        _ => {}
                     }
                 }
 
@@ -1945,6 +1949,9 @@ fn main() -> Result<()> {
         SubCommand::ToggleMaximize => {
             send_message(&SocketMessage::ToggleMaximize)?;
         }
+        SubCommand::ToggleLock => {
+            send_message(&SocketMessage::ToggleLock)?;
+        }
         SubCommand::WorkspaceLayout(arg) => {
             send_message(&SocketMessage::WorkspaceLayout(
                 arg.monitor,

mkdocs.yml

@@ -55,6 +55,12 @@ nav:
       - Installation: installation.md
       - Example configurations: example-configurations.md
       - Troubleshooting: troubleshooting.md
+  - Usage:
+      - usage/focusing-windows.md
+      - usage/moving-windows.md
+      - usage/stacking-windows.md
+      - usage/focusing-workspaces.md
+      - usage/moving-windows-across-workspaces.md
   - Common workflows:
       - common-workflows/komorebi-config-home.md
       - common-workflows/autostart.md
@@ -71,6 +77,7 @@ nav:
       - common-workflows/dynamic-layout-switching.md
       - common-workflows/set-display-index.md
       - common-workflows/multiple-bar-instances.md
+      - common-workflows/multi-monitor-setup.md
   - Configuration reference: https://komorebi.lgug2z.com/schema
   - Bar reference: https://komorebi-bar.lgug2z.com/schema
   - CLI reference:

schema.bar.json

@@ -265,6 +265,10 @@
                         ]
                       }
                     ]
+                  },
+                  "timezone": {
+                    "description": "TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)\n\nUse a custom format to display additional information, i.e.: ```json { \"Date\": { \"enable\": true, \"format\": { \"Custom\": \"%D %Z (Tokyo)\" }, \"timezone\": \"Asia/Tokyo\" } } ```",
+                    "type": "string"
                   }
                 }
               }
@@ -892,6 +896,10 @@
                   "format"
                 ],
                 "properties": {
+                  "changing_icon": {
+                    "description": "Change the icon depending on the time. The default icon is used between 8:30 and 12:00. (default: false)",
+                    "type": "boolean"
+                  },
                   "enable": {
                     "description": "Enable the Time widget",
                     "type": "boolean"
@@ -988,6 +996,10 @@
                         ]
                       }
                     ]
+                  },
+                  "timezone": {
+                    "description": "TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)\n\nUse a custom format to display additional information, i.e.: ```json { \"Time\": { \"enable\": true, \"format\": { \"Custom\": \"%T %Z (Tokyo)\" }, \"timezone\": \"Asia/Tokyo\" } } ```",
+                    "type": "string"
                   }
                 }
               }
@@ -1663,6 +1675,10 @@
                         ]
                       }
                     ]
+                  },
+                  "timezone": {
+                    "description": "TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)\n\nUse a custom format to display additional information, i.e.: ```json { \"Date\": { \"enable\": true, \"format\": { \"Custom\": \"%D %Z (Tokyo)\" }, \"timezone\": \"Asia/Tokyo\" } } ```",
+                    "type": "string"
                   }
                 }
               }
@@ -2290,6 +2306,10 @@
                   "format"
                 ],
                 "properties": {
+                  "changing_icon": {
+                    "description": "Change the icon depending on the time. The default icon is used between 8:30 and 12:00. (default: false)",
+                    "type": "boolean"
+                  },
                   "enable": {
                     "description": "Enable the Time widget",
                     "type": "boolean"
@@ -2386,6 +2406,10 @@
                         ]
                       }
                     ]
+                  },
+                  "timezone": {
+                    "description": "TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)\n\nUse a custom format to display additional information, i.e.: ```json { \"Time\": { \"enable\": true, \"format\": { \"Custom\": \"%T %Z (Tokyo)\" }, \"timezone\": \"Asia/Tokyo\" } } ```",
+                    "type": "string"
                   }
                 }
               }
@@ -2994,6 +3018,10 @@
                         ]
                       }
                     ]
+                  },
+                  "timezone": {
+                    "description": "TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)\n\nUse a custom format to display additional information, i.e.: ```json { \"Date\": { \"enable\": true, \"format\": { \"Custom\": \"%D %Z (Tokyo)\" }, \"timezone\": \"Asia/Tokyo\" } } ```",
+                    "type": "string"
                   }
                 }
               }
@@ -3621,6 +3649,10 @@
                   "format"
                 ],
                 "properties": {
+                  "changing_icon": {
+                    "description": "Change the icon depending on the time. The default icon is used between 8:30 and 12:00. (default: false)",
+                    "type": "boolean"
+                  },
                   "enable": {
                     "description": "Enable the Time widget",
                     "type": "boolean"
@@ -3717,6 +3749,10 @@
                         ]
                       }
                     ]
+                  },
+                  "timezone": {
+                    "description": "TimeZone (https://docs.rs/chrono-tz/latest/chrono_tz/enum.Tz.html)\n\nUse a custom format to display additional information, i.e.: ```json { \"Time\": { \"enable\": true, \"format\": { \"Custom\": \"%T %Z (Tokyo)\" }, \"timezone\": \"Asia/Tokyo\" } } ```",
+                    "type": "string"
                   }
                 }
               }

schema.json

@@ -131,7 +131,19 @@
     },
     "app_specific_configuration_path": {
       "description": "Path to applications.json from komorebi-application-specific-configurations (default: None)",
-      "type": "string"
+      "anyOf": [
+        {
+          "description": "A single applications.json file",
+          "type": "string"
+        },
+        {
+          "description": "Multiple applications.json files",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
     },
     "bar_configurations": {
       "description": "Komorebi status bar configuration files for multiple instances on different monitors",
@@ -2199,6 +2211,38 @@
                 "Mantle",
                 "Crust"
               ]
+            },
+            "unfocused_locked_border": {
+              "description": "Border colour when the container is unfocused and locked (default: Red)",
+              "type": "string",
+              "enum": [
+                "Rosewater",
+                "Flamingo",
+                "Pink",
+                "Mauve",
+                "Red",
+                "Maroon",
+                "Peach",
+                "Yellow",
+                "Green",
+                "Teal",
+                "Sky",
+                "Sapphire",
+                "Blue",
+                "Lavender",
+                "Text",
+                "Subtext1",
+                "Subtext0",
+                "Overlay2",
+                "Overlay1",
+                "Overlay0",
+                "Surface2",
+                "Surface1",
+                "Surface0",
+                "Base",
+                "Mantle",
+                "Crust"
+              ]
             }
           }
         },
@@ -2688,6 +2732,28 @@
                 "Base0E",
                 "Base0F"
               ]
+            },
+            "unfocused_locked_border": {
+              "description": "Border colour when the container is unfocused and locked (default: Base08)",
+              "type": "string",
+              "enum": [
+                "Base00",
+                "Base01",
+                "Base02",
+                "Base03",
+                "Base04",
+                "Base05",
+                "Base06",
+                "Base07",
+                "Base08",
+                "Base09",
+                "Base0A",
+                "Base0B",
+                "Base0C",
+                "Base0D",
+                "Base0E",
+                "Base0F"
+              ]
             }
           }
         }