fix(wm): grow monitors vec to accomodate index prefs

.github/workflows/windows.yaml

@@ -95,7 +95,6 @@ jobs:
             target/${{ matrix.target }}/release/komorebi.exe
             target/${{ matrix.target }}/release/komorebic.exe
             target/${{ matrix.target }}/release/komorebic-no-console.exe
-            target/${{ matrix.target }}/release/komorebi-bar.exe
             target/${{ matrix.target }}/release/komorebi-gui.exe
             target/${{ matrix.target }}/release/komorebi.pdb
             target/${{ matrix.target }}/release/komorebic.pdb
@@ -105,7 +104,7 @@ jobs:
       - name: Check GoReleaser
         uses: goreleaser/goreleaser-action@v3
         env:
-          GORELEASER_CURRENT_TAG: v0.1.29
+          GORELEASER_CURRENT_TAG: v0.1.28
         with:
           version: latest
           args: build --skip=validate --clean

.gitignore

@@ -4,4 +4,3 @@
 CHANGELOG.md
 dummy.go
 komorebic/applications.yaml
-/.vs

.goreleaser.yml

@@ -44,15 +44,6 @@ builds:
       post:
         - mkdir -p dist/windows_amd64
         - cp ".\target\x86_64-pc-windows-msvc\release\komorebi-gui.exe" ".\dist\komorebi-gui_windows_amd64_v1\komorebi-gui.exe"
-  - id: komorebi-bar
-    main: dummy.go
-    goos: [ "windows" ]
-    goarch: [ "amd64" ]
-    binary: komorebi-bar
-    hooks:
-      post:
-        - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi-bar.exe" ".\dist\komorebi-bar_windows_amd64_v1\komorebi-bar.exe"
 
 archives:
   - name_template: "{{ .ProjectName }}-{{ .Version }}-x86_64-pc-windows-msvc"

Cargo.toml

@@ -7,41 +7,24 @@ members = [
     "komorebi-gui",
     "komorebic",
     "komorebic-no-console",
-    "komorebi-bar",
-    "komorebi-themes"
 ]
 
 [workspace.dependencies]
-clap = { version = "4", features = ["derive", "wrap_help"] }
-chrono = "0.4"
-crossbeam-channel = "0.5"
-crossbeam-utils = "0.8"
 color-eyre = "0.6"
-eframe = "0.28"
-egui_extras = "0.28"
 dirs = "5"
 dunce = "1"
-hotwatch = "0.5"
-schemars = "0.8"
-lazy_static = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = { package = "serde_json_lenient", version = "0.2" }
 serde_yaml = "0.9"
-tracing = "0.1"
-tracing-appender = "0.2"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-paste = "1"
-sysinfo = "0.31"
+sysinfo = "0.30"
 uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "dd65e3f22d0521b78fcddde11abc2a3e9dcc32a8" }
-windows-implement = { version = "0.58" }
-windows-interface = { version = "0.58" }
-windows-core = { version = "0.58" }
-shadow-rs = "0.35"
-which = "6"
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "32a45cebf132c3d651ee22c0c40033a6b7edc945" }
+windows-implement = { version = "0.53" }
+windows-interface = { version = "0.53" }
+shadow-rs = "0.29"
 
 [workspace.dependencies.windows]
-version = "0.58"
+version = "0.54"
 features = [
     "implement",
     "Win32_System_Com",
@@ -59,10 +42,5 @@ features = [
     "Win32_UI_Shell_Common",
     "Win32_UI_WindowsAndMessaging",
     "Win32_System_SystemServices",
-    "Win32_System_WindowsProgramming",
-    "Media",
-    "Media_Control"
+    "Win32_System_WindowsProgramming"
 ]
-
-[profile.release]
-lto = true

LICENSE.md

@@ -1,6 +1,6 @@
-# Komorebi License
+# PolyForm Strict License 1.0.0
 
-Version 1.0.0
+<https://polyformproject.org/licenses/strict/1.0.0>
 
 ## Acceptance
 
@@ -13,14 +13,8 @@ your licenses.
 The licensor grants you a copyright license for the software
 to do everything you might do with the software that would
 otherwise infringe the licensor's copyright in it for any
-permitted purpose. However, you may only make changes according
-to the [Changes License](#changes-license), and you may not
-distribute the software or new works based on the software.
-
-## Changes License
-
-The licensor grants you an additional copyright license to
-make changes for any permitted purpose.
+permitted purpose, other than distributing the software or
+making changes or new works based on the software.
 
 ## Patent License
 
@@ -28,6 +22,10 @@ The licensor grants you a patent license for the software that
 covers patent claims the licensor can license, or becomes able
 to license, that you would infringe by using the software.
 
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
 ## Personal Uses
 
 Personal use for research, experiment, and testing for
@@ -36,6 +34,15 @@ entertainment, hobby projects, amateur pursuits, or religious
 observance, without any anticipated commercial application,
 is use for a permitted purpose.
 
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
 ## Fair Use
 
 You may have "fair use" rights for the software under the

PRIVACY.md

@@ -1,8 +0,0 @@
-# Privacy Policy for Komorebi
-
-No data about your device(s) or _komorebi_ usage leave your device.
-
-## Data Maintained by Komorebi
-
-_komorebi_ writes log files to and keeps a list of temporary window handles (HWNDs) currently managed by the process in
-the `$Env:LOCALAPPDATA\komorebi\` directory. This directory is owned by the user running the process.

README.md

@@ -82,7 +82,7 @@ A [detailed installation and quickstart
 guide](https://lgug2z.github.io/komorebi/installation.html) is available which shows how to get started
 using `scoop`, `winget` or building from source.
 
-[![Watch the quickstart walkthrough video](https://img.youtube.com/vi/MMZUAtHbTYY/hqdefault.jpg)](https://www.youtube.com/watch?v=MMZUAtHbTYY)
+[![Watch the quickstart walkthrough video](https://img.youtube.com/vi/H9-_c1egQ4g/hqdefault.jpg)](https://www.youtube.com/watch?v=H9-_c1egQ4g)
 
 # Comparison With Fancy Zones
 
@@ -191,8 +191,7 @@ required.
 
 ## License
 
-`komorebi` is licensed under the [Komorebi 1.0.0 license](./LICENSE.md), which
-is a fork of the [PolyForm Strict 1.0.0
+`komorebi` is licensed under the [PolyForm Strict 1.0.0
 license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
 this means that you are free to do whatever you want with `komorebi` other than
 redistribution, or distribution of new works (ie. hard-forks) based on the
@@ -359,7 +358,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.29"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.28"}
 
 use anyhow::Result;
 use komorebi_client::Notification;

docs/cli/animation-duration.md

@@ -1,16 +0,0 @@
-# animation-duration
-
-```
-Set the duration for movement animations in ms
-
-Usage: komorebic.exe animation-duration <DURATION>
-
-Arguments:
-  <DURATION>
-          Desired animation durations in ms
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/animation-fps.md

@@ -1,16 +0,0 @@
-# animation-fps
-
-```
-Set the frames per second for movement animations
-
-Usage: komorebic.exe animation-fps <FPS>
-
-Arguments:
-  <FPS>
-          Desired animation frames per second
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/animation-style.md

@@ -1,20 +0,0 @@
-# animation-style
-
-```
-Set the ease function for movement animations
-
-Usage: komorebic.exe animation-style [OPTIONS]
-
-Options:
-  -s, --style <STYLE>
-          Desired ease function for animation
-          
-          [default: linear]
-          [possible values: linear, ease-in-sine, ease-out-sine, ease-in-out-sine, ease-in-quad, ease-out-quad, ease-in-out-quad, ease-in-cubic, ease-in-out-cubic, ease-in-quart,
-          ease-out-quart, ease-in-out-quart, ease-in-quint, ease-out-quint, ease-in-out-quint, ease-in-expo, ease-out-expo, ease-in-out-expo, ease-in-circ, ease-out-circ, ease-in-out-circ,
-          ease-in-back, ease-out-back, ease-in-out-back, ease-in-elastic, ease-out-elastic, ease-in-out-elastic, ease-in-bounce, ease-out-bounce, ease-in-out-bounce]
-
-  -h, --help
-          Print help
-
-```

docs/cli/animation.md

@@ -1,16 +0,0 @@
-# animation
-
-```
-Enable or disable movement animations
-
-Usage: komorebic.exe animation <BOOLEAN_STATE>
-
-Arguments:
-  <BOOLEAN_STATE>
-          [possible values: enable, disable]
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/bar-configuration.md

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

docs/cli/complete-configuration.md

@@ -1,7 +1,7 @@
 # complete-configuration
 
 ```
-For legacy komorebi.ahk or komorebi.ps1 configurations, signal that the final configuration option has been sent
+Signal that the final configuration option has been sent
 
 Usage: komorebic.exe complete-configuration
 

docs/cli/enable-autostart.md

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

docs/cli/focus-stack-window.md

@@ -1,16 +0,0 @@
-# focus-stack-window
-
-```
-Focus the specified window index in the focused stack
-
-Usage: komorebic.exe focus-stack-window <TARGET>
-
-Arguments:
-  <TARGET>
-          Target index (zero-indexed)
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/reload-configuration.md

@@ -1,7 +1,7 @@
 # reload-configuration
 
 ```
-Reload legacy komorebi.ahk or komorebi.ps1 configurations (if they exist)
+Reload ~/komorebi.ahk (if it exists)
 
 Usage: komorebic.exe reload-configuration
 

docs/cli/replace-configuration.md

@@ -1,16 +0,0 @@
-# replace-configuration
-
-```
-Replace the configuration of a running instance of komorebi from a static configuration file
-
-Usage: komorebic.exe replace-configuration <PATH>
-
-Arguments:
-  <PATH>
-          Static configuration JSON file from which the configuration should be loaded
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/start.md

@@ -24,9 +24,6 @@ Options:
       --ahk
           Start autohotkey configuration file
 
-      --bar
-          Start komorebi-bar in a background process
-
   -h, --help
           Print help
 

docs/cli/stop.md

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

docs/cli/toggle-transparency.md

@@ -1,12 +0,0 @@
-# toggle-transparency
-
-```
-Toggle transparency for unfocused windows
-
-Usage: komorebic.exe toggle-transparency
-
-Options:
-  -h, --help
-          Print help
-
-```

docs/cli/watch-configuration.md

@@ -1,7 +1,7 @@
 # watch-configuration
 
 ```
-Enable or disable watching of legacy komorebi.ahk or komorebi.ps1 configurations (if they exist)
+Enable or disable watching of ~/komorebi.ahk (if it exists)
 
 Usage: komorebic.exe watch-configuration <BOOLEAN_STATE>
 

docs/example-configurations.md

@@ -16,17 +16,16 @@ the example files have been downloaded. For most new users this will be in the
 komorebic quickstart
 ```
 
-With the example configurations downloaded, you can now start `komorebi`,
-`komorebi-bar` and `whkd`.
+With the example configurations downloaded, you can now start `komorebi` and `whkd.
 
 ```powershell
-komorebic start --whkd --bar
+komorebic start --whkd
 ```
 
 ## komorebi.json
 
 The example window manager configuration sets some sane defaults and provides
-seven preconfigured workspaces on the primary monitor each with a different
+five preconfigured workspaces on the primary monitor each with a different
 layout.
 
 ```json
@@ -214,24 +213,3 @@ reference.
 If you want to use one of those key codes, put them into lower case and remove
 the `VK_` prefix. For example, the keycode `VK_OEM_PLUS` becomes `oem_plus` in
 the sample configuration above.
-
-## komorebi.bar.json
-
-The example status bar configuration sets some sane defaults and provides
-a number of pre-configured widgets on the primary monitor.
-
-```json
-{% include "./komorebi.bar.example.json" %}
-```
-
-### Themes
-
-Themes can be set in either `komorebi.json` or `komorebi.bar.json`. If set
-in `komorebi.json`, the theme will be applied to both komorebi's borders and
-stackbars as well as the status bar.
-
-If set in `komorebi.bar.json`, the theme will only be applied to the status bar.
-
-All [Catppuccin palette variants](https://catppuccin.com/)
-and [most Base16 palette variants](https://tinted-theming.github.io/base16-gallery/)
-are available as themes.

docs/installation.md

@@ -1,6 +1,6 @@
 # Getting started
 
-`komorebi` is a tiling window manager for Windows that is comprised of two
+`komorebi` is a tiling window manager for Windows that is comprised of two 
 main binaries, `komorebi.exe`, which contains the window manager itself,
 and `komorebic.exe`, which is the main way to send commands to the tiling
 window manager.
@@ -23,10 +23,6 @@ suggest that once you are familiar with the main `komorebic.exe` commands used
 to manipulate the window manager, you use
 [AutoHotKey](https://www.autohotkey.com/) to handle your key bindings.
 
-`komorebi` also includes `komorebi-bar.exe`, a simple and reliable status bar which
-is deeply integrated with the tiling window manager, and can be customized with
-various widgets and themes.
-
 ## Installation
 
 `komorebi` is available pre-built to install via
@@ -119,7 +115,6 @@ cargo +stable install --path komorebi --locked
 cargo +stable install --path komorebic --locked
 cargo +stable install --path komorebic-no-console --locked
 cargo +stable install --path komorebi-gui --locked
-cargo +stable install --path komorebi-bar --locked
 ```
 
 If the binaries have been built and added to your `$PATH` correctly, you should
@@ -136,8 +131,8 @@ first-time set up and running komorebi require an internet connection).
 
 ## Uninstallation
 
-Before uninstalling, first run `komorebic stop --whkd --bar` to make sure that
-the `komorebi`, `komorebi-bar` and `whkd` processes have been stopped.
+Before uninstalling, first run `komorebic stop --whkd` to make sure that both
+the `komorebi` and `whkd` processes have been stopped.
 
 Then, depending on whether you installed with Scoop or WinGet, run `scoop
 uninstall komorebi whkd` or `winget uninstall LGUG2Z.komorebi LGUG2Z.whkd`.

docs/komorebi.bar.example.json

@@ -1,76 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.29/schema.bar.json",
-  "monitor": {
-    "index": 0,
-    "work_area_offset": {
-      "left": 0,
-      "top": 40,
-      "right": 0,
-      "bottom": 40
-    }
-  },
-  "font_family": "JetBrains Mono",
-  "theme": {
-    "palette": "Base16",
-    "name": "Ashes",
-    "accent": "Base0D"
-  },
-  "left_widgets": [
-    {
-      "Komorebi": {
-        "workspaces": {
-          "enable": true,
-          "hide_empty_workspaces": false
-        },
-        "layout": {
-          "enable": true
-        },
-        "focused_window": {
-          "enable": true,
-          "show_icon": true
-        }
-      }
-    }
-  ],
-  "right_widgets": [
-    {
-      "Media": {
-        "enable": true
-      }
-    },
-    {
-      "Storage": {
-        "enable": true
-      }
-    },
-    {
-      "Memory": {
-        "enable": true
-      }
-    },
-    {
-      "Network": {
-        "enable": true,
-        "show_total_data_transmitted": true,
-        "show_network_activity": true
-      }
-    },
-    {
-      "Date": {
-        "enable": true,
-        "format": "DayDateMonthYear"
-      }
-    },
-    {
-      "Time": {
-        "enable": true,
-        "format": "TwentyFourHour"
-      }
-    },
-    {
-      "Battery": {
-        "enable": true
-      }
-    }
-  ]
-}

docs/komorebi.example.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.29/schema.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.28/schema.json",
   "app_specific_configuration_path": "$Env:USERPROFILE/applications.yaml",
   "window_hiding_behaviour": "Cloak",
   "cross_monitor_move_behaviour": "Insert",
@@ -8,17 +8,20 @@
   "border": true,
   "border_width": 8,
   "border_offset": -1,
-  "theme": {
-    "palette": "Base16",
-    "name": "Ashes",
-    "unfocused_border": "Base03",
-    "bar_accent": "Base0D"
+  "border_colours": {
+    "single": "#42a5f5",
+    "stack": "#00a542",
+    "monocle": "#ff3399",
+    "unfocused": "#808080"
   },
   "stackbar": {
     "height": 40,
     "mode": "OnStack",
     "tabs": {
-      "width": 300
+      "width": 300,
+      "focused_text": "#00a542",
+      "unfocused_text": "#b3b3b3",
+      "background": "#141414"
     }
   },
   "monitors": [

justfile

@@ -19,8 +19,6 @@ install-target target:
 install:
     just install-target komorebic
     just install-target komorebic-no-console
-    just install-target komorebi-gui
-    just install-target komorebi-bar
     just install-target komorebi
 
 run:
@@ -42,16 +40,9 @@ deadlock $RUST_LOG="trace":
     cargo +stable run --bin komorebi --locked --features deadlock_detection
 
 docgen:
-    cargo run --package komorebic -- docgen
+    komorebic docgen
     Get-ChildItem -Path "docs/cli" -Recurse -File | ForEach-Object { (Get-Content $_.FullName) -replace 'Usage: ', 'Usage: komorebic.exe ' | Set-Content $_.FullName }
 
 schemagen:
-    cargo run --package komorebic -- static-config-schema > schema.json
-    cargo run --package komorebic -- application-specific-configuration-schema > schema.asc.json
-    cargo run --package komorebi-bar -- --schema > schema.bar.json
+    komorebic static-config-schema > schema.json
     generate-schema-doc .\schema.json --config template_name=js_offline --config minify=false .\static-config-docs\
-
-    generate-schema-doc .\schema.bar.json --config template_name=js_offline --config minify=false .\bar-config-docs\
-
-    rm -Force .\bar-config-docs\schema.html
-    mv .\bar-config-docs\schema.bar.html .\bar-config-docs\schema.html

komorebi-bar/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-name = "komorebi-bar"
-version = "0.1.30"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-komorebi-client = { path = "../komorebi-client" }
-komorebi-themes = { path = "../komorebi-themes" }
-
-chrono = { workspace = true }
-clap = { workspace = true }
-color-eyre = { workspace = true }
-crossbeam-channel = { workspace = true }
-dirs = { workspace = true }
-dunce = { workspace = true }
-eframe = { workspace = true }
-egui-phosphor = "0.6.0"
-font-loader = "0.11"
-hotwatch = { workspace = true }
-image = "0.25"
-netdev = "0.31"
-num = "0.4.3"
-num-derive = "0.4.2"
-num-traits = "0.2.19"
-random_word = { version = "0.4.3", features = ["en"] }
-schemars = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-starship-battery = "0.10"
-sysinfo = { workspace = true }
-tracing = { workspace = true }
-tracing-appender = { workspace = true }
-tracing-subscriber = { workspace = true }
-windows = { workspace = true }
-windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }

komorebi-bar/src/bar.rs

@@ -1,458 +0,0 @@
-use crate::config::KomobarConfig;
-use crate::config::KomobarTheme;
-use crate::config::Position;
-use crate::config::PositionConfig;
-use crate::komorebi::Komorebi;
-use crate::komorebi::KomorebiNotificationState;
-use crate::process_hwnd;
-use crate::widget::BarWidget;
-use crate::widget::WidgetConfig;
-use crate::BAR_HEIGHT;
-use crate::MAX_LABEL_WIDTH;
-use crate::MONITOR_LEFT;
-use crate::MONITOR_RIGHT;
-use crate::MONITOR_TOP;
-use crossbeam_channel::Receiver;
-use eframe::egui::Align;
-use eframe::egui::CentralPanel;
-use eframe::egui::Color32;
-use eframe::egui::Context;
-use eframe::egui::FontData;
-use eframe::egui::FontDefinitions;
-use eframe::egui::FontFamily;
-use eframe::egui::FontId;
-use eframe::egui::Frame;
-use eframe::egui::Layout;
-use eframe::egui::Margin;
-use eframe::egui::Style;
-use eframe::egui::TextStyle;
-use font_loader::system_fonts;
-use font_loader::system_fonts::FontPropertyBuilder;
-use komorebi_client::KomorebiTheme;
-use komorebi_themes::catppuccin_egui;
-use komorebi_themes::Base16Value;
-use komorebi_themes::Catppuccin;
-use komorebi_themes::CatppuccinValue;
-use std::cell::RefCell;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-
-pub struct Komobar {
-    pub config: Arc<KomobarConfig>,
-    pub komorebi_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
-    pub left_widgets: Vec<Box<dyn BarWidget>>,
-    pub right_widgets: Vec<Box<dyn BarWidget>>,
-    pub rx_gui: Receiver<komorebi_client::Notification>,
-    pub rx_config: Receiver<KomobarConfig>,
-    pub bg_color: Rc<RefCell<Color32>>,
-    pub scale_factor: f32,
-}
-
-pub fn apply_theme(ctx: &Context, theme: KomobarTheme, bg_color: Rc<RefCell<Color32>>) {
-    match theme {
-        KomobarTheme::Catppuccin {
-            name: catppuccin,
-            accent: catppuccin_value,
-        } => match catppuccin {
-            Catppuccin::Frappe => {
-                catppuccin_egui::set_theme(ctx, catppuccin_egui::FRAPPE);
-                let catppuccin_value = catppuccin_value.unwrap_or_default();
-                let accent = catppuccin_value.color32(catppuccin.as_theme());
-
-                ctx.style_mut(|style| {
-                    style.visuals.selection.stroke.color = accent;
-                    style.visuals.widgets.hovered.fg_stroke.color = accent;
-                    style.visuals.widgets.active.fg_stroke.color = accent;
-                    style.visuals.override_text_color = None;
-                });
-
-                bg_color.replace(catppuccin_egui::FRAPPE.base);
-            }
-            Catppuccin::Latte => {
-                catppuccin_egui::set_theme(ctx, catppuccin_egui::LATTE);
-                let catppuccin_value = catppuccin_value.unwrap_or_default();
-                let accent = catppuccin_value.color32(catppuccin.as_theme());
-
-                ctx.style_mut(|style| {
-                    style.visuals.selection.stroke.color = accent;
-                    style.visuals.widgets.hovered.fg_stroke.color = accent;
-                    style.visuals.widgets.active.fg_stroke.color = accent;
-                    style.visuals.override_text_color = None;
-                });
-
-                bg_color.replace(catppuccin_egui::LATTE.base);
-            }
-            Catppuccin::Macchiato => {
-                catppuccin_egui::set_theme(ctx, catppuccin_egui::MACCHIATO);
-                let catppuccin_value = catppuccin_value.unwrap_or_default();
-                let accent = catppuccin_value.color32(catppuccin.as_theme());
-
-                ctx.style_mut(|style| {
-                    style.visuals.selection.stroke.color = accent;
-                    style.visuals.widgets.hovered.fg_stroke.color = accent;
-                    style.visuals.widgets.active.fg_stroke.color = accent;
-                    style.visuals.override_text_color = None;
-                });
-
-                bg_color.replace(catppuccin_egui::MACCHIATO.base);
-            }
-            Catppuccin::Mocha => {
-                catppuccin_egui::set_theme(ctx, catppuccin_egui::MOCHA);
-                let catppuccin_value = catppuccin_value.unwrap_or_default();
-                let accent = catppuccin_value.color32(catppuccin.as_theme());
-
-                ctx.style_mut(|style| {
-                    style.visuals.selection.stroke.color = accent;
-                    style.visuals.widgets.hovered.fg_stroke.color = accent;
-                    style.visuals.widgets.active.fg_stroke.color = accent;
-                    style.visuals.override_text_color = None;
-                });
-
-                bg_color.replace(catppuccin_egui::MOCHA.base);
-            }
-        },
-        KomobarTheme::Base16 {
-            name: base16,
-            accent: base16_value,
-        } => {
-            ctx.set_style(base16.style());
-            let base16_value = base16_value.unwrap_or_default();
-            let accent = base16_value.color32(base16);
-
-            ctx.style_mut(|style| {
-                style.visuals.selection.stroke.color = accent;
-                style.visuals.widgets.hovered.fg_stroke.color = accent;
-                style.visuals.widgets.active.fg_stroke.color = accent;
-            });
-
-            bg_color.replace(base16.background());
-        }
-    }
-}
-
-impl Komobar {
-    pub fn apply_config(
-        &mut self,
-        ctx: &Context,
-        config: &KomobarConfig,
-        previous_notification_state: Option<Rc<RefCell<KomorebiNotificationState>>>,
-    ) {
-        MAX_LABEL_WIDTH.store(
-            config.max_label_width.unwrap_or(400.0) as i32,
-            Ordering::SeqCst,
-        );
-
-        if let Some(font_family) = &config.font_family {
-            tracing::info!("attempting to add custom font family: {font_family}");
-            Self::add_custom_font(ctx, font_family);
-        }
-
-        let position = config.position.clone().unwrap_or(PositionConfig {
-            start: Some(Position {
-                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
-                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
-            }),
-            end: Some(Position {
-                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
-                y: BAR_HEIGHT,
-            }),
-        });
-
-        if let Some(hwnd) = process_hwnd() {
-            let start = position.start.unwrap_or(Position {
-                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
-                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
-            });
-
-            let end = position.end.unwrap_or(Position {
-                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
-                y: BAR_HEIGHT,
-            });
-
-            let rect = komorebi_client::Rect {
-                left: start.x as i32,
-                top: start.y as i32,
-                right: end.x as i32,
-                bottom: end.y as i32,
-            };
-
-            let window = komorebi_client::Window::from(hwnd);
-            match window.set_position(&rect, false) {
-                Ok(_) => {
-                    tracing::info!("updated bar position");
-                }
-                Err(error) => {
-                    tracing::error!("{}", error.to_string())
-                }
-            }
-        }
-
-        match config.theme {
-            Some(theme) => {
-                apply_theme(ctx, theme, self.bg_color.clone());
-            }
-            None => {
-                let home_dir: PathBuf = std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(
-                    |_| dirs::home_dir().expect("there is no home directory"),
-                    |home_path| {
-                        let home = PathBuf::from(&home_path);
-
-                        if home.as_path().is_dir() {
-                            home
-                        } else {
-                            panic!("$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory");
-                        }
-                    },
-                );
-
-                let config = home_dir.join("komorebi.json");
-                match komorebi_client::StaticConfig::read(&config) {
-                    Ok(config) => {
-                        if let Some(theme) = config.theme {
-                            apply_theme(ctx, KomobarTheme::from(theme), self.bg_color.clone());
-
-                            let stack_accent = match theme {
-                                KomorebiTheme::Catppuccin {
-                                    name, stack_border, ..
-                                } => stack_border
-                                    .unwrap_or(CatppuccinValue::Green)
-                                    .color32(name.as_theme()),
-                                KomorebiTheme::Base16 {
-                                    name, stack_border, ..
-                                } => stack_border.unwrap_or(Base16Value::Base0B).color32(name),
-                            };
-
-                            if let Some(state) = &self.komorebi_notification_state {
-                                state.borrow_mut().stack_accent = Some(stack_accent);
-                            }
-                        }
-                    }
-                    Err(_) => {
-                        ctx.set_style(Style::default());
-                        self.bg_color.replace(Style::default().visuals.panel_fill);
-                    }
-                }
-            }
-        }
-
-        if let Some(font_size) = &config.font_size {
-            tracing::info!("attempting to set custom font size: {font_size}");
-            Self::set_font_size(ctx, *font_size);
-        }
-
-        let mut komorebi_widget = None;
-        let mut komorebi_widget_idx = None;
-        let mut komorebi_notification_state = previous_notification_state;
-        let mut side = None;
-
-        for (idx, widget_config) in config.left_widgets.iter().enumerate() {
-            if let WidgetConfig::Komorebi(config) = widget_config {
-                komorebi_widget = Some(Komorebi::from(config));
-                komorebi_widget_idx = Some(idx);
-                side = Some(Side::Left);
-            }
-        }
-
-        for (idx, widget_config) in config.right_widgets.iter().enumerate() {
-            if let WidgetConfig::Komorebi(config) = widget_config {
-                komorebi_widget = Some(Komorebi::from(config));
-                komorebi_widget_idx = Some(idx);
-                side = Some(Side::Right);
-            }
-        }
-
-        let mut left_widgets = config
-            .left_widgets
-            .iter()
-            .map(|config| config.as_boxed_bar_widget())
-            .collect::<Vec<Box<dyn BarWidget>>>();
-
-        let mut right_widgets = config
-            .right_widgets
-            .iter()
-            .map(|config| config.as_boxed_bar_widget())
-            .collect::<Vec<Box<dyn BarWidget>>>();
-
-        if let (Some(idx), Some(mut widget), Some(side)) =
-            (komorebi_widget_idx, komorebi_widget, side)
-        {
-            match komorebi_notification_state {
-                None => {
-                    komorebi_notification_state = Some(widget.komorebi_notification_state.clone());
-                }
-                Some(ref previous) => {
-                    previous
-                        .borrow_mut()
-                        .update_from_config(&widget.komorebi_notification_state.borrow());
-
-                    widget.komorebi_notification_state = previous.clone();
-                }
-            }
-
-            let boxed: Box<dyn BarWidget> = Box::new(widget);
-            match side {
-                Side::Left => left_widgets[idx] = boxed,
-                Side::Right => right_widgets[idx] = boxed,
-            }
-        }
-
-        right_widgets.reverse();
-
-        self.left_widgets = left_widgets;
-        self.right_widgets = right_widgets;
-
-        tracing::info!("widget configuration options applied");
-
-        self.komorebi_notification_state = komorebi_notification_state;
-    }
-    pub fn new(
-        cc: &eframe::CreationContext<'_>,
-        rx_gui: Receiver<komorebi_client::Notification>,
-        rx_config: Receiver<KomobarConfig>,
-        config: Arc<KomobarConfig>,
-    ) -> Self {
-        let mut komobar = Self {
-            config: config.clone(),
-            komorebi_notification_state: None,
-            left_widgets: vec![],
-            right_widgets: vec![],
-            rx_gui,
-            rx_config,
-            bg_color: Rc::new(RefCell::new(Style::default().visuals.panel_fill)),
-            scale_factor: cc.egui_ctx.native_pixels_per_point().unwrap_or(1.0),
-        };
-
-        komobar.apply_config(&cc.egui_ctx, &config, None);
-        // needs a double apply the first time for some reason
-        komobar.apply_config(&cc.egui_ctx, &config, None);
-
-        komobar
-    }
-
-    fn set_font_size(ctx: &Context, font_size: f32) {
-        ctx.style_mut(|style| {
-            style.text_styles = [
-                (TextStyle::Small, FontId::new(9.0, FontFamily::Proportional)),
-                (
-                    TextStyle::Body,
-                    FontId::new(font_size, FontFamily::Proportional),
-                ),
-                (
-                    TextStyle::Button,
-                    FontId::new(font_size, FontFamily::Proportional),
-                ),
-                (
-                    TextStyle::Heading,
-                    FontId::new(18.0, FontFamily::Proportional),
-                ),
-                (
-                    TextStyle::Monospace,
-                    FontId::new(font_size, FontFamily::Monospace),
-                ),
-            ]
-            .into();
-        });
-    }
-
-    fn add_custom_font(ctx: &Context, name: &str) {
-        let mut fonts = FontDefinitions::default();
-        egui_phosphor::add_to_fonts(&mut fonts, egui_phosphor::Variant::Regular);
-
-        let property = FontPropertyBuilder::new().family(name).build();
-
-        if let Some((font, _)) = system_fonts::get(&property) {
-            fonts
-                .font_data
-                .insert(name.to_owned(), FontData::from_owned(font));
-
-            fonts
-                .families
-                .entry(FontFamily::Proportional)
-                .or_default()
-                .insert(0, name.to_owned());
-
-            fonts
-                .families
-                .entry(FontFamily::Monospace)
-                .or_default()
-                .push(name.to_owned());
-
-            // Tell egui to use these fonts:
-            ctx.set_fonts(fonts);
-        }
-    }
-}
-impl eframe::App for Komobar {
-    // TODO: I think this is needed for transparency??
-    // fn clear_color(&self, _visuals: &Visuals) -> [f32; 4] {
-    // egui::Rgba::TRANSPARENT.to_array()
-    // let mut background = Color32::from_gray(18).to_normalized_gamma_f32();
-    // background[3] = 0.9;
-    // background
-    // }
-
-    fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
-        if self.scale_factor != ctx.native_pixels_per_point().unwrap_or(1.0) {
-            self.scale_factor = ctx.native_pixels_per_point().unwrap_or(1.0);
-            self.apply_config(
-                ctx,
-                &self.config.clone(),
-                self.komorebi_notification_state.clone(),
-            );
-        }
-
-        if let Ok(updated_config) = self.rx_config.try_recv() {
-            self.apply_config(
-                ctx,
-                &updated_config,
-                self.komorebi_notification_state.clone(),
-            );
-        }
-
-        if let Some(komorebi_notification_state) = &self.komorebi_notification_state {
-            komorebi_notification_state
-                .borrow_mut()
-                .handle_notification(
-                    ctx,
-                    self.config.monitor.index,
-                    self.rx_gui.clone(),
-                    self.bg_color.clone(),
-                );
-        }
-
-        let frame = if let Some(frame) = &self.config.frame {
-            Frame::none()
-                .inner_margin(Margin::symmetric(
-                    frame.inner_margin.x,
-                    frame.inner_margin.y,
-                ))
-                .fill(*self.bg_color.borrow())
-        } else {
-            Frame::none().fill(*self.bg_color.borrow())
-        };
-
-        CentralPanel::default().frame(frame).show(ctx, |ui| {
-            ui.horizontal_centered(|ui| {
-                ui.with_layout(Layout::left_to_right(Align::Center), |ui| {
-                    for w in &mut self.left_widgets {
-                        w.render(ctx, ui);
-                    }
-                });
-
-                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
-                    for w in &mut self.right_widgets {
-                        w.render(ctx, ui);
-                    }
-                })
-            })
-        });
-    }
-}
-
-#[derive(Copy, Clone)]
-enum Side {
-    Left,
-    Right,
-}

komorebi-bar/src/battery.rs

@@ -1,141 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use starship_battery::units::ratio::percent;
-use starship_battery::Manager;
-use starship_battery::State;
-use std::time::Duration;
-use std::time::Instant;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct BatteryConfig {
-    /// Enable the Battery widget
-    pub enable: bool,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<BatteryConfig> for Battery {
-    fn from(value: BatteryConfig) -> Self {
-        let manager = Manager::new().unwrap();
-        let mut last_state = String::new();
-        let mut state = None;
-
-        if let Ok(mut batteries) = manager.batteries() {
-            if let Some(Ok(first)) = batteries.nth(0) {
-                let percentage = first.state_of_charge().get::<percent>();
-                match first.state() {
-                    State::Charging => state = Some(BatteryState::Charging),
-                    State::Discharging => state = Some(BatteryState::Discharging),
-                    _ => {}
-                }
-
-                last_state = format!("{percentage}%");
-            }
-        }
-
-        Self {
-            enable: value.enable,
-            manager,
-            last_state,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            state: state.unwrap_or(BatteryState::Discharging),
-            last_updated: Instant::now(),
-        }
-    }
-}
-
-pub enum BatteryState {
-    Charging,
-    Discharging,
-}
-
-pub struct Battery {
-    pub enable: bool,
-    manager: Manager,
-    pub state: BatteryState,
-    data_refresh_interval: u64,
-    last_state: String,
-    last_updated: Instant,
-}
-
-impl Battery {
-    fn output(&mut self) -> String {
-        let mut output = self.last_state.clone();
-
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            output.clear();
-
-            if let Ok(mut batteries) = self.manager.batteries() {
-                if let Some(Ok(first)) = batteries.nth(0) {
-                    let percentage = first.state_of_charge().get::<percent>();
-                    match first.state() {
-                        State::Charging => self.state = BatteryState::Charging,
-                        State::Discharging => self.state = BatteryState::Discharging,
-                        _ => {}
-                    }
-
-                    output = format!("{percentage:.0}%");
-                }
-            }
-
-            self.last_state.clone_from(&output);
-            self.last_updated = now;
-        }
-
-        output
-    }
-}
-
-impl BarWidget for Battery {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let emoji = match self.state {
-                    BatteryState::Charging => egui_phosphor::regular::BATTERY_CHARGING,
-                    BatteryState::Discharging => egui_phosphor::regular::BATTERY_FULL,
-                };
-
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    emoji.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                ui.add(
-                    Label::new(layout_job)
-                        .selectable(false)
-                        .sense(Sense::click()),
-                );
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/config.rs

@@ -1,166 +0,0 @@
-use crate::widget::WidgetConfig;
-use eframe::egui::Pos2;
-use eframe::egui::TextBuffer;
-use eframe::egui::Vec2;
-use komorebi_client::KomorebiTheme;
-use komorebi_client::Rect;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::collections::HashMap;
-use std::path::PathBuf;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.30`
-pub struct KomobarConfig {
-    /// Bar positioning options
-    #[serde(alias = "viewport")]
-    pub position: Option<PositionConfig>,
-    /// Frame options (see: https://docs.rs/egui/latest/egui/containers/struct.Frame.html)
-    pub frame: Option<FrameConfig>,
-    /// Monitor options
-    pub monitor: MonitorConfig,
-    /// Font family
-    pub font_family: Option<String>,
-    /// Font size (default: 12.5)
-    pub font_size: Option<f32>,
-    /// Max label width before text truncation (default: 400.0)
-    pub max_label_width: Option<f32>,
-    /// Theme
-    pub theme: Option<KomobarTheme>,
-    /// Left side widgets (ordered left-to-right)
-    pub left_widgets: Vec<WidgetConfig>,
-    /// Right side widgets (ordered left-to-right)
-    pub right_widgets: Vec<WidgetConfig>,
-}
-
-impl KomobarConfig {
-    pub fn aliases(raw: &str) {
-        let mut map = HashMap::new();
-        map.insert("position", ["viewport"]);
-        map.insert("end", ["inner_frame"]);
-
-        let mut display = false;
-
-        for aliases in map.values() {
-            for a in aliases {
-                if raw.contains(a) {
-                    display = true;
-                }
-            }
-        }
-
-        if display {
-            println!("\nYour bar configuration file contains some options that have been renamed or deprecated:\n");
-            for (canonical, aliases) in map {
-                for alias in aliases {
-                    if raw.contains(alias) {
-                        println!(r#""{alias}" is now "{canonical}""#);
-                    }
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct PositionConfig {
-    /// The desired starting position of the bar (0,0 = top left of the screen)
-    #[serde(alias = "position")]
-    pub start: Option<Position>,
-    /// The desired size of the bar from the starting position (usually monitor width x desired height)
-    #[serde(alias = "inner_size")]
-    pub end: Option<Position>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct FrameConfig {
-    /// Margin inside the painted frame
-    pub inner_margin: Position,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct MonitorConfig {
-    /// Komorebi monitor index of the monitor on which to render the bar
-    pub index: usize,
-    /// Automatically apply a work area offset for this monitor to accommodate the bar
-    pub work_area_offset: Option<Rect>,
-}
-
-impl KomobarConfig {
-    pub fn read(path: &PathBuf) -> color_eyre::Result<Self> {
-        let content = std::fs::read_to_string(path)?;
-        let mut value: Self = match path.extension().unwrap().to_string_lossy().as_str() {
-            "json" => serde_json::from_str(&content)?,
-            _ => panic!("unsupported format"),
-        };
-
-        if value.frame.is_none() {
-            value.frame = Some(FrameConfig {
-                inner_margin: Position { x: 10.0, y: 10.0 },
-            });
-        }
-
-        Ok(value)
-    }
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct Position {
-    /// X coordinate
-    pub x: f32,
-    /// Y coordinate
-    pub y: f32,
-}
-
-impl From<Position> for Vec2 {
-    fn from(value: Position) -> Self {
-        Self {
-            x: value.x,
-            y: value.y,
-        }
-    }
-}
-
-impl From<Position> for Pos2 {
-    fn from(value: Position) -> Self {
-        Self {
-            x: value.x,
-            y: value.y,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(tag = "palette")]
-pub enum KomobarTheme {
-    /// A theme from catppuccin-egui
-    Catppuccin {
-        name: komorebi_themes::Catppuccin,
-        accent: Option<komorebi_themes::CatppuccinValue>,
-    },
-    /// A theme from base16-egui-themes
-    Base16 {
-        name: komorebi_themes::Base16,
-        accent: Option<komorebi_themes::Base16Value>,
-    },
-}
-
-impl From<KomorebiTheme> for KomobarTheme {
-    fn from(value: KomorebiTheme) -> Self {
-        match value {
-            KomorebiTheme::Catppuccin {
-                name, bar_accent, ..
-            } => Self::Catppuccin {
-                name,
-                accent: bar_accent,
-            },
-            KomorebiTheme::Base16 {
-                name, bar_accent, ..
-            } => Self::Base16 {
-                name,
-                accent: bar_accent,
-            },
-        }
-    }
-}

komorebi-bar/src/date.rs

@@ -1,123 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use eframe::egui::WidgetText;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct DateConfig {
-    /// Enable the Date widget
-    pub enable: bool,
-    /// Set the Date format
-    pub format: DateFormat,
-}
-
-impl From<DateConfig> for Date {
-    fn from(value: DateConfig) -> Self {
-        Self {
-            enable: value.enable,
-            format: value.format,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum DateFormat {
-    /// Month/Date/Year format (09/08/24)
-    MonthDateYear,
-    /// Year-Month-Date format (2024-09-08)
-    YearMonthDate,
-    /// Date-Month-Year format (8-Sep-2024)
-    DateMonthYear,
-    /// Day Date Month Year format (8 September 2024)
-    DayDateMonthYear,
-    /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
-    Custom(String),
-}
-
-impl DateFormat {
-    pub fn next(&mut self) {
-        match self {
-            DateFormat::MonthDateYear => *self = Self::YearMonthDate,
-            DateFormat::YearMonthDate => *self = Self::DateMonthYear,
-            DateFormat::DateMonthYear => *self = Self::DayDateMonthYear,
-            DateFormat::DayDateMonthYear => *self = Self::MonthDateYear,
-            _ => {}
-        };
-    }
-
-    fn fmt_string(&self) -> String {
-        match self {
-            DateFormat::MonthDateYear => String::from("%D"),
-            DateFormat::YearMonthDate => String::from("%F"),
-            DateFormat::DateMonthYear => String::from("%v"),
-            DateFormat::DayDateMonthYear => String::from("%A %e %B %Y"),
-            DateFormat::Custom(custom) => custom.to_string(),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Date {
-    pub enable: bool,
-    pub format: DateFormat,
-}
-
-impl Date {
-    fn output(&mut self) -> String {
-        chrono::Local::now()
-            .format(&self.format.fmt_string())
-            .to_string()
-    }
-}
-
-impl BarWidget for Date {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::CALENDAR_DOTS.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(WidgetText::LayoutJob(layout_job.clone()))
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    self.format.next()
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/komorebi.rs

@@ -1,538 +0,0 @@
-use crate::bar::apply_theme;
-use crate::config::KomobarTheme;
-use crate::ui::CustomUi;
-use crate::widget::BarWidget;
-use crate::MAX_LABEL_WIDTH;
-use crate::WIDGET_SPACING;
-use crossbeam_channel::Receiver;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Color32;
-use eframe::egui::ColorImage;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Image;
-use eframe::egui::Label;
-use eframe::egui::SelectableLabel;
-use eframe::egui::Sense;
-use eframe::egui::TextStyle;
-use eframe::egui::TextureHandle;
-use eframe::egui::TextureOptions;
-use eframe::egui::Ui;
-use eframe::egui::Vec2;
-use image::RgbaImage;
-use komorebi_client::CycleDirection;
-use komorebi_client::NotificationEvent;
-use komorebi_client::Rect;
-use komorebi_client::SocketMessage;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::fmt::Display;
-use std::fmt::Formatter;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::sync::atomic::Ordering;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiConfig {
-    /// Configure the Workspaces widget
-    pub workspaces: KomorebiWorkspacesConfig,
-    /// Configure the Layout widget
-    pub layout: Option<KomorebiLayoutConfig>,
-    /// Configure the Focused Window widget
-    pub focused_window: Option<KomorebiFocusedWindowConfig>,
-    /// Configure the Configuration Switcher widget
-    pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiWorkspacesConfig {
-    /// Enable the Komorebi Workspaces widget
-    pub enable: bool,
-    /// Hide workspaces without any windows
-    pub hide_empty_workspaces: bool,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiLayoutConfig {
-    /// Enable the Komorebi Layout widget
-    pub enable: bool,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiFocusedWindowConfig {
-    /// Enable the Komorebi Focused Window widget
-    pub enable: bool,
-    /// Show the icon of the currently focused window
-    pub show_icon: bool,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct KomorebiConfigurationSwitcherConfig {
-    /// Enable the Komorebi Configurations widget
-    pub enable: bool,
-    /// A map of display friendly name => path to configuration.json
-    pub configurations: BTreeMap<String, String>,
-}
-
-impl From<&KomorebiConfig> for Komorebi {
-    fn from(value: &KomorebiConfig) -> Self {
-        let configuration_switcher =
-            if let Some(configuration_switcher) = &value.configuration_switcher {
-                let mut configuration_switcher = configuration_switcher.clone();
-                for (_, location) in configuration_switcher.configurations.iter_mut() {
-                    if let Ok(expanded) = std::env::var("KOMOREBI_CONFIG_HOME") {
-                        *location = location.replace("$Env:KOMOREBI_CONFIG_HOME", &expanded);
-                    }
-
-                    if let Ok(expanded) = std::env::var("USERPROFILE") {
-                        *location = location.replace("$Env:USERPROFILE", &expanded);
-                    }
-
-                    *location = dunce::simplified(&PathBuf::from(location.clone()))
-                        .to_string_lossy()
-                        .to_string();
-                }
-                Some(configuration_switcher)
-            } else {
-                None
-            };
-
-        Self {
-            komorebi_notification_state: Rc::new(RefCell::new(KomorebiNotificationState {
-                selected_workspace: String::new(),
-                layout: KomorebiLayout::Default(komorebi_client::DefaultLayout::BSP),
-                workspaces: vec![],
-                hide_empty_workspaces: value.workspaces.hide_empty_workspaces,
-                mouse_follows_focus: true,
-                work_area_offset: None,
-                focused_container_information: (vec![], vec![], 0),
-                stack_accent: None,
-            })),
-            workspaces: value.workspaces,
-            layout: value.layout,
-            focused_window: value.focused_window,
-            configuration_switcher,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Komorebi {
-    pub komorebi_notification_state: Rc<RefCell<KomorebiNotificationState>>,
-    pub workspaces: KomorebiWorkspacesConfig,
-    pub layout: Option<KomorebiLayoutConfig>,
-    pub focused_window: Option<KomorebiFocusedWindowConfig>,
-    pub configuration_switcher: Option<KomorebiConfigurationSwitcherConfig>,
-}
-
-impl BarWidget for Komorebi {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        let mut komorebi_notification_state = self.komorebi_notification_state.borrow_mut();
-
-        if self.workspaces.enable {
-            let mut update = None;
-
-            for (i, ws) in komorebi_notification_state.workspaces.iter().enumerate() {
-                if ui
-                    .add(SelectableLabel::new(
-                        komorebi_notification_state.selected_workspace.eq(ws),
-                        ws.to_string(),
-                    ))
-                    .clicked()
-                {
-                    update = Some(ws.to_string());
-                    let mut proceed = true;
-
-                    if komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(false))
-                        .is_err()
-                    {
-                        tracing::error!("could not send message to komorebi: MouseFollowsFocus");
-                        proceed = false;
-                    }
-
-                    if proceed
-                        && komorebi_client::send_message(&SocketMessage::FocusWorkspaceNumber(i))
-                            .is_err()
-                    {
-                        tracing::error!("could not send message to komorebi: FocusWorkspaceNumber");
-                        proceed = false;
-                    }
-
-                    if proceed
-                        && komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                            komorebi_notification_state.mouse_follows_focus,
-                        ))
-                        .is_err()
-                    {
-                        tracing::error!("could not send message to komorebi: MouseFollowsFocus");
-                        proceed = false;
-                    }
-
-                    if proceed && komorebi_client::send_message(&SocketMessage::Retile).is_err() {
-                        tracing::error!("could not send message to komorebi: Retile");
-                    }
-                }
-            }
-
-            if let Some(update) = update {
-                komorebi_notification_state.selected_workspace = update;
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if let Some(layout) = self.layout {
-            if layout.enable {
-                if ui
-                    .add(
-                        Label::new(komorebi_notification_state.layout.to_string())
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    match komorebi_notification_state.layout {
-                        KomorebiLayout::Default(_) => {
-                            if komorebi_client::send_message(&SocketMessage::CycleLayout(
-                                CycleDirection::Next,
-                            ))
-                            .is_err()
-                            {
-                                tracing::error!("could not send message to komorebi: CycleLayout");
-                            }
-                        }
-                        KomorebiLayout::Floating => {
-                            if komorebi_client::send_message(&SocketMessage::ToggleTiling).is_err()
-                            {
-                                tracing::error!("could not send message to komorebi: ToggleTiling");
-                            }
-                        }
-                        KomorebiLayout::Paused => {
-                            if komorebi_client::send_message(&SocketMessage::TogglePause).is_err() {
-                                tracing::error!("could not send message to komorebi: TogglePause");
-                            }
-                        }
-                        KomorebiLayout::Custom => {}
-                    }
-                }
-
-                ui.add_space(WIDGET_SPACING);
-            }
-        }
-
-        if let Some(configuration_switcher) = &self.configuration_switcher {
-            if configuration_switcher.enable {
-                for (name, location) in configuration_switcher.configurations.iter() {
-                    let path = PathBuf::from(location);
-                    if path.is_file()
-                        && ui
-                            .add(Label::new(name).selectable(false).sense(Sense::click()))
-                            .clicked()
-                    {
-                        let canonicalized = dunce::canonicalize(path.clone()).unwrap_or(path);
-                        let mut proceed = true;
-                        if komorebi_client::send_message(&SocketMessage::ReplaceConfiguration(
-                            canonicalized,
-                        ))
-                        .is_err()
-                        {
-                            tracing::error!(
-                                "could not send message to komorebi: ReplaceConfiguration"
-                            );
-                            proceed = false;
-                        }
-
-                        if let Some(rect) = komorebi_notification_state.work_area_offset {
-                            if proceed {
-                                match komorebi_client::send_query(&SocketMessage::Query(
-                                    komorebi_client::StateQuery::FocusedMonitorIndex,
-                                )) {
-                                    Ok(idx) => {
-                                        if let Ok(monitor_idx) = idx.parse::<usize>() {
-                                            if komorebi_client::send_message(
-                                                &SocketMessage::MonitorWorkAreaOffset(
-                                                    monitor_idx,
-                                                    rect,
-                                                ),
-                                            )
-                                            .is_err()
-                                            {
-                                                tracing::error!(
-                                                    "could not send message to komorebi: MonitorWorkAreaOffset"
-                                                );
-                                            }
-                                        }
-                                    }
-                                    Err(_) => {
-                                        tracing::error!(
-                                            "could not send message to komorebi: Query"
-                                        );
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                ui.add_space(WIDGET_SPACING);
-            }
-        }
-
-        if let Some(focused_window) = self.focused_window {
-            if focused_window.enable {
-                let titles = &komorebi_notification_state.focused_container_information.0;
-                let icons = &komorebi_notification_state.focused_container_information.1;
-                let focused_window_idx =
-                    komorebi_notification_state.focused_container_information.2;
-
-                let iter = titles.iter().zip(icons.iter());
-
-                for (i, (title, icon)) in iter.enumerate() {
-                    if focused_window.show_icon {
-                        if let Some(img) = icon {
-                            ui.add(
-                                Image::from(&img_to_texture(ctx, img))
-                                    .maintain_aspect_ratio(true)
-                                    .max_height(15.0),
-                            );
-                        }
-                    }
-
-                    if i == focused_window_idx {
-                        let font_id = ctx
-                            .style()
-                            .text_styles
-                            .get(&TextStyle::Body)
-                            .cloned()
-                            .unwrap_or_else(FontId::default);
-
-                        let layout_job = LayoutJob::simple(
-                            title.to_string(),
-                            font_id.clone(),
-                            komorebi_notification_state
-                                .stack_accent
-                                .unwrap_or(ctx.style().visuals.selection.stroke.color),
-                            100.0,
-                        );
-
-                        if titles.len() > 1 {
-                            let available_height = ui.available_height();
-                            let mut custom_ui = CustomUi(ui);
-                            custom_ui.add_sized_left_to_right(
-                                Vec2::new(
-                                    MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
-                                    available_height,
-                                ),
-                                Label::new(layout_job).selectable(false).truncate(),
-                            );
-                        } else {
-                            let available_height = ui.available_height();
-                            let mut custom_ui = CustomUi(ui);
-                            custom_ui.add_sized_left_to_right(
-                                Vec2::new(
-                                    MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
-                                    available_height,
-                                ),
-                                Label::new(title).selectable(false).truncate(),
-                            );
-                        }
-                    } else {
-                        let available_height = ui.available_height();
-                        let mut custom_ui = CustomUi(ui);
-
-                        if custom_ui
-                            .add_sized_left_to_right(
-                                Vec2::new(
-                                    MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
-                                    available_height,
-                                ),
-                                Label::new(title)
-                                    .selectable(false)
-                                    .sense(Sense::click())
-                                    .truncate(),
-                            )
-                            .clicked()
-                        {
-                            if komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                                false,
-                            ))
-                            .is_err()
-                            {
-                                tracing::error!(
-                                    "could not send message to komorebi: MouseFollowsFocus"
-                                );
-                            }
-
-                            if komorebi_client::send_message(&SocketMessage::FocusStackWindow(i))
-                                .is_err()
-                            {
-                                tracing::error!(
-                                    "could not send message to komorebi: FocusStackWindow"
-                                );
-                            }
-
-                            if komorebi_client::send_message(&SocketMessage::MouseFollowsFocus(
-                                komorebi_notification_state.mouse_follows_focus,
-                            ))
-                            .is_err()
-                            {
-                                tracing::error!(
-                                    "could not send message to komorebi: MouseFollowsFocus"
-                                );
-                            }
-                        }
-                    }
-
-                    ui.add_space(WIDGET_SPACING);
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}
-
-fn img_to_texture(ctx: &Context, rgba_image: &RgbaImage) -> TextureHandle {
-    let size = [rgba_image.width() as usize, rgba_image.height() as usize];
-    let pixels = rgba_image.as_flat_samples();
-    let color_image = ColorImage::from_rgba_unmultiplied(size, pixels.as_slice());
-    ctx.load_texture("icon", color_image, TextureOptions::default())
-}
-
-#[derive(Clone, Debug)]
-pub struct KomorebiNotificationState {
-    pub workspaces: Vec<String>,
-    pub selected_workspace: String,
-    pub focused_container_information: (Vec<String>, Vec<Option<RgbaImage>>, usize),
-    pub layout: KomorebiLayout,
-    pub hide_empty_workspaces: bool,
-    pub mouse_follows_focus: bool,
-    pub work_area_offset: Option<Rect>,
-    pub stack_accent: Option<Color32>,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum KomorebiLayout {
-    Default(komorebi_client::DefaultLayout),
-    Floating,
-    Paused,
-    Custom,
-}
-
-impl Display for KomorebiLayout {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            KomorebiLayout::Default(layout) => write!(f, "{layout}"),
-            KomorebiLayout::Floating => write!(f, "Floating"),
-            KomorebiLayout::Paused => write!(f, "Paused"),
-            KomorebiLayout::Custom => write!(f, "Custom"),
-        }
-    }
-}
-
-impl KomorebiNotificationState {
-    pub fn update_from_config(&mut self, config: &Self) {
-        self.hide_empty_workspaces = config.hide_empty_workspaces;
-    }
-
-    pub fn handle_notification(
-        &mut self,
-        ctx: &Context,
-        monitor_index: usize,
-        rx_gui: Receiver<komorebi_client::Notification>,
-        bg_color: Rc<RefCell<Color32>>,
-    ) {
-        if let Ok(notification) = rx_gui.try_recv() {
-            if let NotificationEvent::Socket(SocketMessage::ReloadStaticConfiguration(path)) =
-                notification.event
-            {
-                if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
-                    if let Some(theme) = config.theme {
-                        apply_theme(ctx, KomobarTheme::from(theme), bg_color);
-                        tracing::info!("applied theme from updated komorebi.json");
-                    }
-                }
-            }
-
-            self.mouse_follows_focus = notification.state.mouse_follows_focus;
-
-            let monitor = &notification.state.monitors.elements()[monitor_index];
-            self.work_area_offset =
-                notification.state.monitors.elements()[monitor_index].work_area_offset();
-
-            let focused_workspace_idx = monitor.focused_workspace_idx();
-
-            let mut workspaces = vec![];
-            self.selected_workspace = monitor.workspaces()[focused_workspace_idx]
-                .name()
-                .to_owned()
-                .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));
-
-            for (i, ws) in monitor.workspaces().iter().enumerate() {
-                let should_add = if self.hide_empty_workspaces {
-                    focused_workspace_idx == i || !ws.containers().is_empty()
-                } else {
-                    true
-                };
-
-                if should_add {
-                    workspaces.push(ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)));
-                }
-            }
-
-            self.workspaces = workspaces;
-            self.layout = match monitor.workspaces()[focused_workspace_idx].layout() {
-                komorebi_client::Layout::Default(layout) => KomorebiLayout::Default(*layout),
-                komorebi_client::Layout::Custom(_) => KomorebiLayout::Custom,
-            };
-
-            if !*monitor.workspaces()[focused_workspace_idx].tile() {
-                self.layout = KomorebiLayout::Floating;
-            }
-
-            if notification.state.is_paused {
-                self.layout = KomorebiLayout::Paused;
-            }
-
-            if let Some(container) = monitor.workspaces()[focused_workspace_idx].monocle_container()
-            {
-                self.focused_container_information = (
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| w.title().unwrap_or_default())
-                        .collect::<Vec<_>>(),
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
-                        .collect::<Vec<_>>(),
-                    container.focused_window_idx(),
-                );
-            } else if let Some(container) =
-                monitor.workspaces()[focused_workspace_idx].focused_container()
-            {
-                self.focused_container_information = (
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| w.title().unwrap_or_default())
-                        .collect::<Vec<_>>(),
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
-                        .collect::<Vec<_>>(),
-                    container.focused_window_idx(),
-                );
-            } else {
-                self.focused_container_information.0.clear();
-                self.focused_container_information.1.clear();
-                self.focused_container_information.2 = 0;
-            }
-        }
-    }
-}

komorebi-bar/src/main.rs

@@ -1,404 +0,0 @@
-mod bar;
-mod battery;
-mod config;
-mod date;
-mod komorebi;
-mod media;
-mod memory;
-mod network;
-mod storage;
-mod time;
-mod ui;
-mod widget;
-
-use crate::bar::Komobar;
-use crate::config::KomobarConfig;
-use crate::config::Position;
-use crate::config::PositionConfig;
-use clap::Parser;
-use eframe::egui::ViewportBuilder;
-use font_loader::system_fonts;
-use hotwatch::EventKind;
-use hotwatch::Hotwatch;
-use komorebi_client::SocketMessage;
-use schemars::gen::SchemaSettings;
-use std::io::BufReader;
-use std::io::Read;
-use std::path::PathBuf;
-use std::sync::atomic::AtomicI32;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-use std::time::Duration;
-use tracing_subscriber::EnvFilter;
-use windows::Win32::Foundation::BOOL;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::Foundation::LPARAM;
-use windows::Win32::System::Threading::GetCurrentProcessId;
-use windows::Win32::System::Threading::GetCurrentThreadId;
-use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
-use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
-use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
-use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
-
-pub static WIDGET_SPACING: f32 = 10.0;
-
-pub static MAX_LABEL_WIDTH: AtomicI32 = AtomicI32::new(400);
-pub static MONITOR_LEFT: AtomicI32 = AtomicI32::new(0);
-pub static MONITOR_TOP: AtomicI32 = AtomicI32::new(0);
-pub static MONITOR_RIGHT: AtomicI32 = AtomicI32::new(0);
-pub static BAR_HEIGHT: f32 = 50.0;
-
-#[derive(Parser)]
-#[clap(author, about, version)]
-struct Opts {
-    /// Print the JSON schema of the configuration file and exit
-    #[clap(long)]
-    schema: bool,
-    /// Print a list of fonts available on this system and exit
-    #[clap(long)]
-    fonts: bool,
-    /// Path to a JSON or YAML configuration file
-    #[clap(short, long)]
-    config: Option<PathBuf>,
-    /// Write an example komorebi.bar.json to disk
-    #[clap(long)]
-    quickstart: bool,
-    /// Print a list of aliases that can be renamed to canonical variants
-    #[clap(long)]
-    #[clap(hide = true)]
-    aliases: bool,
-}
-
-extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    unsafe {
-        let mut process_id = 0;
-        GetWindowThreadProcessId(hwnd, Some(&mut process_id));
-
-        if process_id == GetCurrentProcessId() {
-            *(lparam.0 as *mut HWND) = hwnd;
-            BOOL::from(false) // Stop enumeration
-        } else {
-            BOOL::from(true) // Continue enumeration
-        }
-    }
-}
-
-fn process_hwnd() -> Option<isize> {
-    unsafe {
-        let mut hwnd = HWND::default();
-        let _ = EnumThreadWindows(
-            GetCurrentThreadId(),
-            Some(enum_window),
-            LPARAM(&mut hwnd as *mut HWND as isize),
-        );
-
-        if hwnd.0 as isize == 0 {
-            None
-        } else {
-            Some(hwnd.0 as isize)
-        }
-    }
-}
-
-fn main() -> color_eyre::Result<()> {
-    unsafe { SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) }?;
-
-    let opts: Opts = Opts::parse();
-
-    if opts.schema {
-        let settings = SchemaSettings::default().with(|s| {
-            s.option_nullable = false;
-            s.option_add_null_type = false;
-            s.inline_subschemas = true;
-        });
-
-        let gen = settings.into_generator();
-        let socket_message = gen.into_root_schema_for::<KomobarConfig>();
-        let schema = serde_json::to_string_pretty(&socket_message)?;
-
-        println!("{schema}");
-        std::process::exit(0);
-    }
-
-    if opts.fonts {
-        for font in system_fonts::query_all() {
-            println!("{font}");
-        }
-
-        std::process::exit(0);
-    }
-
-    if std::env::var("RUST_LIB_BACKTRACE").is_err() {
-        std::env::set_var("RUST_LIB_BACKTRACE", "1");
-    }
-
-    color_eyre::install()?;
-
-    if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
-    }
-
-    tracing::subscriber::set_global_default(
-        tracing_subscriber::fmt::Subscriber::builder()
-            .with_env_filter(EnvFilter::from_default_env())
-            .finish(),
-    )?;
-
-    let home_dir: PathBuf = std::env::var("KOMOREBI_CONFIG_HOME").map_or_else(
-        |_| dirs::home_dir().expect("there is no home directory"),
-        |home_path| {
-            let home = PathBuf::from(&home_path);
-
-            if home.as_path().is_dir() {
-                home
-            } else {
-                panic!("$Env:KOMOREBI_CONFIG_HOME is set to '{home_path}', which is not a valid directory");
-            }
-        },
-    );
-
-    if opts.quickstart {
-        let komorebi_bar_json = include_str!("../../docs/komorebi.bar.example.json").to_string();
-        std::fs::write(home_dir.join("komorebi.bar.json"), komorebi_bar_json)?;
-        println!(
-            "Example komorebi.bar.json file written to {}",
-            home_dir.as_path().display()
-        );
-
-        std::process::exit(0);
-    }
-
-    let default_config_path = home_dir.join("komorebi.bar.json");
-
-    let config_path = opts.config.map_or_else(
-        || {
-            if !default_config_path.is_file() {
-                None
-            } else {
-                Some(default_config_path.clone())
-            }
-        },
-        Option::from,
-    );
-
-    let mut config = match config_path {
-        None => {
-            let komorebi_bar_json =
-                include_str!("../../docs/komorebi.bar.example.json").to_string();
-
-            std::fs::write(&default_config_path, komorebi_bar_json)?;
-            tracing::info!(
-                "created example configuration file: {}",
-                default_config_path.as_path().display()
-            );
-
-            KomobarConfig::read(&default_config_path)?
-        }
-        Some(ref config) => {
-            if !opts.aliases {
-                tracing::info!(
-                    "found configuration file: {}",
-                    config.as_path().to_string_lossy()
-                );
-            }
-
-            KomobarConfig::read(config)?
-        }
-    };
-
-    let config_path = config_path.unwrap_or(default_config_path);
-
-    if opts.aliases {
-        KomobarConfig::aliases(&std::fs::read_to_string(&config_path)?);
-        std::process::exit(0);
-    }
-
-    let state = serde_json::from_str::<komorebi_client::State>(&komorebi_client::send_query(
-        &SocketMessage::State,
-    )?)?;
-
-    MONITOR_RIGHT.store(
-        state.monitors.elements()[config.monitor.index].size().right,
-        Ordering::SeqCst,
-    );
-
-    MONITOR_TOP.store(
-        state.monitors.elements()[config.monitor.index].size().top,
-        Ordering::SeqCst,
-    );
-
-    MONITOR_TOP.store(
-        state.monitors.elements()[config.monitor.index].size().left,
-        Ordering::SeqCst,
-    );
-
-    match config.position {
-        None => {
-            config.position = Some(PositionConfig {
-                start: Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().left as f32,
-                    y: state.monitors.elements()[config.monitor.index].size().top as f32,
-                }),
-                end: Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().right as f32,
-                    y: 50.0,
-                }),
-            })
-        }
-        Some(ref mut position) => {
-            if position.start.is_none() {
-                position.start = Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().left as f32,
-                    y: state.monitors.elements()[config.monitor.index].size().top as f32,
-                });
-            }
-
-            if position.end.is_none() {
-                position.end = Some(Position {
-                    x: state.monitors.elements()[config.monitor.index].size().right as f32,
-                    y: 50.0,
-                })
-            }
-        }
-    }
-
-    let viewport_builder = ViewportBuilder::default()
-        .with_decorations(false)
-        // .with_transparent(config.transparent)
-        .with_taskbar(false);
-
-    let native_options = eframe::NativeOptions {
-        viewport: viewport_builder,
-        ..Default::default()
-    };
-
-    if let Some(rect) = &config.monitor.work_area_offset {
-        komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(
-            config.monitor.index,
-            *rect,
-        ))?;
-        tracing::info!(
-            "work area offset applied to monitor: {}",
-            config.monitor.index
-        );
-    }
-
-    let (tx_gui, rx_gui) = crossbeam_channel::unbounded();
-    let (tx_config, rx_config) = crossbeam_channel::unbounded();
-
-    let mut hotwatch = Hotwatch::new()?;
-    let config_path_cl = config_path.clone();
-
-    hotwatch.watch(config_path, move |event| match event.kind {
-        EventKind::Modify(_) | EventKind::Remove(_) => match KomobarConfig::read(&config_path_cl) {
-            Ok(updated) => {
-                tracing::info!(
-                    "configuration file updated: {}",
-                    config_path_cl.as_path().to_string_lossy()
-                );
-
-                if let Err(error) = tx_config.send(updated) {
-                    tracing::error!("could not send configuration update to gui: {error}")
-                }
-            }
-            Err(error) => {
-                tracing::error!("{error}");
-            }
-        },
-        _ => {}
-    })?;
-
-    tracing::info!("watching configuration file for changes");
-
-    let config_arc = Arc::new(config);
-    eframe::run_native(
-        "komorebi-bar",
-        native_options,
-        Box::new(|cc| {
-            let config_cl = config_arc.clone();
-
-            let ctx_repainter = cc.egui_ctx.clone();
-            std::thread::spawn(move || loop {
-                std::thread::sleep(Duration::from_secs(1));
-                ctx_repainter.request_repaint();
-            });
-
-            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 listener = komorebi_client::subscribe(&subscriber_name)
-                    .expect("could not subscribe to komorebi notifications");
-
-                tracing::info!("subscribed to komorebi notifications: \"{}\"", subscriber_name);
-
-                for client in listener.incoming() {
-                    match client {
-                        Ok(subscription) => {
-                            let mut buffer = Vec::new();
-                            let mut reader = BufReader::new(subscription);
-
-                            // this is when we know a shutdown has been sent
-                            if matches!(reader.read_to_end(&mut buffer), Ok(0)) {
-                                tracing::info!("disconnected from komorebi");
-
-                                // keep trying to reconnect to komorebi
-                                while komorebi_client::send_message(
-                                    &SocketMessage::AddSubscriberSocket(subscriber_name.clone()),
-                                )
-                                .is_err()
-                                {
-                                    std::thread::sleep(Duration::from_secs(1));
-                                }
-
-                                tracing::info!("reconnected to komorebi");
-
-                                if let Some(rect) = &config_cl.monitor.work_area_offset {
-                                    while komorebi_client::send_message(
-                                        &SocketMessage::MonitorWorkAreaOffset(
-                                            config_cl.monitor.index,
-                                            *rect,
-                                        ),
-                                    )
-                                    .is_err()
-                                    {
-                                        std::thread::sleep(Duration::from_secs(1));
-                                    }
-                                }
-                            }
-
-                            match String::from_utf8(buffer) {
-                                Ok(notification_string) => {
-                                    if let Ok(notification) =
-                                        serde_json::from_str::<komorebi_client::Notification>(
-                                            &notification_string,
-                                        )
-                                    {
-                                        tracing::debug!("received notification from komorebi");
-
-                                        if let Err(error) = tx_gui.send(notification) {
-                                            tracing::error!("could not send komorebi notification update to gui: {error}")
-                                        }
-
-                                        ctx_komorebi.request_repaint();
-                                    }
-                                }
-                                Err(error) => {
-                                    tracing::error!(
-                                        "komorebi notification string was invalid utf8: {error}"
-                                    )
-                                }
-                            }
-                        }
-                        Err(error) => {
-                            tracing::error!("{error}");
-                        }
-                    }
-                }
-            });
-
-            Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config_arc)))
-        }),
-    )
-    .map_err(|error| color_eyre::eyre::Error::msg(error.to_string()))
-}

komorebi-bar/src/media.rs

@@ -1,128 +0,0 @@
-use crate::ui::CustomUi;
-use crate::widget::BarWidget;
-use crate::MAX_LABEL_WIDTH;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use eframe::egui::Vec2;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::sync::atomic::Ordering;
-use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct MediaConfig {
-    /// Enable the Media widget
-    pub enable: bool,
-}
-
-impl From<MediaConfig> for Media {
-    fn from(value: MediaConfig) -> Self {
-        Self::new(value.enable)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Media {
-    pub enable: bool,
-    pub session_manager: GlobalSystemMediaTransportControlsSessionManager,
-}
-
-impl Media {
-    pub fn new(enable: bool) -> Self {
-        Self {
-            enable,
-            session_manager: GlobalSystemMediaTransportControlsSessionManager::RequestAsync()
-                .unwrap()
-                .get()
-                .unwrap(),
-        }
-    }
-
-    pub fn toggle(&self) {
-        if let Ok(session) = self.session_manager.GetCurrentSession() {
-            if let Ok(op) = session.TryTogglePlayPauseAsync() {
-                op.get().unwrap_or_default();
-            }
-        }
-    }
-
-    fn output(&mut self) -> String {
-        if let Ok(session) = self.session_manager.GetCurrentSession() {
-            if let Ok(operation) = session.TryGetMediaPropertiesAsync() {
-                if let Ok(properties) = operation.get() {
-                    if let (Ok(artist), Ok(title)) = (properties.Artist(), properties.Title()) {
-                        if artist.is_empty() {
-                            return format!("{title}");
-                        }
-
-                        if title.is_empty() {
-                            return format!("{artist}");
-                        }
-
-                        return format!("{artist} - {title}");
-                    }
-                }
-            }
-        }
-
-        String::new()
-    }
-}
-
-impl BarWidget for Media {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::HEADPHONES.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                let available_height = ui.available_height();
-                let mut custom_ui = CustomUi(ui);
-
-                if custom_ui
-                    .add_sized_left_to_right(
-                        Vec2::new(
-                            MAX_LABEL_WIDTH.load(Ordering::SeqCst) as f32,
-                            available_height,
-                        ),
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click())
-                            .truncate(),
-                    )
-                    .clicked()
-                {
-                    self.toggle();
-                }
-
-                ui.add_space(WIDGET_SPACING);
-            }
-        }
-    }
-}

komorebi-bar/src/memory.rs

@@ -1,108 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::process::Command;
-use std::time::Duration;
-use std::time::Instant;
-use sysinfo::RefreshKind;
-use sysinfo::System;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct MemoryConfig {
-    /// Enable the Memory widget
-    pub enable: bool,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<MemoryConfig> for Memory {
-    fn from(value: MemoryConfig) -> Self {
-        let mut system =
-            System::new_with_specifics(RefreshKind::default().without_cpu().without_processes());
-
-        system.refresh_memory();
-
-        Self {
-            enable: value.enable,
-            system,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            last_updated: Instant::now(),
-        }
-    }
-}
-
-pub struct Memory {
-    pub enable: bool,
-    system: System,
-    data_refresh_interval: u64,
-    last_updated: Instant,
-}
-
-impl Memory {
-    fn output(&mut self) -> String {
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            self.system.refresh_memory();
-            self.last_updated = now;
-        }
-
-        let used = self.system.used_memory();
-        let total = self.system.total_memory();
-        format!("RAM: {}%", (used * 100) / total)
-    }
-}
-
-impl BarWidget for Memory {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::MEMORY.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    if let Err(error) = Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
-                    {
-                        eprintln!("{}", error)
-                    }
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/network.rs

@@ -1,297 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use num_derive::FromPrimitive;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::fmt;
-use std::process::Command;
-use std::time::Duration;
-use std::time::Instant;
-use sysinfo::Networks;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct NetworkConfig {
-    /// Enable the Network widget
-    pub enable: bool,
-    /// Show total data transmitted
-    pub show_total_data_transmitted: bool,
-    /// Show network activity
-    pub show_network_activity: bool,
-    /// Characters to reserve for network activity data
-    pub network_activity_fill_characters: Option<usize>,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<NetworkConfig> for Network {
-    fn from(value: NetworkConfig) -> Self {
-        let mut last_state_data = vec![];
-        let mut last_state_transmitted = vec![];
-
-        let mut networks_total_data_transmitted = Networks::new_with_refreshed_list();
-        let mut networks_network_activity = Networks::new_with_refreshed_list();
-
-        let mut default_interface = String::new();
-
-        if let Ok(interface) = netdev::get_default_interface() {
-            if let Some(friendly_name) = interface.friendly_name {
-                default_interface.clone_from(&friendly_name);
-
-                if value.show_total_data_transmitted {
-                    networks_total_data_transmitted.refresh();
-                    for (interface_name, data) in &networks_total_data_transmitted {
-                        if friendly_name.eq(interface_name) {
-                            last_state_data.push(format!(
-                                "{} {} / {} {}",
-                                egui_phosphor::regular::ARROW_FAT_DOWN,
-                                to_pretty_bytes(data.total_received(), 1),
-                                egui_phosphor::regular::ARROW_FAT_UP,
-                                to_pretty_bytes(data.total_transmitted(), 1),
-                            ))
-                        }
-                    }
-                }
-
-                if value.show_network_activity {
-                    networks_network_activity.refresh();
-                    for (interface_name, data) in &networks_network_activity {
-                        if friendly_name.eq(interface_name) {
-                            last_state_transmitted.push(format!(
-                                "{} {: >width$}/s {} {: >width$}/s",
-                                egui_phosphor::regular::ARROW_FAT_DOWN,
-                                to_pretty_bytes(data.received(), 1),
-                                egui_phosphor::regular::ARROW_FAT_UP,
-                                to_pretty_bytes(data.transmitted(), 1),
-                                width = value.network_activity_fill_characters.unwrap_or_default(),
-                            ))
-                        }
-                    }
-                }
-            }
-        }
-
-        Self {
-            enable: value.enable,
-            networks_total_data_transmitted,
-            networks_network_activity,
-            default_interface,
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            show_total_data_transmitted: value.show_total_data_transmitted,
-            show_network_activity: value.show_network_activity,
-            network_activity_fill_characters: value
-                .network_activity_fill_characters
-                .unwrap_or_default(),
-            last_state_total_data_transmitted: last_state_data,
-            last_state_network_activity: last_state_transmitted,
-            last_updated_total_data_transmitted: Instant::now(),
-            last_updated_network_activity: Instant::now(),
-        }
-    }
-}
-
-pub struct Network {
-    pub enable: bool,
-    pub show_total_data_transmitted: bool,
-    pub show_network_activity: bool,
-    networks_total_data_transmitted: Networks,
-    networks_network_activity: Networks,
-    data_refresh_interval: u64,
-    default_interface: String,
-    last_state_total_data_transmitted: Vec<String>,
-    last_state_network_activity: Vec<String>,
-    last_updated_total_data_transmitted: Instant,
-    last_updated_network_activity: Instant,
-    network_activity_fill_characters: usize,
-}
-
-impl Network {
-    fn default_interface(&mut self) {
-        if let Ok(interface) = netdev::get_default_interface() {
-            if let Some(friendly_name) = &interface.friendly_name {
-                self.default_interface.clone_from(friendly_name);
-            }
-        }
-    }
-
-    fn network_activity(&mut self) -> Vec<String> {
-        let mut outputs = self.last_state_network_activity.clone();
-        let now = Instant::now();
-
-        if self.show_network_activity
-            && now.duration_since(self.last_updated_network_activity)
-                > Duration::from_secs(self.data_refresh_interval)
-        {
-            outputs.clear();
-
-            if let Ok(interface) = netdev::get_default_interface() {
-                if let Some(friendly_name) = &interface.friendly_name {
-                    if self.show_network_activity {
-                        self.networks_network_activity.refresh();
-                        for (interface_name, data) in &self.networks_network_activity {
-                            if friendly_name.eq(interface_name) {
-                                outputs.push(format!(
-                                    "{} {: >width$}/s {} {: >width$}/s",
-                                    egui_phosphor::regular::ARROW_FAT_DOWN,
-                                    to_pretty_bytes(data.received(), self.data_refresh_interval),
-                                    egui_phosphor::regular::ARROW_FAT_UP,
-                                    to_pretty_bytes(data.transmitted(), self.data_refresh_interval),
-                                    width = self.network_activity_fill_characters,
-                                ))
-                            }
-                        }
-                    }
-                }
-            }
-
-            self.last_state_network_activity.clone_from(&outputs);
-            self.last_updated_network_activity = now;
-        }
-
-        outputs
-    }
-
-    fn total_data_transmitted(&mut self) -> Vec<String> {
-        let mut outputs = self.last_state_total_data_transmitted.clone();
-        let now = Instant::now();
-
-        if self.show_total_data_transmitted
-            && now.duration_since(self.last_updated_total_data_transmitted)
-                > Duration::from_secs(self.data_refresh_interval)
-        {
-            outputs.clear();
-
-            if let Ok(interface) = netdev::get_default_interface() {
-                if let Some(friendly_name) = &interface.friendly_name {
-                    if self.show_total_data_transmitted {
-                        self.networks_total_data_transmitted.refresh();
-
-                        for (interface_name, data) in &self.networks_total_data_transmitted {
-                            if friendly_name.eq(interface_name) {
-                                outputs.push(format!(
-                                    "{} {} / {} {}",
-                                    egui_phosphor::regular::ARROW_FAT_DOWN,
-                                    to_pretty_bytes(data.total_received(), 1),
-                                    egui_phosphor::regular::ARROW_FAT_UP,
-                                    to_pretty_bytes(data.total_transmitted(), 1),
-                                ))
-                            }
-                        }
-                    }
-                }
-            }
-
-            self.last_state_total_data_transmitted.clone_from(&outputs);
-            self.last_updated_total_data_transmitted = now;
-        }
-
-        outputs
-    }
-}
-
-impl BarWidget for Network {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.show_total_data_transmitted {
-            for output in self.total_data_transmitted() {
-                ui.add(Label::new(output).selectable(false));
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if self.show_network_activity {
-            for output in self.network_activity() {
-                ui.add(Label::new(output).selectable(false));
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-
-        if self.enable {
-            self.default_interface();
-
-            if !self.default_interface.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::WIFI_HIGH.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &self.default_interface,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    if let Err(error) = Command::new("cmd.exe").args(["/C", "ncpa"]).spawn() {
-                        eprintln!("{}", error)
-                    }
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}
-
-#[derive(Debug, FromPrimitive)]
-enum DataUnit {
-    B = 0,
-    K = 1,
-    M = 2,
-    G = 3,
-    T = 4,
-    P = 5,
-    E = 6,
-    Z = 7,
-    Y = 8,
-}
-
-impl fmt::Display for DataUnit {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-fn to_pretty_bytes(input_in_bytes: u64, timespan_in_s: u64) -> String {
-    let input = input_in_bytes as f32 / timespan_in_s as f32;
-    let mut magnitude = input.log(1024f32) as u32;
-
-    // let the base unit be KiB
-    if magnitude < 1 {
-        magnitude = 1;
-    }
-
-    let base: Option<DataUnit> = num::FromPrimitive::from_u32(magnitude);
-    let result = input / ((1u64) << (magnitude * 10)) as f32;
-
-    match base {
-        Some(DataUnit::B) => format!("{result:.1} B"),
-        Some(unit) => format!("{result:.1} {unit}iB"),
-        None => String::from("Unknown data unit"),
-    }
-}

komorebi-bar/src/storage.rs

@@ -1,123 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-use std::process::Command;
-use std::time::Duration;
-use std::time::Instant;
-use sysinfo::Disks;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct StorageConfig {
-    /// Enable the Storage widget
-    pub enable: bool,
-    /// Data refresh interval (default: 10 seconds)
-    pub data_refresh_interval: Option<u64>,
-}
-
-impl From<StorageConfig> for Storage {
-    fn from(value: StorageConfig) -> Self {
-        Self {
-            enable: value.enable,
-            disks: Disks::new_with_refreshed_list(),
-            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
-            last_updated: Instant::now(),
-        }
-    }
-}
-
-pub struct Storage {
-    pub enable: bool,
-    disks: Disks,
-    data_refresh_interval: u64,
-    last_updated: Instant,
-}
-
-impl Storage {
-    fn output(&mut self) -> Vec<String> {
-        let now = Instant::now();
-        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
-            self.disks.refresh();
-            self.last_updated = now;
-        }
-
-        let mut disks = vec![];
-
-        for disk in &self.disks {
-            let mount = disk.mount_point();
-            let total = disk.total_space();
-            let available = disk.available_space();
-            let used = total - available;
-
-            disks.push(format!(
-                "{} {}%",
-                mount.to_string_lossy(),
-                (used * 100) / total
-            ))
-        }
-
-        disks.sort();
-        disks.reverse();
-
-        disks
-    }
-}
-
-impl BarWidget for Storage {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let font_id = ctx
-                .style()
-                .text_styles
-                .get(&TextStyle::Body)
-                .cloned()
-                .unwrap_or_else(FontId::default);
-
-            for output in self.output() {
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::HARD_DRIVES.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id.clone(), ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    if let Err(error) = Command::new("cmd.exe")
-                        .args([
-                            "/C",
-                            "explorer.exe",
-                            output.split(' ').collect::<Vec<&str>>()[0],
-                        ])
-                        .spawn()
-                    {
-                        eprintln!("{}", error)
-                    }
-                }
-
-                ui.add_space(WIDGET_SPACING);
-            }
-        }
-    }
-}

komorebi-bar/src/time.rs

@@ -1,114 +0,0 @@
-use crate::widget::BarWidget;
-use crate::WIDGET_SPACING;
-use eframe::egui::text::LayoutJob;
-use eframe::egui::Context;
-use eframe::egui::FontId;
-use eframe::egui::Label;
-use eframe::egui::Sense;
-use eframe::egui::TextFormat;
-use eframe::egui::TextStyle;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct TimeConfig {
-    /// Enable the Time widget
-    pub enable: bool,
-    /// Set the Time format
-    pub format: TimeFormat,
-}
-
-impl From<TimeConfig> for Time {
-    fn from(value: TimeConfig) -> Self {
-        Self {
-            enable: value.enable,
-            format: value.format,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum TimeFormat {
-    /// Twelve-hour format (with seconds)
-    TwelveHour,
-    /// Twenty-four-hour format (with seconds)
-    TwentyFourHour,
-    /// Custom format (https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
-    Custom(String),
-}
-
-impl TimeFormat {
-    pub fn toggle(&mut self) {
-        match self {
-            TimeFormat::TwelveHour => *self = TimeFormat::TwentyFourHour,
-            TimeFormat::TwentyFourHour => *self = TimeFormat::TwelveHour,
-            _ => {}
-        };
-    }
-
-    fn fmt_string(&self) -> String {
-        match self {
-            TimeFormat::TwelveHour => String::from("%l:%M:%S %p"),
-            TimeFormat::TwentyFourHour => String::from("%T"),
-            TimeFormat::Custom(format) => format.to_string(),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Time {
-    pub enable: bool,
-    pub format: TimeFormat,
-}
-
-impl Time {
-    fn output(&mut self) -> String {
-        chrono::Local::now()
-            .format(&self.format.fmt_string())
-            .to_string()
-    }
-}
-
-impl BarWidget for Time {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
-        if self.enable {
-            let output = self.output();
-            if !output.is_empty() {
-                let font_id = ctx
-                    .style()
-                    .text_styles
-                    .get(&TextStyle::Body)
-                    .cloned()
-                    .unwrap_or_else(FontId::default);
-
-                let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::CLOCK.to_string(),
-                    font_id.clone(),
-                    ctx.style().visuals.selection.stroke.color,
-                    100.0,
-                );
-
-                layout_job.append(
-                    &output,
-                    10.0,
-                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
-                );
-
-                if ui
-                    .add(
-                        Label::new(layout_job)
-                            .selectable(false)
-                            .sense(Sense::click()),
-                    )
-                    .clicked()
-                {
-                    self.format.toggle()
-                }
-            }
-
-            ui.add_space(WIDGET_SPACING);
-        }
-    }
-}

komorebi-bar/src/ui.rs

@@ -1,22 +0,0 @@
-use eframe::egui::Align;
-use eframe::egui::Layout;
-use eframe::egui::Response;
-use eframe::egui::Ui;
-use eframe::egui::Vec2;
-use eframe::egui::Widget;
-
-pub struct CustomUi<'ui>(pub &'ui mut Ui);
-
-impl CustomUi<'_> {
-    pub fn add_sized_left_to_right(
-        &mut self,
-        max_size: impl Into<Vec2>,
-        widget: impl Widget,
-    ) -> Response {
-        let layout =
-            Layout::from_main_dir_and_cross_align(self.0.layout().main_dir(), Align::Center);
-        self.0
-            .allocate_ui_with_layout(max_size.into(), layout, |ui| ui.add(widget))
-            .inner
-    }
-}

komorebi-bar/src/widget.rs

@@ -1,52 +0,0 @@
-use crate::battery::Battery;
-use crate::battery::BatteryConfig;
-use crate::date::Date;
-use crate::date::DateConfig;
-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::storage::Storage;
-use crate::storage::StorageConfig;
-use crate::time::Time;
-use crate::time::TimeConfig;
-use eframe::egui::Context;
-use eframe::egui::Ui;
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-pub trait BarWidget {
-    fn render(&mut self, ctx: &Context, ui: &mut Ui);
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum WidgetConfig {
-    Battery(BatteryConfig),
-    Date(DateConfig),
-    Komorebi(KomorebiConfig),
-    Media(MediaConfig),
-    Memory(MemoryConfig),
-    Network(NetworkConfig),
-    Storage(StorageConfig),
-    Time(TimeConfig),
-}
-
-impl WidgetConfig {
-    pub fn as_boxed_bar_widget(&self) -> Box<dyn BarWidget> {
-        match self {
-            WidgetConfig::Battery(config) => Box::new(Battery::from(*config)),
-            WidgetConfig::Date(config) => Box::new(Date::from(config.clone())),
-            WidgetConfig::Komorebi(config) => Box::new(Komorebi::from(config)),
-            WidgetConfig::Media(config) => Box::new(Media::from(*config)),
-            WidgetConfig::Memory(config) => Box::new(Memory::from(*config)),
-            WidgetConfig::Network(config) => Box::new(Network::from(*config)),
-            WidgetConfig::Storage(config) => Box::new(Storage::from(*config)),
-            WidgetConfig::Time(config) => Box::new(Time::from(config.clone())),
-        }
-    }
-}

komorebi-client/Cargo.toml

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

komorebi-client/src/lib.rs

@@ -3,7 +3,6 @@
 
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;
-pub use komorebi::config_generation::ApplicationConfiguration;
 pub use komorebi::container::Container;
 pub use komorebi::core::config_generation::ApplicationConfigurationGenerator;
 pub use komorebi::core::resolve_home_path;
@@ -37,7 +36,6 @@ pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
 pub use komorebi::BorderColours;
 pub use komorebi::GlobalState;
-pub use komorebi::KomorebiTheme;
 pub use komorebi::Notification;
 pub use komorebi::NotificationEvent;
 pub use komorebi::RuleDebug;

komorebi-gui/Cargo.toml

@@ -1,15 +1,14 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.30"
+version = "0.1.29"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+egui_extras = { version = "0.28" }
+eframe = "0.28"
 komorebi-client = { path = "../komorebi-client" }
-
-eframe = { workspace = true }
-egui_extras = { workspace = true }
+serde_json = "1"
 random_word = { version = "0.4.3", features = ["en"] }
-serde_json = { workspace = true }
 windows = { workspace = true }

komorebi-gui/src/main.rs

@@ -218,7 +218,7 @@ extern "system" fn enum_window(
     lparam: windows::Win32::Foundation::LPARAM,
 ) -> windows::Win32::Foundation::BOOL {
     let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
-    let window = Window::from(hwnd.0 as isize);
+    let window = Window::from(hwnd.0);
 
     if window.is_window()
         && !window.is_miminized()

komorebi-themes/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "komorebi-themes"
-version = "0.1.30"
-edition = "2021"
-
-[dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "a2c48f45782c5604bf5482d3873021a9fe45ea1a" }
-catppuccin-egui = { version = "5.1", default-features = false, features = ["egui28"] }
-eframe = { workspace = true }
-schemars = { workspace = true }
-serde = { workspace = true }

komorebi-themes/src/lib.rs

@@ -1,158 +0,0 @@
-#![warn(clippy::all)]
-#![allow(clippy::missing_errors_doc)]
-
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde::Serialize;
-
-pub use base16_egui_themes::Base16;
-pub use catppuccin_egui;
-pub use eframe::egui::Color32;
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(tag = "type")]
-pub enum Theme {
-    /// A theme from catppuccin-egui
-    Catppuccin {
-        name: Catppuccin,
-        accent: Option<CatppuccinValue>,
-    },
-    /// A theme from base16-egui-themes
-    Base16 {
-        name: Base16,
-        accent: Option<Base16Value>,
-    },
-}
-
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
-pub enum Base16Value {
-    Base00,
-    Base01,
-    Base02,
-    Base03,
-    Base04,
-    Base05,
-    #[default]
-    Base06,
-    Base07,
-    Base08,
-    Base09,
-    Base0A,
-    Base0B,
-    Base0C,
-    Base0D,
-    Base0E,
-    Base0F,
-}
-
-impl Base16Value {
-    pub fn color32(&self, theme: Base16) -> Color32 {
-        match self {
-            Base16Value::Base00 => theme.base00(),
-            Base16Value::Base01 => theme.base01(),
-            Base16Value::Base02 => theme.base02(),
-            Base16Value::Base03 => theme.base03(),
-            Base16Value::Base04 => theme.base04(),
-            Base16Value::Base05 => theme.base05(),
-            Base16Value::Base06 => theme.base06(),
-            Base16Value::Base07 => theme.base07(),
-            Base16Value::Base08 => theme.base08(),
-            Base16Value::Base09 => theme.base09(),
-            Base16Value::Base0A => theme.base0a(),
-            Base16Value::Base0B => theme.base0b(),
-            Base16Value::Base0C => theme.base0c(),
-            Base16Value::Base0D => theme.base0d(),
-            Base16Value::Base0E => theme.base0e(),
-            Base16Value::Base0F => theme.base0f(),
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub enum Catppuccin {
-    Frappe,
-    Latte,
-    Macchiato,
-    Mocha,
-}
-
-impl Catppuccin {
-    pub fn as_theme(self) -> catppuccin_egui::Theme {
-        self.into()
-    }
-}
-
-impl From<Catppuccin> for catppuccin_egui::Theme {
-    fn from(val: Catppuccin) -> Self {
-        match val {
-            Catppuccin::Frappe => catppuccin_egui::FRAPPE,
-            Catppuccin::Latte => catppuccin_egui::LATTE,
-            Catppuccin::Macchiato => catppuccin_egui::MACCHIATO,
-            Catppuccin::Mocha => catppuccin_egui::MOCHA,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
-pub enum CatppuccinValue {
-    Rosewater,
-    Flamingo,
-    Pink,
-    Mauve,
-    Red,
-    Maroon,
-    Peach,
-    Yellow,
-    Green,
-    Teal,
-    Sky,
-    Sapphire,
-    Blue,
-    Lavender,
-    #[default]
-    Text,
-    Subtext1,
-    Subtext0,
-    Overlay2,
-    Overlay1,
-    Overlay0,
-    Surface2,
-    Surface1,
-    Surface0,
-    Base,
-    Mantle,
-    Crust,
-}
-
-impl CatppuccinValue {
-    pub fn color32(&self, theme: catppuccin_egui::Theme) -> Color32 {
-        match self {
-            CatppuccinValue::Rosewater => theme.rosewater,
-            CatppuccinValue::Flamingo => theme.flamingo,
-            CatppuccinValue::Pink => theme.pink,
-            CatppuccinValue::Mauve => theme.mauve,
-            CatppuccinValue::Red => theme.red,
-            CatppuccinValue::Maroon => theme.maroon,
-            CatppuccinValue::Peach => theme.peach,
-            CatppuccinValue::Yellow => theme.yellow,
-            CatppuccinValue::Green => theme.green,
-            CatppuccinValue::Teal => theme.teal,
-            CatppuccinValue::Sky => theme.sky,
-            CatppuccinValue::Sapphire => theme.sapphire,
-            CatppuccinValue::Blue => theme.blue,
-            CatppuccinValue::Lavender => theme.lavender,
-            CatppuccinValue::Text => theme.text,
-            CatppuccinValue::Subtext1 => theme.subtext1,
-            CatppuccinValue::Subtext0 => theme.subtext0,
-            CatppuccinValue::Overlay2 => theme.overlay2,
-            CatppuccinValue::Overlay1 => theme.overlay1,
-            CatppuccinValue::Overlay0 => theme.overlay0,
-            CatppuccinValue::Surface2 => theme.surface2,
-            CatppuccinValue::Surface1 => theme.surface1,
-            CatppuccinValue::Surface0 => theme.surface0,
-            CatppuccinValue::Base => theme.base,
-            CatppuccinValue::Mantle => theme.mantle,
-            CatppuccinValue::Crust => theme.crust,
-        }
-    }
-}

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.30"
+version = "0.1.29"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -11,47 +11,44 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-komorebi-themes = { path = "../komorebi-themes" }
-
 bitflags = { version = "2", features = ["serde"] }
-clap = { workspace = true }
+clap = { version = "4", features = ["derive"] }
 color-eyre = { workspace = true }
-crossbeam-channel = { workspace = true }
-crossbeam-utils = { workspace = true }
+crossbeam-channel = "0.5"
+crossbeam-utils = "0.8"
 ctrlc = { version = "3", features = ["termination"] }
 dirs = { workspace = true }
 dunce = { workspace = true }
 getset = "0.1"
 hex_color = { version = "3", features = ["serde"] }
-hotwatch = { workspace = true }
-lazy_static = { workspace = true }
+hotwatch = "0.5"
+lazy_static = "1"
 miow = "0.6"
 nanoid = "0.4"
 net2 = "0.2"
 os_info = "3.8"
 parking_lot = "0.12"
-paste = { workspace = true }
+paste = "1"
 regex = "1"
-schemars = { workspace = true }
-serde = { workspace = true }
+schemars = "0.8"
+serde = { version = "1", features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }
-shadow-rs = { workspace = true }
 strum = { version = "0.26", features = ["derive"] }
 sysinfo = { workspace = true }
-tracing = { workspace = true }
-tracing-appender = { workspace = true }
-tracing-subscriber = { workspace = true }
-uds_windows = { workspace = true }
-which = { workspace = true }
+tracing = "0.1"
+tracing-appender = "0.2"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+uds_windows = "1"
+which = "6"
 widestring = "1"
 win32-display-data = { workspace = true }
 windows = { workspace = true }
-windows-core = { workspace = true }
 windows-implement = { workspace = true }
 windows-interface = { workspace = true }
 winput = "0.2"
 winreg = "0.52"
+shadow-rs = { workspace = true }
 
 [build-dependencies]
 shadow-rs = { workspace = true }

komorebi/src/border_manager/border.rs

@@ -5,7 +5,6 @@ use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::FOCUS_STATE;
 use crate::border_manager::STYLE;
 use crate::border_manager::Z_ORDER;
-use crate::windows_api;
 use crate::WindowsApi;
 use crate::WINDOWS_11;
 
@@ -47,11 +46,10 @@ use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 
 pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
-    let hwnd = hwnd.0 as isize;
 
     if let Ok(class) = WindowsApi::real_window_class_w(hwnd) {
         if class.starts_with("komoborder") {
-            hwnds.push(hwnd);
+            hwnds.push(hwnd.0);
         }
     }
 
@@ -71,7 +69,7 @@ impl From<isize> for Border {
 
 impl Border {
     pub const fn hwnd(&self) -> HWND {
-        HWND(windows_api::as_ptr!(self.hwnd))
+        HWND(self.hwnd)
     }
 
     pub fn create(id: &str) -> color_eyre::Result<Self> {
@@ -93,9 +91,8 @@ impl Border {
 
         let (hwnd_sender, hwnd_receiver) = mpsc::channel();
 
-        let instance = h_module.0 as isize;
         std::thread::spawn(move || -> color_eyre::Result<()> {
-            let hwnd = WindowsApi::create_border_window(PCWSTR(name.as_ptr()), instance)?;
+            let hwnd = WindowsApi::create_border_window(PCWSTR(name.as_ptr()), h_module)?;
             hwnd_sender.send(hwnd)?;
 
             let mut msg: MSG = MSG::default();
@@ -106,8 +103,7 @@ impl Border {
                         tracing::debug!("border window event processing thread shutdown");
                         break;
                     };
-                    // TODO: error handling
-                    let _ = TranslateMessage(&msg);
+                    TranslateMessage(&msg);
                     DispatchMessageW(&msg);
                 }
 
@@ -123,7 +119,7 @@ impl Border {
     }
 
     pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd)
+        WindowsApi::close_window(self.hwnd())
     }
 
     pub fn update(&self, rect: &Rect, mut should_invalidate: bool) -> color_eyre::Result<()> {
@@ -133,8 +129,8 @@ impl Border {
         rect.add_padding(-BORDER_OFFSET.load(Ordering::SeqCst));
 
         // Update the position of the border if required
-        if !WindowsApi::window_rect(self.hwnd)?.eq(&rect) {
-            WindowsApi::set_border_pos(self.hwnd, &rect, Z_ORDER.load().into())?;
+        if !WindowsApi::window_rect(self.hwnd())?.eq(&rect) {
+            WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((Z_ORDER.load()).into()))?;
             should_invalidate = true;
         }
 
@@ -163,13 +159,13 @@ impl Border {
                     let hdc = BeginPaint(window, &mut ps);
 
                     // With the rect that we set in Self::update
-                    match WindowsApi::window_rect(window.0 as isize) {
+                    match WindowsApi::window_rect(window) {
                         Ok(rect) => {
                             // Grab the focus kind for this border
                             let window_kind = {
                                 FOCUS_STATE
                                     .lock()
-                                    .get(&(window.0 as isize))
+                                    .get(&window.0)
                                     .copied()
                                     .unwrap_or(WindowKind::Unfocused)
                             };
@@ -195,35 +191,27 @@ impl Border {
                             match STYLE.load() {
                                 BorderStyle::System => {
                                     if *WINDOWS_11 {
-                                        // TODO: error handling
-                                        let _ =
-                                            RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                                        RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
                                     } else {
-                                        // TODO: error handling
-                                        let _ = Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                                        Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                     }
                                 }
                                 BorderStyle::Rounded => {
-                                    // TODO: error handling
-                                    let _ = RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                                    RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
                                 }
                                 BorderStyle::Square => {
-                                    // TODO: error handling
-                                    let _ = Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                                    Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                 }
                             }
-                            // TODO: error handling
-                            let _ = DeleteObject(hpen);
-                            // TODO: error handling
-                            let _ = DeleteObject(hbrush);
+                            DeleteObject(hpen);
+                            DeleteObject(hbrush);
                         }
                         Err(error) => {
                             tracing::error!("could not get border rect: {}", error.to_string())
                         }
                     }
 
-                    // TODO: error handling
-                    let _ = EndPaint(window, &ps);
+                    EndPaint(window, &ps);
                     LRESULT(0)
                 }
                 WM_DESTROY => {

komorebi/src/border_manager/mod.rs

@@ -4,15 +4,6 @@ mod border;
 
 use crate::core::BorderImplementation;
 use crate::core::BorderStyle;
-use crate::core::WindowKind;
-use crate::ring::Ring;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::Colour;
-use crate::Rgb;
-use crate::WindowManager;
-use crate::WindowsApi;
-use border::border_hwnds;
-use border::Border;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
@@ -30,6 +21,17 @@ use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
+use windows::Win32::Foundation::HWND;
+
+use crate::core::WindowKind;
+use crate::ring::Ring;
+use crate::workspace_reconciliator::ALT_TAB_HWND;
+use crate::Colour;
+use crate::Rgb;
+use crate::WindowManager;
+use crate::WindowsApi;
+use border::border_hwnds;
+use border::Border;
 
 pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
 pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
@@ -298,7 +300,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             }
 
                             let rect = WindowsApi::window_rect(
-                                monocle.focused_window().copied().unwrap_or_default().hwnd,
+                                monocle.focused_window().copied().unwrap_or_default().hwnd(),
                             )?;
 
                             border.update(&rect, true)?;
@@ -322,9 +324,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             continue 'monitors;
                         }
 
-                        let is_maximized = WindowsApi::is_zoomed(
+                        let is_maximized = WindowsApi::is_zoomed(HWND(
                             WindowsApi::foreground_window().unwrap_or_default(),
-                        );
+                        ));
 
                         if is_maximized {
                             let mut to_remove = vec![];
@@ -372,7 +374,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 Z_ORDER.store(ZOrder::TopMost);
 
                                 let mut rect = WindowsApi::window_rect(
-                                    c.focused_window().copied().unwrap_or_default().hwnd,
+                                    c.focused_window().copied().unwrap_or_default().hwnd(),
                                 )?;
 
                                 while WindowsApi::lbutton_is_pressed() {
@@ -388,7 +390,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                     };
 
                                     let new_rect = WindowsApi::window_rect(
-                                        c.focused_window().copied().unwrap_or_default().hwnd,
+                                        c.focused_window().copied().unwrap_or_default().hwnd(),
                                     )?;
 
                                     if rect != new_rect {
@@ -436,7 +438,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                             }
 
                             let rect = WindowsApi::window_rect(
-                                c.focused_window().copied().unwrap_or_default().hwnd,
+                                c.focused_window().copied().unwrap_or_default().hwnd(),
                             )?;
 
                             let should_invalidate = match last_focus_state {

komorebi/src/colour.rs

@@ -1,5 +1,4 @@
 use hex_color::HexColor;
-use komorebi_themes::Color32;
 use schemars::gen::SchemaGenerator;
 use schemars::schema::InstanceType;
 use schemars::schema::Schema;
@@ -29,16 +28,6 @@ impl From<u32> for Colour {
     }
 }
 
-impl From<Color32> for Colour {
-    fn from(value: Color32) -> Self {
-        Colour::Rgb(Rgb::new(
-            value.r() as u32,
-            value.g() as u32,
-            value.b() as u32,
-        ))
-    }
-}
-
 #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
 pub struct Hex(HexColor);
 

komorebi/src/com/mod.rs

@@ -10,13 +10,13 @@ use interfaces::IServiceProvider;
 
 use std::ffi::c_void;
 
+use windows::core::Interface;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::System::Com::CoCreateInstance;
 use windows::Win32::System::Com::CoInitializeEx;
 use windows::Win32::System::Com::CoUninitialize;
 use windows::Win32::System::Com::CLSCTX_ALL;
 use windows::Win32::System::Com::COINIT_APARTMENTTHREADED;
-use windows_core::Interface;
 
 struct ComInit();
 
@@ -77,7 +77,7 @@ pub extern "C" fn SetCloak(hwnd: HWND, cloak_type: u32, flags: i32) {
             if view_collection.get_view_for_hwnd(hwnd, &mut view).is_err() {
                 tracing::error!(
                     "could not get view for hwnd {} due to os error: {}",
-                    hwnd.0 as isize,
+                    hwnd.0,
                     std::io::Error::last_os_error()
                 );
             }
@@ -85,14 +85,14 @@ pub extern "C" fn SetCloak(hwnd: HWND, cloak_type: u32, flags: i32) {
 
         view.map_or_else(
             || {
-                tracing::error!("no view was found for {}", hwnd.0 as isize);
+                tracing::error!("no view was found for {}", hwnd.0,);
             },
             |view| {
                 unsafe {
                     if view.set_cloak(cloak_type, flags).is_err() {
                         tracing::error!(
                             "could not change the cloaking status for hwnd {} due to os error: {}",
-                            hwnd.0 as isize,
+                            hwnd.0,
                             std::io::Error::last_os_error()
                         );
                     }

komorebi/src/core/config_generation.rs

@@ -59,14 +59,6 @@ pub enum MatchingRule {
     Composite(Vec<IdWithIdentifier>),
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
-pub struct WorkspaceMatchingRule {
-    pub monitor_index: usize,
-    pub workspace_index: usize,
-    pub matching_rule: MatchingRule,
-    pub initial_only: bool,
-}
-
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct IdWithIdentifier {
     pub kind: ApplicationIdentifier,

komorebi/src/core/default_layout.rs

@@ -35,37 +35,6 @@ pub enum DefaultLayout {
 }
 
 impl DefaultLayout {
-    pub fn leftmost_index(&self, len: usize) -> usize {
-        match self {
-            Self::UltrawideVerticalStack | Self::RightMainVerticalStack => match len {
-                n if n > 1 => 1,
-                _ => 0,
-            },
-            DefaultLayout::BSP
-            | DefaultLayout::Columns
-            | DefaultLayout::Rows
-            | DefaultLayout::VerticalStack
-            | DefaultLayout::HorizontalStack
-            | DefaultLayout::Grid => 0,
-        }
-    }
-
-    pub fn rightmost_index(&self, len: usize) -> usize {
-        match self {
-            DefaultLayout::BSP
-            | DefaultLayout::Columns
-            | DefaultLayout::Rows
-            | DefaultLayout::VerticalStack
-            | DefaultLayout::HorizontalStack
-            | DefaultLayout::Grid => len.saturating_sub(1),
-            DefaultLayout::UltrawideVerticalStack => match len {
-                2 => 0,
-                _ => len.saturating_sub(1),
-            },
-            DefaultLayout::RightMainVerticalStack => 0,
-        }
-    }
-
     #[must_use]
     #[allow(clippy::cast_precision_loss, clippy::only_used_in_recursion)]
     pub fn resize(

komorebi/src/core/mod.rs

@@ -133,7 +133,6 @@ pub enum SocketMessage {
     ClearNamedWorkspaceLayoutRules(String),
     // Configuration
     ReloadConfiguration,
-    ReplaceConfiguration(PathBuf),
     ReloadStaticConfiguration(PathBuf),
     WatchConfiguration(bool),
     CompleteConfiguration,

komorebi/src/lib.rs

@@ -62,7 +62,6 @@ pub use windows_api::*;
 use crate::core::config_generation::IdWithIdentifier;
 use crate::core::config_generation::MatchingRule;
 use crate::core::config_generation::MatchingStrategy;
-use crate::core::config_generation::WorkspaceMatchingRule;
 use color_eyre::Result;
 use os_info::Version;
 use parking_lot::Mutex;
@@ -75,6 +74,8 @@ use which::which;
 use winreg::enums::HKEY_CURRENT_USER;
 use winreg::RegKey;
 
+type WorkspaceRule = (usize, usize, bool);
+
 lazy_static! {
     static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
     static ref LAYERED_WHITELIST: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
@@ -129,13 +130,12 @@ lazy_static! {
             matching_strategy: Option::from(MatchingStrategy::Equals),
         }),
     ]));
-    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 WORKSPACE_MATCHING_RULES: Arc<Mutex<Vec<WorkspaceMatchingRule>>> =
-        Arc::new(Mutex::new(Vec::new()));
+    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, WorkspaceRule>>> =
+        Arc::new(Mutex::new(HashMap::new()));
     static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
@@ -151,13 +151,9 @@ lazy_static! {
             kind: ApplicationIdentifier::Class,
             id: String::from("IHWindowClass"),
             matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
-        MatchingRule::Simple(IdWithIdentifier {
-            kind: ApplicationIdentifier::Exe,
-            id: String::from("komorebi-bar.exe"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
         })
     ]));
+
     static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "Chrome_RenderWidgetHostHWND".to_string(),
     ]));
@@ -165,13 +161,6 @@ lazy_static! {
         "X410.exe".to_string(),
         "vcxsrv.exe".to_string(),
     ]));
-    static ref SLOW_APPLICATION_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
-        MatchingRule::Simple(IdWithIdentifier {
-            kind: ApplicationIdentifier::Exe,
-            id: String::from("firefox.exe"),
-            matching_strategy: Option::from(MatchingStrategy::Equals),
-        }),
-    ]));
     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>>> =
@@ -238,8 +227,6 @@ pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
 pub static ANIMATION_ENABLED: AtomicBool = AtomicBool::new(false);
 pub static ANIMATION_DURATION: AtomicU64 = AtomicU64::new(250);
 
-pub static SLOW_APPLICATION_COMPENSATION_TIME: AtomicU64 = AtomicU64::new(20);
-
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
     let hkcu = RegKey::predef(HKEY_CURRENT_USER);

komorebi/src/main.rs

@@ -21,7 +21,6 @@ use crossbeam_utils::Backoff;
 use parking_lot::deadlock;
 use parking_lot::Mutex;
 use sysinfo::Process;
-use sysinfo::ProcessesToUpdate;
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
@@ -168,9 +167,9 @@ fn main() -> Result<()> {
     SESSION_ID.store(session_id, Ordering::SeqCst);
 
     let mut system = sysinfo::System::new_all();
-    system.refresh_processes(ProcessesToUpdate::All);
+    system.refresh_processes();
 
-    let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe".as_ref()).collect();
+    let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();
 
     if matched_procs.len() > 1 {
         let mut len = matched_procs.len();
@@ -221,7 +220,6 @@ fn main() -> Result<()> {
         Arc::new(Mutex::new(StaticConfig::preload(
             config,
             winevent_listener::event_rx(),
-            None,
         )?))
     } else {
         Arc::new(Mutex::new(WindowManager::new(

komorebi/src/monitor.rs

@@ -17,8 +17,6 @@ use crate::core::Rect;
 use crate::container::Container;
 use crate::ring::Ring;
 use crate::workspace::Workspace;
-use crate::DefaultLayout;
-use crate::Layout;
 use crate::OperationDirection;
 
 #[derive(
@@ -193,52 +191,10 @@ impl Monitor {
             Some(workspace) => workspace,
         };
 
-        match direction {
-            Some(OperationDirection::Left) => match target_workspace.layout() {
-                Layout::Default(layout) => match layout {
-                    DefaultLayout::RightMainVerticalStack => {
-                        target_workspace.add_container_to_front(container);
-                    }
-                    DefaultLayout::UltrawideVerticalStack => {
-                        if target_workspace.containers().len() == 1 {
-                            target_workspace.insert_container_at_idx(0, container);
-                        } else {
-                            target_workspace.add_container_to_back(container);
-                        }
-                    }
-                    _ => {
-                        target_workspace.add_container_to_back(container);
-                    }
-                },
-                Layout::Custom(_) => {
-                    target_workspace.add_container_to_back(container);
-                }
-            },
-            Some(OperationDirection::Right) => match target_workspace.layout() {
-                Layout::Default(layout) => {
-                    let target_index = layout.leftmost_index(target_workspace.containers().len());
-
-                    match layout {
-                        DefaultLayout::RightMainVerticalStack
-                        | DefaultLayout::UltrawideVerticalStack => {
-                            if target_workspace.containers().len() == 1 {
-                                target_workspace.add_container_to_back(container);
-                            } else {
-                                target_workspace.insert_container_at_idx(target_index, container);
-                            }
-                        }
-                        _ => {
-                            target_workspace.insert_container_at_idx(target_index, container);
-                        }
-                    }
-                }
-                Layout::Custom(_) => {
-                    target_workspace.add_container_to_front(container);
-                }
-            },
-            _ => {
-                target_workspace.add_container_to_back(container);
-            }
+        if matches!(direction, Some(OperationDirection::Right)) {
+            target_workspace.add_container_to_front(container);
+        } else {
+            target_workspace.add_container_to_back(container);
         }
 
         if follow {

komorebi/src/monitor_reconciliator/hidden.rs

@@ -28,7 +28,6 @@ use windows::Win32::UI::WindowsAndMessaging::WTS_SESSION_LOCK;
 use windows::Win32::UI::WindowsAndMessaging::WTS_SESSION_UNLOCK;
 
 use crate::monitor_reconciliator;
-use crate::windows_api;
 use crate::WindowsApi;
 
 // This is a hidden window specifically spawned to listen to system-wide events related to monitors
@@ -45,7 +44,7 @@ impl From<isize> for Hidden {
 
 impl Hidden {
     pub const fn hwnd(self) -> HWND {
-        HWND(windows_api::as_ptr!(self.hwnd))
+        HWND(self.hwnd)
     }
 
     pub fn create(name: &str) -> color_eyre::Result<Self> {
@@ -66,9 +65,8 @@ impl Hidden {
 
         let (hwnd_sender, hwnd_receiver) = mpsc::channel();
 
-        let instance = h_module.0 as isize;
         std::thread::spawn(move || -> color_eyre::Result<()> {
-            let hwnd = WindowsApi::create_hidden_window(PCWSTR(name.as_ptr()), instance)?;
+            let hwnd = WindowsApi::create_hidden_window(PCWSTR(name.as_ptr()), h_module)?;
             hwnd_sender.send(hwnd)?;
 
             let mut msg: MSG = MSG::default();
@@ -79,8 +77,7 @@ impl Hidden {
                         tracing::debug!("hidden window event processing thread shutdown");
                         break;
                     };
-                    // TODO: error handling
-                    let _ = TranslateMessage(&msg);
+                    TranslateMessage(&msg);
                     DispatchMessageW(&msg);
                 }
 

komorebi/src/process_command.rs

@@ -44,7 +44,6 @@ use crate::border_manager;
 use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
 use crate::colour::Rgb;
-use crate::config_generation::WorkspaceMatchingRule;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
@@ -57,7 +56,6 @@ use crate::window::Window;
 use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
-use crate::winevent_listener;
 use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
@@ -82,7 +80,7 @@ use crate::SUBSCRIPTION_SOCKETS;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WINDOWS_11;
-use crate::WORKSPACE_MATCHING_RULES;
+use crate::WORKSPACE_RULES;
 use stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use stackbar_manager::STACKBAR_LABEL;
 use stackbar_manager::STACKBAR_MODE;
@@ -237,7 +235,7 @@ impl WindowManager {
             }
             SocketMessage::ForceFocus => {
                 let focused_window = self.focused_window()?;
-                let focused_window_rect = WindowsApi::window_rect(focused_window.hwnd)?;
+                let focused_window_rect = WindowsApi::window_rect(focused_window.hwnd())?;
                 WindowsApi::center_cursor_in_rect(&focused_window_rect)?;
                 WindowsApi::left_click();
             }
@@ -270,101 +268,58 @@ impl WindowManager {
                     self.set_workspace_padding(monitor_idx, workspace_idx, size)?;
                 }
             }
-            SocketMessage::InitialWorkspaceRule(identifier, ref id, monitor_idx, workspace_idx) => {
-                let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
-                let workspace_matching_rule = WorkspaceMatchingRule {
-                    monitor_index: monitor_idx,
-                    workspace_index: workspace_idx,
-                    matching_rule: MatchingRule::Simple(IdWithIdentifier {
-                        kind: identifier,
-                        id: id.to_string(),
-                        matching_strategy: Some(MatchingStrategy::Legacy),
-                    }),
-                    initial_only: true,
-                };
-
-                if !workspace_rules.contains(&workspace_matching_rule) {
-                    workspace_rules.push(workspace_matching_rule);
-                }
+            SocketMessage::InitialWorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
+                self.handle_initial_workspace_rules(id, monitor_idx, workspace_idx)?;
             }
-            SocketMessage::InitialNamedWorkspaceRule(identifier, ref id, ref workspace) => {
+            SocketMessage::InitialNamedWorkspaceRule(_, ref id, ref workspace) => {
                 if let Some((monitor_idx, workspace_idx)) =
                     self.monitor_workspace_index_by_name(workspace)
                 {
-                    let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
-                    let workspace_matching_rule = WorkspaceMatchingRule {
-                        monitor_index: monitor_idx,
-                        workspace_index: workspace_idx,
-                        matching_rule: MatchingRule::Simple(IdWithIdentifier {
-                            kind: identifier,
-                            id: id.to_string(),
-                            matching_strategy: Some(MatchingStrategy::Legacy),
-                        }),
-                        initial_only: true,
-                    };
-
-                    if !workspace_rules.contains(&workspace_matching_rule) {
-                        workspace_rules.push(workspace_matching_rule);
-                    }
+                    self.handle_initial_workspace_rules(id, monitor_idx, workspace_idx)?;
                 }
             }
-            SocketMessage::WorkspaceRule(identifier, ref id, monitor_idx, workspace_idx) => {
-                let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
-                let workspace_matching_rule = WorkspaceMatchingRule {
-                    monitor_index: monitor_idx,
-                    workspace_index: workspace_idx,
-                    matching_rule: MatchingRule::Simple(IdWithIdentifier {
-                        kind: identifier,
-                        id: id.to_string(),
-                        matching_strategy: Some(MatchingStrategy::Legacy),
-                    }),
-                    initial_only: false,
-                };
-
-                if !workspace_rules.contains(&workspace_matching_rule) {
-                    workspace_rules.push(workspace_matching_rule);
-                }
+            SocketMessage::WorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
+                self.handle_definitive_workspace_rules(id, monitor_idx, workspace_idx)?;
             }
-            SocketMessage::NamedWorkspaceRule(identifier, ref id, ref workspace) => {
+            SocketMessage::NamedWorkspaceRule(_, ref id, ref workspace) => {
                 if let Some((monitor_idx, workspace_idx)) =
                     self.monitor_workspace_index_by_name(workspace)
                 {
-                    let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
-                    let workspace_matching_rule = WorkspaceMatchingRule {
-                        monitor_index: monitor_idx,
-                        workspace_index: workspace_idx,
-                        matching_rule: MatchingRule::Simple(IdWithIdentifier {
-                            kind: identifier,
-                            id: id.to_string(),
-                            matching_strategy: Some(MatchingStrategy::Legacy),
-                        }),
-                        initial_only: false,
-                    };
-
-                    if !workspace_rules.contains(&workspace_matching_rule) {
-                        workspace_rules.push(workspace_matching_rule);
-                    }
+                    self.handle_definitive_workspace_rules(id, monitor_idx, workspace_idx)?;
                 }
             }
             SocketMessage::ClearWorkspaceRules(monitor_idx, workspace_idx) => {
-                let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
+                let mut workspace_rules = WORKSPACE_RULES.lock();
+                let mut to_remove = vec![];
+                for (id, (m_idx, w_idx, _)) in workspace_rules.iter() {
+                    if monitor_idx == *m_idx && workspace_idx == *w_idx {
+                        to_remove.push(id.clone());
+                    }
+                }
 
-                workspace_rules.retain(|r| {
-                    r.monitor_index != monitor_idx && r.workspace_index != workspace_idx
-                });
+                for rule in to_remove {
+                    workspace_rules.remove(&rule);
+                }
             }
             SocketMessage::ClearNamedWorkspaceRules(ref workspace) => {
                 if let Some((monitor_idx, workspace_idx)) =
                     self.monitor_workspace_index_by_name(workspace)
                 {
-                    let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
-                    workspace_rules.retain(|r| {
-                        r.monitor_index != monitor_idx && r.workspace_index != workspace_idx
-                    });
+                    let mut workspace_rules = WORKSPACE_RULES.lock();
+                    let mut to_remove = vec![];
+                    for (id, (m_idx, w_idx, _)) in workspace_rules.iter() {
+                        if monitor_idx == *m_idx && workspace_idx == *w_idx {
+                            to_remove.push(id.clone());
+                        }
+                    }
+
+                    for rule in to_remove {
+                        workspace_rules.remove(&rule);
+                    }
                 }
             }
             SocketMessage::ClearAllWorkspaceRules => {
-                let mut workspace_rules = WORKSPACE_MATCHING_RULES.lock();
+                let mut workspace_rules = WORKSPACE_RULES.lock();
                 workspace_rules.clear();
             }
             SocketMessage::ManageRule(identifier, ref id) => {
@@ -1142,33 +1097,6 @@ impl WindowManager {
             SocketMessage::ReloadConfiguration => {
                 Self::reload_configuration();
             }
-            SocketMessage::ReplaceConfiguration(ref config) => {
-                // Check that this is a valid static config file first
-                if StaticConfig::read(config).is_ok() {
-                    // Clear workspace rules; these will need to be replaced
-                    WORKSPACE_MATCHING_RULES.lock().clear();
-                    // Pause so that restored windows come to the foreground from all workspaces
-                    self.is_paused = true;
-                    // Bring all windows to the foreground
-                    self.restore_all_windows()?;
-
-                    // Create a new wm from the config path
-                    let mut wm = StaticConfig::preload(
-                        config,
-                        winevent_listener::event_rx(),
-                        self.command_listener.try_clone().ok(),
-                    )?;
-
-                    // Initialize the new wm
-                    wm.init()?;
-
-                    // This is equivalent to StaticConfig::postload for this use case
-                    StaticConfig::reload(config, &mut wm)?;
-
-                    // Set self to the new wm instance
-                    *self = wm;
-                }
-            }
             SocketMessage::ReloadStaticConfiguration(ref pathbuf) => {
                 self.reload_static_configuration(pathbuf)?;
             }
@@ -1540,6 +1468,51 @@ impl WindowManager {
         tracing::info!("processed");
         Ok(())
     }
+
+    #[tracing::instrument(skip(self), level = "debug")]
+    fn handle_initial_workspace_rules(
+        &mut self,
+        id: &String,
+        monitor_idx: usize,
+        workspace_idx: usize,
+    ) -> Result<()> {
+        self.handle_workspace_rules(id, monitor_idx, workspace_idx, true)?;
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self), level = "debug")]
+    fn handle_definitive_workspace_rules(
+        &mut self,
+        id: &String,
+        monitor_idx: usize,
+        workspace_idx: usize,
+    ) -> Result<()> {
+        self.handle_workspace_rules(id, monitor_idx, workspace_idx, false)?;
+
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(self), level = "debug")]
+    pub fn handle_workspace_rules(
+        &mut self,
+        id: &String,
+        monitor_idx: usize,
+        workspace_idx: usize,
+        initial_workspace_rule: bool,
+    ) -> Result<()> {
+        {
+            let mut workspace_rules = WORKSPACE_RULES.lock();
+            workspace_rules.insert(
+                id.to_string(),
+                (monitor_idx, workspace_idx, initial_workspace_rule),
+            );
+        }
+
+        self.enforce_workspace_rules()?;
+
+        Ok(())
+    }
 }
 
 pub fn read_commands_uds(wm: &Arc<Mutex<WindowManager>>, mut stream: UnixStream) -> Result<()> {

komorebi/src/process_event.rs

@@ -383,7 +383,7 @@ impl WindowManager {
                         .ok_or_else(|| anyhow!("there is no workspace with this idx"))?
                         .focused_container_idx();
 
-                    WindowsApi::bring_window_to_top(window.hwnd)?;
+                    WindowsApi::bring_window_to_top(window.hwnd())?;
 
                     self.pending_move_op =
                         Option::from((monitor_idx, workspace_idx, container_idx));
@@ -407,7 +407,7 @@ impl WindowManager {
 
                 let workspace = self.focused_workspace_mut()?;
                 let focused_container_idx = workspace.focused_container_idx();
-                let new_position = WindowsApi::window_rect(window.hwnd)?;
+                let new_position = WindowsApi::window_rect(window.hwnd())?;
                 let old_position = *workspace
                     .latest_layout()
                     .get(focused_container_idx)

komorebi/src/stackbar_manager/mod.rs

@@ -21,6 +21,7 @@ use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
+use windows::Win32::Foundation::HWND;
 
 pub static STACKBAR_FONT_SIZE: AtomicI32 = AtomicI32::new(0); // 0 will produce the system default
 pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
@@ -127,8 +128,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     continue 'receiver;
                 }
 
-                let is_maximized =
-                    WindowsApi::is_zoomed(WindowsApi::foreground_window().unwrap_or_default());
+                let is_maximized = WindowsApi::is_zoomed(HWND(
+                    WindowsApi::foreground_window().unwrap_or_default(),
+                ));
 
                 // Handle the monocle container separately
                 if ws.monocle_container().is_some() || is_maximized {
@@ -205,7 +207,11 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     stackbars_monitors.insert(container.id().clone(), monitor_idx);
 
                     let rect = WindowsApi::window_rect(
-                        container.focused_window().copied().unwrap_or_default().hwnd,
+                        container
+                            .focused_window()
+                            .copied()
+                            .unwrap_or_default()
+                            .hwnd(),
                     )?;
 
                     stackbar.update(container_padding, container, &rect)?;

komorebi/src/stackbar_manager/stackbar.rs

@@ -14,7 +14,6 @@ use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
 use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
 use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::windows_api;
 use crate::WindowsApi;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::WINDOWS_11;
@@ -25,7 +24,6 @@ use std::sync::mpsc;
 use std::time::Duration;
 use windows::core::PCWSTR;
 use windows::Win32::Foundation::COLORREF;
-use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::LRESULT;
@@ -86,7 +84,7 @@ impl From<isize> for Stackbar {
 
 impl Stackbar {
     pub const fn hwnd(&self) -> HWND {
-        HWND(windows_api::as_ptr!(self.hwnd))
+        HWND(self.hwnd)
     }
 
     pub fn create(id: &str) -> color_eyre::Result<Self> {
@@ -109,7 +107,6 @@ impl Stackbar {
         let (hwnd_sender, hwnd_receiver) = mpsc::channel();
 
         let name_cl = name.clone();
-        let instance = h_module.0 as isize;
         std::thread::spawn(move || -> color_eyre::Result<()> {
             unsafe {
                 let hwnd = CreateWindowExW(
@@ -123,12 +120,12 @@ impl Stackbar {
                     0,
                     None,
                     None,
-                    HINSTANCE(windows_api::as_ptr!(instance)),
+                    h_module,
                     None,
-                )?;
+                );
 
                 SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
-                hwnd_sender.send(hwnd.0 as isize)?;
+                hwnd_sender.send(hwnd)?;
 
                 let mut msg: MSG = MSG::default();
 
@@ -137,8 +134,7 @@ impl Stackbar {
                         tracing::debug!("stackbar window event processing thread shutdown");
                         break;
                     };
-                    // TODO: error handling
-                    let _ = TranslateMessage(&msg);
+                    TranslateMessage(&msg);
                     DispatchMessageW(&msg);
 
                     std::thread::sleep(Duration::from_millis(10))
@@ -149,12 +145,12 @@ impl Stackbar {
         });
 
         Ok(Self {
-            hwnd: hwnd_receiver.recv()?,
+            hwnd: hwnd_receiver.recv()?.0,
         })
     }
 
     pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd)
+        WindowsApi::close_window(self.hwnd())
     }
 
     pub fn update(
@@ -180,7 +176,7 @@ impl Stackbar {
         layout.top -= workspace_specific_offset + STACKBAR_TAB_HEIGHT.load_consume();
         layout.left -= workspace_specific_offset;
 
-        WindowsApi::position_window(self.hwnd, &layout, false)?;
+        WindowsApi::position_window(self.hwnd(), &layout, false)?;
 
         unsafe {
             let hdc = GetDC(self.hwnd());
@@ -236,29 +232,16 @@ impl Stackbar {
                 match STYLE.load() {
                     BorderStyle::System => {
                         if *WINDOWS_11 {
-                            // TODO: error handling
-                            let _ = RoundRect(
-                                hdc,
-                                rect.left,
-                                rect.top,
-                                rect.right,
-                                rect.bottom,
-                                20,
-                                20,
-                            );
+                            RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
                         } else {
-                            // TODO: error handling
-                            let _ = Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
+                            Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
                         }
                     }
                     BorderStyle::Rounded => {
-                        // TODO: error handling
-                        let _ =
-                            RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
+                        RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, 20, 20);
                     }
                     BorderStyle::Square => {
-                        // TODO: error handling
-                        let _ = Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
+                        Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
                     }
                 }
 
@@ -284,12 +267,9 @@ impl Stackbar {
             }
 
             ReleaseDC(self.hwnd(), hdc);
-            // TODO: error handling
-            let _ = DeleteObject(hpen);
-            // TODO: error handling
-            let _ = DeleteObject(hbrush);
-            // TODO: error handling
-            let _ = DeleteObject(hfont);
+            DeleteObject(hpen);
+            DeleteObject(hbrush);
+            DeleteObject(hfont);
         }
 
         Ok(())
@@ -312,7 +292,7 @@ impl Stackbar {
             match msg {
                 WM_LBUTTONDOWN => {
                     let stackbars_containers = STACKBARS_CONTAINERS.lock();
-                    if let Some(container) = stackbars_containers.get(&(hwnd.0 as isize)) {
+                    if let Some(container) = stackbars_containers.get(&hwnd.0) {
                         let x = l_param.0 as i32 & 0xFFFF;
                         let y = (l_param.0 as i32 >> 16) & 0xFFFF;
 
@@ -322,7 +302,11 @@ impl Stackbar {
 
                         let focused_window_idx = container.focused_window_idx();
                         let focused_window_rect = WindowsApi::window_rect(
-                            container.focused_window().cloned().unwrap_or_default().hwnd,
+                            container
+                                .focused_window()
+                                .cloned()
+                                .unwrap_or_default()
+                                .hwnd(),
                         )
                         .unwrap_or_default();
 

komorebi/src/static_config.rs

@@ -42,21 +42,19 @@ use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
-use crate::SLOW_APPLICATION_COMPENSATION_TIME;
-use crate::SLOW_APPLICATION_IDENTIFIERS;
-use crate::TRANSPARENCY_BLACKLIST;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WINDOWS_11;
-use crate::WORKSPACE_MATCHING_RULES;
+use crate::WORKSPACE_RULES;
 
-use crate::config_generation::WorkspaceMatchingRule;
 use crate::core::config_generation::ApplicationConfiguration;
 use crate::core::config_generation::ApplicationConfigurationGenerator;
 use crate::core::config_generation::ApplicationOptions;
+use crate::core::config_generation::IdWithIdentifier;
 use crate::core::config_generation::MatchingRule;
 use crate::core::config_generation::MatchingStrategy;
 use crate::core::resolve_home_path;
 use crate::core::AnimationStyle;
+use crate::core::ApplicationIdentifier;
 use crate::core::BorderStyle;
 use crate::core::DefaultLayout;
 use crate::core::FocusFollowsMouseImplementation;
@@ -122,10 +120,10 @@ pub struct WorkspaceConfig {
     pub workspace_padding: Option<i32>,
     /// Initial workspace application rules
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub initial_workspace_rules: Option<Vec<MatchingRule>>,
+    pub initial_workspace_rules: Option<Vec<IdWithIdentifier>>,
     /// Permanent workspace application rules
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub workspace_rules: Option<Vec<MatchingRule>>,
+    pub workspace_rules: Option<Vec<IdWithIdentifier>>,
     /// Apply this monitor's window-based work area offset (default: true)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub apply_window_based_work_area_offset: Option<bool>,
@@ -143,6 +141,37 @@ impl From<&Workspace> for WorkspaceConfig {
             }
         }
 
+        let workspace_rules = WORKSPACE_RULES.lock();
+        let mut initial_ws_rules = vec![];
+        let mut ws_rules = vec![];
+
+        for (identifier, (_, _, is_initial)) in &*workspace_rules {
+            if identifier.ends_with("exe") {
+                let rule = IdWithIdentifier {
+                    kind: ApplicationIdentifier::Exe,
+                    id: identifier.clone(),
+                    matching_strategy: None,
+                };
+
+                if *is_initial {
+                    initial_ws_rules.push(rule);
+                } else {
+                    ws_rules.push(rule);
+                }
+            }
+        }
+
+        let initial_ws_rules = if initial_ws_rules.is_empty() {
+            None
+        } else {
+            Option::from(initial_ws_rules)
+        };
+        let ws_rules = if ws_rules.is_empty() {
+            None
+        } else {
+            Option::from(ws_rules)
+        };
+
         let default_container_padding = DEFAULT_CONTAINER_PADDING.load(Ordering::SeqCst);
         let default_workspace_padding = DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst);
 
@@ -178,8 +207,8 @@ impl From<&Workspace> for WorkspaceConfig {
             custom_layout_rules: None,
             container_padding,
             workspace_padding,
-            initial_workspace_rules: None,
-            workspace_rules: None,
+            initial_workspace_rules: initial_ws_rules,
+            workspace_rules: ws_rules,
             apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
         }
     }
@@ -217,7 +246,7 @@ impl From<&Monitor> for MonitorConfig {
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.30`
+/// The `komorebi.json` static configuration file reference for `v0.1.28`
 pub struct StaticConfig {
     /// DEPRECATED from v0.1.22: no longer required
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -284,9 +313,6 @@ pub struct StaticConfig {
     /// Alpha value for unfocused window transparency [[0-255]] (default: 200)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transparency_alpha: Option<u8>,
-    /// Individual window transparency ignore rules
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub transparency_ignore_rules: Option<Vec<MatchingRule>>,
     /// Global default workspace padding (default: 10)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub default_workspace_padding: Option<i32>,
@@ -332,15 +358,6 @@ pub struct StaticConfig {
     /// Animations configuration options
     #[serde(skip_serializing_if = "Option::is_none")]
     pub animation: Option<AnimationsConfig>,
-    /// Theme configuration options
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub theme: Option<KomorebiTheme>,
-    /// Identify applications which are slow to send initial event notifications
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub slow_application_identifiers: Option<Vec<MatchingRule>>,
-    /// How long to wait when compensating for slow applications, in milliseconds (default: 20)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub slow_application_compensation_time: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -354,52 +371,6 @@ pub struct AnimationsConfig {
     /// Set the animation FPS (default: 60)
     fps: Option<u64>,
 }
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(tag = "palette")]
-pub enum KomorebiTheme {
-    /// A theme from catppuccin-egui
-    Catppuccin {
-        /// Name of the Catppuccin theme
-        name: komorebi_themes::Catppuccin,
-        /// Border colour when the container contains a single window (default: Blue)
-        single_border: Option<komorebi_themes::CatppuccinValue>,
-        /// Border colour when the container contains multiple windows (default: Green)
-        stack_border: Option<komorebi_themes::CatppuccinValue>,
-        /// Border colour when the container is in monocle mode (default: Pink)
-        monocle_border: Option<komorebi_themes::CatppuccinValue>,
-        /// Border colour when the container is unfocused (default: Base)
-        unfocused_border: Option<komorebi_themes::CatppuccinValue>,
-        /// Stackbar focused tab text colour (default: Green)
-        stackbar_focused_text: Option<komorebi_themes::CatppuccinValue>,
-        /// Stackbar unfocused tab text colour (default: Text)
-        stackbar_unfocused_text: Option<komorebi_themes::CatppuccinValue>,
-        /// Stackbar tab background colour (default: Base)
-        stackbar_background: Option<komorebi_themes::CatppuccinValue>,
-        /// Komorebi status bar accent (default: Blue)
-        bar_accent: Option<komorebi_themes::CatppuccinValue>,
-    },
-    /// A theme from base16-egui-themes
-    Base16 {
-        /// Name of the Base16 theme
-        name: komorebi_themes::Base16,
-        /// Border colour when the container contains a single window (default: Base0D)
-        single_border: Option<komorebi_themes::Base16Value>,
-        /// Border colour when the container contains multiple windows (default: Base0B)
-        stack_border: Option<komorebi_themes::Base16Value>,
-        /// Border colour when the container is in monocle mode (default: Base0F)
-        monocle_border: Option<komorebi_themes::Base16Value>,
-        /// Border colour when the container is unfocused (default: Base01)
-        unfocused_border: Option<komorebi_themes::Base16Value>,
-        /// Stackbar focused tab text colour (default: Base0B)
-        stackbar_focused_text: Option<komorebi_themes::Base16Value>,
-        /// Stackbar unfocused tab text colour (default: Base05)
-        stackbar_unfocused_text: Option<komorebi_themes::Base16Value>,
-        /// Stackbar tab background colour (default: Base01)
-        stackbar_background: Option<komorebi_themes::Base16Value>,
-        /// Komorebi status bar accent (default: Base0D)
-        bar_accent: Option<komorebi_themes::Base16Value>,
-    },
-}
 
 impl StaticConfig {
     pub fn aliases(raw: &str) {
@@ -475,7 +446,7 @@ pub struct TabsConfig {
 pub struct StackbarConfig {
     /// Stackbar height
     pub height: Option<i32>,
-    /// Stackbar label
+    /// Stackbar height
     pub label: Option<StackbarLabel>,
     /// Stackbar mode
     pub mode: Option<StackbarMode>,
@@ -491,6 +462,95 @@ impl From<&WindowManager> for StaticConfig {
             monitors.push(MonitorConfig::from(m));
         }
 
+        let mut to_remove = vec![];
+        let mut to_add_initial = vec![];
+        let mut to_add_persistent = vec![];
+
+        let workspace_rules = WORKSPACE_RULES.lock();
+        for (m_idx, m) in monitors.iter().enumerate() {
+            for (w_idx, w) in m.workspaces.iter().enumerate() {
+                if let Some(rules) = &w.initial_workspace_rules {
+                    for iwsr in rules {
+                        for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
+                            if iwsr.id.eq(identifier)
+                                && (*monitor_idx != m_idx || *workspace_idx != w_idx)
+                            {
+                                to_remove.push((m_idx, w_idx, iwsr.id.clone()));
+                            }
+                        }
+                    }
+                }
+
+                for (identifier, (monitor_idx, workspace_idx, initial)) in &*workspace_rules {
+                    if *initial && (*monitor_idx == m_idx && *workspace_idx == w_idx) {
+                        to_add_initial.push((m_idx, w_idx, identifier.clone()));
+                    }
+                }
+
+                if let Some(rules) = &w.workspace_rules {
+                    for wsr in rules {
+                        for (identifier, (monitor_idx, workspace_idx, _)) in &*workspace_rules {
+                            if wsr.id.eq(identifier)
+                                && (*monitor_idx != m_idx || *workspace_idx != w_idx)
+                            {
+                                to_remove.push((m_idx, w_idx, wsr.id.clone()));
+                            }
+                        }
+                    }
+                }
+
+                for (identifier, (monitor_idx, workspace_idx, initial)) in &*workspace_rules {
+                    if !*initial && (*monitor_idx == m_idx && *workspace_idx == w_idx) {
+                        to_add_persistent.push((m_idx, w_idx, identifier.clone()));
+                    }
+                }
+            }
+        }
+
+        for (m_idx, w_idx, id) in to_remove {
+            if let Some(monitor) = monitors.get_mut(m_idx) {
+                if let Some(workspace) = monitor.workspaces.get_mut(w_idx) {
+                    if workspace.workspace_rules.is_none() {
+                        workspace.workspace_rules = Some(vec![]);
+                    }
+
+                    if let Some(rules) = &mut workspace.workspace_rules {
+                        rules.retain(|r| r.id != id);
+                        for (monitor_idx, workspace_idx, id) in &to_add_persistent {
+                            if m_idx == *monitor_idx && w_idx == *workspace_idx {
+                                rules.push(IdWithIdentifier {
+                                    kind: ApplicationIdentifier::Exe,
+                                    id: id.clone(),
+                                    matching_strategy: None,
+                                })
+                            }
+                        }
+
+                        rules.dedup();
+                    }
+
+                    if workspace.initial_workspace_rules.is_none() {
+                        workspace.workspace_rules = Some(vec![]);
+                    }
+
+                    if let Some(rules) = &mut workspace.initial_workspace_rules {
+                        rules.retain(|r| r.id != id);
+                        for (monitor_idx, workspace_idx, id) in &to_add_initial {
+                            if m_idx == *monitor_idx && w_idx == *workspace_idx {
+                                rules.push(IdWithIdentifier {
+                                    kind: ApplicationIdentifier::Exe,
+                                    id: id.clone(),
+                                    matching_strategy: None,
+                                })
+                            }
+                        }
+
+                        rules.dedup();
+                    }
+                }
+            }
+        }
+
         let border_colours = if border_manager::FOCUSED.load(Ordering::SeqCst) == 0 {
             None
         } else {
@@ -528,7 +588,6 @@ impl From<&WindowManager> for StaticConfig {
             transparency_alpha: Option::from(
                 transparency_manager::TRANSPARENCY_ALPHA.load(Ordering::SeqCst),
             ),
-            transparency_ignore_rules: None,
             border_style: Option::from(STYLE.load()),
             border_z_order: Option::from(Z_ORDER.load()),
             border_implementation: Option::from(IMPLEMENTATION.load()),
@@ -551,11 +610,6 @@ impl From<&WindowManager> for StaticConfig {
             display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.lock().clone()),
             stackbar: None,
             animation: None,
-            theme: None,
-            slow_application_compensation_time: Option::from(
-                SLOW_APPLICATION_COMPENSATION_TIME.load(Ordering::SeqCst),
-            ),
-            slow_application_identifiers: Option::from(SLOW_APPLICATION_IDENTIFIERS.lock().clone()),
         }
     }
 }
@@ -663,8 +717,6 @@ impl StaticConfig {
         let mut tray_and_multi_window_identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
         let mut object_name_change_identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
         let mut layered_identifiers = LAYERED_WHITELIST.lock();
-        let mut transparency_blacklist = TRANSPARENCY_BLACKLIST.lock();
-        let mut slow_application_identifiers = SLOW_APPLICATION_IDENTIFIERS.lock();
 
         if let Some(rules) = &mut self.float_rules {
             populate_rules(rules, &mut float_identifiers, &mut regex_identifiers)?;
@@ -694,18 +746,6 @@ impl StaticConfig {
             )?;
         }
 
-        if let Some(rules) = &mut self.transparency_ignore_rules {
-            populate_rules(rules, &mut transparency_blacklist, &mut regex_identifiers)?;
-        }
-
-        if let Some(rules) = &mut self.slow_application_identifiers {
-            populate_rules(
-                rules,
-                &mut slow_application_identifiers,
-                &mut regex_identifiers,
-            )?;
-        }
-
         if let Some(stackbar) = &self.stackbar {
             if let Some(height) = &stackbar.height {
                 STACKBAR_TAB_HEIGHT.store(*height, Ordering::SeqCst);
@@ -742,139 +782,6 @@ impl StaticConfig {
             }
         }
 
-        if let Some(theme) = &self.theme {
-            let (
-                single_border,
-                stack_border,
-                monocle_border,
-                unfocused_border,
-                stackbar_focused_text,
-                stackbar_unfocused_text,
-                stackbar_background,
-            ) = match theme {
-                KomorebiTheme::Catppuccin {
-                    name,
-                    single_border,
-                    stack_border,
-                    monocle_border,
-                    unfocused_border,
-                    stackbar_focused_text,
-                    stackbar_unfocused_text,
-                    stackbar_background,
-                    ..
-                } => {
-                    let single_border = single_border
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Blue)
-                        .color32(name.as_theme());
-
-                    let stack_border = stack_border
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Green)
-                        .color32(name.as_theme());
-
-                    let monocle_border = monocle_border
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Pink)
-                        .color32(name.as_theme());
-
-                    let unfocused_border = unfocused_border
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Base)
-                        .color32(name.as_theme());
-
-                    let stackbar_focused_text = stackbar_focused_text
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Green)
-                        .color32(name.as_theme());
-
-                    let stackbar_unfocused_text = stackbar_unfocused_text
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Text)
-                        .color32(name.as_theme());
-
-                    let stackbar_background = stackbar_background
-                        .unwrap_or(komorebi_themes::CatppuccinValue::Base)
-                        .color32(name.as_theme());
-
-                    (
-                        single_border,
-                        stack_border,
-                        monocle_border,
-                        unfocused_border,
-                        stackbar_focused_text,
-                        stackbar_unfocused_text,
-                        stackbar_background,
-                    )
-                }
-                KomorebiTheme::Base16 {
-                    name,
-                    single_border,
-                    stack_border,
-                    monocle_border,
-                    unfocused_border,
-                    stackbar_focused_text,
-                    stackbar_unfocused_text,
-                    stackbar_background,
-                    ..
-                } => {
-                    let single_border = single_border
-                        .unwrap_or(komorebi_themes::Base16Value::Base0D)
-                        .color32(*name);
-
-                    let stack_border = stack_border
-                        .unwrap_or(komorebi_themes::Base16Value::Base0B)
-                        .color32(*name);
-
-                    let monocle_border = monocle_border
-                        .unwrap_or(komorebi_themes::Base16Value::Base0F)
-                        .color32(*name);
-
-                    let unfocused_border = unfocused_border
-                        .unwrap_or(komorebi_themes::Base16Value::Base01)
-                        .color32(*name);
-
-                    let stackbar_focused_text = stackbar_focused_text
-                        .unwrap_or(komorebi_themes::Base16Value::Base0B)
-                        .color32(*name);
-
-                    let stackbar_unfocused_text = stackbar_unfocused_text
-                        .unwrap_or(komorebi_themes::Base16Value::Base05)
-                        .color32(*name);
-
-                    let stackbar_background = stackbar_background
-                        .unwrap_or(komorebi_themes::Base16Value::Base01)
-                        .color32(*name);
-
-                    (
-                        single_border,
-                        stack_border,
-                        monocle_border,
-                        unfocused_border,
-                        stackbar_focused_text,
-                        stackbar_unfocused_text,
-                        stackbar_background,
-                    )
-                }
-            };
-
-            border_manager::FOCUSED.store(u32::from(Colour::from(single_border)), Ordering::SeqCst);
-            border_manager::MONOCLE
-                .store(u32::from(Colour::from(monocle_border)), Ordering::SeqCst);
-            border_manager::STACK.store(u32::from(Colour::from(stack_border)), Ordering::SeqCst);
-            border_manager::UNFOCUSED
-                .store(u32::from(Colour::from(unfocused_border)), Ordering::SeqCst);
-
-            STACKBAR_TAB_BACKGROUND_COLOUR.store(
-                u32::from(Colour::from(stackbar_background)),
-                Ordering::SeqCst,
-            );
-
-            STACKBAR_FOCUSED_TEXT_COLOUR.store(
-                u32::from(Colour::from(stackbar_focused_text)),
-                Ordering::SeqCst,
-            );
-
-            STACKBAR_UNFOCUSED_TEXT_COLOUR.store(
-                u32::from(Colour::from(stackbar_unfocused_text)),
-                Ordering::SeqCst,
-            );
-        }
-
         if let Some(path) = &self.app_specific_configuration_path {
             let path = resolve_home_path(path)?;
             let content = std::fs::read_to_string(path)?;
@@ -927,42 +834,30 @@ impl StaticConfig {
         Ok(())
     }
 
-    pub fn read(path: &PathBuf) -> Result<Self> {
-        let content = std::fs::read_to_string(path)?;
-        let value: Self = serde_json::from_str(&content)?;
-        Ok(value)
-    }
-
     #[allow(clippy::too_many_lines)]
     pub fn preload(
         path: &PathBuf,
         incoming: Receiver<WindowManagerEvent>,
-        unix_listener: Option<UnixListener>,
     ) -> Result<WindowManager> {
         let content = std::fs::read_to_string(path)?;
         let mut value: Self = serde_json::from_str(&content)?;
         value.apply_globals()?;
 
-        let listener = match unix_listener {
-            Some(listener) => listener,
-            None => {
-                let socket = DATA_DIR.join("komorebi.sock");
+        let socket = DATA_DIR.join("komorebi.sock");
 
-                match std::fs::remove_file(&socket) {
-                    Ok(()) => {}
-                    Err(error) => match error.kind() {
-                        // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
-                        ErrorKind::NotFound => {}
-                        _ => {
-                            return Err(error.into());
-                        }
-                    },
-                };
-
-                UnixListener::bind(&socket)?
-            }
+        match std::fs::remove_file(&socket) {
+            Ok(()) => {}
+            Err(error) => match error.kind() {
+                // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
+                ErrorKind::NotFound => {}
+                _ => {
+                    return Err(error.into());
+                }
+            },
         };
 
+        let listener = UnixListener::bind(&socket)?;
+
         let mut wm = WindowManager {
             monitors: Ring::default(),
             incoming_events: incoming,
@@ -1050,35 +945,22 @@ impl StaticConfig {
                     }
                 }
 
-                let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
                 for (j, ws) in monitor.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {
-                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                monitor_index: i,
-                                workspace_index: j,
-                                matching_rule: r.clone(),
-                                initial_only: false,
-                            });
+                            wm.handle_workspace_rules(&r.id, i, j, false)?;
                         }
                     }
 
                     if let Some(rules) = &ws.initial_workspace_rules {
                         for r in rules {
-                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                monitor_index: i,
-                                workspace_index: j,
-                                matching_rule: r.clone(),
-                                initial_only: true,
-                            });
+                            wm.handle_workspace_rules(&r.id, i, j, true)?;
                         }
                     }
                 }
             }
         }
 
-        wm.enforce_workspace_rules()?;
-
         if value.border == Some(true) {
             border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
         }
@@ -1096,9 +978,7 @@ impl StaticConfig {
             for (i, monitor) in monitors.iter().enumerate() {
                 if let Some(m) = wm.monitors_mut().get_mut(i) {
                     m.ensure_workspace_count(monitor.workspaces.len());
-                    if m.work_area_offset().is_none() {
-                        m.set_work_area_offset(monitor.work_area_offset);
-                    }
+                    m.set_work_area_offset(monitor.work_area_offset);
                     m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
                     m.set_window_based_work_area_offset_limit(
                         monitor.window_based_work_area_offset_limit.unwrap_or(1),
@@ -1114,36 +994,22 @@ impl StaticConfig {
                     }
                 }
 
-                let mut workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-                workspace_matching_rules.clear();
                 for (j, ws) in monitor.workspaces.iter().enumerate() {
                     if let Some(rules) = &ws.workspace_rules {
                         for r in rules {
-                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                monitor_index: i,
-                                workspace_index: j,
-                                matching_rule: r.clone(),
-                                initial_only: false,
-                            });
+                            wm.handle_workspace_rules(&r.id, i, j, false)?;
                         }
                     }
 
                     if let Some(rules) = &ws.initial_workspace_rules {
                         for r in rules {
-                            workspace_matching_rules.push(WorkspaceMatchingRule {
-                                monitor_index: i,
-                                workspace_index: j,
-                                matching_rule: r.clone(),
-                                initial_only: true,
-                            });
+                            wm.handle_workspace_rules(&r.id, i, j, true)?;
                         }
                     }
                 }
             }
         }
 
-        wm.enforce_workspace_rules()?;
-
         if let Some(enabled) = value.border {
             border_manager::BORDER_ENABLED.store(enabled, Ordering::SeqCst);
         }
@@ -1156,10 +1022,6 @@ impl StaticConfig {
             wm.cross_monitor_move_behaviour = val;
         }
 
-        if let Some(val) = value.cross_boundary_behaviour {
-            wm.cross_boundary_behaviour = val;
-        }
-
         if let Some(val) = value.unmanaged_window_operation_behaviour {
             wm.unmanaged_window_operation_behaviour = val;
         }

komorebi/src/transparency_manager.rs

@@ -8,13 +8,11 @@ use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU8;
 use std::sync::Arc;
 use std::sync::OnceLock;
+use windows::Win32::Foundation::HWND;
 
-use crate::should_act;
 use crate::Window;
 use crate::WindowManager;
 use crate::WindowsApi;
-use crate::REGEX_IDENTIFIERS;
-use crate::TRANSPARENCY_BLACKLIST;
 
 pub static TRANSPARENCY_ENABLED: AtomicBool = AtomicBool::new(false);
 pub static TRANSPARENCY_ALPHA: AtomicU8 = AtomicU8::new(200);
@@ -125,7 +123,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                 }
 
                 let foreground_hwnd = WindowsApi::foreground_window().unwrap_or_default();
-                let is_maximized = WindowsApi::is_zoomed(foreground_hwnd);
+                let is_maximized = WindowsApi::is_zoomed(HWND(foreground_hwnd));
 
                 if is_maximized {
                     if let Err(error) = Window::from(foreground_hwnd).opaque() {
@@ -136,9 +134,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     continue 'monitors;
                 }
 
-                let transparency_blacklist = TRANSPARENCY_BLACKLIST.lock();
-                let regex_identifiers = REGEX_IDENTIFIERS.lock();
-
                 for (idx, c) in ws.containers().iter().enumerate() {
                     // Update the transparency for all containers on this workspace
 
@@ -149,37 +144,15 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         let focused_window_idx = c.focused_window_idx();
                         for (window_idx, window) in c.windows().iter().enumerate() {
                             if window_idx == focused_window_idx {
-                                let mut should_make_transparent = true;
-                                if !transparency_blacklist.is_empty() {
-                                    if let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) = (
-                                        window.title(),
-                                        window.exe(),
-                                        window.class(),
-                                        window.path(),
-                                    ) {
-                                        let is_blacklisted = should_act(
-                                            &title,
-                                            &exe_name,
-                                            &class,
-                                            &path,
-                                            &transparency_blacklist,
-                                            &regex_identifiers,
-                                        )
-                                        .is_some();
-
-                                        should_make_transparent = !is_blacklisted;
+                                match window.transparent() {
+                                    Err(error) => {
+                                        let hwnd = foreground_hwnd;
+                                        tracing::error!(
+                                    "failed to make unfocused window {hwnd} transparent: {error}"
+                                )
                                     }
-                                }
-
-                                if should_make_transparent {
-                                    match window.transparent() {
-                                        Err(error) => {
-                                            let hwnd = foreground_hwnd;
-                                            tracing::error!("failed to make unfocused window {hwnd} transparent: {error}" )
-                                        }
-                                        Ok(..) => {
-                                            known_hwnds.lock().push(window.hwnd);
-                                        }
+                                    Ok(..) => {
+                                        known_hwnds.lock().push(window.hwnd);
                                     }
                                 }
                             } else {

komorebi/src/window.rs

@@ -2,12 +2,9 @@ use crate::border_manager;
 use crate::com::SetCloak;
 use crate::focus_manager;
 use crate::stackbar_manager;
-use crate::windows_api;
 use crate::ANIMATIONS_IN_PROGRESS;
 use crate::ANIMATION_DURATION;
 use crate::ANIMATION_ENABLED;
-use crate::SLOW_APPLICATION_COMPENSATION_TIME;
-use crate::SLOW_APPLICATION_IDENTIFIERS;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
@@ -73,8 +70,8 @@ impl From<isize> for Window {
 impl From<HWND> for Window {
     fn from(value: HWND) -> Self {
         Self {
-            hwnd: value.0 as isize,
-            animation: Animation::new(value.0 as isize),
+            hwnd: value.0,
+            animation: Animation::new(value.0),
         }
     }
 }
@@ -148,7 +145,7 @@ impl Serialize for Window {
         )?;
         state.serialize_field(
             "rect",
-            &WindowsApi::window_rect(self.hwnd).unwrap_or_default(),
+            &WindowsApi::window_rect(self.hwnd()).unwrap_or_default(),
         )?;
         state.end()
     }
@@ -156,7 +153,7 @@ impl Serialize for Window {
 
 impl Window {
     pub const fn hwnd(self) -> HWND {
-        HWND(windows_api::as_ptr!(self.hwnd))
+        HWND(self.hwnd)
     }
 
     pub fn center(&mut self, work_area: &Rect) -> Result<()> {
@@ -175,6 +172,7 @@ impl Window {
     }
 
     pub fn animate_position(&self, start_rect: &Rect, target_rect: &Rect, top: bool) -> Result<()> {
+        let hwnd = self.hwnd();
         let start_rect = *start_rect;
         let target_rect = *target_rect;
         let duration = Duration::from_millis(ANIMATION_DURATION.load(Ordering::SeqCst));
@@ -186,16 +184,14 @@ impl Window {
         stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
         stackbar_manager::send_notification();
 
-        let hwnd = self.hwnd;
-
         std::thread::spawn(move || {
             animation.animate(duration, |progress: f64| {
                 let new_rect = Animation::lerp_rect(&start_rect, &target_rect, progress);
 
                 if progress == 1.0 {
                     WindowsApi::position_window(hwnd, &new_rect, top)?;
-                    if WindowsApi::foreground_window().unwrap_or_default() == hwnd {
-                        focus_manager::send_notification(hwnd)
+                    if WindowsApi::foreground_window().unwrap_or_default() == hwnd.0 {
+                        focus_manager::send_notification(hwnd.0)
                     }
 
                     if ANIMATIONS_IN_PROGRESS.load(Ordering::Acquire) == 0 {
@@ -222,7 +218,7 @@ impl Window {
     }
 
     pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
-        let window_rect = WindowsApi::window_rect(self.hwnd)?;
+        let window_rect = WindowsApi::window_rect(self.hwnd())?;
 
         if window_rect.eq(layout) {
             return Ok(());
@@ -231,20 +227,20 @@ impl Window {
         if ANIMATION_ENABLED.load(Ordering::SeqCst) {
             self.animate_position(&window_rect, layout, top)
         } else {
-            WindowsApi::position_window(self.hwnd, layout, top)
+            WindowsApi::position_window(self.hwnd(), layout, top)
         }
     }
 
     pub fn is_maximized(self) -> bool {
-        WindowsApi::is_zoomed(self.hwnd)
+        WindowsApi::is_zoomed(self.hwnd())
     }
 
     pub fn is_miminized(self) -> bool {
-        WindowsApi::is_iconic(self.hwnd)
+        WindowsApi::is_iconic(self.hwnd())
     }
 
     pub fn is_visible(self) -> bool {
-        WindowsApi::is_window_visible(self.hwnd)
+        WindowsApi::is_window_visible(self.hwnd())
     }
 
     pub fn hide(self) {
@@ -255,8 +251,8 @@ impl Window {
 
         let hiding_behaviour = HIDING_BEHAVIOUR.lock();
         match *hiding_behaviour {
-            HidingBehaviour::Hide => WindowsApi::hide_window(self.hwnd),
-            HidingBehaviour::Minimize => WindowsApi::minimize_window(self.hwnd),
+            HidingBehaviour::Hide => WindowsApi::hide_window(self.hwnd()),
+            HidingBehaviour::Minimize => WindowsApi::minimize_window(self.hwnd()),
             HidingBehaviour::Cloak => SetCloak(self.hwnd(), 1, 2),
         }
     }
@@ -273,18 +269,18 @@ impl Window {
         let hiding_behaviour = HIDING_BEHAVIOUR.lock();
         match *hiding_behaviour {
             HidingBehaviour::Hide | HidingBehaviour::Minimize => {
-                WindowsApi::restore_window(self.hwnd);
+                WindowsApi::restore_window(self.hwnd());
             }
             HidingBehaviour::Cloak => SetCloak(self.hwnd(), 1, 0),
         }
     }
 
     pub fn minimize(self) {
-        WindowsApi::minimize_window(self.hwnd);
+        WindowsApi::minimize_window(self.hwnd());
     }
 
     pub fn close(self) -> Result<()> {
-        WindowsApi::close_window(self.hwnd)
+        WindowsApi::close_window(self.hwnd())
     }
 
     pub fn maximize(self) {
@@ -296,7 +292,7 @@ impl Window {
             programmatically_hidden_hwnds.remove(idx);
         }
 
-        WindowsApi::maximize_window(self.hwnd);
+        WindowsApi::maximize_window(self.hwnd());
     }
 
     pub fn unmaximize(self) {
@@ -308,27 +304,27 @@ impl Window {
             programmatically_hidden_hwnds.remove(idx);
         }
 
-        WindowsApi::unmaximize_window(self.hwnd);
+        WindowsApi::unmaximize_window(self.hwnd());
     }
 
     pub fn focus(self, mouse_follows_focus: bool) -> Result<()> {
         // If the target window is already focused, do nothing.
         if let Ok(ihwnd) = WindowsApi::foreground_window() {
-            if ihwnd == self.hwnd {
+            if HWND(ihwnd) == self.hwnd() {
                 // Center cursor in Window
                 if mouse_follows_focus {
-                    WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd)?)?;
+                    WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd())?)?;
                 }
 
                 return Ok(());
             }
         }
 
-        WindowsApi::raise_and_focus_window(self.hwnd)?;
+        WindowsApi::raise_and_focus_window(self.hwnd())?;
 
         // Center cursor in Window
         if mouse_follows_focus {
-            WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd)?)?;
+            WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd())?)?;
         }
 
         Ok(())
@@ -339,7 +335,7 @@ impl Window {
         ex_style.insert(ExtendedWindowStyle::LAYERED);
         self.update_ex_style(&ex_style)?;
         WindowsApi::set_transparent(
-            self.hwnd,
+            self.hwnd(),
             transparency_manager::TRANSPARENCY_ALPHA.load_consume(),
         )
     }
@@ -358,42 +354,31 @@ impl Window {
         WindowsApi::set_window_accent(self.hwnd, None)
     }
 
-    #[cfg(target_pointer_width = "64")]
+    #[allow(dead_code)]
     pub fn update_style(self, style: &WindowStyle) -> Result<()> {
-        WindowsApi::update_style(self.hwnd, isize::try_from(style.bits())?)
+        WindowsApi::update_style(self.hwnd(), isize::try_from(style.bits())?)
     }
 
-    #[cfg(target_pointer_width = "32")]
-    pub fn update_style(self, style: &WindowStyle) -> Result<()> {
-        WindowsApi::update_style(self.hwnd, i32::try_from(style.bits())?)
-    }
-
-    #[cfg(target_pointer_width = "64")]
     pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> Result<()> {
-        WindowsApi::update_ex_style(self.hwnd, isize::try_from(style.bits())?)
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    pub fn update_ex_style(self, style: &ExtendedWindowStyle) -> Result<()> {
-        WindowsApi::update_ex_style(self.hwnd, i32::try_from(style.bits())?)
+        WindowsApi::update_ex_style(self.hwnd(), isize::try_from(style.bits())?)
     }
 
     pub fn style(self) -> Result<WindowStyle> {
-        let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd)?)?;
+        let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd())?)?;
         Ok(WindowStyle::from_bits_truncate(bits))
     }
 
     pub fn ex_style(self) -> Result<ExtendedWindowStyle> {
-        let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd)?)?;
+        let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd())?)?;
         Ok(ExtendedWindowStyle::from_bits_truncate(bits))
     }
 
     pub fn title(self) -> Result<String> {
-        WindowsApi::window_text_w(self.hwnd)
+        WindowsApi::window_text_w(self.hwnd())
     }
 
     pub fn path(self) -> Result<String> {
-        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd);
+        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd());
         let handle = WindowsApi::process_handle(process_id)?;
         let path = WindowsApi::exe_path(handle);
         WindowsApi::close_process(handle)?;
@@ -401,28 +386,23 @@ impl Window {
     }
 
     pub fn exe(self) -> Result<String> {
-        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd);
+        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd());
         let handle = WindowsApi::process_handle(process_id)?;
         let exe = WindowsApi::exe(handle);
         WindowsApi::close_process(handle)?;
         exe
     }
 
-    pub fn process_id(self) -> u32 {
-        let (process_id, _) = WindowsApi::window_thread_process_id(self.hwnd);
-        process_id
-    }
-
     pub fn class(self) -> Result<String> {
-        WindowsApi::real_window_class_w(self.hwnd)
+        WindowsApi::real_window_class_w(self.hwnd())
     }
 
     pub fn is_cloaked(self) -> Result<bool> {
-        WindowsApi::is_window_cloaked(self.hwnd)
+        WindowsApi::is_window_cloaked(self.hwnd())
     }
 
     pub fn is_window(self) -> bool {
-        WindowsApi::is_window(self.hwnd)
+        WindowsApi::is_window(self.hwnd())
     }
 
     pub fn remove_title_bar(self) -> Result<()> {
@@ -451,7 +431,7 @@ impl Window {
 
         debug.is_window = true;
 
-        let rect = WindowsApi::window_rect(self.hwnd).unwrap_or_default();
+        let rect = WindowsApi::window_rect(self.hwnd()).unwrap_or_default();
 
         if rect.right < MINIMUM_WIDTH.load(Ordering::SeqCst) {
             return Ok(false);
@@ -636,23 +616,8 @@ fn window_is_eligible(
         titlebars_removed.contains(exe_name)
     };
 
-    {
-        let slow_application_identifiers = SLOW_APPLICATION_IDENTIFIERS.lock();
-        let should_sleep = should_act(
-            title,
-            exe_name,
-            class,
-            path,
-            &slow_application_identifiers,
-            &regex_identifiers,
-        )
-        .is_some();
-
-        if should_sleep {
-            std::thread::sleep(Duration::from_millis(
-                SLOW_APPLICATION_COMPENSATION_TIME.load(Ordering::SeqCst),
-            ));
-        }
+    if exe_name.contains("firefox") {
+        std::thread::sleep(Duration::from_millis(10));
     }
 
     if (allow_wsl2_gui || allow_titlebar_removed || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))

komorebi/src/window_manager.rs

@@ -16,6 +16,7 @@ use hotwatch::notify::ErrorKind as NotifyErrorKind;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
 use parking_lot::Mutex;
+use regex::Regex;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
@@ -42,14 +43,12 @@ use crate::core::WindowContainerBehaviour;
 
 use crate::border_manager;
 use crate::border_manager::STYLE;
-use crate::config_generation::WorkspaceMatchingRule;
 use crate::container::Container;
 use crate::core::StackbarMode;
 use crate::current_virtual_desktop;
 use crate::load_configuration;
 use crate::monitor::Monitor;
 use crate::ring::Ring;
-use crate::should_act_individual;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use crate::stackbar_manager::STACKBAR_LABEL;
 use crate::stackbar_manager::STACKBAR_MODE;
@@ -68,6 +67,7 @@ use crate::BorderColours;
 use crate::Colour;
 use crate::CrossBoundaryBehaviour;
 use crate::Rgb;
+use crate::WorkspaceRule;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
@@ -79,10 +79,9 @@ use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
 use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
-use crate::REGEX_IDENTIFIERS;
 use crate::REMOVE_TITLEBARS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
-use crate::WORKSPACE_MATCHING_RULES;
+use crate::WORKSPACE_RULES;
 
 #[derive(Debug)]
 pub struct WindowManager {
@@ -143,7 +142,7 @@ pub struct GlobalState {
     pub name_change_on_launch_identifiers: Vec<MatchingRule>,
     pub monitor_index_preferences: HashMap<usize, Rect>,
     pub display_index_preferences: HashMap<usize, String>,
-    pub workspace_rules: Vec<WorkspaceMatchingRule>,
+    pub workspace_rules: HashMap<String, WorkspaceRule>,
     pub window_hiding_behaviour: HidingBehaviour,
     pub configuration_dir: PathBuf,
     pub data_dir: PathBuf,
@@ -192,7 +191,7 @@ impl Default for GlobalState {
             name_change_on_launch_identifiers: OBJECT_NAME_CHANGE_ON_LAUNCH.lock().clone(),
             monitor_index_preferences: MONITOR_INDEX_PREFERENCES.lock().clone(),
             display_index_preferences: DISPLAY_INDEX_PREFERENCES.lock().clone(),
-            workspace_rules: WORKSPACE_MATCHING_RULES.lock().clone(),
+            workspace_rules: WORKSPACE_RULES.lock().clone(),
             window_hiding_behaviour: *HIDING_BEHAVIOUR.lock(),
             configuration_dir: HOME_DIR.clone(),
             data_dir: DATA_DIR.clone(),
@@ -234,6 +233,7 @@ struct EnforceWorkspaceRuleOp {
     target_monitor_idx: usize,
     target_workspace_idx: usize,
 }
+
 impl EnforceWorkspaceRuleOp {
     const fn is_origin(&self, monitor_idx: usize, workspace_idx: usize) -> bool {
         self.origin_monitor_idx == monitor_idx && self.origin_workspace_idx == workspace_idx
@@ -450,8 +450,7 @@ impl WindowManager {
             .ok_or_else(|| anyhow!("there is no monitor with that index"))?
             .focused_workspace_idx();
 
-        let workspace_matching_rules = WORKSPACE_MATCHING_RULES.lock();
-        let regex_identifiers = REGEX_IDENTIFIERS.lock();
+        let workspace_rules = WORKSPACE_RULES.lock();
         // Go through all the monitors and workspaces
         for (i, monitor) in self.monitors().iter().enumerate() {
             for (j, workspace) in monitor.workspaces().iter().enumerate() {
@@ -461,61 +460,63 @@ impl WindowManager {
                     let exe_name = window.exe()?;
                     let title = window.title()?;
                     let class = window.class()?;
-                    let path = window.path()?;
 
-                    for rule in &*workspace_matching_rules {
-                        let matched = match &rule.matching_rule {
-                            MatchingRule::Simple(r) => should_act_individual(
-                                &title,
-                                &exe_name,
-                                &class,
-                                &path,
-                                r,
-                                &regex_identifiers,
-                            ),
-                            MatchingRule::Composite(r) => {
-                                let mut composite_results = vec![];
-                                for identifier in r {
-                                    composite_results.push(should_act_individual(
-                                        &title,
-                                        &exe_name,
-                                        &class,
-                                        &path,
-                                        identifier,
-                                        &regex_identifiers,
-                                    ));
+                    let mut found_workspace_rule = workspace_rules.get(&exe_name);
+
+                    if found_workspace_rule.is_none() {
+                        found_workspace_rule = workspace_rules.get(&title);
+                    }
+
+                    if found_workspace_rule.is_none() {
+                        found_workspace_rule = workspace_rules.get(&class);
+                    }
+
+                    if found_workspace_rule.is_none() {
+                        for (k, v) in workspace_rules.iter() {
+                            if let Ok(re) = Regex::new(k) {
+                                if re.is_match(&exe_name) {
+                                    found_workspace_rule = Some(v);
                                 }
 
-                                composite_results.iter().all(|&x| x)
+                                if re.is_match(&title) {
+                                    found_workspace_rule = Some(v);
+                                }
+
+                                if re.is_match(&class) {
+                                    found_workspace_rule = Some(v);
+                                }
                             }
-                        };
+                        }
+                    }
 
-                        if matched {
-                            if rule.initial_only {
-                                if !already_moved_window_handles.contains(&window.hwnd) {
-                                    already_moved_window_handles.insert(window.hwnd);
+                    // If the executable names or titles of any of those windows are in our rules map
+                    if let Some((monitor_idx, workspace_idx, apply_on_first_show_only)) =
+                        found_workspace_rule
+                    {
+                        if *apply_on_first_show_only {
+                            if !already_moved_window_handles.contains(&window.hwnd) {
+                                already_moved_window_handles.insert(window.hwnd);
 
-                                    self.add_window_handle_to_move_based_on_workspace_rule(
-                                        &window.title()?,
-                                        window.hwnd,
-                                        i,
-                                        j,
-                                        rule.monitor_index,
-                                        rule.workspace_index,
-                                        &mut to_move,
-                                    );
-                                }
-                            } else {
                                 self.add_window_handle_to_move_based_on_workspace_rule(
                                     &window.title()?,
                                     window.hwnd,
                                     i,
                                     j,
-                                    rule.monitor_index,
-                                    rule.workspace_index,
+                                    *monitor_idx,
+                                    *workspace_idx,
                                     &mut to_move,
                                 );
                             }
+                        } else {
+                            self.add_window_handle_to_move_based_on_workspace_rule(
+                                &window.title()?,
+                                window.hwnd,
+                                i,
+                                j,
+                                *monitor_idx,
+                                *workspace_idx,
+                                &mut to_move,
+                            );
                         }
                     }
                 }
@@ -818,44 +819,35 @@ impl WindowManager {
                 let rect = self.focused_monitor_size()?;
                 WindowsApi::center_cursor_in_rect(&rect)?;
 
-                match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
+                match WindowsApi::raise_and_focus_window(desktop_window.hwnd()) {
                     Ok(()) => {}
                     Err(error) => {
                         tracing::warn!("{} {}:{}", error, file!(), line!());
                     }
                 }
             }
-        } else {
-            if self.focused_workspace()?.containers().is_empty() {
-                let desktop_window = Window::from(WindowsApi::desktop_window()?);
+        }
 
-                match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
-                    Ok(()) => {}
-                    Err(error) => {
-                        tracing::warn!("{} {}:{}", error, file!(), line!());
+        // if we passed false for follow_focus and there is a container on the workspace
+        if !follow_focus && self.focused_container_mut().is_ok() {
+            // and we have a stack with >1 windows
+            if self.focused_container_mut()?.windows().len() > 1
+                // and we don't have a maxed window 
+                && self.focused_workspace()?.maximized_window().is_none()
+                // and we don't have a monocle container
+                && self.focused_workspace()?.monocle_container().is_none()
+            {
+                if let Ok(window) = self.focused_window_mut() {
+                    if trigger_focus {
+                        window.focus(self.mouse_follows_focus)?;
                     }
                 }
             }
+        }
 
-            // if we passed false for follow_focus and there is a container on the workspace
-            if self.focused_container_mut().is_ok() {
-                // and we have a stack with >1 windows
-                if self.focused_container_mut()?.windows().len() > 1
-                    // and we don't have a maxed window
-                    && self.focused_workspace()?.maximized_window().is_none()
-                    // and we don't have a monocle container
-                    && self.focused_workspace()?.monocle_container().is_none()
-                {
-                    if let Ok(window) = self.focused_window_mut() {
-                        if trigger_focus {
-                            window.focus(self.mouse_follows_focus)?;
-                        }
-                    }
-                }
-            }
-
-            // This is to correctly restore and focus when switching to a workspace which
-            // contains a managed maximized window
+        // This is to correctly restore and focus when switching to a workspace which
+        // contains a managed maximized window
+        if !follow_focus {
             if let Some(window) = self.focused_workspace()?.maximized_window() {
                 window.restore();
                 if trigger_focus {
@@ -968,14 +960,6 @@ impl WindowManager {
 
         for monitor in self.monitors_mut() {
             for workspace in monitor.workspaces_mut() {
-                if let Some(monocle) = workspace.monocle_container() {
-                    for window in monocle.windows() {
-                        if matches!(border_implementation, BorderImplementation::Windows) {
-                            window.remove_accent()?;
-                        }
-                    }
-                }
-
                 for containers in workspace.containers_mut() {
                     for window in containers.windows_mut() {
                         if no_titlebar.contains(&window.exe()?) {
@@ -1275,7 +1259,6 @@ impl WindowManager {
 
         let mut cross_monitor_monocle = false;
 
-        // this is for when we are scrolling across workspaces like PaperWM
         if new_idx.is_none()
             && matches!(
                 self.cross_boundary_behaviour,
@@ -1306,36 +1289,6 @@ impl WindowManager {
 
             self.focus_workspace(next_idx)?;
 
-            if let Ok(focused_workspace) = self.focused_workspace_mut() {
-                if focused_workspace.monocle_container().is_none() {
-                    match direction {
-                        OperationDirection::Left => match focused_workspace.layout() {
-                            Layout::Default(layout) => {
-                                let target_index =
-                                    layout.rightmost_index(focused_workspace.containers().len());
-                                focused_workspace.focus_container(target_index);
-                            }
-                            Layout::Custom(_) => {
-                                focused_workspace.focus_container(
-                                    focused_workspace.containers().len().saturating_sub(1),
-                                );
-                            }
-                        },
-                        OperationDirection::Right => match focused_workspace.layout() {
-                            Layout::Default(layout) => {
-                                let target_index =
-                                    layout.leftmost_index(focused_workspace.containers().len());
-                                focused_workspace.focus_container(target_index);
-                            }
-                            Layout::Custom(_) => {
-                                focused_workspace.focus_container(0);
-                            }
-                        },
-                        _ => {}
-                    };
-                }
-            }
-
             return Ok(());
         }
 
@@ -1347,44 +1300,17 @@ impl WindowManager {
                     .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
 
                 self.focus_monitor(monitor_idx)?;
-                let mouse_follows_focus = self.mouse_follows_focus;
 
-                if let Ok(focused_workspace) = self.focused_workspace_mut() {
+                if let Ok(focused_workspace) = self.focused_workspace() {
                     if let Some(monocle) = focused_workspace.monocle_container() {
                         if let Some(window) = monocle.focused_window() {
-                            window.focus(mouse_follows_focus)?;
+                            window.focus(self.mouse_follows_focus)?;
                             WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(
-                                window.hwnd,
+                                window.hwnd(),
                             )?)?;
 
                             cross_monitor_monocle = true;
                         }
-                    } else {
-                        match direction {
-                            OperationDirection::Left => match focused_workspace.layout() {
-                                Layout::Default(layout) => {
-                                    let target_index = layout
-                                        .rightmost_index(focused_workspace.containers().len());
-                                    focused_workspace.focus_container(target_index);
-                                }
-                                Layout::Custom(_) => {
-                                    focused_workspace.focus_container(
-                                        focused_workspace.containers().len().saturating_sub(1),
-                                    );
-                                }
-                            },
-                            OperationDirection::Right => match focused_workspace.layout() {
-                                Layout::Default(layout) => {
-                                    let target_index =
-                                        layout.leftmost_index(focused_workspace.containers().len());
-                                    focused_workspace.focus_container(target_index);
-                                }
-                                Layout::Custom(_) => {
-                                    focused_workspace.focus_container(0);
-                                }
-                            },
-                            _ => {}
-                        };
                     }
                 }
             }
@@ -1422,7 +1348,6 @@ impl WindowManager {
         let origin_monitor_idx = self.focused_monitor_idx();
         let target_container_idx = workspace.new_idx_for_direction(direction);
 
-        // this is for when we are scrolling across workspaces like PaperWM
         if target_container_idx.is_none()
             && matches!(
                 self.cross_boundary_behaviour,
@@ -1451,8 +1376,6 @@ impl WindowManager {
                 _ => workspace_idx,
             };
 
-            // passing the direction here is how we handle whether to insert at the front
-            // or the back of the container vecdeque in the target workspace
             self.move_container_to_workspace(next_idx, true, Some(direction))?;
             self.update_focused_workspace(self.mouse_follows_focus, true)?;
 
@@ -1501,78 +1424,12 @@ impl WindowManager {
                     // get a mutable ref to the focused workspace on the target monitor
                     let target_workspace = self.focused_workspace_mut()?;
 
-                    match direction {
-                        OperationDirection::Left => {
-                            // insert the origin container into the focused workspace on the target monitor
-                            // at the back (or rightmost position) if we are moving across a boundary to
-                            // the left (back = right side of the target)
-                            match target_workspace.layout() {
-                                Layout::Default(layout) => match layout {
-                                    DefaultLayout::RightMainVerticalStack => {
-                                        target_workspace.add_container_to_front(origin_container);
-                                    }
-                                    DefaultLayout::UltrawideVerticalStack => {
-                                        if target_workspace.containers().len() == 1 {
-                                            target_workspace
-                                                .insert_container_at_idx(0, origin_container);
-                                        } else {
-                                            target_workspace
-                                                .add_container_to_back(origin_container);
-                                        }
-                                    }
-                                    _ => {
-                                        target_workspace.add_container_to_back(origin_container);
-                                    }
-                                },
-                                Layout::Custom(_) => {
-                                    target_workspace.add_container_to_back(origin_container);
-                                }
-                            }
-                        }
-                        OperationDirection::Right => {
-                            // insert the origin container into the focused workspace on the target monitor
-                            // at the front (or leftmost position) if we are moving across a boundary to the
-                            // right (front = left side of the target)
-                            match target_workspace.layout() {
-                                Layout::Default(layout) => {
-                                    let target_index =
-                                        layout.leftmost_index(target_workspace.containers().len());
-
-                                    match layout {
-                                        DefaultLayout::RightMainVerticalStack
-                                        | DefaultLayout::UltrawideVerticalStack => {
-                                            if target_workspace.containers().len() == 1 {
-                                                target_workspace
-                                                    .add_container_to_back(origin_container);
-                                            } else {
-                                                target_workspace.insert_container_at_idx(
-                                                    target_index,
-                                                    origin_container,
-                                                );
-                                            }
-                                        }
-                                        _ => {
-                                            target_workspace.insert_container_at_idx(
-                                                target_index,
-                                                origin_container,
-                                            );
-                                        }
-                                    }
-                                }
-                                Layout::Custom(_) => {
-                                    target_workspace.add_container_to_front(origin_container);
-                                }
-                            }
-                        }
-                        OperationDirection::Up | OperationDirection::Down => {
-                            // insert the origin container into the focused workspace on the target monitor
-                            // at the position where the currently focused container on that workspace is
-                            target_workspace.insert_container_at_idx(
-                                target_workspace.focused_container_idx(),
-                                origin_container,
-                            );
-                        }
-                    };
+                    // insert the origin container into the focused workspace on the target monitor
+                    // at the position where the currently focused container on that workspace is
+                    target_workspace.insert_container_at_idx(
+                        target_workspace.focused_container_idx(),
+                        origin_container,
+                    );
 
                     // if there is only one container on the target workspace after the insertion
                     // it means that there won't be one swapped back, so we have to decrement the
@@ -2621,7 +2478,7 @@ impl WindowManager {
     }
 
     pub fn monitor_idx_from_window(&mut self, window: Window) -> Option<usize> {
-        let hmonitor = WindowsApi::monitor_from_window(window.hwnd);
+        let hmonitor = WindowsApi::monitor_from_window(window.hwnd());
 
         for (i, monitor) in self.monitors().iter().enumerate() {
             if monitor.id() == hmonitor {

komorebi/src/windows_api.rs

@@ -14,7 +14,6 @@ use windows::Win32::Foundation::CloseHandle;
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HANDLE;
-use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HMODULE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -147,14 +146,6 @@ use crate::Window;
 use crate::DISPLAY_INDEX_PREFERENCES;
 use crate::MONITOR_INDEX_PREFERENCES;
 
-macro_rules! as_ptr {
-    ($value:expr) => {
-        $value as *mut core::ffi::c_void
-    };
-}
-
-pub(crate) use as_ptr;
-
 pub enum WindowsResult<T, E> {
     Err(E),
     Ok(T),
@@ -196,10 +187,10 @@ macro_rules! impl_process_windows_crate_integer_wrapper_result {
             $(
                 impl ProcessWindowsCrateResult<$deref> for $input {
                     fn process(self) -> Result<$deref> {
-                        if self == $input(std::ptr::null_mut()) {
+                        if self == $input(0) {
                             Err(std::io::Error::last_os_error().into())
                         } else {
-                            Ok(self.0 as $deref)
+                            Ok(self.0)
                         }
                     }
                 }
@@ -228,16 +219,9 @@ impl WindowsApi {
         callback: MONITORENUMPROC,
         callback_data_address: isize,
     ) -> Result<()> {
-        unsafe {
-            EnumDisplayMonitors(
-                HDC(std::ptr::null_mut()),
-                None,
-                callback,
-                LPARAM(callback_data_address),
-            )
-        }
-        .ok()
-        .process()
+        unsafe { EnumDisplayMonitors(HDC(0), None, callback, LPARAM(callback_data_address)) }
+            .ok()
+            .process()
     }
 
     pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
@@ -344,8 +328,8 @@ impl WindowsApi {
 
                 for container in workspace.containers_mut() {
                     for window in container.windows() {
-                        if Self::monitor_name_from_window(window.hwnd)? != monitor_name {
-                            windows_on_other_monitors.push(window.hwnd);
+                        if Self::monitor_name_from_window(window.hwnd())? != monitor_name {
+                            windows_on_other_monitors.push(window.hwnd().0);
                         }
                     }
                 }
@@ -363,34 +347,32 @@ impl WindowsApi {
         unsafe { AllowSetForegroundWindow(process_id) }.process()
     }
 
-    pub fn monitor_from_window(hwnd: isize) -> isize {
+    pub fn monitor_from_window(hwnd: HWND) -> isize {
         // MONITOR_DEFAULTTONEAREST ensures that the return value will never be NULL
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-monitorfromwindow
-        unsafe { MonitorFromWindow(HWND(as_ptr!(hwnd)), MONITOR_DEFAULTTONEAREST) }.0 as isize
+        unsafe { MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) }.0
     }
 
-    pub fn monitor_name_from_window(hwnd: isize) -> Result<String> {
+    pub fn monitor_name_from_window(hwnd: HWND) -> Result<String> {
         // MONITOR_DEFAULTTONEAREST ensures that the return value will never be NULL
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-monitorfromwindow
-        Ok(Self::monitor(
-            unsafe { MonitorFromWindow(HWND(as_ptr!(hwnd)), MONITOR_DEFAULTTONEAREST) }.0 as isize,
-        )?
-        .name()
-        .to_string())
+        Ok(
+            Self::monitor(unsafe { MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) }.0)?
+                .name()
+                .to_string(),
+        )
     }
 
     pub fn monitor_from_point(point: POINT) -> isize {
         // MONITOR_DEFAULTTONEAREST ensures that the return value will never be NULL
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-monitorfromwindow
-        unsafe { MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST) }.0 as isize
+        unsafe { MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST) }.0
     }
 
     /// position window resizes the target window to the given layout, adjusting
     /// the layout to account for any window shadow borders (the window painted
     /// region will match layout on completion).
-    pub fn position_window(hwnd: isize, layout: &Rect, top: bool) -> Result<()> {
-        let hwnd = HWND(as_ptr!(hwnd));
-
+    pub fn position_window(hwnd: HWND, layout: &Rect, top: bool) -> Result<()> {
         let mut flags = SetWindowPosition::NO_ACTIVATE
             | SetWindowPosition::NO_SEND_CHANGING
             | SetWindowPosition::NO_COPY_BITS
@@ -426,32 +408,22 @@ impl WindowsApi {
         Self::set_window_pos(hwnd, &rect, HWND_TOP, flags.bits())
     }
 
-    pub fn bring_window_to_top(hwnd: isize) -> Result<()> {
-        unsafe { BringWindowToTop(HWND(as_ptr!(hwnd))) }.process()
+    pub fn bring_window_to_top(hwnd: HWND) -> Result<()> {
+        unsafe { BringWindowToTop(hwnd) }.process()
     }
 
     // Raise the window to the top of the Z order, but do not activate or focus
     // it. Use raise_and_focus_window to activate and focus a window.
-    pub fn raise_window(hwnd: isize) -> Result<()> {
+    pub fn raise_window(hwnd: HWND) -> Result<()> {
         let flags = SetWindowPosition::NO_MOVE | SetWindowPosition::NO_ACTIVATE;
 
         let position = HWND_TOP;
-        Self::set_window_pos(
-            HWND(as_ptr!(hwnd)),
-            &Rect::default(),
-            position,
-            flags.bits(),
-        )
+        Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
     }
 
-    pub fn set_border_pos(hwnd: isize, layout: &Rect, position: isize) -> Result<()> {
+    pub fn set_border_pos(hwnd: HWND, layout: &Rect, position: HWND) -> Result<()> {
         let flags = { SetWindowPosition::SHOW_WINDOW | SetWindowPosition::NO_ACTIVATE };
-        Self::set_window_pos(
-            HWND(as_ptr!(hwnd)),
-            layout,
-            HWND(as_ptr!(position)),
-            flags.bits(),
-        )
+        Self::set_window_pos(hwnd, layout, position, flags.bits())
     }
 
     /// set_window_pos calls SetWindowPos without any accounting for Window decorations.
@@ -470,9 +442,7 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn move_window(hwnd: isize, layout: &Rect, repaint: bool) -> Result<()> {
-        let hwnd = HWND(as_ptr!(hwnd));
-
+    pub fn move_window(hwnd: HWND, layout: &Rect, repaint: bool) -> Result<()> {
         let shadow_rect = Self::shadow_rect(hwnd).unwrap_or_default();
         let rect = Rect {
             left: layout.left + shadow_rect.left,
@@ -483,16 +453,13 @@ impl WindowsApi {
         unsafe { MoveWindow(hwnd, rect.left, rect.top, rect.right, rect.bottom, repaint) }.process()
     }
 
-    pub fn show_window(hwnd: isize, command: SHOW_WINDOW_CMD) {
+    pub fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
         // BOOL is returned but does not signify whether or not the operation was succesful
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow
-        // TODO: error handling
-        unsafe {
-            let _ = ShowWindow(HWND(as_ptr!(hwnd)), command);
-        };
+        unsafe { ShowWindow(hwnd, command) };
     }
 
-    pub fn minimize_window(hwnd: isize) {
+    pub fn minimize_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_MINIMIZE);
     }
 
@@ -500,26 +467,26 @@ impl WindowsApi {
         unsafe { PostMessageW(hwnd, message, wparam, lparam) }.process()
     }
 
-    pub fn close_window(hwnd: isize) -> Result<()> {
-        match Self::post_message(HWND(as_ptr!(hwnd)), WM_CLOSE, WPARAM(0), LPARAM(0)) {
+    pub fn close_window(hwnd: HWND) -> Result<()> {
+        match Self::post_message(hwnd, WM_CLOSE, WPARAM(0), LPARAM(0)) {
             Ok(()) => Ok(()),
             Err(_) => Err(anyhow!("could not close window")),
         }
     }
 
-    pub fn hide_window(hwnd: isize) {
+    pub fn hide_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_HIDE);
     }
 
-    pub fn restore_window(hwnd: isize) {
+    pub fn restore_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_SHOWNOACTIVATE);
     }
 
-    pub fn unmaximize_window(hwnd: isize) {
+    pub fn unmaximize_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_NORMAL);
     }
 
-    pub fn maximize_window(hwnd: isize) {
+    pub fn maximize_window(hwnd: HWND) {
         Self::show_window(hwnd, SW_MAXIMIZE);
     }
 
@@ -527,7 +494,7 @@ impl WindowsApi {
         unsafe { GetForegroundWindow() }.process()
     }
 
-    pub fn raise_and_focus_window(hwnd: isize) -> Result<()> {
+    pub fn raise_and_focus_window(hwnd: HWND) -> Result<()> {
         let event = [INPUT {
             r#type: INPUT_MOUSE,
             ..Default::default()
@@ -539,7 +506,7 @@ impl WindowsApi {
             SendInput(&event, size_of::<INPUT>() as i32);
             // Error ignored, as the operation is not always necessary.
             let _ = SetWindowPos(
-                HWND(as_ptr!(hwnd)),
+                hwnd,
                 HWND_TOP,
                 0,
                 0,
@@ -548,7 +515,7 @@ impl WindowsApi {
                 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW,
             )
             .process();
-            SetForegroundWindow(HWND(as_ptr!(hwnd)))
+            SetForegroundWindow(hwnd)
         }
         .ok()
         .process()
@@ -556,7 +523,7 @@ impl WindowsApi {
 
     #[allow(dead_code)]
     pub fn top_window() -> Result<isize> {
-        unsafe { GetTopWindow(HWND::default())? }.process()
+        unsafe { GetTopWindow(HWND::default()) }.process()
     }
 
     pub fn desktop_window() -> Result<isize> {
@@ -564,8 +531,8 @@ impl WindowsApi {
     }
 
     #[allow(dead_code)]
-    pub fn next_window(hwnd: isize) -> Result<isize> {
-        unsafe { GetWindow(HWND(as_ptr!(hwnd)), GW_HWNDNEXT)? }.process()
+    pub fn next_window(hwnd: HWND) -> Result<isize> {
+        unsafe { GetWindow(hwnd, GW_HWNDNEXT) }.process()
     }
 
     pub fn alt_tab_windows() -> Result<Vec<Window>> {
@@ -584,17 +551,17 @@ impl WindowsApi {
         let mut next_hwnd = hwnd;
 
         while next_hwnd != 0 {
-            if Self::is_window_visible(next_hwnd) {
+            if Self::is_window_visible(HWND(next_hwnd)) {
                 return Ok(next_hwnd);
             }
 
-            next_hwnd = Self::next_window(next_hwnd)?;
+            next_hwnd = Self::next_window(HWND(next_hwnd))?;
         }
 
         Err(anyhow!("could not find next window"))
     }
 
-    pub fn window_rect(hwnd: isize) -> Result<Rect> {
+    pub fn window_rect(hwnd: HWND) -> Result<Rect> {
         let mut rect = unsafe { std::mem::zeroed() };
 
         if Self::dwm_get_window_attribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &mut rect).is_ok() {
@@ -604,7 +571,7 @@ impl WindowsApi {
             // Ok(Rect::from(rect).scale(system_scale.try_into()?, window_scale.try_into()?))
             Ok(Rect::from(rect))
         } else {
-            unsafe { GetWindowRect(HWND(as_ptr!(hwnd)), &mut rect) }.process()?;
+            unsafe { GetWindowRect(hwnd, &mut rect) }.process()?;
             Ok(Rect::from(rect))
         }
     }
@@ -614,7 +581,7 @@ impl WindowsApi {
     /// added to a position rect to compute a size for set_window_pos that will
     /// fill the target area, ignoring shadows.
     fn shadow_rect(hwnd: HWND) -> Result<Rect> {
-        let window_rect = Self::window_rect(hwnd.0 as isize)?;
+        let window_rect = Self::window_rect(hwnd)?;
 
         let mut srect = Default::default();
         unsafe { GetWindowRect(hwnd, &mut srect) }.process()?;
@@ -630,8 +597,7 @@ impl WindowsApi {
 
     pub fn round_rect(hdc: HDC, rect: &Rect, border_radius: i32) {
         unsafe {
-            // TODO: error handling
-            let _ = RoundRect(
+            RoundRect(
                 hdc,
                 rect.left,
                 rect.top,
@@ -644,8 +610,7 @@ impl WindowsApi {
     }
     pub fn rectangle(hdc: HDC, rect: &Rect) {
         unsafe {
-            // TODO: error handling
-            let _ = Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
+            Rectangle(hdc, rect.left, rect.top, rect.right, rect.bottom);
         }
     }
     fn set_cursor_pos(x: i32, y: i32) -> Result<()> {
@@ -671,16 +636,13 @@ impl WindowsApi {
         Self::set_cursor_pos(rect.left + (rect.right / 2), rect.top + (rect.bottom / 2))
     }
 
-    pub fn window_thread_process_id(hwnd: isize) -> (u32, u32) {
+    pub fn window_thread_process_id(hwnd: HWND) -> (u32, u32) {
         let mut process_id: u32 = 0;
 
         // Behaviour is undefined if an invalid HWND is given
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowthreadprocessid
         let thread_id = unsafe {
-            GetWindowThreadProcessId(
-                HWND(as_ptr!(hwnd)),
-                Option::from(std::ptr::addr_of_mut!(process_id)),
-            )
+            GetWindowThreadProcessId(hwnd, Option::from(std::ptr::addr_of_mut!(process_id)))
         };
 
         (process_id, thread_id)
@@ -703,7 +665,7 @@ impl WindowsApi {
         }
     }
 
-    #[cfg(target_pointer_width = "64")]
+    #[allow(dead_code)]
     fn set_window_long_ptr_w(
         hwnd: HWND,
         index: WINDOW_LONG_PTR_INDEX,
@@ -715,39 +677,14 @@ impl WindowsApi {
         .map(|_| {})
     }
 
-    #[cfg(target_pointer_width = "32")]
-    fn set_window_long_ptr_w(
-        hwnd: HWND,
-        index: WINDOW_LONG_PTR_INDEX,
-        new_value: i32,
-    ) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
-            SetWindowLongPtrW(hwnd, index, new_value)
-        }))
-        .map(|_| {})
+    pub fn gwl_style(hwnd: HWND) -> Result<isize> {
+        Self::window_long_ptr_w(hwnd, GWL_STYLE)
     }
 
-    #[cfg(target_pointer_width = "64")]
-    pub fn gwl_style(hwnd: isize) -> Result<isize> {
-        Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE)
+    pub fn gwl_ex_style(hwnd: HWND) -> Result<isize> {
+        Self::window_long_ptr_w(hwnd, GWL_EXSTYLE)
     }
 
-    #[cfg(target_pointer_width = "32")]
-    pub fn gwl_style(hwnd: isize) -> Result<i32> {
-        Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE)
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    pub fn gwl_ex_style(hwnd: isize) -> Result<isize> {
-        Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE)
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    pub fn gwl_ex_style(hwnd: isize) -> Result<i32> {
-        Self::window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE)
-    }
-
-    #[cfg(target_pointer_width = "64")]
     fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> Result<isize> {
         // Can return 0, which does not always mean that an error has occurred
         // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowlongptrw
@@ -756,38 +693,19 @@ impl WindowsApi {
         }))
     }
 
-    #[cfg(target_pointer_width = "32")]
-    fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> Result<i32> {
-        // Can return 0, which does not always mean that an error has occurred
-        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowlongptrw
-        Result::from(WindowsResult::from(unsafe {
-            GetWindowLongPtrW(hwnd, index)
-        }))
+    #[allow(dead_code)]
+    pub fn update_style(hwnd: HWND, new_value: isize) -> Result<()> {
+        Self::set_window_long_ptr_w(hwnd, GWL_STYLE, new_value)
     }
 
-    #[cfg(target_pointer_width = "64")]
-    pub fn update_style(hwnd: isize, new_value: isize) -> Result<()> {
-        Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE, new_value)
+    #[allow(dead_code)]
+    pub fn update_ex_style(hwnd: HWND, new_value: isize) -> Result<()> {
+        Self::set_window_long_ptr_w(hwnd, GWL_EXSTYLE, new_value)
     }
 
-    #[cfg(target_pointer_width = "32")]
-    pub fn update_style(hwnd: isize, new_value: i32) -> Result<()> {
-        Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_STYLE, new_value)
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    pub fn update_ex_style(hwnd: isize, new_value: isize) -> Result<()> {
-        Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE, new_value)
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    pub fn update_ex_style(hwnd: isize, new_value: i32) -> Result<()> {
-        Self::set_window_long_ptr_w(HWND(as_ptr!(hwnd)), GWL_EXSTYLE, new_value)
-    }
-
-    pub fn window_text_w(hwnd: isize) -> Result<String> {
+    pub fn window_text_w(hwnd: HWND) -> Result<String> {
         let mut text: [u16; 512] = [0; 512];
-        match WindowsResult::from(unsafe { GetWindowTextW(HWND(as_ptr!(hwnd)), &mut text) }) {
+        match WindowsResult::from(unsafe { GetWindowTextW(hwnd, &mut text) }) {
             WindowsResult::Ok(len) => {
                 let length = usize::try_from(len)?;
                 Ok(String::from_utf16(&text[..length])?)
@@ -833,25 +751,25 @@ impl WindowsApi {
             .to_string())
     }
 
-    pub fn real_window_class_w(hwnd: isize) -> Result<String> {
+    pub fn real_window_class_w(hwnd: HWND) -> Result<String> {
         const BUF_SIZE: usize = 512;
         let mut class: [u16; BUF_SIZE] = [0; BUF_SIZE];
 
         let len = Result::from(WindowsResult::from(unsafe {
-            RealGetWindowClassW(HWND(as_ptr!(hwnd)), &mut class)
+            RealGetWindowClassW(hwnd, &mut class)
         }))?;
 
         Ok(String::from_utf16(&class[0..len as usize])?)
     }
 
     pub fn dwm_get_window_attribute<T>(
-        hwnd: isize,
+        hwnd: HWND,
         attribute: DWMWINDOWATTRIBUTE,
         value: &mut T,
     ) -> Result<()> {
         unsafe {
             DwmGetWindowAttribute(
-                HWND(as_ptr!(hwnd)),
+                hwnd,
                 attribute,
                 (value as *mut T).cast(),
                 u32::try_from(std::mem::size_of::<T>())?,
@@ -861,7 +779,7 @@ impl WindowsApi {
         Ok(())
     }
 
-    pub fn is_window_cloaked(hwnd: isize) -> Result<bool> {
+    pub fn is_window_cloaked(hwnd: HWND) -> Result<bool> {
         let mut cloaked: u32 = 0;
         Self::dwm_get_window_attribute(hwnd, DWMWA_CLOAKED, &mut cloaked)?;
 
@@ -871,20 +789,20 @@ impl WindowsApi {
         ))
     }
 
-    pub fn is_window(hwnd: isize) -> bool {
-        unsafe { IsWindow(HWND(as_ptr!(hwnd))) }.into()
+    pub fn is_window(hwnd: HWND) -> bool {
+        unsafe { IsWindow(hwnd) }.into()
     }
 
-    pub fn is_window_visible(hwnd: isize) -> bool {
-        unsafe { IsWindowVisible(HWND(as_ptr!(hwnd))) }.into()
+    pub fn is_window_visible(hwnd: HWND) -> bool {
+        unsafe { IsWindowVisible(hwnd) }.into()
     }
 
-    pub fn is_iconic(hwnd: isize) -> bool {
-        unsafe { IsIconic(HWND(as_ptr!(hwnd))) }.into()
+    pub fn is_iconic(hwnd: HWND) -> bool {
+        unsafe { IsIconic(hwnd) }.into()
     }
 
-    pub fn is_zoomed(hwnd: isize) -> bool {
-        unsafe { IsZoomed(HWND(as_ptr!(hwnd))) }.into()
+    pub fn is_zoomed(hwnd: HWND) -> bool {
+        unsafe { IsZoomed(hwnd) }.into()
     }
 
     pub fn monitor_info_w(hmonitor: HMONITOR) -> Result<MONITORINFOEXW> {
@@ -1036,7 +954,7 @@ impl WindowsApi {
 
         unsafe {
             GetDpiForMonitor(
-                HMONITOR(as_ptr!(hmonitor)),
+                HMONITOR(hmonitor),
                 MDT_EFFECTIVE_DPI,
                 std::ptr::addr_of_mut!(dpi_x),
                 std::ptr::addr_of_mut!(dpi_y),
@@ -1060,7 +978,7 @@ impl WindowsApi {
 
         unsafe {
             DwmSetWindowAttribute(
-                HWND(as_ptr!(hwnd)),
+                HWND(hwnd),
                 DWMWA_WINDOW_CORNER_PREFERENCE,
                 std::ptr::addr_of!(round).cast(),
                 4,
@@ -1073,7 +991,7 @@ impl WindowsApi {
         let col_ref = COLORREF(color.unwrap_or(DWMWA_COLOR_NONE));
         unsafe {
             DwmSetWindowAttribute(
-                HWND(as_ptr!(hwnd)),
+                HWND(hwnd),
                 DWMWA_BORDER_COLOR,
                 std::ptr::addr_of!(col_ref).cast(),
                 4,
@@ -1082,7 +1000,7 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn create_border_window(name: PCWSTR, instance: isize) -> Result<isize> {
+    pub fn create_border_window(name: PCWSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             let hwnd = CreateWindowExW(
                 WS_EX_TOOLWINDOW | WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_NOACTIVATE,
@@ -1095,9 +1013,9 @@ impl WindowsApi {
                 CW_USEDEFAULT,
                 None,
                 None,
-                HINSTANCE(as_ptr!(instance)),
+                instance,
                 None,
-            )?;
+            );
 
             SetLayeredWindowAttributes(hwnd, COLORREF(0), 0, LWA_COLORKEY)?;
 
@@ -1106,21 +1024,16 @@ impl WindowsApi {
         .process()
     }
 
-    pub fn set_transparent(hwnd: isize, alpha: u8) -> Result<()> {
+    pub fn set_transparent(hwnd: HWND, alpha: u8) -> Result<()> {
         unsafe {
             #[allow(clippy::cast_sign_loss)]
-            SetLayeredWindowAttributes(
-                HWND(as_ptr!(hwnd)),
-                COLORREF(-1i32 as u32),
-                alpha,
-                LWA_ALPHA,
-            )?;
+            SetLayeredWindowAttributes(hwnd, COLORREF(-1i32 as u32), alpha, LWA_ALPHA)?;
         }
 
         Ok(())
     }
 
-    pub fn create_hidden_window(name: PCWSTR, instance: isize) -> Result<isize> {
+    pub fn create_hidden_window(name: PCWSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             CreateWindowExW(
                 WS_EX_NOACTIVATE,
@@ -1133,16 +1046,16 @@ impl WindowsApi {
                 CW_USEDEFAULT,
                 None,
                 None,
-                HINSTANCE(as_ptr!(instance)),
+                instance,
                 None,
-            )?
+            )
         }
         .process()
     }
 
-    pub fn invalidate_rect(hwnd: isize, rect: Option<&Rect>, erase: bool) -> bool {
+    pub fn invalidate_rect(hwnd: HWND, rect: Option<&Rect>, erase: bool) -> bool {
         let rect = rect.map(|rect| &rect.rect() as *const RECT);
-        unsafe { InvalidateRect(HWND(as_ptr!(hwnd)), rect, erase) }.as_bool()
+        unsafe { InvalidateRect(hwnd, rect, erase) }.as_bool()
     }
 
     pub fn alt_is_pressed() -> bool {
@@ -1196,6 +1109,6 @@ impl WindowsApi {
     }
 
     pub fn wts_register_session_notification(hwnd: isize) -> Result<()> {
-        unsafe { WTSRegisterSessionNotification(HWND(as_ptr!(hwnd)), 1) }.process()
+        unsafe { WTSRegisterSessionNotification(HWND(hwnd), 1) }.process()
     }
 }

komorebi/src/windows_callbacks.rs

@@ -16,10 +16,10 @@ use crate::winevent_listener;
 pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let containers = unsafe { &mut *(lparam.0 as *mut VecDeque<Container>) };
 
-    let is_visible = WindowsApi::is_window_visible(hwnd.0 as isize);
-    let is_window = WindowsApi::is_window(hwnd.0 as isize);
-    let is_minimized = WindowsApi::is_iconic(hwnd.0 as isize);
-    let is_maximized = WindowsApi::is_zoomed(hwnd.0 as isize);
+    let is_visible = WindowsApi::is_window_visible(hwnd);
+    let is_window = WindowsApi::is_window(hwnd);
+    let is_minimized = WindowsApi::is_iconic(hwnd);
+    let is_maximized = WindowsApi::is_zoomed(hwnd);
 
     if is_visible && is_window && !is_minimized {
         let window = Window::from(hwnd);
@@ -27,7 +27,7 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
         if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
             if should_manage {
                 if is_maximized {
-                    WindowsApi::restore_window(window.hwnd);
+                    WindowsApi::restore_window(hwnd);
                 }
 
                 let mut container = Container::default();
@@ -43,9 +43,9 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
 pub extern "system" fn alt_tab_windows(hwnd: HWND, lparam: LPARAM) -> BOOL {
     let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
 
-    let is_visible = WindowsApi::is_window_visible(hwnd.0 as isize);
-    let is_window = WindowsApi::is_window(hwnd.0 as isize);
-    let is_minimized = WindowsApi::is_iconic(hwnd.0 as isize);
+    let is_visible = WindowsApi::is_window_visible(hwnd);
+    let is_window = WindowsApi::is_window(hwnd);
+    let is_minimized = WindowsApi::is_iconic(hwnd);
 
     if is_visible && is_window && !is_minimized {
         let window = Window::from(hwnd);

komorebi/src/winevent_listener.rs

@@ -39,12 +39,11 @@ pub fn start() {
 
             loop {
                 unsafe {
-                    if !GetMessageW(&mut msg, HWND(std::ptr::null_mut()), 0, 0).as_bool() {
+                    if !GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {
                         tracing::debug!("windows event processing thread shutdown");
                         break;
                     };
-                    // TODO: error handling
-                    let _ = TranslateMessage(&msg);
+                    TranslateMessage(&msg);
                     DispatchMessageW(&msg);
                 }
 

komorebi/src/workspace.rs

@@ -357,7 +357,7 @@ impl Workspace {
                         // If a window has been unmaximized via toggle-maximize, this block
                         // will make sure that it is unmaximized via restore_window
                         if window.is_maximized() && !managed_maximized_window {
-                            WindowsApi::restore_window(window.hwnd);
+                            WindowsApi::restore_window(window.hwnd());
                         }
 
                         {
@@ -668,7 +668,6 @@ impl Workspace {
 
     pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) {
         self.containers_mut().insert(idx, container);
-        self.focus_container(idx);
     }
 
     pub fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {

komorebic-no-console/Cargo.toml

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

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.30"
+version = "0.1.29"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
@@ -13,28 +13,27 @@ edition = "2021"
 [dependencies]
 komorebi-client = { path = "../komorebi-client" }
 
-chrono = { workspace = true }
-clap = { workspace = true }
+clap = { version = "4", features = ["derive", "wrap_help"] }
+chrono = "0.4"
 color-eyre = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 fs-tail = "0.1"
-lazy_static = { workspace = true }
+lazy_static = "1"
 miette = { version = "7", features = ["fancy"] }
-paste = { workspace = true }
+paste = "1"
 powershell_script = "1.0"
 reqwest = { version = "0.12", features = ["blocking"] }
-schemars = { workspace = true }
-serde = { workspace = true }
+serde = { version = "1", features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = "0.9"
-shadow-rs = { workspace = true }
 sysinfo = { workspace = true }
 thiserror = "1"
-uds_windows = { workspace = true }
-which = { workspace = true }
+uds_windows = "1"
+which = "6"
 win32-display-data = { workspace = true }
 windows = { workspace = true }
+shadow-rs = { workspace = true }
 
 [build-dependencies]
 reqwest = { version = "0.12", features = ["blocking"] }

komorebic/src/main.rs

@@ -25,17 +25,12 @@ use fs_tail::TailedFile;
 use komorebi_client::resolve_home_path;
 use komorebi_client::send_message;
 use komorebi_client::send_query;
-use komorebi_client::ApplicationConfiguration;
-use komorebi_client::Notification;
 use lazy_static::lazy_static;
 use miette::NamedSource;
 use miette::Report;
 use miette::SourceOffset;
 use miette::SourceSpan;
 use paste::paste;
-use schemars::gen::SchemaSettings;
-use schemars::schema_for;
-use sysinfo::ProcessesToUpdate;
 use which::which;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
@@ -765,9 +760,6 @@ struct Start {
     /// Start autohotkey configuration file
     #[clap(long)]
     ahk: bool,
-    /// Start komorebi-bar in a background process
-    #[clap(long)]
-    bar: bool,
 }
 
 #[derive(Parser)]
@@ -775,9 +767,6 @@ struct Stop {
     /// Stop whkd if it is running as a background process
     #[clap(long)]
     whkd: bool,
-    /// Stop komorebi-bar if it is running as a background process
-    #[clap(long)]
-    bar: bool,
 }
 
 #[derive(Parser)]
@@ -864,15 +853,6 @@ struct EnableAutostart {
     /// Enable autostart of ahk
     #[clap(long)]
     ahk: bool,
-    /// Enable autostart of komorebi-bar
-    #[clap(long)]
-    bar: bool,
-}
-
-#[derive(Parser)]
-struct ReplaceConfiguration {
-    /// Static configuration JSON file from which the configuration should be loaded
-    path: PathBuf,
 }
 
 #[derive(Parser)]
@@ -897,10 +877,6 @@ enum SubCommand {
     /// Show the path to komorebi.json
     #[clap(alias = "config")]
     Configuration,
-    /// Show the path to komorebi.bar.json
-    #[clap(alias = "bar-config")]
-    #[clap(alias = "bconfig")]
-    BarConfiguration,
     /// Show the path to whkdrc
     #[clap(alias = "whkd")]
     Whkdrc,
@@ -1183,15 +1159,12 @@ enum SubCommand {
     Manage,
     /// Unmanage a window that was forcibly managed
     Unmanage,
-    /// Replace the configuration of a running instance of komorebi from a static configuration file
-    #[clap(arg_required_else_help = true)]
-    ReplaceConfiguration(ReplaceConfiguration),
-    /// Reload legacy komorebi.ahk or komorebi.ps1 configurations (if they exist)
+    /// Reload ~/komorebi.ahk (if it exists)
     ReloadConfiguration,
-    /// Enable or disable watching of legacy komorebi.ahk or komorebi.ps1 configurations (if they exist)
+    /// Enable or disable watching of ~/komorebi.ahk (if it exists)
     #[clap(arg_required_else_help = true)]
     WatchConfiguration(WatchConfiguration),
-    /// For legacy komorebi.ahk or komorebi.ps1 configurations, signal that the final configuration option has been sent
+    /// Signal that the final configuration option has been sent
     CompleteConfiguration,
     /// DEPRECATED since v0.1.22
     #[clap(arg_required_else_help = true)]
@@ -1282,16 +1255,16 @@ enum SubCommand {
     TransparencyAlpha(TransparencyAlpha),
     /// Toggle transparency for unfocused windows
     ToggleTransparency,
-    /// Enable or disable movement animations
+    /// Enable or disable the window move animation
     #[clap(arg_required_else_help = true)]
     Animation(Animation),
-    /// Set the duration for movement animations in ms
+    /// Set the duration for the window move animation in ms
     #[clap(arg_required_else_help = true)]
     AnimationDuration(AnimationDuration),
-    /// Set the frames per second for movement animations
+    /// Set the frames per second for the window move animation
     #[clap(arg_required_else_help = true)]
     AnimationFps(AnimationFps),
-    /// Set the ease function for movement animations
+    /// Set the ease function for the window move animation
     #[clap(arg_required_else_help = true)]
     AnimationStyle(AnimationStyle),
     /// Enable or disable focus follows mouse for the operating system
@@ -1399,16 +1372,12 @@ fn main() -> Result<()> {
             std::fs::create_dir_all(data_dir)?;
 
             let mut komorebi_json = include_str!("../../docs/komorebi.example.json").to_string();
-            let komorebi_bar_json =
-                include_str!("../../docs/komorebi.bar.example.json").to_string();
-
             if std::env::var("KOMOREBI_CONFIG_HOME").is_ok() {
                 komorebi_json =
                     komorebi_json.replace("Env:USERPROFILE", "Env:KOMOREBI_CONFIG_HOME");
             }
 
             std::fs::write(HOME_DIR.join("komorebi.json"), komorebi_json)?;
-            std::fs::write(HOME_DIR.join("komorebi.bar.json"), komorebi_bar_json)?;
 
             let applications_yaml = include_str!("../applications.yaml");
             std::fs::write(HOME_DIR.join("applications.yaml"), applications_yaml)?;
@@ -1416,8 +1385,8 @@ fn main() -> Result<()> {
             let whkdrc = include_str!("../../docs/whkdrc.sample");
             std::fs::write(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;
 
-            println!("Example komorebi.json, komorebi.bar.json, whkdrc and latest applications.yaml files created");
-            println!("You can now run komorebic start --whkd --bar");
+            println!("Example ~/komorebi.json, ~/.config/whkdrc and latest ~/applications.yaml files downloaded");
+            println!("You can now run komorebic start --whkd");
         }
         SubCommand::EnableAutostart(args) => {
             let mut current_exe = std::env::current_exe().expect("unable to get exec path");
@@ -1440,10 +1409,6 @@ fn main() -> Result<()> {
                 arguments.push_str(" --ffm");
             }
 
-            if args.bar {
-                arguments.push_str(" --bar");
-            }
-
             if args.whkd {
                 arguments.push_str(" --whkd");
             } else if args.ahk {
@@ -1457,10 +1422,6 @@ fn main() -> Result<()> {
                 .env("TARGET_PATH", komorebic_exe.as_os_str())
                 .env("TARGET_ARGS", arguments)
                 .output()?;
-
-            println!("NOTE: If your komorebi.json file contains a reference to $Env:KOMOREBI_CONFIG_HOME,");
-            println!("you need to add this to System Properties > Environment Variables > User Variables");
-            println!("in order for the autostart command to work properly");
         }
         SubCommand::DisableAutostart => {
             let startup_dir = startup_dir()?;
@@ -1544,7 +1505,7 @@ fn main() -> Result<()> {
                 // Check that this file adheres to the schema static config schema as the last step,
                 // so that more basic errors above can be shown to the error before schema-specific
                 // errors
-                let _ = serde_json::from_str::<StaticConfig>(&config_source)?;
+                let _ = serde_json::from_str::<komorebi_client::StaticConfig>(&config_source)?;
 
                 if config_whkd.exists() {
                     println!("Found {}; key bindings will be loaded from here when whkd is started, and you can start it automatically using the --whkd flag\n", config_whkd.to_string_lossy());
@@ -1575,13 +1536,6 @@ fn main() -> Result<()> {
                 println!("{}", static_config.display());
             }
         }
-        SubCommand::BarConfiguration => {
-            let static_config = HOME_DIR.join("komorebi.bar.json");
-
-            if static_config.exists() {
-                println!("{}", static_config.display());
-            }
-        }
         SubCommand::Whkdrc => {
             let whkdrc = WHKD_CONFIG_DIR.join("whkdrc");
 
@@ -1955,13 +1909,9 @@ fn main() -> Result<()> {
                 std::thread::sleep(Duration::from_secs(3));
 
                 let mut system = sysinfo::System::new_all();
-                system.refresh_processes(ProcessesToUpdate::All);
+                system.refresh_processes();
 
-                if system
-                    .processes_by_name("komorebi.exe".as_ref())
-                    .next()
-                    .is_some()
-                {
+                if system.processes_by_name("komorebi.exe").next().is_some() {
                     println!("Started!");
                     running = true;
                 } else {
@@ -2025,23 +1975,6 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                 }
             }
 
-            if arg.bar {
-                let script = r"
-if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
-{
-  Start-Process komorebi-bar -WindowStyle hidden
-}
-                ";
-                match powershell_script::run(script) {
-                    Ok(_) => {
-                        println!("{script}");
-                    }
-                    Err(error) => {
-                        println!("Error: {error}");
-                    }
-                }
-            }
-
             println!("\nThank you for using komorebi!\n");
             println!("* Become a sponsor https://github.com/sponsors/LGUG2Z - Even $1/month makes a big difference");
             println!(
@@ -2050,7 +1983,7 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
             println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
             println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");
 
-            let static_config = arg.config.clone().map_or_else(
+            let static_config = arg.config.map_or_else(
                 || {
                     let komorebi_json = HOME_DIR.join("komorebi.json");
                     if komorebi_json.is_file() {
@@ -2062,30 +1995,12 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
                 Option::from,
             );
 
-            let bar_config = arg.config.map_or_else(
-                || {
-                    let bar_json = HOME_DIR.join("komorebi.bar.json");
-                    if bar_json.is_file() {
-                        Option::from(bar_json)
-                    } else {
-                        None
-                    }
-                },
-                Option::from,
-            );
-
             if let Some(config) = static_config {
                 let path = resolve_home_path(config)?;
                 let raw = std::fs::read_to_string(path)?;
                 StaticConfig::aliases(&raw);
                 StaticConfig::deprecated(&raw);
             }
-
-            if bar_config.is_some() {
-                let output = Command::new("komorebi-bar.exe").arg("--aliases").output()?;
-                let stdout = String::from_utf8(output.stdout)?;
-                println!("{stdout}");
-            }
         }
         SubCommand::Stop(arg) => {
             if arg.whkd {
@@ -2102,25 +2017,11 @@ Stop-Process -Name:whkd -ErrorAction SilentlyContinue
                 }
             }
 
-            if arg.bar {
-                let script = r"
-Stop-Process -Name:komorebi-bar -ErrorAction SilentlyContinue
-                ";
-                match powershell_script::run(script) {
-                    Ok(_) => {
-                        println!("{script}");
-                    }
-                    Err(error) => {
-                        println!("Error: {error}");
-                    }
-                }
-            }
-
             send_message(&SocketMessage::Stop)?;
             let mut system = sysinfo::System::new_all();
-            system.refresh_processes(ProcessesToUpdate::All);
+            system.refresh_processes();
 
-            if system.processes_by_name("komorebi.exe".as_ref()).count() >= 1 {
+            if system.processes_by_name("komorebi.exe").count() >= 1 {
                 println!("komorebi is still running, attempting to force-quit");
 
                 let script = r"
@@ -2137,7 +2038,7 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
                         let hwnds: Vec<isize> = serde_json::from_reader(reader)?;
 
                         for hwnd in hwnds {
-                            restore_window(hwnd);
+                            restore_window(HWND(hwnd));
                         }
                     }
                     Err(error) => {
@@ -2316,7 +2217,7 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
             let hwnds: Vec<isize> = serde_json::from_reader(reader)?;
 
             for hwnd in hwnds {
-                restore_window(hwnd);
+                restore_window(HWND(hwnd));
             }
         }
         SubCommand::ResizeEdge(resize) => {
@@ -2331,9 +2232,6 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
                 arg.boolean_state.into(),
             ))?;
         }
-        SubCommand::ReplaceConfiguration(arg) => {
-            send_message(&SocketMessage::ReplaceConfiguration(arg.path))?;
-        }
         SubCommand::ReloadConfiguration => {
             send_message(&SocketMessage::ReloadConfiguration)?;
         }
@@ -2567,31 +2465,16 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
             );
         }
         SubCommand::ApplicationSpecificConfigurationSchema => {
-            let asc = schema_for!(Vec<ApplicationConfiguration>);
-            let schema = serde_json::to_string_pretty(&asc)?;
-            println!("{schema}");
+            print_query(&SocketMessage::ApplicationSpecificConfigurationSchema);
         }
         SubCommand::NotificationSchema => {
-            let notification = schema_for!(Notification);
-            let schema = serde_json::to_string_pretty(&notification)?;
-            println!("{schema}");
+            print_query(&SocketMessage::NotificationSchema);
         }
         SubCommand::SocketSchema => {
-            let socket_message = schema_for!(SocketMessage);
-            let schema = serde_json::to_string_pretty(&socket_message)?;
-            println!("{schema}");
+            print_query(&SocketMessage::SocketSchema);
         }
         SubCommand::StaticConfigSchema => {
-            let settings = SchemaSettings::default().with(|s| {
-                s.option_nullable = false;
-                s.option_add_null_type = false;
-                s.inline_subschemas = true;
-            });
-
-            let gen = settings.into_generator();
-            let socket_message = gen.into_root_schema_for::<StaticConfig>();
-            let schema = serde_json::to_string_pretty(&socket_message)?;
-            println!("{schema}");
+            print_query(&SocketMessage::StaticConfigSchema);
         }
         SubCommand::GenerateStaticConfig => {
             print_query(&SocketMessage::GenerateStaticConfig);
@@ -2608,17 +2491,14 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
 fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
     // BOOL is returned but does not signify whether or not the operation was succesful
     // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow
-    // TODO: error handling
-    unsafe {
-        let _ = ShowWindow(hwnd, command);
-    };
+    unsafe { ShowWindow(hwnd, command) };
 }
 
-fn remove_transparency(hwnd: isize) {
-    let _ = komorebi_client::Window::from(hwnd).opaque();
+fn remove_transparency(hwnd: HWND) {
+    let _ = komorebi_client::Window::from(hwnd.0).opaque();
 }
 
-fn restore_window(hwnd: isize) {
-    show_window(HWND(hwnd as *mut core::ffi::c_void), SW_RESTORE);
+fn restore_window(hwnd: HWND) {
+    show_window(hwnd, SW_RESTORE);
     remove_transparency(hwnd);
 }

mkdocs.yml

@@ -73,14 +73,12 @@ nav:
   - Release notes:
       - release/v0-1-22.md
   - Configuration reference: https://komorebi.lgug2z.com/schema
-  - Bar reference: https://komorebi-bar.lgug2z.com/schema
   - CLI reference:
       - cli/quickstart.md
       - cli/start.md
       - cli/stop.md
       - cli/check.md
       - cli/configuration.md
-      - cli/bar-configuration.md
       - cli/whkdrc.md
       - cli/state.md
       - cli/global-state.md
@@ -105,13 +103,12 @@ nav:
       - cli/cycle-focus.md
       - cli/cycle-move.md
       - cli/stack.md
-      - cli/unstack.md
-      - cli/cycle-stack.md
-      - cli/focus-stack-window.md
       - cli/stack-all.md
       - cli/unstack-all.md
       - cli/resize-edge.md
       - cli/resize-axis.md
+      - cli/unstack.md
+      - cli/cycle-stack.md
       - cli/move-to-monitor.md
       - cli/cycle-move-to-monitor.md
       - cli/move-to-workspace.md
@@ -182,7 +179,6 @@ nav:
       - cli/restore-windows.md
       - cli/manage.md
       - cli/unmanage.md
-      - cli/replace-configuration.md
       - cli/reload-configuration.md
       - cli/watch-configuration.md
       - cli/complete-configuration.md
@@ -212,11 +208,6 @@ nav:
       - cli/border-implementation.md
       - cli/transparency.md
       - cli/transparency-alpha.md
-      - cli/toggle-transparency.md
-      - cli/animation.md
-      - cli/animation-duration.md
-      - cli/animation-fps.md
-      - cli/animation-style.md
       - cli/focus-follows-mouse.md
       - cli/toggle-focus-follows-mouse.md
       - cli/mouse-follows-focus.md

schema.asc.json

@@ -19,7 +19,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/definitions/MatchingRule"
+            "$ref": "#/definitions/IdWithIdentifierAndComment"
           }
         },
         "identifier": {
@@ -53,9 +53,9 @@
       "enum": [
         "object_name_change",
         "layered",
+        "border_overflow",
         "tray_and_multi_window",
-        "force",
-        "border_overflow"
+        "force"
       ]
     },
     "IdWithIdentifier": {
@@ -83,18 +83,36 @@
         }
       }
     },
-    "MatchingRule": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/IdWithIdentifier"
+    "IdWithIdentifierAndComment": {
+      "type": "object",
+      "required": [
+        "id",
+        "kind"
+      ],
+      "properties": {
+        "comment": {
+          "type": [
+            "string",
+            "null"
+          ]
         },
-        {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/IdWithIdentifier"
-          }
+        "id": {
+          "type": "string"
+        },
+        "kind": {
+          "$ref": "#/definitions/ApplicationIdentifier"
+        },
+        "matching_strategy": {
+          "anyOf": [
+            {
+              "$ref": "#/definitions/MatchingStrategy"
+            },
+            {
+              "type": "null"
+            }
+          ]
         }
-      ]
+      }
     },
     "MatchingStrategy": {
       "type": "string",
@@ -104,11 +122,7 @@
         "StartsWith",
         "EndsWith",
         "Contains",
-        "Regex",
-        "DoesNotEndWith",
-        "DoesNotStartWith",
-        "DoesNotEqual",
-        "DoesNotContain"
+        "Regex"
       ]
     }
   }

schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "StaticConfig",
-  "description": "The `komorebi.json` static configuration file reference for `v0.1.30`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.28`",
   "type": "object",
   "properties": {
     "animation": {
@@ -236,7 +236,7 @@
       }
     },
     "border_implementation": {
-      "description": "Active window border implementation (default: Komorebi)",
+      "description": "Display an active window border (default: false)",
       "oneOf": [
         {
           "description": "Use the adjustable komorebi border implementation",
@@ -383,25 +383,6 @@
         "TopMost"
       ]
     },
-    "cross_boundary_behaviour": {
-      "description": "Determine what happens when an action is called on a window at a monitor boundary (default: Monitor)",
-      "oneOf": [
-        {
-          "description": "Attempt to perform actions across a workspace boundary",
-          "type": "string",
-          "enum": [
-            "Workspace"
-          ]
-        },
-        {
-          "description": "Attempt to perform actions across a monitor boundary",
-          "type": "string",
-          "enum": [
-            "Monitor"
-          ]
-        }
-      ]
-    },
     "cross_monitor_move_behaviour": {
       "description": "Determine what happens when a window is moved across a monitor boundary (default: Swap)",
       "oneOf": [
@@ -1157,7 +1138,7 @@
           "format": "int32"
         },
         "label": {
-          "description": "Stackbar label",
+          "description": "Stackbar height",
           "type": "string",
           "enum": [
             "Process",
@@ -1312,760 +1293,6 @@
         }
       }
     },
-    "theme": {
-      "description": "Theme configuration options",
-      "oneOf": [
-        {
-          "description": "A theme from catppuccin-egui",
-          "type": "object",
-          "required": [
-            "name",
-            "palette"
-          ],
-          "properties": {
-            "bar_accent": {
-              "description": "Komorebi status bar accent (default: Blue)",
-              "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"
-              ]
-            },
-            "monocle_border": {
-              "description": "Border colour when the container is in monocle mode (default: Pink)",
-              "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"
-              ]
-            },
-            "name": {
-              "description": "Name of the Catppuccin theme",
-              "type": "string",
-              "enum": [
-                "Frappe",
-                "Latte",
-                "Macchiato",
-                "Mocha"
-              ]
-            },
-            "palette": {
-              "type": "string",
-              "enum": [
-                "Catppuccin"
-              ]
-            },
-            "single_border": {
-              "description": "Border colour when the container contains a single window (default: Blue)",
-              "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"
-              ]
-            },
-            "stack_border": {
-              "description": "Border colour when the container contains multiple windows (default: Green)",
-              "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"
-              ]
-            },
-            "stackbar_background": {
-              "description": "Stackbar tab background colour (default: Base)",
-              "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"
-              ]
-            },
-            "stackbar_focused_text": {
-              "description": "Stackbar focused tab text colour (default: Green)",
-              "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"
-              ]
-            },
-            "stackbar_unfocused_text": {
-              "description": "Stackbar unfocused tab text colour (default: Text)",
-              "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"
-              ]
-            },
-            "unfocused_border": {
-              "description": "Border colour when the container is unfocused (default: Base)",
-              "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"
-              ]
-            }
-          }
-        },
-        {
-          "description": "A theme from base16-egui-themes",
-          "type": "object",
-          "required": [
-            "name",
-            "palette"
-          ],
-          "properties": {
-            "bar_accent": {
-              "description": "Komorebi status bar accent (default: Base0D)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "monocle_border": {
-              "description": "Border colour when the container is in monocle mode (default: Base0F)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "name": {
-              "description": "Name of the Base16 theme",
-              "type": "string",
-              "enum": [
-                "3024",
-                "Apathy",
-                "Apprentice",
-                "Ashes",
-                "AtelierCaveLight",
-                "AtelierCave",
-                "AtelierDuneLight",
-                "AtelierDune",
-                "AtelierEstuaryLight",
-                "AtelierEstuary",
-                "AtelierForestLight",
-                "AtelierForest",
-                "AtelierHeathLight",
-                "AtelierHeath",
-                "AtelierLakesideLight",
-                "AtelierLakeside",
-                "AtelierPlateauLight",
-                "AtelierPlateau",
-                "AtelierSavannaLight",
-                "AtelierSavanna",
-                "AtelierSeasideLight",
-                "AtelierSeaside",
-                "AtelierSulphurpoolLight",
-                "AtelierSulphurpool",
-                "Atlas",
-                "AyuDark",
-                "AyuLight",
-                "AyuMirage",
-                "Aztec",
-                "Bespin",
-                "BlackMetalBathory",
-                "BlackMetalBurzum",
-                "BlackMetalDarkFuneral",
-                "BlackMetalGorgoroth",
-                "BlackMetalImmortal",
-                "BlackMetalKhold",
-                "BlackMetalMarduk",
-                "BlackMetalMayhem",
-                "BlackMetalNile",
-                "BlackMetalVenom",
-                "BlackMetal",
-                "Blueforest",
-                "Blueish",
-                "Brewer",
-                "Bright",
-                "Brogrammer",
-                "BrushtreesDark",
-                "Brushtrees",
-                "Caroline",
-                "CatppuccinFrappe",
-                "CatppuccinLatte",
-                "CatppuccinMacchiato",
-                "CatppuccinMocha",
-                "Chalk",
-                "Circus",
-                "ClassicDark",
-                "ClassicLight",
-                "Codeschool",
-                "Colors",
-                "Cupcake",
-                "Cupertino",
-                "DaOneBlack",
-                "DaOneGray",
-                "DaOneOcean",
-                "DaOnePaper",
-                "DaOneSea",
-                "DaOneWhite",
-                "DanqingLight",
-                "Danqing",
-                "Darcula",
-                "Darkmoss",
-                "Darktooth",
-                "Darkviolet",
-                "Decaf",
-                "DefaultDark",
-                "DefaultLight",
-                "Dirtysea",
-                "Dracula",
-                "EdgeDark",
-                "EdgeLight",
-                "Eighties",
-                "EmbersLight",
-                "Embers",
-                "Emil",
-                "EquilibriumDark",
-                "EquilibriumGrayDark",
-                "EquilibriumGrayLight",
-                "EquilibriumLight",
-                "Eris",
-                "Espresso",
-                "EvaDim",
-                "Eva",
-                "EvenokDark",
-                "EverforestDarkHard",
-                "Everforest",
-                "Flat",
-                "Framer",
-                "FruitSoda",
-                "Gigavolt",
-                "Github",
-                "GoogleDark",
-                "GoogleLight",
-                "Gotham",
-                "GrayscaleDark",
-                "GrayscaleLight",
-                "Greenscreen",
-                "Gruber",
-                "GruvboxDarkHard",
-                "GruvboxDarkMedium",
-                "GruvboxDarkPale",
-                "GruvboxDarkSoft",
-                "GruvboxLightHard",
-                "GruvboxLightMedium",
-                "GruvboxLightSoft",
-                "GruvboxMaterialDarkHard",
-                "GruvboxMaterialDarkMedium",
-                "GruvboxMaterialDarkSoft",
-                "GruvboxMaterialLightHard",
-                "GruvboxMaterialLightMedium",
-                "GruvboxMaterialLightSoft",
-                "Hardcore",
-                "Harmonic16Dark",
-                "Harmonic16Light",
-                "HeetchLight",
-                "Heetch",
-                "Helios",
-                "Hopscotch",
-                "HorizonDark",
-                "HorizonLight",
-                "HorizonTerminalDark",
-                "HorizonTerminalLight",
-                "HumanoidDark",
-                "HumanoidLight",
-                "IaDark",
-                "IaLight",
-                "Icy",
-                "Irblack",
-                "Isotope",
-                "Jabuti",
-                "Kanagawa",
-                "Katy",
-                "Kimber",
-                "Lime",
-                "Macintosh",
-                "Marrakesh",
-                "Materia",
-                "MaterialDarker",
-                "MaterialLighter",
-                "MaterialPalenight",
-                "MaterialVivid",
-                "Material",
-                "MeasuredDark",
-                "MeasuredLight",
-                "MellowPurple",
-                "MexicoLight",
-                "Mocha",
-                "Monokai",
-                "Moonlight",
-                "Mountain",
-                "Nebula",
-                "NordLight",
-                "Nord",
-                "Nova",
-                "Ocean",
-                "Oceanicnext",
-                "OneLight",
-                "OnedarkDark",
-                "Onedark",
-                "OutrunDark",
-                "OxocarbonDark",
-                "OxocarbonLight",
-                "Pandora",
-                "PapercolorDark",
-                "PapercolorLight",
-                "Paraiso",
-                "Pasque",
-                "Phd",
-                "Pico",
-                "Pinky",
-                "Pop",
-                "Porple",
-                "PreciousDarkEleven",
-                "PreciousDarkFifteen",
-                "PreciousLightWarm",
-                "PreciousLightWhite",
-                "PrimerDarkDimmed",
-                "PrimerDark",
-                "PrimerLight",
-                "Purpledream",
-                "Qualia",
-                "Railscasts",
-                "Rebecca",
-                "RosePineDawn",
-                "RosePineMoon",
-                "RosePine",
-                "Saga",
-                "Sagelight",
-                "Sakura",
-                "Sandcastle",
-                "SelenizedBlack",
-                "SelenizedDark",
-                "SelenizedLight",
-                "SelenizedWhite",
-                "Seti",
-                "ShadesOfPurple",
-                "ShadesmearDark",
-                "ShadesmearLight",
-                "Shapeshifter",
-                "SilkDark",
-                "SilkLight",
-                "Snazzy",
-                "SolarflareLight",
-                "Solarflare",
-                "SolarizedDark",
-                "SolarizedLight",
-                "Spaceduck",
-                "Spacemacs",
-                "Sparky",
-                "StandardizedDark",
-                "StandardizedLight",
-                "Stella",
-                "StillAlive",
-                "Summercamp",
-                "SummerfruitDark",
-                "SummerfruitLight",
-                "SynthMidnightDark",
-                "SynthMidnightLight",
-                "Tango",
-                "Tarot",
-                "Tender",
-                "TerracottaDark",
-                "Terracotta",
-                "TokyoCityDark",
-                "TokyoCityLight",
-                "TokyoCityTerminalDark",
-                "TokyoCityTerminalLight",
-                "TokyoNightDark",
-                "TokyoNightLight",
-                "TokyoNightMoon",
-                "TokyoNightStorm",
-                "TokyoNightTerminalDark",
-                "TokyoNightTerminalLight",
-                "TokyoNightTerminalStorm",
-                "TokyodarkTerminal",
-                "Tokyodark",
-                "TomorrowNightEighties",
-                "TomorrowNight",
-                "Tomorrow",
-                "Tube",
-                "Twilight",
-                "UnikittyDark",
-                "UnikittyLight",
-                "UnikittyReversible",
-                "Uwunicorn",
-                "Vesper",
-                "Vice",
-                "Vulcan",
-                "Windows10Light",
-                "Windows10",
-                "Windows95Light",
-                "Windows95",
-                "WindowsHighcontrastLight",
-                "WindowsHighcontrast",
-                "WindowsNtLight",
-                "WindowsNt",
-                "Woodland",
-                "XcodeDusk",
-                "Zenbones",
-                "Zenburn"
-              ]
-            },
-            "palette": {
-              "type": "string",
-              "enum": [
-                "Base16"
-              ]
-            },
-            "single_border": {
-              "description": "Border colour when the container contains a single window (default: Base0D)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "stack_border": {
-              "description": "Border colour when the container contains multiple windows (default: Base0B)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "stackbar_background": {
-              "description": "Stackbar tab background colour (default: Base01)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "stackbar_focused_text": {
-              "description": "Stackbar focused tab text colour (default: Base0B)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "stackbar_unfocused_text": {
-              "description": "Stackbar unfocused tab text colour (default: Base05)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            },
-            "unfocused_border": {
-              "description": "Border colour when the container is unfocused (default: Base01)",
-              "type": "string",
-              "enum": [
-                "Base00",
-                "Base01",
-                "Base02",
-                "Base03",
-                "Base04",
-                "Base05",
-                "Base06",
-                "Base07",
-                "Base08",
-                "Base09",
-                "Base0A",
-                "Base0B",
-                "Base0C",
-                "Base0D",
-                "Base0E",
-                "Base0F"
-              ]
-            }
-          }
-        }
-      ]
-    },
     "transparency": {
       "description": "Add transparency to unfocused windows (default: false)",
       "type": "boolean"
@@ -2076,89 +1303,6 @@
       "format": "uint8",
       "minimum": 0.0
     },
-    "transparency_ignore_rules": {
-      "description": "Individual window transparency ignore rules",
-      "type": "array",
-      "items": {
-        "anyOf": [
-          {
-            "type": "object",
-            "required": [
-              "id",
-              "kind"
-            ],
-            "properties": {
-              "id": {
-                "type": "string"
-              },
-              "kind": {
-                "type": "string",
-                "enum": [
-                  "Exe",
-                  "Class",
-                  "Title",
-                  "Path"
-                ]
-              },
-              "matching_strategy": {
-                "type": "string",
-                "enum": [
-                  "Legacy",
-                  "Equals",
-                  "StartsWith",
-                  "EndsWith",
-                  "Contains",
-                  "Regex",
-                  "DoesNotEndWith",
-                  "DoesNotStartWith",
-                  "DoesNotEqual",
-                  "DoesNotContain"
-                ]
-              }
-            }
-          },
-          {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "required": [
-                "id",
-                "kind"
-              ],
-              "properties": {
-                "id": {
-                  "type": "string"
-                },
-                "kind": {
-                  "type": "string",
-                  "enum": [
-                    "Exe",
-                    "Class",
-                    "Title",
-                    "Path"
-                  ]
-                },
-                "matching_strategy": {
-                  "type": "string",
-                  "enum": [
-                    "Legacy",
-                    "Equals",
-                    "StartsWith",
-                    "EndsWith",
-                    "Contains",
-                    "Regex",
-                    "DoesNotEndWith",
-                    "DoesNotStartWith",
-                    "DoesNotEqual",
-                    "DoesNotContain"
-                  ]
-                }
-              }
-            }
-          }
-        ]
-      }
-    },
     "tray_and_multi_window_applications": {
       "description": "Identify tray and multi-window applications",
       "type": "array",

wix/main.wxs

@@ -98,9 +98,6 @@
             <Component Id='binary3' Guid='*'>
               <File Id='exe3' Name='komorebi-gui.exe' DiskId='1' Source='$(var.CargoTargetBinDir)\komorebi-gui.exe' KeyPath='yes' />
             </Component>
-            <Component Id='binary4' Guid='*'>
-              <File Id='exe4' Name='komorebi-bar.exe' DiskId='1' Source='$(var.CargoTargetBinDir)\komorebi-bar.exe' KeyPath='yes' />
-            </Component>
           </Directory>
         </Directory>
       </Directory>
@@ -121,8 +118,6 @@
 
       <ComponentRef Id='binary3' />
 
-      <ComponentRef Id='binary4' />
-
       <Feature Id='Environment' Title='PATH Environment Variable' Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.' Level='1' Absent='allow'>
         <ComponentRef Id='Path' />
       </Feature>