feat(animation): add window animations

Work on this feature was first started by @thearturca in November 2023
before komorebi v0.1.21 in #597 and has undergone numerous revisions
to reach the point of this commit.

Although this is a single squashed commit, almost all of the heavy
lifting for this feature was done by @thearturca, which is where all of
the kudos and gratitude should be directed.

This commit adds a new static configuration block for animations, where
they can be enabled, and have their style, fps and duration set.
Corresponding SocketMessages and komorebic cli commands have also been
exposed.

There are some caveats to the use of this feature, which revolve around
the quality of the Windows compositor (it is not very good):

* There will be visual artifacts with various apps when animations are
  taking place - komorebi can't do anything about this as it is a
  limitation of the Windows compositor
* Since komorebi's borders are implemented as independent windows are
  are not a part of the windows they are drawn around, these borders
  will be hidden while animations are in progress
* If you wish to use borders with this feature, you'll probably better
  off using BorderImplementation::Windows, which uses the native thin
  "accent" borders, which are part of the windows they are drawn around,
  and can be moved with those windows during animations

As a result of these and other caveats, this feature will be marked as
"experimental" for the foreseeable future and will be off-by-default.

Below, a number of now-squashed commits that contributed to the
stabilization of this feature are referenced to help with code
archeology in the future.

fix(animation): Fixed cancelling logic
(57e9b2f4bcaedb4fdfa71adf785d661690d81dfc)

Added static animation state manager for tracking "in_progress" and
"is_cancelled" states. The idea is not to have states in Animation
struct but to keep them in HashMap<hwnd, AnimationState> behind
reference (Arc<Mutex<>>). So we each animation frame we have access to
state and can cancel animation if we have to.

Need review and testings

refactor(animation): avoid unwrap
(fa6d5bbc77c1882f85ee1ce73733ff7e53b39eaa)

fix(animation): Move cancel call to Animation struct
(306513f5dbe5f6bd6ce817f3edca0bfda13d9442)

Only focused window was cancelling its animation because we call cancel
in window::set_position and waiting for its cancelling. And because we
waiting for cancelling second window is still moving. Second window will stop
moving only after the first window. So I moved `cancel` call to
Animation struct so its happening in its own thread and doesn't block
others animation moves and cancels.

refactor(animation): renamed args parameters and variables names
(8abb4b9618bbb3823b868fc37551f0a70b98281e)

refactor(animation): inverse if-statement in `window::animate_position`
(3de2c6e932614651892da4a8c626946e427375dd)

There is was a bug when ease function generates `t` greater the
`SetWindowPos` function will be called instead of `move_window`.
`SetWindowPos` is only for last frame of animation.

fix(wm): add shadow rect to `move_window` calls
(b58620fb4de36d8e422a80541bedf9c1c1579a31)

This fixes a bug when windows get shunk during the animation

.github/workflows/windows.yaml

@@ -14,14 +14,16 @@ on:
     tags:
       - v*
   schedule:
-    - cron: "30 0 * * 1" # Every Monday at half past midnight UTC
+    - cron: "30 0 * * 0" # Every day at 00:30 UTC
 
 jobs:
   build:
     name: Build
     runs-on: windows-latest
+    permissions: write-all
     env:
       RUSTFLAGS: -Ctarget-feature=+crt-static
+      GH_TOKEN: ${{ github.token }}
     strategy:
       fail-fast: false
       matrix:
@@ -96,15 +98,36 @@ jobs:
             target/${{ matrix.target }}/release/komorebi-gui.exe
             target/${{ matrix.target }}/release/komorebi.pdb
             target/${{ matrix.target }}/release/komorebic.pdb
-            target/${{ matrix.target }}/release/komorebi-gui.pdb
+            target/${{ matrix.target }}/release/komorebi_gui.pdb
             target/wix/komorebi-*.msi
           retention-days: 7
       - name: Check GoReleaser
         uses: goreleaser/goreleaser-action@v3
+        env:
+          GORELEASER_CURRENT_TAG: v0.1.28
         with:
           version: latest
           args: build --skip=validate --clean
-
+      - name: Prepare nightly artifacts
+        if: ${{ github.ref == 'refs/heads/master' && github.event_name == 'schedule' }}
+        run: |
+          Compress-Archive .\target\${{ matrix.target }}\release\*.exe komorebi-nightly-x86_64-pc-windows-msvc.zip
+          Copy-Item ./target/wix/*.msi -Destination ./komorebi-nightly-x86_64.msi
+          echo "$((Get-FileHash komorebi-nightly-x86_64-pc-windows-msvc.zip).Hash.ToLower())  komorebi-nightly-x86_64-pc-windows-msvc.zip" >checksums.txt
+      - name: Update nightly
+        if: ${{ github.ref == 'refs/heads/master' && github.event_name == 'schedule' }}
+        shell: bash
+        run: |
+          gh release delete nightly --yes || true
+          git push origin :nightly || true
+          gh release create nightly \
+            --target $GITHUB_SHA \
+            --prerelease \
+            --title "komorebi nightly (${GITHUB_SHA})" \
+            --notes "This nightly release of komorebi corresponds to [this commit](https://github.com/LGUG2Z/komorebi/commit/${GITHUB_SHA})." \
+            komorebi-nightly-x86_64-pc-windows-msvc.zip \
+            komorebi-nightly-x86_64.msi \
+            checksums.txt
       # Release
       - name: Generate changelog
         if: startsWith(github.ref, 'refs/tags/v')

Cargo.toml

@@ -21,6 +21,7 @@ uds_windows = "1"
 win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "2a0f7166da154880a1750b91829b1186d9c6a00c" }
 windows-implement = { version = "0.53" }
 windows-interface = { version = "0.53" }
+shadow-rs = "0.29"
 
 [workspace.dependencies.windows]
 version = "0.54"
@@ -40,5 +41,6 @@ features = [
     "Win32_UI_Shell",
     "Win32_UI_Shell_Common",
     "Win32_UI_WindowsAndMessaging",
-    "Win32_System_SystemServices"
+    "Win32_System_SystemServices",
+    "Win32_System_WindowsProgramming"
 ]

README.md

@@ -60,7 +60,7 @@ channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
 _komorebi_ development videos. If you would like to be notified of upcoming
 videos please subscribe and turn on notifications.
 
-_komorebi_ is a free and open-source project, and one that encourages you to
+_komorebi_ is a free and source-available project, and one that encourages you to
 make charitable donations if you find the software to be useful and have the
 financial means.
 
@@ -99,6 +99,13 @@ video will answer the majority of your questions.
 
 # Demonstrations
 
+[@amnweb](https://github.com/amnweb) showing _komorebi_ `v0.1.28-dev.0` running on Windows 11 with window borders,
+unfocused window transparency and animations enabled, using a custom status bar integrated using
+_komorebi_'s [Window Manager Event Subscriptions](https://github.com/LGUG2Z/komorebi?tab=readme-ov-file#window-manager-event-subscriptions).
+
+https://github.com/LGUG2Z/komorebi/assets/13164844/21be8dc4-fa76-4f70-9b37-1d316f4b40c2
+
+
 [@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
 11 with a terminal emulator, a web browser and a code editor. The original
 video can be viewed

komorebi-client/Cargo.toml

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

komorebi-core/Cargo.toml

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

komorebi-core/src/animation.rs

@@ -0,0 +1,42 @@
+use clap::ValueEnum;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use strum::Display;
+use strum::EnumString;
+
+#[derive(
+    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+)]
+pub enum AnimationStyle {
+    Linear,
+    EaseInSine,
+    EaseOutSine,
+    EaseInOutSine,
+    EaseInQuad,
+    EaseOutQuad,
+    EaseInOutQuad,
+    EaseInCubic,
+    EaseInOutCubic,
+    EaseInQuart,
+    EaseOutQuart,
+    EaseInOutQuart,
+    EaseInQuint,
+    EaseOutQuint,
+    EaseInOutQuint,
+    EaseInExpo,
+    EaseOutExpo,
+    EaseInOutExpo,
+    EaseInCirc,
+    EaseOutCirc,
+    EaseInOutCirc,
+    EaseInBack,
+    EaseOutBack,
+    EaseInOutBack,
+    EaseInElastic,
+    EaseOutElastic,
+    EaseInOutElastic,
+    EaseInBounce,
+    EaseOutBounce,
+    EaseInOutBounce,
+}

komorebi-core/src/lib.rs

@@ -14,6 +14,7 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
+pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
 pub use custom_layout::CustomLayout;
@@ -24,6 +25,7 @@ pub use layout::Layout;
 pub use operation_direction::OperationDirection;
 pub use rect::Rect;
 
+pub mod animation;
 pub mod arrangement;
 pub mod config_generation;
 pub mod custom_layout;
@@ -134,6 +136,10 @@ pub enum SocketMessage {
     WatchConfiguration(bool),
     CompleteConfiguration,
     AltFocusHack(bool),
+    Animation(bool),
+    AnimationDuration(u64),
+    AnimationFps(u64),
+    AnimationStyle(AnimationStyle),
     #[serde(alias = "ActiveWindowBorder")]
     Border(bool),
     #[serde(alias = "ActiveWindowBorderColour")]
@@ -142,6 +148,7 @@ pub enum SocketMessage {
     BorderStyle(BorderStyle),
     BorderWidth(i32),
     BorderOffset(i32),
+    BorderImplementation(BorderImplementation),
     Transparency(bool),
     TransparencyAlpha(u8),
     InvisibleBorders(Rect),
@@ -152,6 +159,8 @@ pub enum SocketMessage {
     StackbarBackgroundColour(u32, u32, u32),
     StackbarHeight(i32),
     StackbarTabWidth(i32),
+    StackbarFontSize(i32),
+    StackbarFontFamily(Option<String>),
     WorkAreaOffset(Rect),
     MonitorWorkAreaOffset(usize, Rect),
     ResizeDelta(i32),
@@ -159,6 +168,9 @@ pub enum SocketMessage {
     InitialNamedWorkspaceRule(ApplicationIdentifier, String, String),
     WorkspaceRule(ApplicationIdentifier, String, usize, usize),
     NamedWorkspaceRule(ApplicationIdentifier, String, String),
+    ClearWorkspaceRules(usize, usize),
+    ClearNamedWorkspaceRules(String),
+    ClearAllWorkspaceRules,
     FloatRule(ApplicationIdentifier, String),
     ManageRule(ApplicationIdentifier, String),
     IdentifyObjectNameChangeApplication(ApplicationIdentifier, String),
@@ -219,7 +231,17 @@ pub enum StackbarLabel {
 }
 
 #[derive(
-    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
+    Default,
+    Copy,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Display,
+    Serialize,
+    Deserialize,
+    JsonSchema,
+    ValueEnum,
 )]
 pub enum BorderStyle {
     #[default]
@@ -231,6 +253,27 @@ pub enum BorderStyle {
     Square,
 }
 
+#[derive(
+    Default,
+    Copy,
+    Clone,
+    Debug,
+    Eq,
+    PartialEq,
+    Display,
+    Serialize,
+    Deserialize,
+    JsonSchema,
+    ValueEnum,
+)]
+pub enum BorderImplementation {
+    #[default]
+    /// Use the adjustable komorebi border implementation
+    Komorebi,
+    /// Use the thin Windows accent border implementation
+    Windows,
+}
+
 #[derive(
     Copy,
     Clone,
@@ -324,7 +367,7 @@ pub enum HidingBehaviour {
     Hide,
     /// Use the SW_MINIMIZE flag to hide windows when switching workspaces (has issues with frequent workspace switching)
     Minimize,
-    /// Use the undocumented SetCloak Win32 function to hide windows when switching workspaces (has foregrounding issues)
+    /// Use the undocumented SetCloak Win32 function to hide windows when switching workspaces
     Cloak,
 }
 

komorebi-core/src/rect.rs

@@ -84,4 +84,14 @@ impl Rect {
             bottom: (self.bottom * rect_dpi) / system_dpi,
         }
     }
+
+    #[must_use]
+    pub const fn rect(&self) -> RECT {
+        RECT {
+            left: self.left,
+            top: self.top,
+            right: self.left + self.right,
+            bottom: self.top + self.bottom,
+        }
+    }
 }

komorebi-gui/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.27"
+version = "0.1.28-dev.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-egui_extras = { version = "0.27" }
-eframe = "0.27"
+egui_extras = { version = "0.28" }
+eframe = "0.28"
 komorebi-client = { path = "../komorebi-client" }
 serde_json = "1"
 random_word = { version = "0.4.3", features = ["en"] }

komorebi-gui/src/main.rs

@@ -34,7 +34,7 @@ fn main() {
     let _ = eframe::run_native(
         "komorebi-gui",
         native_options,
-        Box::new(|cc| Box::new(KomorebiGui::new(cc))),
+        Box::new(|cc| Ok(Box::new(KomorebiGui::new(cc)))),
     );
 }
 
@@ -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 { hwnd: hwnd.0 };
+    let window = Window::from(hwnd.0);
 
     if window.is_window()
         && !window.is_miminized()
@@ -246,9 +246,7 @@ impl eframe::App for KomorebiGui {
                 ui.set_width(ctx.screen_rect().width());
                 ui.collapsing("Debugging", |ui| {
                     ui.collapsing("Window Rules", |ui| {
-                        let window = Window {
-                            hwnd: self.debug_hwnd,
-                        };
+                        let window = Window::from(self.debug_hwnd);
 
                         let label = if let (Ok(title), Ok(exe)) = (window.title(), window.exe()) {
                             format!("{title} ({exe})")

komorebi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.27"
+version = "0.1.28-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -48,6 +48,10 @@ windows-implement = { workspace = true }
 windows-interface = { workspace = true }
 winput = "0.2"
 winreg = "0.52"
+shadow-rs = { workspace = true }
+
+[build-dependencies]
+shadow-rs = { workspace = true }
 
 [features]
 deadlock_detection = ["parking_lot/deadlock_detection"]

komorebi/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    shadow_rs::new().unwrap();
+}

komorebi/src/animation.rs

@@ -0,0 +1,503 @@
+use color_eyre::Result;
+use komorebi_core::AnimationStyle;
+use komorebi_core::Rect;
+
+use schemars::JsonSchema;
+
+use serde::Deserialize;
+use serde::Serialize;
+use std::f64::consts::PI;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+use std::time::Instant;
+
+use crate::ANIMATION_DURATION;
+use crate::ANIMATION_MANAGER;
+use crate::ANIMATION_STYLE;
+
+pub static ANIMATION_FPS: AtomicU64 = AtomicU64::new(60);
+
+pub trait Ease {
+    fn evaluate(t: f64) -> f64;
+}
+
+pub struct Linear;
+
+impl Ease for Linear {
+    fn evaluate(t: f64) -> f64 {
+        t
+    }
+}
+
+pub struct EaseInSine;
+
+impl Ease for EaseInSine {
+    fn evaluate(t: f64) -> f64 {
+        1.0 - f64::cos((t * PI) / 2.0)
+    }
+}
+
+pub struct EaseOutSine;
+
+impl Ease for EaseOutSine {
+    fn evaluate(t: f64) -> f64 {
+        f64::sin((t * PI) / 2.0)
+    }
+}
+
+pub struct EaseInOutSine;
+
+impl Ease for EaseInOutSine {
+    fn evaluate(t: f64) -> f64 {
+        -(f64::cos(PI * t) - 1.0) / 2.0
+    }
+}
+
+pub struct EaseInQuad;
+
+impl Ease for EaseInQuad {
+    fn evaluate(t: f64) -> f64 {
+        t * t
+    }
+}
+
+pub struct EaseOutQuad;
+
+impl Ease for EaseOutQuad {
+    fn evaluate(t: f64) -> f64 {
+        (1.0 - t).mul_add(-1.0 - t, 1.0)
+    }
+}
+
+pub struct EaseInOutQuad;
+
+impl Ease for EaseInOutQuad {
+    fn evaluate(t: f64) -> f64 {
+        if t < 0.5 {
+            2.0 * t * t
+        } else {
+            1.0 - (-2.0f64).mul_add(t, 2.0).powi(2) / 2.0
+        }
+    }
+}
+
+pub struct EaseInCubic;
+
+impl Ease for EaseInCubic {
+    fn evaluate(t: f64) -> f64 {
+        t * t * t
+    }
+}
+
+pub struct EaseOutCubic;
+
+impl Ease for EaseOutCubic {
+    fn evaluate(t: f64) -> f64 {
+        1.0 - (1.0 - t).powi(3)
+    }
+}
+
+pub struct EaseInOutCubic;
+
+impl Ease for EaseInOutCubic {
+    fn evaluate(t: f64) -> f64 {
+        if t < 0.5 {
+            4.0 * t * t * t
+        } else {
+            1.0 - (-2.0f64).mul_add(t, 2.0).powi(3) / 2.0
+        }
+    }
+}
+
+pub struct EaseInQuart;
+
+impl Ease for EaseInQuart {
+    fn evaluate(t: f64) -> f64 {
+        t * t * t * t
+    }
+}
+
+pub struct EaseOutQuart;
+
+impl Ease for EaseOutQuart {
+    fn evaluate(t: f64) -> f64 {
+        1.0 - (1.0 - t).powi(4)
+    }
+}
+
+pub struct EaseInOutQuart;
+
+impl Ease for EaseInOutQuart {
+    fn evaluate(t: f64) -> f64 {
+        if t < 0.5 {
+            8.0 * t * t * t * t
+        } else {
+            1.0 - (-2.0f64).mul_add(t, 2.0).powi(4) / 2.0
+        }
+    }
+}
+
+pub struct EaseInQuint;
+
+impl Ease for EaseInQuint {
+    fn evaluate(t: f64) -> f64 {
+        t * t * t * t * t
+    }
+}
+
+pub struct EaseOutQuint;
+
+impl Ease for EaseOutQuint {
+    fn evaluate(t: f64) -> f64 {
+        1.0 - (1.0 - t).powi(5)
+    }
+}
+
+pub struct EaseInOutQuint;
+
+impl Ease for EaseInOutQuint {
+    fn evaluate(t: f64) -> f64 {
+        if t < 0.5 {
+            16.0 * t * t * t * t
+        } else {
+            1.0 - (-2.0f64).mul_add(t, 2.0).powi(5) / 2.0
+        }
+    }
+}
+
+pub struct EaseInExpo;
+
+impl Ease for EaseInExpo {
+    fn evaluate(t: f64) -> f64 {
+        if t == 0.0 {
+            return t;
+        }
+
+        10.0f64.mul_add(t, -10.0).exp2()
+    }
+}
+
+pub struct EaseOutExpo;
+
+impl Ease for EaseOutExpo {
+    fn evaluate(t: f64) -> f64 {
+        if (t - 1.0).abs() < f64::EPSILON {
+            return t;
+        }
+
+        1.0 - (-10.0 * t).exp2()
+    }
+}
+
+pub struct EaseInOutExpo;
+
+impl Ease for EaseInOutExpo {
+    fn evaluate(t: f64) -> f64 {
+        if t == 0.0 || (t - 1.0).abs() < f64::EPSILON {
+            return t;
+        }
+
+        if t < 0.5 {
+            20.0f64.mul_add(t, -10.0).exp2() / 2.0
+        } else {
+            (2.0 - (-20.0f64).mul_add(t, 10.0).exp2()) / 2.0
+        }
+    }
+}
+
+pub struct EaseInCirc;
+
+impl Ease for EaseInCirc {
+    fn evaluate(t: f64) -> f64 {
+        1.0 - f64::sqrt(t.mul_add(-t, 1.0))
+    }
+}
+
+pub struct EaseOutCirc;
+
+impl Ease for EaseOutCirc {
+    fn evaluate(t: f64) -> f64 {
+        f64::sqrt((t - 1.0).mul_add(-(t - 1.0), 1.0))
+    }
+}
+
+pub struct EaseInOutCirc;
+
+impl Ease for EaseInOutCirc {
+    fn evaluate(t: f64) -> f64 {
+        if t < 0.5 {
+            (1.0 - f64::sqrt((2.0 * t).mul_add(-(2.0 * t), 1.0))) / 2.0
+        } else {
+            (f64::sqrt(
+                (-2.0f64)
+                    .mul_add(t, 2.0)
+                    .mul_add(-(-2.0f64).mul_add(t, 2.0), 1.0),
+            ) + 1.0)
+                / 2.0
+        }
+    }
+}
+
+pub struct EaseInBack;
+
+impl Ease for EaseInBack {
+    fn evaluate(t: f64) -> f64 {
+        let c1 = 1.70158;
+        let c3 = c1 + 1.0;
+
+        (c3 * t * t).mul_add(t, -c1 * t * t)
+    }
+}
+
+pub struct EaseOutBack;
+
+impl Ease for EaseOutBack {
+    fn evaluate(t: f64) -> f64 {
+        let c1: f64 = 1.70158;
+        let c3: f64 = c1 + 1.0;
+
+        c1.mul_add((t - 1.0).powi(2), c3.mul_add((t - 1.0).powi(3), 1.0))
+    }
+}
+
+pub struct EaseInOutBack;
+
+impl Ease for EaseInOutBack {
+    fn evaluate(t: f64) -> f64 {
+        let c1: f64 = 1.70158;
+        let c2: f64 = c1 * 1.525;
+
+        if t < 0.5 {
+            ((2.0 * t).powi(2) * ((c2 + 1.0) * 2.0).mul_add(t, -c2)) / 2.0
+        } else {
+            ((2.0f64.mul_add(t, -2.0))
+                .powi(2)
+                .mul_add((c2 + 1.0).mul_add(t.mul_add(2.0, -2.0), c2), 2.0))
+                / 2.0
+        }
+    }
+}
+
+pub struct EaseInElastic;
+
+impl Ease for EaseInElastic {
+    fn evaluate(t: f64) -> f64 {
+        if (t - 1.0).abs() < f64::EPSILON || t == 0.0 {
+            return t;
+        }
+
+        let c4 = (2.0 * PI) / 3.0;
+
+        -(10.0f64.mul_add(t, -10.0).exp2()) * f64::sin(t.mul_add(10.0, -10.75) * c4)
+    }
+}
+
+pub struct EaseOutElastic;
+
+impl Ease for EaseOutElastic {
+    fn evaluate(t: f64) -> f64 {
+        if (t - 1.0).abs() < f64::EPSILON || t == 0.0 {
+            return t;
+        }
+
+        let c4 = (2.0 * PI) / 3.0;
+
+        (-10.0 * t)
+            .exp2()
+            .mul_add(f64::sin(t.mul_add(10.0, -0.75) * c4), 1.0)
+    }
+}
+
+pub struct EaseInOutElastic;
+
+impl Ease for EaseInOutElastic {
+    fn evaluate(t: f64) -> f64 {
+        if (t - 1.0).abs() < f64::EPSILON || t == 0.0 {
+            return t;
+        }
+
+        let c5 = (2.0 * PI) / 4.5;
+
+        if t < 0.5 {
+            -(20.0f64.mul_add(t, -10.0).exp2() * f64::sin(20.0f64.mul_add(t, -11.125) * c5)) / 2.0
+        } else {
+            ((-20.0f64).mul_add(t, 10.0).exp2() * f64::sin(20.0f64.mul_add(t, -11.125) * c5)) / 2.0
+                + 1.0
+        }
+    }
+}
+
+pub struct EaseInBounce;
+
+impl Ease for EaseInBounce {
+    fn evaluate(t: f64) -> f64 {
+        1.0 - EaseOutBounce::evaluate(1.0 - t)
+    }
+}
+
+pub struct EaseOutBounce;
+
+impl Ease for EaseOutBounce {
+    fn evaluate(t: f64) -> f64 {
+        let mut time = t;
+        let n1 = 7.5625;
+        let d1 = 2.75;
+
+        if t < 1.0 / d1 {
+            n1 * time * time
+        } else if time < 2.0 / d1 {
+            time -= 1.5 / d1;
+            (n1 * time).mul_add(time, 0.75)
+        } else if time < 2.5 / d1 {
+            time -= 2.25 / d1;
+            (n1 * time).mul_add(time, 0.9375)
+        } else {
+            time -= 2.625 / d1;
+            (n1 * time).mul_add(time, 0.984_375)
+        }
+    }
+}
+
+pub struct EaseInOutBounce;
+
+impl Ease for EaseInOutBounce {
+    fn evaluate(t: f64) -> f64 {
+        if t < 0.5 {
+            (1.0 - EaseOutBounce::evaluate(2.0f64.mul_add(-t, 1.0))) / 2.0
+        } else {
+            (1.0 + EaseOutBounce::evaluate(2.0f64.mul_add(t, -1.0))) / 2.0
+        }
+    }
+}
+fn apply_ease_func(t: f64) -> f64 {
+    let style = *ANIMATION_STYLE.lock();
+
+    match style {
+        AnimationStyle::Linear => Linear::evaluate(t),
+        AnimationStyle::EaseInSine => EaseInSine::evaluate(t),
+        AnimationStyle::EaseOutSine => EaseOutSine::evaluate(t),
+        AnimationStyle::EaseInOutSine => EaseInOutSine::evaluate(t),
+        AnimationStyle::EaseInQuad => EaseInQuad::evaluate(t),
+        AnimationStyle::EaseOutQuad => EaseOutQuad::evaluate(t),
+        AnimationStyle::EaseInOutQuad => EaseInOutQuad::evaluate(t),
+        AnimationStyle::EaseInCubic => EaseInCubic::evaluate(t),
+        AnimationStyle::EaseInOutCubic => EaseInOutCubic::evaluate(t),
+        AnimationStyle::EaseInQuart => EaseInQuart::evaluate(t),
+        AnimationStyle::EaseOutQuart => EaseOutQuart::evaluate(t),
+        AnimationStyle::EaseInOutQuart => EaseInOutQuart::evaluate(t),
+        AnimationStyle::EaseInQuint => EaseInQuint::evaluate(t),
+        AnimationStyle::EaseOutQuint => EaseOutQuint::evaluate(t),
+        AnimationStyle::EaseInOutQuint => EaseInOutQuint::evaluate(t),
+        AnimationStyle::EaseInExpo => EaseInExpo::evaluate(t),
+        AnimationStyle::EaseOutExpo => EaseOutExpo::evaluate(t),
+        AnimationStyle::EaseInOutExpo => EaseInOutExpo::evaluate(t),
+        AnimationStyle::EaseInCirc => EaseInCirc::evaluate(t),
+        AnimationStyle::EaseOutCirc => EaseOutCirc::evaluate(t),
+        AnimationStyle::EaseInOutCirc => EaseInOutCirc::evaluate(t),
+        AnimationStyle::EaseInBack => EaseInBack::evaluate(t),
+        AnimationStyle::EaseOutBack => EaseOutBack::evaluate(t),
+        AnimationStyle::EaseInOutBack => EaseInOutBack::evaluate(t),
+        AnimationStyle::EaseInElastic => EaseInElastic::evaluate(t),
+        AnimationStyle::EaseOutElastic => EaseOutElastic::evaluate(t),
+        AnimationStyle::EaseInOutElastic => EaseInOutElastic::evaluate(t),
+        AnimationStyle::EaseInBounce => EaseInBounce::evaluate(t),
+        AnimationStyle::EaseOutBounce => EaseOutBounce::evaluate(t),
+        AnimationStyle::EaseInOutBounce => EaseInOutBounce::evaluate(t),
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
+pub struct Animation {
+    pub hwnd: isize,
+}
+
+impl Animation {
+    pub fn new(hwnd: isize) -> Self {
+        Self { hwnd }
+    }
+    pub fn cancel(&mut self) {
+        if !ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
+            return;
+        }
+
+        ANIMATION_MANAGER.lock().cancel(self.hwnd);
+        let max_duration = Duration::from_secs(1);
+        let spent_duration = Instant::now();
+
+        while ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
+            if spent_duration.elapsed() >= max_duration {
+                ANIMATION_MANAGER.lock().end(self.hwnd);
+            }
+
+            std::thread::sleep(Duration::from_millis(
+                ANIMATION_DURATION.load(Ordering::SeqCst) / 2,
+            ));
+        }
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    pub fn lerp(start: i32, end: i32, t: f64) -> i32 {
+        let time = apply_ease_func(t);
+        f64::from(end - start)
+            .mul_add(time, f64::from(start))
+            .round() as i32
+    }
+
+    pub fn lerp_rect(start_rect: &Rect, end_rect: &Rect, t: f64) -> Rect {
+        Rect {
+            left: Self::lerp(start_rect.left, end_rect.left, t),
+            top: Self::lerp(start_rect.top, end_rect.top, t),
+            right: Self::lerp(start_rect.right, end_rect.right, t),
+            bottom: Self::lerp(start_rect.bottom, end_rect.bottom, t),
+        }
+    }
+
+    #[allow(clippy::cast_precision_loss)]
+    pub fn animate(
+        &mut self,
+        duration: Duration,
+        mut render_callback: impl FnMut(f64) -> Result<()>,
+    ) -> Result<()> {
+        if ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
+            self.cancel();
+        }
+
+        ANIMATION_MANAGER.lock().start(self.hwnd);
+
+        let target_frame_time = Duration::from_millis(1000 / ANIMATION_FPS.load(Ordering::Relaxed));
+        let mut progress = 0.0;
+        let animation_start = Instant::now();
+
+        // start animation
+        while progress < 1.0 {
+            // check if animation is cancelled
+            if ANIMATION_MANAGER.lock().is_cancelled(self.hwnd) {
+                // cancel animation
+                // set all flags
+                ANIMATION_MANAGER.lock().end(self.hwnd);
+                return Ok(());
+            }
+
+            let frame_start = Instant::now();
+            // calculate progress
+            progress = animation_start.elapsed().as_millis() as f64 / duration.as_millis() as f64;
+            render_callback(progress).ok();
+
+            // sleep until next frame
+            if frame_start.elapsed() < target_frame_time {
+                std::thread::sleep(target_frame_time - frame_start.elapsed());
+            }
+        }
+
+        ANIMATION_MANAGER.lock().end(self.hwnd);
+
+        // limit progress to 1.0 if animation took longer
+        if progress > 1.0 {
+            progress = 1.0;
+        }
+
+        // process animation for 1.0 to set target position
+        render_callback(progress)
+    }
+}

komorebi/src/animation_manager.rs

@@ -0,0 +1,79 @@
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+pub static ANIMATIONS_IN_PROGRESS: AtomicUsize = AtomicUsize::new(0);
+
+#[derive(Debug, Clone, Copy)]
+struct AnimationState {
+    pub in_progress: bool,
+    pub is_cancelled: bool,
+}
+
+#[derive(Debug)]
+pub struct AnimationManager {
+    animations: HashMap<isize, AnimationState>,
+}
+
+impl Default for AnimationManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AnimationManager {
+    pub fn new() -> Self {
+        Self {
+            animations: HashMap::new(),
+        }
+    }
+
+    pub fn is_cancelled(&self, hwnd: isize) -> bool {
+        if let Some(animation_state) = self.animations.get(&hwnd) {
+            animation_state.is_cancelled
+        } else {
+            false
+        }
+    }
+
+    pub fn in_progress(&self, hwnd: isize) -> bool {
+        if let Some(animation_state) = self.animations.get(&hwnd) {
+            animation_state.in_progress
+        } else {
+            false
+        }
+    }
+
+    pub fn cancel(&mut self, hwnd: isize) {
+        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
+            animation_state.is_cancelled = true;
+        }
+    }
+
+    pub fn start(&mut self, hwnd: isize) {
+        if let Entry::Vacant(e) = self.animations.entry(hwnd) {
+            e.insert(AnimationState {
+                in_progress: true,
+                is_cancelled: false,
+            });
+
+            ANIMATIONS_IN_PROGRESS.store(self.animations.len(), Ordering::Release);
+            return;
+        }
+
+        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
+            animation_state.in_progress = true;
+        }
+    }
+
+    pub fn end(&mut self, hwnd: isize) {
+        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
+            animation_state.in_progress = false;
+            animation_state.is_cancelled = false;
+
+            self.animations.remove(&hwnd);
+            ANIMATIONS_IN_PROGRESS.store(self.animations.len(), Ordering::Release);
+        }
+    }
+}

komorebi/src/border_manager/border.rs

@@ -1,12 +1,9 @@
+use crate::border_manager::window_kind_colour;
 use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
-use crate::border_manager::FOCUSED;
 use crate::border_manager::FOCUS_STATE;
-use crate::border_manager::MONOCLE;
-use crate::border_manager::STACK;
 use crate::border_manager::STYLE;
-use crate::border_manager::UNFOCUSED;
 use crate::border_manager::Z_ORDER;
 use crate::WindowsApi;
 use crate::WINDOWS_11;
@@ -165,7 +162,7 @@ impl Border {
                     match WindowsApi::window_rect(window) {
                         Ok(rect) => {
                             // Grab the focus kind for this border
-                            let focus_kind = {
+                            let window_kind = {
                                 FOCUS_STATE
                                     .lock()
                                     .get(&window.0)
@@ -177,12 +174,7 @@ impl Border {
                             let hpen = CreatePen(
                                 PS_SOLID | PS_INSIDEFRAME,
                                 BORDER_WIDTH.load(Ordering::SeqCst),
-                                COLORREF(match focus_kind {
-                                    WindowKind::Unfocused => UNFOCUSED.load(Ordering::SeqCst),
-                                    WindowKind::Single => FOCUSED.load(Ordering::SeqCst),
-                                    WindowKind::Stack => STACK.load(Ordering::SeqCst),
-                                    WindowKind::Monocle => MONOCLE.load(Ordering::SeqCst),
-                                }),
+                                COLORREF(window_kind_colour(window_kind)),
                             );
 
                             let hbrush = WindowsApi::create_solid_brush(0);

komorebi/src/border_manager/mod.rs

@@ -6,6 +6,7 @@ use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicCell;
 use crossbeam_utils::atomic::AtomicConsume;
+use komorebi_core::BorderImplementation;
 use komorebi_core::BorderStyle;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
@@ -17,6 +18,7 @@ use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use windows::Win32::Foundation::HWND;
@@ -35,10 +37,13 @@ pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
 pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
 
 pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(true);
+pub static BORDER_TEMPORARILY_DISABLED: AtomicBool = AtomicBool::new(false);
 
 lazy_static! {
     pub static ref Z_ORDER: AtomicCell<ZOrder> = AtomicCell::new(ZOrder::Bottom);
     pub static ref STYLE: AtomicCell<BorderStyle> = AtomicCell::new(BorderStyle::System);
+    pub static ref IMPLEMENTATION: AtomicCell<BorderImplementation> =
+        AtomicCell::new(BorderImplementation::Windows);
     pub static ref FOCUSED: AtomicU32 =
         AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
     pub static ref UNFOCUSED: AtomicU32 =
@@ -59,7 +64,7 @@ pub struct Notification;
 static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
 
 pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
+    CHANNEL.get_or_init(|| crossbeam_channel::bounded(50))
 }
 
 fn event_tx() -> Sender<Notification> {
@@ -109,6 +114,15 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
     Ok(())
 }
 
+fn window_kind_colour(focus_kind: WindowKind) -> u32 {
+    match focus_kind {
+        WindowKind::Unfocused => UNFOCUSED.load(Ordering::SeqCst),
+        WindowKind::Single => FOCUSED.load(Ordering::SeqCst),
+        WindowKind::Stack => STACK.load(Ordering::SeqCst),
+        WindowKind::Monocle => MONOCLE.load(Ordering::SeqCst),
+    }
+}
+
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
     std::thread::spawn(move || loop {
         match handle_notifications(wm.clone()) {
@@ -125,6 +139,7 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
 pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
     tracing::info!("listening");
 
+    BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
     let receiver = event_rx();
     event_tx().send(Notification)?;
 
@@ -141,179 +156,255 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
         let pending_move_op = state.pending_move_op;
         drop(state);
 
-        let mut should_process_notification = true;
-
-        if monitors == previous_snapshot
-            // handle the window dragging edge case
-            && pending_move_op == previous_pending_move_op
-        {
-            should_process_notification = false;
-        }
-
-        // handle the pause edge case
-        if is_paused && !previous_is_paused {
-            should_process_notification = true;
-        }
-
-        // handle the unpause edge case
-        if previous_is_paused && !is_paused {
-            should_process_notification = true;
-        }
-
-        // handle the retile edge case
-        if !should_process_notification && BORDER_STATE.lock().is_empty() {
-            should_process_notification = true;
-        }
-
-        if !should_process_notification {
-            tracing::trace!("monitor state matches latest snapshot, skipping notification");
-            continue 'receiver;
-        }
-
-        let mut borders = BORDER_STATE.lock();
-        let mut borders_monitors = BORDERS_MONITORS.lock();
-
-        // If borders are disabled
-        if !BORDER_ENABLED.load_consume()
-           // Or if the wm is paused
-            || is_paused
-            // Or if we are handling an alt-tab across workspaces
-            || ALT_TAB_HWND.load().is_some()
-        {
-            // Destroy the borders we know about
-            for (_, border) in borders.iter() {
-                border.destroy()?;
-            }
-
-            borders.clear();
-
-            previous_is_paused = is_paused;
-            continue 'receiver;
-        }
-
-        'monitors: for (monitor_idx, m) in monitors.elements().iter().enumerate() {
-            // Only operate on the focused workspace of each monitor
-            if let Some(ws) = m.focused_workspace() {
-                // Workspaces with tiling disabled don't have borders
-                if !ws.tile() {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'monitors;
-                }
-
-                // Handle the monocle container separately
-                if let Some(monocle) = ws.monocle_container() {
-                    let border = match borders.entry(monocle.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(border) = Border::create(monocle.id()) {
-                                entry.insert(border)
-                            } else {
-                                continue 'monitors;
-                            }
-                        }
-                    };
-
-                    borders_monitors.insert(monocle.id().clone(), monitor_idx);
-
-                    {
-                        let mut focus_state = FOCUS_STATE.lock();
-                        focus_state.insert(
-                            border.hwnd,
-                            if monitor_idx != focused_monitor_idx {
+        match IMPLEMENTATION.load() {
+            BorderImplementation::Windows => {
+                'monitors: for (monitor_idx, m) in monitors.elements().iter().enumerate() {
+                    // Only operate on the focused workspace of each monitor
+                    if let Some(ws) = m.focused_workspace() {
+                        // Handle the monocle container separately
+                        if let Some(monocle) = ws.monocle_container() {
+                            let window_kind = if monitor_idx != focused_monitor_idx {
                                 WindowKind::Unfocused
                             } else {
                                 WindowKind::Monocle
-                            },
-                        );
-                    }
+                            };
 
-                    let rect = WindowsApi::window_rect(
-                        monocle.focused_window().copied().unwrap_or_default().hwnd(),
-                    )?;
+                            monocle
+                                .focused_window()
+                                .copied()
+                                .unwrap_or_default()
+                                .set_accent(window_kind_colour(window_kind))?;
 
-                    border.update(&rect, true)?;
+                            continue 'monitors;
+                        }
 
-                    let border_hwnd = border.hwnd;
-                    let mut to_remove = vec![];
-                    for (id, b) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                            && border_hwnd != b.hwnd
-                        {
-                            b.destroy()?;
-                            to_remove.push(id.clone());
+                        for (idx, c) in ws.containers().iter().enumerate() {
+                            let window_kind = if idx != ws.focused_container_idx()
+                                || monitor_idx != focused_monitor_idx
+                            {
+                                WindowKind::Unfocused
+                            } else if c.windows().len() > 1 {
+                                WindowKind::Stack
+                            } else {
+                                WindowKind::Single
+                            };
+
+                            c.focused_window()
+                                .copied()
+                                .unwrap_or_default()
+                                .set_accent(window_kind_colour(window_kind))?;
                         }
                     }
+                }
+            }
+            BorderImplementation::Komorebi => {
+                let mut should_process_notification = true;
 
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'monitors;
+                if monitors == previous_snapshot
+                    // handle the window dragging edge case
+                    && pending_move_op == previous_pending_move_op
+                {
+                    should_process_notification = false;
                 }
 
-                let is_maximized = WindowsApi::is_zoomed(HWND(
-                    WindowsApi::foreground_window().unwrap_or_default(),
-                ));
-
-                if is_maximized {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'monitors;
+                // handle the pause edge case
+                if is_paused && !previous_is_paused {
+                    should_process_notification = true;
                 }
 
-                // Destroy any borders not associated with the focused workspace
-                let container_ids = ws
-                    .containers()
-                    .iter()
-                    .map(|c| c.id().clone())
-                    .collect::<Vec<_>>();
+                // handle the unpause edge case
+                if previous_is_paused && !is_paused {
+                    should_process_notification = true;
+                }
 
-                let mut to_remove = vec![];
-                for (id, border) in borders.iter() {
-                    if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                        && !container_ids.contains(id)
-                    {
+                // handle the retile edge case
+                if !should_process_notification && BORDER_STATE.lock().is_empty() {
+                    should_process_notification = true;
+                }
+
+                if !should_process_notification {
+                    tracing::trace!("monitor state matches latest snapshot, skipping notification");
+                    continue 'receiver;
+                }
+
+                let mut borders = BORDER_STATE.lock();
+                let mut borders_monitors = BORDERS_MONITORS.lock();
+
+                // If borders are disabled
+                if !BORDER_ENABLED.load_consume()
+                    // Or if they are temporarily disabled
+                    || BORDER_TEMPORARILY_DISABLED.load(Ordering::SeqCst)
+                    // Or if the wm is paused
+                    || is_paused
+                    // Or if we are handling an alt-tab across workspaces
+                    || ALT_TAB_HWND.load().is_some()
+                {
+                    // Destroy the borders we know about
+                    for (_, border) in borders.iter() {
                         border.destroy()?;
-                        to_remove.push(id.clone());
                     }
+
+                    borders.clear();
+
+                    previous_is_paused = is_paused;
+                    continue 'receiver;
                 }
 
-                for id in &to_remove {
-                    borders.remove(id);
-                }
+                'monitors: for (monitor_idx, m) in monitors.elements().iter().enumerate() {
+                    // Only operate on the focused workspace of each monitor
+                    if let Some(ws) = m.focused_workspace() {
+                        // Workspaces with tiling disabled don't have borders
+                        if !ws.tile() {
+                            let mut to_remove = vec![];
+                            for (id, border) in borders.iter() {
+                                if borders_monitors.get(id).copied().unwrap_or_default()
+                                    == monitor_idx
+                                {
+                                    border.destroy()?;
+                                    to_remove.push(id.clone());
+                                }
+                            }
 
-                for (idx, c) in ws.containers().iter().enumerate() {
-                    // Update border when moving or resizing with mouse
-                    if pending_move_op.is_some() && idx == ws.focused_container_idx() {
-                        let restore_z_order = Z_ORDER.load();
-                        Z_ORDER.store(ZOrder::TopMost);
+                            for id in &to_remove {
+                                borders.remove(id);
+                            }
 
-                        let mut rect = WindowsApi::window_rect(
-                            c.focused_window().copied().unwrap_or_default().hwnd(),
-                        )?;
+                            continue 'monitors;
+                        }
 
-                        while WindowsApi::lbutton_is_pressed() {
+                        // Handle the monocle container separately
+                        if let Some(monocle) = ws.monocle_container() {
+                            let border = match borders.entry(monocle.id().clone()) {
+                                Entry::Occupied(entry) => entry.into_mut(),
+                                Entry::Vacant(entry) => {
+                                    if let Ok(border) = Border::create(monocle.id()) {
+                                        entry.insert(border)
+                                    } else {
+                                        continue 'monitors;
+                                    }
+                                }
+                            };
+
+                            borders_monitors.insert(monocle.id().clone(), monitor_idx);
+
+                            {
+                                let mut focus_state = FOCUS_STATE.lock();
+                                focus_state.insert(
+                                    border.hwnd,
+                                    if monitor_idx != focused_monitor_idx {
+                                        WindowKind::Unfocused
+                                    } else {
+                                        WindowKind::Monocle
+                                    },
+                                );
+                            }
+
+                            let rect = WindowsApi::window_rect(
+                                monocle.focused_window().copied().unwrap_or_default().hwnd(),
+                            )?;
+
+                            border.update(&rect, true)?;
+
+                            let border_hwnd = border.hwnd;
+                            let mut to_remove = vec![];
+                            for (id, b) in borders.iter() {
+                                if borders_monitors.get(id).copied().unwrap_or_default()
+                                    == monitor_idx
+                                    && border_hwnd != b.hwnd
+                                {
+                                    b.destroy()?;
+                                    to_remove.push(id.clone());
+                                }
+                            }
+
+                            for id in &to_remove {
+                                borders.remove(id);
+                            }
+
+                            continue 'monitors;
+                        }
+
+                        let is_maximized = WindowsApi::is_zoomed(HWND(
+                            WindowsApi::foreground_window().unwrap_or_default(),
+                        ));
+
+                        if is_maximized {
+                            let mut to_remove = vec![];
+                            for (id, border) in borders.iter() {
+                                if borders_monitors.get(id).copied().unwrap_or_default()
+                                    == monitor_idx
+                                {
+                                    border.destroy()?;
+                                    to_remove.push(id.clone());
+                                }
+                            }
+
+                            for id in &to_remove {
+                                borders.remove(id);
+                            }
+
+                            continue 'monitors;
+                        }
+
+                        // Destroy any borders not associated with the focused workspace
+                        let container_ids = ws
+                            .containers()
+                            .iter()
+                            .map(|c| c.id().clone())
+                            .collect::<Vec<_>>();
+
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                                && !container_ids.contains(id)
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
+
+                        for (idx, c) in ws.containers().iter().enumerate() {
+                            // Update border when moving or resizing with mouse
+                            if pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                                let restore_z_order = Z_ORDER.load();
+                                Z_ORDER.store(ZOrder::TopMost);
+
+                                let mut rect = WindowsApi::window_rect(
+                                    c.focused_window().copied().unwrap_or_default().hwnd(),
+                                )?;
+
+                                while WindowsApi::lbutton_is_pressed() {
+                                    let border = match borders.entry(c.id().clone()) {
+                                        Entry::Occupied(entry) => entry.into_mut(),
+                                        Entry::Vacant(entry) => {
+                                            if let Ok(border) = Border::create(c.id()) {
+                                                entry.insert(border)
+                                            } else {
+                                                continue 'monitors;
+                                            }
+                                        }
+                                    };
+
+                                    let new_rect = WindowsApi::window_rect(
+                                        c.focused_window().copied().unwrap_or_default().hwnd(),
+                                    )?;
+
+                                    if rect != new_rect {
+                                        rect = new_rect;
+                                        border.update(&rect, true)?;
+                                    }
+                                }
+
+                                Z_ORDER.store(restore_z_order);
+
+                                continue 'monitors;
+                            }
+
+                            // Get the border entry for this container from the map or create one
                             let border = match borders.entry(c.id().clone()) {
                                 Entry::Occupied(entry) => entry.into_mut(),
                                 Entry::Vacant(entry) => {
@@ -325,64 +416,39 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                 }
                             };
 
-                            let new_rect = WindowsApi::window_rect(
+                            borders_monitors.insert(c.id().clone(), monitor_idx);
+
+                            #[allow(unused_assignments)]
+                            let mut last_focus_state = None;
+
+                            let new_focus_state = if idx != ws.focused_container_idx()
+                                || monitor_idx != focused_monitor_idx
+                            {
+                                WindowKind::Unfocused
+                            } else if c.windows().len() > 1 {
+                                WindowKind::Stack
+                            } else {
+                                WindowKind::Single
+                            };
+
+                            // Update the focused state for all containers on this workspace
+                            {
+                                let mut focus_state = FOCUS_STATE.lock();
+                                last_focus_state = focus_state.insert(border.hwnd, new_focus_state);
+                            }
+
+                            let rect = WindowsApi::window_rect(
                                 c.focused_window().copied().unwrap_or_default().hwnd(),
                             )?;
 
-                            if rect != new_rect {
-                                rect = new_rect;
-                                border.update(&rect, true)?;
-                            }
+                            let should_invalidate = match last_focus_state {
+                                None => true,
+                                Some(last_focus_state) => last_focus_state != new_focus_state,
+                            };
+
+                            border.update(&rect, should_invalidate)?;
                         }
-
-                        Z_ORDER.store(restore_z_order);
-
-                        continue 'monitors;
                     }
-
-                    // Get the border entry for this container from the map or create one
-                    let border = match borders.entry(c.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(border) = Border::create(c.id()) {
-                                entry.insert(border)
-                            } else {
-                                continue 'monitors;
-                            }
-                        }
-                    };
-
-                    borders_monitors.insert(c.id().clone(), monitor_idx);
-
-                    #[allow(unused_assignments)]
-                    let mut last_focus_state = None;
-
-                    let new_focus_state = if idx != ws.focused_container_idx()
-                        || monitor_idx != focused_monitor_idx
-                    {
-                        WindowKind::Unfocused
-                    } else if c.windows().len() > 1 {
-                        WindowKind::Stack
-                    } else {
-                        WindowKind::Single
-                    };
-
-                    // Update the focused state for all containers on this workspace
-                    {
-                        let mut focus_state = FOCUS_STATE.lock();
-                        last_focus_state = focus_state.insert(border.hwnd, new_focus_state);
-                    }
-
-                    let rect = WindowsApi::window_rect(
-                        c.focused_window().copied().unwrap_or_default().hwnd(),
-                    )?;
-
-                    let should_invalidate = match last_focus_state {
-                        None => true,
-                        Some(last_focus_state) => last_focus_state != new_focus_state,
-                    };
-
-                    border.update(&rect, should_invalidate)?;
                 }
             }
         }

komorebi/src/container.rs

@@ -116,6 +116,13 @@ impl Container {
     pub fn add_window(&mut self, window: Window) {
         self.windows_mut().push_back(window);
         self.focus_window(self.windows().len().saturating_sub(1));
+        let focused_window_idx = self.focused_window_idx();
+
+        for (i, window) in self.windows().iter().enumerate() {
+            if i != focused_window_idx {
+                window.hide();
+            }
+        }
     }
 
     #[tracing::instrument(skip(self))]

komorebi/src/lib.rs

@@ -1,5 +1,7 @@
 #![warn(clippy::all)]
 
+pub mod animation;
+pub mod animation_manager;
 pub mod border_manager;
 pub mod com;
 #[macro_use]
@@ -38,9 +40,12 @@ use std::process::Command;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
+use std::sync::atomic::AtomicU64;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 
+pub use animation::*;
+pub use animation_manager::*;
 pub use colour::*;
 pub use process_command::*;
 pub use process_event::*;
@@ -55,6 +60,7 @@ use color_eyre::Result;
 use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
+use komorebi_core::AnimationStyle;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
@@ -197,6 +203,12 @@ lazy_static! {
         )
     };
 
+    static ref ANIMATION_STYLE: Arc<Mutex<AnimationStyle >> =
+        Arc::new(Mutex::new(AnimationStyle::Linear));
+
+    static ref ANIMATION_MANAGER: Arc<Mutex<AnimationManager>> =
+        Arc::new(Mutex::new(AnimationManager::new()));
+
     // Use app-specific titlebar removal options where possible
     // eg. Windows Terminal, IntelliJ IDEA, Firefox
     static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
@@ -214,6 +226,8 @@ pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
 
 pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);
+pub static ANIMATION_ENABLED: AtomicBool = AtomicBool::new(false);
+pub static ANIMATION_DURATION: AtomicU64 = AtomicU64::new(250);
 
 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {

komorebi/src/main.rs

@@ -45,6 +45,8 @@ use komorebi::HOME_DIR;
 use komorebi::INITIAL_CONFIGURATION_LOADED;
 use komorebi::SESSION_ID;
 
+shadow_rs::shadow!(build);
+
 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
     if std::env::var("RUST_LIB_BACKTRACE").is_err() {
         std::env::set_var("RUST_LIB_BACKTRACE", "1");
@@ -132,7 +134,7 @@ fn detect_deadlocks() {
 }
 
 #[derive(Parser)]
-#[clap(author, about, version)]
+#[clap(author, about, version = build::CLAP_LONG_VERSION)]
 struct Opts {
     /// Allow the use of komorebi's custom focus-follows-mouse implementation
     #[clap(short, long = "ffm")]

komorebi/src/process_command.rs

@@ -27,6 +27,7 @@ use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
+use komorebi_core::BorderImplementation;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
 use komorebi_core::MoveBehaviour;
@@ -39,11 +40,14 @@ use komorebi_core::WindowContainerBehaviour;
 use komorebi_core::WindowKind;
 
 use crate::border_manager;
+use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
 use crate::colour::Rgb;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::stackbar_manager;
+use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
+use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 use crate::static_config::StaticConfig;
 use crate::transparency_manager;
 use crate::window::RuleDebug;
@@ -54,6 +58,10 @@ use crate::windows_api::WindowsApi;
 use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::ANIMATION_DURATION;
+use crate::ANIMATION_ENABLED;
+use crate::ANIMATION_FPS;
+use crate::ANIMATION_STYLE;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
@@ -70,6 +78,7 @@ use crate::SUBSCRIPTION_PIPES;
 use crate::SUBSCRIPTION_SOCKETS;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WINDOWS_11;
 use crate::WORKSPACE_RULES;
 use stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
 use stackbar_manager::STACKBAR_LABEL;
@@ -274,6 +283,40 @@ impl WindowManager {
                     self.handle_definitive_workspace_rules(id, monitor_idx, workspace_idx)?;
                 }
             }
+            SocketMessage::ClearWorkspaceRules(monitor_idx, 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::ClearNamedWorkspaceRules(ref workspace) => {
+                if let Some((monitor_idx, workspace_idx)) =
+                    self.monitor_workspace_index_by_name(workspace)
+                {
+                    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_RULES.lock();
+                workspace_rules.clear();
+            }
             SocketMessage::ManageRule(identifier, ref id) => {
                 let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
 
@@ -522,6 +565,7 @@ impl WindowManager {
                 self.update_focused_workspace(self.mouse_follows_focus, true)?;
             }
             SocketMessage::Retile => {
+                border_manager::BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
                 border_manager::destroy_all_borders()?;
                 self.retile_all(false)?
             }
@@ -1241,6 +1285,25 @@ impl WindowManager {
             SocketMessage::Border(enable) => {
                 border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst);
             }
+            SocketMessage::BorderImplementation(implementation) => {
+                if !*WINDOWS_11 && matches!(implementation, BorderImplementation::Windows) {
+                    tracing::error!(
+                        "BorderImplementation::Windows is only supported on Windows 11 and above"
+                    );
+                } else {
+                    IMPLEMENTATION.store(implementation);
+                    match IMPLEMENTATION.load() {
+                        BorderImplementation::Komorebi => {
+                            self.remove_all_accents()?;
+                        }
+                        BorderImplementation::Windows => {
+                            border_manager::destroy_all_borders()?;
+                        }
+                    }
+
+                    border_manager::send_notification();
+                }
+            }
             SocketMessage::BorderColour(kind, r, g, b) => match kind {
                 WindowKind::Single => {
                     border_manager::FOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
@@ -1264,6 +1327,18 @@ impl WindowManager {
             SocketMessage::BorderOffset(offset) => {
                 border_manager::BORDER_OFFSET.store(offset, Ordering::SeqCst);
             }
+            SocketMessage::Animation(enable) => {
+                ANIMATION_ENABLED.store(enable, Ordering::SeqCst);
+            }
+            SocketMessage::AnimationDuration(duration) => {
+                ANIMATION_DURATION.store(duration, Ordering::SeqCst);
+            }
+            SocketMessage::AnimationFps(fps) => {
+                ANIMATION_FPS.store(fps, Ordering::SeqCst);
+            }
+            SocketMessage::AnimationStyle(style) => {
+                *ANIMATION_STYLE.lock() = style;
+            }
             SocketMessage::Transparency(enable) => {
                 transparency_manager::TRANSPARENCY_ENABLED.store(enable, Ordering::SeqCst);
             }
@@ -1294,6 +1369,13 @@ impl WindowManager {
             SocketMessage::StackbarTabWidth(width) => {
                 STACKBAR_TAB_WIDTH.store(width, Ordering::SeqCst);
             }
+            SocketMessage::StackbarFontSize(size) => {
+                STACKBAR_FONT_SIZE.store(size, Ordering::SeqCst);
+            }
+            #[allow(clippy::assigning_clones)]
+            SocketMessage::StackbarFontFamily(ref font_family) => {
+                *STACKBAR_FONT_FAMILY.lock() = font_family.clone();
+            }
             SocketMessage::ApplicationSpecificConfigurationSchema => {
                 let asc = schema_for!(Vec<ApplicationConfiguration>);
                 let schema = serde_json::to_string_pretty(&asc)?;

komorebi/src/process_event.rs

@@ -329,7 +329,8 @@ impl WindowManager {
                 }
 
                 if proceed {
-                    let behaviour = self.window_container_behaviour;
+                    let behaviour =
+                        self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
                     let workspace = self.focused_workspace_mut()?;
                     let workspace_contains_window = workspace.contains_window(window.hwnd);
                     let monocle_container = workspace.monocle_container().clone();
@@ -346,6 +347,8 @@ impl WindowManager {
                                     .ok_or_else(|| anyhow!("there is no focused container"))?
                                     .add_window(window);
                                 self.update_focused_workspace(true, false)?;
+
+                                stackbar_manager::send_notification();
                             }
                         }
                     }
@@ -397,10 +400,12 @@ impl WindowManager {
                     .monitor_idx_from_current_pos()
                     .ok_or_else(|| anyhow!("cannot get monitor idx from current position"))?;
 
-                let new_window_behaviour = self.window_container_behaviour;
+                let focused_monitor_idx = self.focused_monitor_idx();
+                let focused_workspace_idx = self.focused_workspace_idx().unwrap_or_default();
+                let window_container_behaviour =
+                    self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
 
                 let workspace = self.focused_workspace_mut()?;
-
                 let focused_container_idx = workspace.focused_container_idx();
                 let new_position = WindowsApi::window_rect(window.hwnd())?;
                 let old_position = *workspace
@@ -517,7 +522,7 @@ impl WindowManager {
                             // Here we handle a simple move on the same monitor which is treated as
                             // a container swap
                         } else {
-                            match new_window_behaviour {
+                            match window_container_behaviour {
                                 WindowContainerBehaviour::Create => {
                                     match workspace.container_idx_from_current_point() {
                                         Some(target_idx) => {
@@ -546,6 +551,8 @@ impl WindowManager {
                                             )?;
                                         }
                                     }
+
+                                    stackbar_manager::send_notification();
                                 }
                             }
                         }
@@ -599,7 +606,7 @@ impl WindowManager {
         };
 
         // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
-        if let WindowManagerEvent::Unmanage(window) = event {
+        if let WindowManagerEvent::Unmanage(mut window) = event {
             window.center(&self.focused_monitor_work_area()?)?;
         }
 

komorebi/src/stackbar_manager/mod.rs

@@ -15,12 +15,15 @@ use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
+use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
 use 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
 pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947); // gray text
 pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
@@ -29,8 +32,11 @@ pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
 pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
 pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::OnStack);
 
+pub static STACKBAR_TEMPORARILY_DISABLED: AtomicBool = AtomicBool::new(false);
+
 lazy_static! {
     pub static ref STACKBAR_STATE: Mutex<HashMap<String, Stackbar>> = Mutex::new(HashMap::new());
+    pub static ref STACKBAR_FONT_FAMILY: Mutex<Option<String>> = Mutex::new(None);
     static ref STACKBARS_MONITORS: Mutex<HashMap<String, usize>> = Mutex::new(HashMap::new());
     static ref STACKBARS_CONTAINERS: Mutex<HashMap<isize, Container>> = Mutex::new(HashMap::new());
 }
@@ -91,7 +97,9 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
         let mut state = wm.lock();
 
         // If stackbars are disabled
-        if matches!(STACKBAR_MODE.load(), StackbarMode::Never) {
+        if matches!(STACKBAR_MODE.load(), StackbarMode::Never)
+            || STACKBAR_TEMPORARILY_DISABLED.load(Ordering::SeqCst)
+        {
             for (_, stackbar) in stackbars.iter() {
                 stackbar.destroy()?;
             }

komorebi/src/stackbar_manager/stackbar.rs

@@ -4,6 +4,8 @@ use crate::border_manager::STYLE;
 use crate::container::Container;
 use crate::stackbar_manager::STACKBARS_CONTAINERS;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
+use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 use crate::stackbar_manager::STACKBAR_LABEL;
 use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
@@ -16,6 +18,8 @@ use crossbeam_utils::atomic::AtomicConsume;
 use komorebi_core::BorderStyle;
 use komorebi_core::Rect;
 use komorebi_core::StackbarLabel;
+use std::os::windows::ffi::OsStrExt;
+use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::time::Duration;
 use windows::core::PCWSTR;
@@ -30,6 +34,7 @@ use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::DeleteObject;
 use windows::Win32::Graphics::Gdi::DrawTextW;
 use windows::Win32::Graphics::Gdi::GetDC;
+use windows::Win32::Graphics::Gdi::GetDeviceCaps;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::ReleaseDC;
 use windows::Win32::Graphics::Gdi::RoundRect;
@@ -43,8 +48,10 @@ use windows::Win32::Graphics::Gdi::DT_VCENTER;
 use windows::Win32::Graphics::Gdi::FONT_QUALITY;
 use windows::Win32::Graphics::Gdi::FW_BOLD;
 use windows::Win32::Graphics::Gdi::LOGFONTW;
+use windows::Win32::Graphics::Gdi::LOGPIXELSY;
 use windows::Win32::Graphics::Gdi::PROOF_QUALITY;
 use windows::Win32::Graphics::Gdi::PS_SOLID;
+use windows::Win32::System::WindowsProgramming::MulDiv;
 use windows::Win32::UI::WindowsAndMessaging::CreateWindowExW;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
@@ -181,11 +188,29 @@ impl Stackbar {
             SelectObject(hdc, hbrush);
             SetBkColor(hdc, COLORREF(background));
 
-            let hfont = CreateFontIndirectW(&LOGFONTW {
+            let mut logfont = LOGFONTW {
                 lfWeight: FW_BOLD.0 as i32,
                 lfQuality: FONT_QUALITY(PROOF_QUALITY.0),
+                lfFaceName: [0; 32],
                 ..Default::default()
-            });
+            };
+
+            if let Some(font_name) = &*STACKBAR_FONT_FAMILY.lock() {
+                let font = wide_string(font_name);
+                for (i, &c) in font.iter().enumerate() {
+                    logfont.lfFaceName[i] = c;
+                }
+            }
+
+            let logical_height = -MulDiv(
+                STACKBAR_FONT_SIZE.load(Ordering::SeqCst),
+                72,
+                GetDeviceCaps(hdc, LOGPIXELSY),
+            );
+
+            logfont.lfHeight = logical_height;
+
+            let hfont = CreateFontIndirectW(&logfont);
 
             SelectObject(hdc, hfont);
 
@@ -336,3 +361,10 @@ impl Stackbar {
         }
     }
 }
+
+fn wide_string(s: &str) -> Vec<u16> {
+    std::ffi::OsStr::new(s)
+        .encode_wide()
+        .chain(std::iter::once(0))
+        .collect()
+}

komorebi/src/static_config.rs

@@ -1,5 +1,6 @@
 use crate::border_manager;
 use crate::border_manager::ZOrder;
+use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
 use crate::border_manager::Z_ORDER;
 use crate::colour::Colour;
@@ -8,6 +9,8 @@ use crate::monitor::Monitor;
 use crate::monitor_reconciliator;
 use crate::ring::Ring;
 use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
+use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
+use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 use crate::stackbar_manager::STACKBAR_LABEL;
 use crate::stackbar_manager::STACKBAR_MODE;
 use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
@@ -15,10 +18,15 @@ use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
 use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
 use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::transparency_manager;
+use crate::window;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
+use crate::ANIMATION_DURATION;
+use crate::ANIMATION_ENABLED;
+use crate::ANIMATION_FPS;
+use crate::ANIMATION_STYLE;
 use crate::DATA_DIR;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
@@ -31,7 +39,9 @@ use crate::MONITOR_INDEX_PREFERENCES;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WINDOWS_11;
 use crate::WORKSPACE_RULES;
+use komorebi_core::BorderImplementation;
 use komorebi_core::StackbarLabel;
 use komorebi_core::StackbarMode;
 
@@ -46,6 +56,7 @@ use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::resolve_home_path;
+use komorebi_core::AnimationStyle;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::BorderStyle;
 use komorebi_core::DefaultLayout;
@@ -112,6 +123,9 @@ pub struct WorkspaceConfig {
     /// Permanent workspace application rules
     #[serde(skip_serializing_if = "Option::is_none")]
     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>,
 }
 
 impl From<&Workspace> for WorkspaceConfig {
@@ -194,6 +208,7 @@ impl From<&Workspace> for WorkspaceConfig {
             workspace_padding,
             initial_workspace_rules: initial_ws_rules,
             workspace_rules: ws_rules,
+            apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
         }
     }
 }
@@ -230,11 +245,17 @@ impl From<&Monitor> for MonitorConfig {
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.27`
+/// 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")]
     pub invisible_borders: Option<Rect>,
+    /// DISCOURAGED: Minimum width for a window to be eligible for tiling
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minimum_window_width: Option<i32>,
+    /// DISCOURAGED: Minimum height for a window to be eligible for tiling
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub minimum_window_height: Option<i32>,
     /// Delta to resize windows by (default 50)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub resize_delta: Option<i32>,
@@ -279,6 +300,9 @@ pub struct StaticConfig {
     /// Active window border z-order (default: System)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub border_z_order: Option<ZOrder>,
+    /// Display an active window border (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub border_implementation: Option<BorderImplementation>,
     /// Add transparency to unfocused windows (default: false)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub transparency: Option<bool>,
@@ -294,7 +318,7 @@ pub struct StaticConfig {
     /// Monitor and workspace configurations
     #[serde(skip_serializing_if = "Option::is_none")]
     pub monitors: Option<Vec<MonitorConfig>>,
-    /// Which Windows signal to use when hiding windows (default: minimize)
+    /// Which Windows signal to use when hiding windows (default: Cloak)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_hiding_behaviour: Option<HidingBehaviour>,
     /// Global work area (space used for tiling) offset (default: None)
@@ -327,6 +351,21 @@ pub struct StaticConfig {
     /// Stackbar configuration options
     #[serde(skip_serializing_if = "Option::is_none")]
     pub stackbar: Option<StackbarConfig>,
+    /// Animations configuration options
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub animation: Option<AnimationsConfig>,
+}
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct AnimationsConfig {
+    /// Enable or disable animations (default: false)
+    enabled: bool,
+    /// Set the animation duration in ms (default: 250)
+    duration: Option<u64>,
+    /// Set the animation style (default: Linear)
+    style: Option<AnimationStyle>,
+    /// Set the animation FPS (default: 60)
+    fps: Option<u64>,
 }
 
 impl StaticConfig {
@@ -361,13 +400,25 @@ impl StaticConfig {
     }
 
     pub fn deprecated(raw: &str) {
-        let deprecated = ["invisible_borders"];
+        let deprecated_options = ["invisible_borders"];
+        let deprecated_variants = vec![
+            ("Hide", "window_hiding_behaviour", "Cloak"),
+            ("Minimize", "window_hiding_behaviour", "Cloak"),
+        ];
 
-        for option in deprecated {
+        for option in deprecated_options {
             if raw.contains(option) {
                 println!(r#""{option}" is deprecated and can be removed"#);
             }
         }
+
+        for (variant, option, recommended) in deprecated_variants {
+            if raw.contains(option) && raw.contains(variant) {
+                println!(
+                    r#"The "{variant}" option for "{option}" is deprecated and can be removed or replaced with "{recommended}""#
+                );
+            }
+        }
     }
 }
 
@@ -381,7 +432,12 @@ pub struct TabsConfig {
     unfocused_text: Option<Colour>,
     /// Tab background colour
     background: Option<Colour>,
+    /// Font family
+    font_family: Option<String>,
+    /// Font size
+    font_size: Option<i32>,
 }
+
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct StackbarConfig {
     /// Stackbar height
@@ -403,6 +459,8 @@ impl From<&WindowManager> for StaticConfig {
         }
 
         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() {
@@ -419,6 +477,12 @@ impl From<&WindowManager> for StaticConfig {
                     }
                 }
 
+                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 {
@@ -430,18 +494,54 @@ impl From<&WindowManager> for StaticConfig {
                         }
                     }
                 }
+
+                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();
                     }
                 }
             }
@@ -468,6 +568,8 @@ impl From<&WindowManager> for StaticConfig {
             unmanaged_window_operation_behaviour: Option::from(
                 value.unmanaged_window_operation_behaviour,
             ),
+            minimum_window_height: Some(window::MINIMUM_HEIGHT.load(Ordering::SeqCst)),
+            minimum_window_width: Some(window::MINIMUM_WIDTH.load(Ordering::SeqCst)),
             focus_follows_mouse: value.focus_follows_mouse,
             mouse_follows_focus: Option::from(value.mouse_follows_focus),
             app_specific_configuration_path: None,
@@ -483,6 +585,7 @@ impl From<&WindowManager> for StaticConfig {
             ),
             border_style: Option::from(STYLE.load()),
             border_z_order: Option::from(Z_ORDER.load()),
+            border_implementation: Option::from(IMPLEMENTATION.load()),
             default_workspace_padding: Option::from(
                 DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
             ),
@@ -501,6 +604,7 @@ impl From<&WindowManager> for StaticConfig {
             monitor_index_preferences: Option::from(MONITOR_INDEX_PREFERENCES.lock().clone()),
             display_index_preferences: Option::from(DISPLAY_INDEX_PREFERENCES.lock().clone()),
             stackbar: None,
+            animation: None,
         }
     }
 }
@@ -523,6 +627,22 @@ impl StaticConfig {
             *window_hiding_behaviour = behaviour;
         }
 
+        if let Some(height) = self.minimum_window_height {
+            window::MINIMUM_HEIGHT.store(height, Ordering::SeqCst);
+        }
+
+        if let Some(width) = self.minimum_window_width {
+            window::MINIMUM_WIDTH.store(width, Ordering::SeqCst);
+        }
+
+        if let Some(animations) = &self.animation {
+            ANIMATION_ENABLED.store(animations.enabled, Ordering::SeqCst);
+            ANIMATION_DURATION.store(animations.duration.unwrap_or(250), Ordering::SeqCst);
+            ANIMATION_FPS.store(animations.fps.unwrap_or(60), Ordering::SeqCst);
+            let mut animation_style = ANIMATION_STYLE.lock();
+            *animation_style = animations.style.unwrap_or(AnimationStyle::Linear);
+        }
+
         if let Some(container) = self.default_container_padding {
             DEFAULT_CONTAINER_PADDING.store(container, Ordering::SeqCst);
         }
@@ -558,6 +678,29 @@ impl StaticConfig {
 
         STYLE.store(self.border_style.unwrap_or_default());
 
+        if !*WINDOWS_11
+            && matches!(
+                self.border_implementation.unwrap_or_default(),
+                BorderImplementation::Windows
+            )
+        {
+            tracing::error!(
+                "BorderImplementation::Windows is only supported on Windows 11 and above"
+            );
+        } else {
+            IMPLEMENTATION.store(self.border_implementation.unwrap_or_default());
+            match IMPLEMENTATION.load() {
+                BorderImplementation::Komorebi => {
+                    border_manager::destroy_all_borders()?;
+                }
+                BorderImplementation::Windows => {
+                    // TODO: figure out how to call wm.remove_all_accents here
+                }
+            }
+
+            border_manager::send_notification();
+        }
+
         transparency_manager::TRANSPARENCY_ENABLED
             .store(self.transparency.unwrap_or(false), Ordering::SeqCst);
         transparency_manager::TRANSPARENCY_ALPHA
@@ -611,6 +754,7 @@ impl StaticConfig {
                 STACKBAR_MODE.store(*mode);
             }
 
+            #[allow(clippy::assigning_clones)]
             if let Some(tabs) = &stackbar.tabs {
                 if let Some(background) = &tabs.background {
                     STACKBAR_TAB_BACKGROUND_COLOUR.store((*background).into(), Ordering::SeqCst);
@@ -627,6 +771,9 @@ impl StaticConfig {
                 if let Some(width) = &tabs.width {
                     STACKBAR_TAB_WIDTH.store(*width, Ordering::SeqCst);
                 }
+
+                STACKBAR_FONT_SIZE.store(tabs.font_size.unwrap_or(0), Ordering::SeqCst);
+                *STACKBAR_FONT_FAMILY.lock() = tabs.font_family.clone();
             }
         }
 

komorebi/src/window.rs

@@ -1,9 +1,16 @@
+use crate::border_manager;
 use crate::com::SetCloak;
+use crate::stackbar_manager;
+use crate::ANIMATIONS_IN_PROGRESS;
+use crate::ANIMATION_DURATION;
+use crate::ANIMATION_ENABLED;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::fmt::Write as _;
+use std::sync::atomic::AtomicI32;
+use std::sync::atomic::Ordering;
 use std::time::Duration;
 
 use color_eyre::eyre;
@@ -24,6 +31,7 @@ use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 
+use crate::animation::Animation;
 use crate::styles::ExtendedWindowStyle;
 use crate::styles::WindowStyle;
 use crate::transparency_manager;
@@ -39,20 +47,30 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;
 
+pub static MINIMUM_WIDTH: AtomicI32 = AtomicI32::new(0);
+pub static MINIMUM_HEIGHT: AtomicI32 = AtomicI32::new(0);
+
 #[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema, PartialEq)]
 pub struct Window {
     pub hwnd: isize,
+    animation: Animation,
 }
 
 impl From<isize> for Window {
     fn from(value: isize) -> Self {
-        Self { hwnd: value }
+        Self {
+            hwnd: value,
+            animation: Animation::new(value),
+        }
     }
 }
 
 impl From<HWND> for Window {
     fn from(value: HWND) -> Self {
-        Self { hwnd: value.0 }
+        Self {
+            hwnd: value.0,
+            animation: Animation::new(value.0),
+        }
     }
 }
 
@@ -136,7 +154,7 @@ impl Window {
         HWND(self.hwnd)
     }
 
-    pub fn center(&self, work_area: &Rect) -> Result<()> {
+    pub fn center(&mut self, work_area: &Rect) -> Result<()> {
         let half_width = work_area.right / 2;
         let half_weight = work_area.bottom / 2;
 
@@ -151,13 +169,61 @@ impl Window {
         )
     }
 
+    pub fn animate_position(&self, layout: &Rect, top: bool) -> Result<()> {
+        let hwnd = self.hwnd();
+        let curr_rect = WindowsApi::window_rect(hwnd).unwrap();
+
+        let target_rect = *layout;
+        let duration = Duration::from_millis(ANIMATION_DURATION.load(Ordering::SeqCst));
+        let mut animation = self.animation;
+
+        border_manager::BORDER_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
+        border_manager::send_notification();
+
+        stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
+        stackbar_manager::send_notification();
+
+        std::thread::spawn(move || {
+            animation.animate(duration, |progress: f64| {
+                let new_rect = Animation::lerp_rect(&curr_rect, &target_rect, progress);
+
+                if progress == 1.0 {
+                    WindowsApi::position_window(hwnd, &new_rect, top)?;
+
+                    if ANIMATIONS_IN_PROGRESS.load(Ordering::Acquire) == 0 {
+                        border_manager::BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
+                        stackbar_manager::STACKBAR_TEMPORARILY_DISABLED
+                            .store(false, Ordering::SeqCst);
+
+                        border_manager::send_notification();
+                        stackbar_manager::send_notification();
+                        transparency_manager::send_notification();
+                    }
+                } else {
+                    // using MoveWindow because it runs faster than SetWindowPos
+                    // so animation have more fps and feel smoother
+                    WindowsApi::move_window(hwnd, &new_rect, false)?;
+                    // WindowsApi::position_window(hwnd, &new_rect, top)?;
+                    WindowsApi::invalidate_rect(hwnd, None, false);
+                }
+
+                Ok(())
+            })
+        });
+
+        Ok(())
+    }
+
     pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
         if WindowsApi::window_rect(self.hwnd())?.eq(layout) {
             return Ok(());
         }
 
-        let rect = *layout;
-        WindowsApi::position_window(self.hwnd(), &rect, top)
+        if ANIMATION_ENABLED.load(Ordering::SeqCst) {
+            self.animate_position(layout, top)
+        } else {
+            WindowsApi::position_window(self.hwnd(), layout, top)
+        }
     }
 
     pub fn is_maximized(self) -> bool {
@@ -275,6 +341,14 @@ impl Window {
         self.update_ex_style(&ex_style)
     }
 
+    pub fn set_accent(self, colour: u32) -> Result<()> {
+        WindowsApi::set_window_accent(self.hwnd, Some(colour))
+    }
+
+    pub fn remove_accent(self) -> Result<()> {
+        WindowsApi::set_window_accent(self.hwnd, None)
+    }
+
     #[allow(dead_code)]
     pub fn update_style(self, style: &WindowStyle) -> Result<()> {
         WindowsApi::update_style(self.hwnd(), isize::try_from(style.bits())?)
@@ -352,6 +426,20 @@ impl Window {
 
         debug.is_window = true;
 
+        let rect = WindowsApi::window_rect(self.hwnd()).unwrap_or_default();
+
+        if rect.right < MINIMUM_WIDTH.load(Ordering::SeqCst) {
+            return Ok(false);
+        }
+
+        debug.has_minimum_width = true;
+
+        if rect.bottom < MINIMUM_HEIGHT.load(Ordering::SeqCst) {
+            return Ok(false);
+        }
+
+        debug.has_minimum_height = true;
+
         if self.title().is_err() {
             return Ok(false);
         }
@@ -408,6 +496,8 @@ impl Window {
 pub struct RuleDebug {
     pub should_manage: bool,
     pub is_window: bool,
+    pub has_minimum_width: bool,
+    pub has_minimum_height: bool,
     pub has_title: bool,
     pub is_cloaked: bool,
     pub allow_cloaked: bool,

komorebi/src/window_manager.rs

@@ -303,6 +303,24 @@ impl WindowManager {
         StaticConfig::reload(pathbuf, self)
     }
 
+    pub fn window_container_behaviour(
+        &self,
+        monitor_idx: usize,
+        workspace_idx: usize,
+    ) -> WindowContainerBehaviour {
+        if let Some(monitor) = self.monitors().get(monitor_idx) {
+            if let Some(workspace) = monitor.workspaces().get(workspace_idx) {
+                return if workspace.containers().is_empty() {
+                    WindowContainerBehaviour::Create
+                } else {
+                    self.window_container_behaviour
+                };
+            }
+        }
+
+        WindowContainerBehaviour::Create
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn watch_configuration(&mut self, enable: bool) -> Result<()> {
         let config_pwsh = HOME_DIR.join("komorebi.ps1");
@@ -947,6 +965,8 @@ impl WindowManager {
                             window.opaque()?;
                         }
 
+                        window.remove_accent()?;
+
                         window.restore();
                     }
                 }
@@ -956,6 +976,29 @@ impl WindowManager {
         Ok(())
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn remove_all_accents(&mut self) -> Result<()> {
+        tracing::info!("removing all window accents");
+
+        for monitor in self.monitors() {
+            for workspace in monitor.workspaces() {
+                if let Some(monocle) = workspace.monocle_container() {
+                    for window in monocle.windows() {
+                        window.remove_accent()?
+                    }
+                }
+
+                for containers in workspace.containers() {
+                    for window in containers.windows() {
+                        window.remove_accent()?;
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     #[tracing::instrument(skip(self))]
     fn handle_unmanaged_window_behaviour(&self) -> Result<()> {
         if matches!(

komorebi/src/windows_api.rs

@@ -18,10 +18,13 @@ use windows::Win32::Foundation::HMODULE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
+use windows::Win32::Foundation::RECT;
 use windows::Win32::Foundation::WPARAM;
 use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
 use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DWMWA_BORDER_COLOR;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
+use windows::Win32::Graphics::Dwm::DWMWA_COLOR_NONE;
 use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
 use windows::Win32::Graphics::Dwm::DWMWA_WINDOW_CORNER_PREFERENCE;
 use windows::Win32::Graphics::Dwm::DWMWCP_ROUND;
@@ -32,6 +35,7 @@ use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use windows::Win32::Graphics::Gdi::CreateSolidBrush;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
+use windows::Win32::Graphics::Gdi::InvalidateRect;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use windows::Win32::Graphics::Gdi::Rectangle;
@@ -82,6 +86,7 @@ use windows::Win32::UI::WindowsAndMessaging::IsIconic;
 use windows::Win32::UI::WindowsAndMessaging::IsWindow;
 use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
 use windows::Win32::UI::WindowsAndMessaging::IsZoomed;
+use windows::Win32::UI::WindowsAndMessaging::MoveWindow;
 use windows::Win32::UI::WindowsAndMessaging::PostMessageW;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
 use windows::Win32::UI::WindowsAndMessaging::RegisterClassW;
@@ -427,6 +432,17 @@ impl WindowsApi {
         .process()
     }
 
+    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,
+            top: layout.top + shadow_rect.top,
+            right: layout.right + shadow_rect.right,
+            bottom: layout.bottom + shadow_rect.bottom,
+        };
+        unsafe { MoveWindow(hwnd, rect.left, rect.top, rect.right, rect.bottom, repaint) }.process()
+    }
+
     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
@@ -955,6 +971,19 @@ impl WindowsApi {
         .process()
     }
 
+    pub fn set_window_accent(hwnd: isize, color: Option<u32>) -> Result<()> {
+        let col_ref = COLORREF(color.unwrap_or(DWMWA_COLOR_NONE));
+        unsafe {
+            DwmSetWindowAttribute(
+                HWND(hwnd),
+                DWMWA_BORDER_COLOR,
+                std::ptr::addr_of!(col_ref).cast(),
+                4,
+            )
+        }
+        .process()
+    }
+
     pub fn create_border_window(name: PCWSTR, instance: HMODULE) -> Result<isize> {
         unsafe {
             let hwnd = CreateWindowExW(
@@ -1008,6 +1037,11 @@ impl WindowsApi {
         .process()
     }
 
+    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, rect, erase) }.as_bool()
+    }
+
     pub fn alt_is_pressed() -> bool {
         let state = unsafe { GetKeyState(i32::from(VK_MENU.0)) };
         #[allow(clippy::cast_sign_loss)]

komorebi/src/workspace.rs

@@ -81,6 +81,8 @@ pub struct Workspace {
     resize_dimensions: Vec<Option<Rect>>,
     #[getset(get = "pub", set = "pub")]
     tile: bool,
+    #[getset(get_copy = "pub", set = "pub")]
+    apply_window_based_work_area_offset: bool,
 }
 
 impl_ring_elements!(Workspace, Container);
@@ -103,6 +105,7 @@ impl Default for Workspace {
             latest_layout: vec![],
             resize_dimensions: vec![],
             tile: true,
+            apply_window_based_work_area_offset: true,
         }
     }
 }
@@ -155,6 +158,10 @@ impl Workspace {
             self.tile = true;
         }
 
+        self.set_apply_window_based_work_area_offset(
+            config.apply_window_based_work_area_offset.unwrap_or(true),
+        );
+
         Ok(())
     }
 
@@ -260,7 +267,9 @@ impl Workspace {
             },
         );
 
-        if self.containers().len() <= window_based_work_area_offset_limit as usize {
+        if self.containers().len() <= window_based_work_area_offset_limit as usize
+            && self.apply_window_based_work_area_offset
+        {
             adjusted_work_area = window_based_work_area_offset.map_or_else(
                 || adjusted_work_area,
                 |offset| {
@@ -748,6 +757,9 @@ impl Workspace {
             self.focus_previous_container();
         } else {
             container.load_focused_window();
+            if let Some(window) = container.focused_window() {
+                window.focus(false)?;
+            }
         }
 
         Ok(())

komorebic-no-console/Cargo.toml

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

komorebic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.27"
+version = "0.1.28-dev.0"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
@@ -34,6 +34,8 @@ 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"] }
+shadow-rs = { workspace = true }

komorebic/build.rs

@@ -5,4 +5,6 @@ fn main() {
     ).unwrap().text().unwrap();
         std::fs::write("applications.yaml", applications_yaml).unwrap();
     }
+
+    shadow_rs::new().unwrap();
 }

komorebic/src/main.rs

@@ -99,6 +99,8 @@ lazy_static! {
     };
 }
 
+shadow_rs::shadow!(build);
+
 #[derive(thiserror::Error, Debug, miette::Diagnostic)]
 #[error("{message}")]
 #[diagnostic(code(komorebi::configuration), help("try fixing this syntax error"))]
@@ -629,6 +631,20 @@ struct NamedWorkspaceRule {
     workspace: String,
 }
 
+#[derive(Parser)]
+struct ClearWorkspaceRules {
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+}
+
+#[derive(Parser)]
+struct ClearNamedWorkspaceRules {
+    /// Name of a workspace
+    workspace: String,
+}
+
 #[derive(Parser)]
 struct ToggleFocusFollowsMouse {
     #[clap(value_enum, short, long, default_value = "windows")]
@@ -684,6 +700,44 @@ struct BorderOffset {
     /// Desired offset of the window border
     offset: i32,
 }
+#[derive(Parser)]
+struct BorderStyle {
+    /// Desired border style
+    #[clap(value_enum)]
+    style: komorebi_core::BorderStyle,
+}
+
+#[derive(Parser)]
+struct BorderImplementation {
+    /// Desired border implementation
+    #[clap(value_enum)]
+    style: komorebi_core::BorderImplementation,
+}
+
+#[derive(Parser)]
+struct Animation {
+    #[clap(value_enum)]
+    boolean_state: BooleanState,
+}
+
+#[derive(Parser)]
+struct AnimationDuration {
+    /// Desired animation durations in ms
+    duration: u64,
+}
+
+#[derive(Parser)]
+struct AnimationFps {
+    /// Desired animation frames per second
+    fps: u64,
+}
+
+#[derive(Parser)]
+struct AnimationStyle {
+    /// Desired ease function for animation
+    #[clap(value_enum, short, long, default_value = "linear")]
+    style: komorebi_core::AnimationStyle,
+}
 
 #[derive(Parser)]
 #[allow(clippy::struct_excessive_bools)]
@@ -802,7 +856,7 @@ struct EnableAutostart {
 }
 
 #[derive(Parser)]
-#[clap(author, about, version)]
+#[clap(author, about, version = build::CLAP_LONG_VERSION)]
 struct Opts {
     #[clap(subcommand)]
     subcmd: SubCommand,
@@ -1142,6 +1196,14 @@ enum SubCommand {
     /// Add a rule to associate an application with a named workspace
     #[clap(arg_required_else_help = true)]
     NamedWorkspaceRule(NamedWorkspaceRule),
+    /// Remove all application association rules for a workspace by monitor and workspace index
+    #[clap(arg_required_else_help = true)]
+    ClearWorkspaceRules(ClearWorkspaceRules),
+    /// Remove all application association rules for a named workspace
+    #[clap(arg_required_else_help = true)]
+    ClearNamedWorkspaceRules(ClearNamedWorkspaceRules),
+    /// Remove all application association rules for all workspaces
+    ClearAllWorkspaceRules,
     /// Identify an application that sends EVENT_OBJECT_NAMECHANGE on launch
     #[clap(arg_required_else_help = true)]
     IdentifyObjectNameChangeApplication(IdentifyObjectNameChangeApplication),
@@ -1176,12 +1238,30 @@ enum SubCommand {
     #[clap(arg_required_else_help = true)]
     #[clap(alias = "active-window-border-offset")]
     BorderOffset(BorderOffset),
+    /// Set the border style
+    #[clap(arg_required_else_help = true)]
+    BorderStyle(BorderStyle),
+    /// Set the border implementation
+    #[clap(arg_required_else_help = true)]
+    BorderImplementation(BorderImplementation),
     /// Enable or disable transparency for unfocused windows
     #[clap(arg_required_else_help = true)]
     Transparency(Transparency),
     /// Set the alpha value for unfocused window transparency
     #[clap(arg_required_else_help = true)]
     TransparencyAlpha(TransparencyAlpha),
+    /// Enable or disable the window move animation
+    #[clap(arg_required_else_help = true)]
+    Animation(Animation),
+    /// Set the duration for the window move animation in ms
+    #[clap(arg_required_else_help = true)]
+    AnimationDuration(AnimationDuration),
+    /// Set the frames per second for the window move animation
+    #[clap(arg_required_else_help = true)]
+    AnimationFps(AnimationFps),
+    /// 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
     #[clap(arg_required_else_help = true)]
     FocusFollowsMouse(FocusFollowsMouse),
@@ -2042,6 +2122,17 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
                     .as_bytes()?,
             )?;
         }
+        SubCommand::ClearWorkspaceRules(arg) => {
+            send_message(
+                &SocketMessage::ClearWorkspaceRules(arg.monitor, arg.workspace).as_bytes()?,
+            )?;
+        }
+        SubCommand::ClearNamedWorkspaceRules(arg) => {
+            send_message(&SocketMessage::ClearNamedWorkspaceRules(arg.workspace).as_bytes()?)?;
+        }
+        SubCommand::ClearAllWorkspaceRules => {
+            send_message(&SocketMessage::ClearAllWorkspaceRules.as_bytes()?)?;
+        }
         SubCommand::Stack(arg) => {
             send_message(&SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
         }
@@ -2269,12 +2360,31 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         SubCommand::BorderOffset(arg) => {
             send_message(&SocketMessage::BorderOffset(arg.offset).as_bytes()?)?;
         }
+        SubCommand::BorderStyle(arg) => {
+            send_message(&SocketMessage::BorderStyle(arg.style).as_bytes()?)?;
+        }
+        SubCommand::BorderImplementation(arg) => {
+            send_message(&SocketMessage::BorderImplementation(arg.style).as_bytes()?)?;
+        }
         SubCommand::Transparency(arg) => {
             send_message(&SocketMessage::Transparency(arg.boolean_state.into()).as_bytes()?)?;
         }
         SubCommand::TransparencyAlpha(arg) => {
             send_message(&SocketMessage::TransparencyAlpha(arg.alpha).as_bytes()?)?;
         }
+        SubCommand::Animation(arg) => {
+            send_message(&SocketMessage::Animation(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::AnimationDuration(arg) => {
+            send_message(&SocketMessage::AnimationDuration(arg.duration).as_bytes()?)?;
+        }
+        SubCommand::AnimationFps(arg) => {
+            send_message(&SocketMessage::AnimationFps(arg.fps).as_bytes()?)?;
+        }
+        SubCommand::AnimationStyle(arg) => {
+            send_message(&SocketMessage::AnimationStyle(arg.style).as_bytes()?)?;
+        }
+
         SubCommand::ResizeDelta(arg) => {
             send_message(&SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
         }