refactor(animation): new animations engine

This commit is comprised of the following interactively rebased commits
from PR #1002 by @thearturca.

1a184a4442
refactor(animation): move animations to its own mod

First step for more rusty version animations. The goal is to make
animations more generic so its easier to add new animations to komorebi!

d3ac6b72c2
refactor(animation): reduce mutex calls on `ANIMATION_STYLE`

8a42b738fe
refactor(animation): introduce `Lerp` trait

e449861c10
refactor(animation): generalized ANIMATION_MANAGER

Instead of a isize key for the ANIMATION_MANAGER HashMap, now we use a
String key. For window move animation, the key would be
`window_move:{hwnd}`.

This allows us to use single manager for more types of animations.

67b2a7a284
feat(animation): introduce `AnimationPrefix` enum

8290f143a6
feat(animation): introduce `RenderDispatcher` trait

2400d757fe
feat(animation): implement window transparency animation

This commit also fixes graceful shutdown of animations by disabling them
before exit and wait for all remaining animations for 20 seconds.

44189d8382
refactor(animation): move generation of `animation key` to `RenderDispatcher`

e502cb3ffb
refactor(animation): rename `animation` mod to `engine`

Linter was upset about this:
> error: module has the same name as its containing module

369107f5e0
feat(config): adds per animation configuration options

Originally static config only allowed global config for animations.

Since this refactor introduces the abilty to add more type of
animations, this change allows us to configure `enabled`, `duration` and
`style` state per animation type.

Now each of them take either the raw value or a JSON object where keys
are the animation types and values are desired config value. Also adds
support for per animation configuration for komorebic commands.

komorebi-client/src/lib.rs

@@ -1,6 +1,7 @@
 #![warn(clippy::all)]
 #![allow(clippy::missing_errors_doc)]
 
+pub use komorebi::animation::prefix::AnimationPrefix;
 pub use komorebi::asc::ApplicationSpecificConfiguration;
 pub use komorebi::colour::Colour;
 pub use komorebi::colour::Rgb;

komorebi/src/animation/animation_manager.rs

@@ -0,0 +1,115 @@
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+
+use super::prefix::AnimationPrefix;
+
+#[derive(Debug, Clone, Copy)]
+struct AnimationState {
+    pub in_progress: bool,
+    pub cancel_idx_counter: usize,
+    pub pending_cancel_count: usize,
+}
+
+#[derive(Debug)]
+pub struct AnimationManager {
+    animations: HashMap<String, 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, animation_key: &str) -> bool {
+        if let Some(animation_state) = self.animations.get(animation_key) {
+            animation_state.pending_cancel_count > 0
+        } else {
+            false
+        }
+    }
+
+    pub fn in_progress(&self, animation_key: &str) -> bool {
+        if let Some(animation_state) = self.animations.get(animation_key) {
+            animation_state.in_progress
+        } else {
+            false
+        }
+    }
+
+    pub fn init_cancel(&mut self, animation_key: &str) -> usize {
+        if let Some(animation_state) = self.animations.get_mut(animation_key) {
+            animation_state.pending_cancel_count += 1;
+            animation_state.cancel_idx_counter += 1;
+
+            // return cancel idx
+            animation_state.cancel_idx_counter
+        } else {
+            0
+        }
+    }
+
+    pub fn latest_cancel_idx(&mut self, animation_key: &str) -> usize {
+        if let Some(animation_state) = self.animations.get_mut(animation_key) {
+            animation_state.cancel_idx_counter
+        } else {
+            0
+        }
+    }
+
+    pub fn end_cancel(&mut self, animation_key: &str) {
+        if let Some(animation_state) = self.animations.get_mut(animation_key) {
+            animation_state.pending_cancel_count -= 1;
+        }
+    }
+
+    pub fn cancel(&mut self, animation_key: &str) {
+        if let Some(animation_state) = self.animations.get_mut(animation_key) {
+            animation_state.in_progress = false;
+        }
+    }
+
+    pub fn start(&mut self, animation_key: &str) {
+        if let Entry::Vacant(e) = self.animations.entry(animation_key.to_string()) {
+            e.insert(AnimationState {
+                in_progress: true,
+                cancel_idx_counter: 0,
+                pending_cancel_count: 0,
+            });
+
+            return;
+        }
+
+        if let Some(animation_state) = self.animations.get_mut(animation_key) {
+            animation_state.in_progress = true;
+        }
+    }
+
+    pub fn end(&mut self, animation_key: &str) {
+        if let Some(animation_state) = self.animations.get_mut(animation_key) {
+            animation_state.in_progress = false;
+
+            if animation_state.pending_cancel_count == 0 {
+                self.animations.remove(animation_key);
+            }
+        }
+    }
+
+    pub fn count_in_progress(&self, animation_key_prefix: AnimationPrefix) -> usize {
+        self.animations
+            .keys()
+            .filter(|key| key.starts_with(animation_key_prefix.to_string().as_str()))
+            .count()
+    }
+
+    pub fn count(&self) -> usize {
+        self.animations.len()
+    }
+}

komorebi/src/animation/engine.rs

@@ -0,0 +1,122 @@
+use color_eyre::Result;
+
+use schemars::JsonSchema;
+
+use serde::Deserialize;
+use serde::Serialize;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+use std::time::Instant;
+
+use super::RenderDispatcher;
+use super::ANIMATION_DURATION_GLOBAL;
+use super::ANIMATION_FPS;
+use super::ANIMATION_MANAGER;
+
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, JsonSchema, PartialEq)]
+pub struct AnimationEngine;
+
+impl AnimationEngine {
+    pub fn wait_for_all_animations() {
+        let max_duration = Duration::from_secs(20);
+        let spent_duration = Instant::now();
+
+        while ANIMATION_MANAGER.lock().count() > 0 {
+            if spent_duration.elapsed() >= max_duration {
+                break;
+            }
+
+            std::thread::sleep(Duration::from_millis(
+                ANIMATION_DURATION_GLOBAL.load(Ordering::SeqCst),
+            ));
+        }
+    }
+
+    /// Returns true if the animation needs to continue
+    pub fn cancel(animation_key: &str) -> bool {
+        // should be more than 0
+        let cancel_idx = ANIMATION_MANAGER.lock().init_cancel(animation_key);
+        let max_duration = Duration::from_secs(5);
+        let spent_duration = Instant::now();
+
+        while ANIMATION_MANAGER.lock().in_progress(animation_key) {
+            if spent_duration.elapsed() >= max_duration {
+                ANIMATION_MANAGER.lock().end(animation_key);
+            }
+
+            std::thread::sleep(Duration::from_millis(250 / 2));
+        }
+
+        let latest_cancel_idx = ANIMATION_MANAGER.lock().latest_cancel_idx(animation_key);
+
+        ANIMATION_MANAGER.lock().end_cancel(animation_key);
+
+        latest_cancel_idx == cancel_idx
+    }
+
+    #[allow(clippy::cast_precision_loss)]
+    pub fn animate(
+        render_dispatcher: (impl RenderDispatcher + Send + 'static),
+        duration: Duration,
+    ) -> Result<()> {
+        std::thread::spawn(move || {
+            let animation_key = render_dispatcher.get_animation_key();
+            if ANIMATION_MANAGER.lock().in_progress(animation_key.as_str()) {
+                let should_animate = Self::cancel(animation_key.as_str());
+
+                if !should_animate {
+                    return Ok(());
+                }
+            }
+
+            render_dispatcher.pre_render()?;
+
+            ANIMATION_MANAGER.lock().start(animation_key.as_str());
+
+            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(animation_key.as_str())
+                {
+                    // cancel animation
+                    ANIMATION_MANAGER.lock().cancel(animation_key.as_str());
+                    return Ok(());
+                }
+
+                let frame_start = Instant::now();
+                // calculate progress
+                progress =
+                    animation_start.elapsed().as_millis() as f64 / duration.as_millis() as f64;
+                render_dispatcher.render(progress).ok();
+
+                // sleep until next frame
+                let frame_time_elapsed = frame_start.elapsed();
+
+                if frame_time_elapsed < target_frame_time {
+                    std::thread::sleep(target_frame_time - frame_time_elapsed);
+                }
+            }
+
+            ANIMATION_MANAGER.lock().end(animation_key.as_str());
+
+            // 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_dispatcher.render(progress).ok();
+            }
+
+            render_dispatcher.post_render()
+        });
+
+        Ok(())
+    }
+}

komorebi/src/animation/lerp.rs

@@ -0,0 +1,42 @@
+use crate::core::Rect;
+use crate::AnimationStyle;
+
+use super::style::apply_ease_func;
+
+pub trait Lerp<T = Self> {
+    fn lerp(self, end: T, time: f64, style: AnimationStyle) -> T;
+}
+
+impl Lerp for i32 {
+    #[allow(clippy::cast_possible_truncation)]
+    fn lerp(self, end: i32, time: f64, style: AnimationStyle) -> i32 {
+        let time = apply_ease_func(time, style);
+
+        f64::from(end - self).mul_add(time, f64::from(self)).round() as i32
+    }
+}
+
+impl Lerp for f64 {
+    fn lerp(self, end: f64, time: f64, style: AnimationStyle) -> f64 {
+        let time = apply_ease_func(time, style);
+
+        (end - self).mul_add(time, self)
+    }
+}
+
+impl Lerp for u8 {
+    fn lerp(self, end: u8, time: f64, style: AnimationStyle) -> u8 {
+        (self as f64).lerp(end as f64, time, style) as u8
+    }
+}
+
+impl Lerp for Rect {
+    fn lerp(self, end: Rect, time: f64, style: AnimationStyle) -> Rect {
+        Rect {
+            left: self.left.lerp(end.left, time, style),
+            top: self.top.lerp(end.top, time, style),
+            right: self.right.lerp(end.right, time, style),
+            bottom: self.bottom.lerp(end.bottom, time, style),
+        }
+    }
+}

komorebi/src/animation/mod.rs

@@ -0,0 +1,54 @@
+use crate::animation::animation_manager::AnimationManager;
+use crate::core::animation::AnimationStyle;
+
+use lazy_static::lazy_static;
+use prefix::AnimationPrefix;
+use std::collections::HashMap;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+
+pub use engine::AnimationEngine;
+pub mod animation_manager;
+pub mod engine;
+pub mod lerp;
+pub mod prefix;
+pub mod render_dispatcher;
+pub use render_dispatcher::RenderDispatcher;
+pub mod style;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(untagged)]
+pub enum PerAnimationPrefixConfig<T> {
+    Prefix(HashMap<AnimationPrefix, T>),
+    Global(T),
+}
+
+pub const DEFAULT_ANIMATION_ENABLED: bool = false;
+pub const DEFAULT_ANIMATION_STYLE: AnimationStyle = AnimationStyle::Linear;
+pub const DEFAULT_ANIMATION_DURATION: u64 = 250;
+pub const DEFAULT_ANIMATION_FPS: u64 = 60;
+
+lazy_static! {
+    pub static ref ANIMATION_MANAGER: Arc<Mutex<AnimationManager>> =
+        Arc::new(Mutex::new(AnimationManager::new()));
+    pub static ref ANIMATION_STYLE_GLOBAL: Arc<Mutex<AnimationStyle>> =
+        Arc::new(Mutex::new(DEFAULT_ANIMATION_STYLE));
+    pub static ref ANIMATION_ENABLED_GLOBAL: Arc<AtomicBool> =
+        Arc::new(AtomicBool::new(DEFAULT_ANIMATION_ENABLED));
+    pub static ref ANIMATION_DURATION_GLOBAL: Arc<AtomicU64> =
+        Arc::new(AtomicU64::new(DEFAULT_ANIMATION_DURATION));
+    pub static ref ANIMATION_STYLE_PER_ANIMATION: Arc<Mutex<HashMap<AnimationPrefix, AnimationStyle>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    pub static ref ANIMATION_ENABLED_PER_ANIMATION: Arc<Mutex<HashMap<AnimationPrefix, bool>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    pub static ref ANIMATION_DURATION_PER_ANIMATION: Arc<Mutex<HashMap<AnimationPrefix, u64>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+}
+
+pub static ANIMATION_FPS: AtomicU64 = AtomicU64::new(DEFAULT_ANIMATION_FPS);

komorebi/src/animation/prefix.rs

@@ -0,0 +1,31 @@
+use clap::ValueEnum;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use strum::Display;
+use strum::EnumString;
+
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+)]
+#[strum(serialize_all = "snake_case")]
+#[serde(rename_all = "snake_case")]
+pub enum AnimationPrefix {
+    Movement,
+    Transparency,
+}
+
+pub fn new_animation_key(prefix: AnimationPrefix, key: String) -> String {
+    format!("{}:{}", prefix, key)
+}

komorebi/src/animation/render_dispatcher.rs

@@ -0,0 +1,8 @@
+use color_eyre::Result;
+
+pub trait RenderDispatcher {
+    fn get_animation_key(&self) -> String;
+    fn pre_render(&self) -> Result<()>;
+    fn render(&self, delta: f64) -> Result<()>;
+    fn post_render(&self) -> Result<()>;
+}

komorebi/src/animation/style.rs

@@ -1,22 +1,6 @@
 use crate::core::AnimationStyle;
-use crate::core::Rect;
-use color_eyre::Result;
 
-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;
@@ -370,9 +354,8 @@ impl Ease for EaseInOutBounce {
         }
     }
 }
-fn apply_ease_func(t: f64) -> f64 {
-    let style = *ANIMATION_STYLE.lock();
 
+pub fn apply_ease_func(t: f64, style: AnimationStyle) -> f64 {
     match style {
         AnimationStyle::Linear => Linear::evaluate(t),
         AnimationStyle::EaseInSine => EaseInSine::evaluate(t),
@@ -406,112 +389,3 @@ fn apply_ease_func(t: f64) -> f64 {
         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 }
-    }
-
-    /// Returns true if the animation needs to continue
-    pub fn cancel(&mut self) -> bool {
-        if !ANIMATION_MANAGER.lock().in_progress(self.hwnd) {
-            return true;
-        }
-
-        // should be more than 0
-        let cancel_idx = ANIMATION_MANAGER.lock().init_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,
-            ));
-        }
-
-        let latest_cancel_idx = ANIMATION_MANAGER.lock().latest_cancel_idx(self.hwnd);
-
-        ANIMATION_MANAGER.lock().end_cancel(self.hwnd);
-
-        latest_cancel_idx == cancel_idx
-    }
-
-    #[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) {
-            let should_animate = self.cancel();
-
-            if !should_animate {
-                return Ok(());
-            }
-        }
-
-        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
-                ANIMATION_MANAGER.lock().cancel(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
-            let frame_time_elapsed = frame_start.elapsed();
-
-            if frame_time_elapsed < target_frame_time {
-                std::thread::sleep(target_frame_time - frame_time_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

@@ -1,108 +0,0 @@
-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 cancel_idx_counter: usize,
-    pub pending_cancel_count: usize,
-}
-
-#[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.pending_cancel_count > 0
-        } 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 init_cancel(&mut self, hwnd: isize) -> usize {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.pending_cancel_count += 1;
-            animation_state.cancel_idx_counter += 1;
-
-            // return cancel idx
-            animation_state.cancel_idx_counter
-        } else {
-            0
-        }
-    }
-
-    pub fn latest_cancel_idx(&mut self, hwnd: isize) -> usize {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.cancel_idx_counter
-        } else {
-            0
-        }
-    }
-
-    pub fn end_cancel(&mut self, hwnd: isize) {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.pending_cancel_count -= 1;
-        }
-    }
-
-    pub fn cancel(&mut self, hwnd: isize) {
-        if let Some(animation_state) = self.animations.get_mut(&hwnd) {
-            animation_state.in_progress = false;
-        }
-    }
-
-    pub fn start(&mut self, hwnd: isize) {
-        if let Entry::Vacant(e) = self.animations.entry(hwnd) {
-            e.insert(AnimationState {
-                in_progress: true,
-                cancel_idx_counter: 0,
-                pending_cancel_count: 0,
-            });
-
-            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;
-
-            if animation_state.pending_cancel_count == 0 {
-                self.animations.remove(&hwnd);
-                ANIMATIONS_IN_PROGRESS.store(self.animations.len(), Ordering::Release);
-            }
-        }
-    }
-}

komorebi/src/core/mod.rs

@@ -14,6 +14,7 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;
 
+use crate::animation::prefix::AnimationPrefix;
 use crate::KomorebiTheme;
 pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
@@ -147,10 +148,10 @@ pub enum SocketMessage {
     CompleteConfiguration,
     AltFocusHack(bool),
     Theme(KomorebiTheme),
-    Animation(bool),
-    AnimationDuration(u64),
+    Animation(bool, Option<AnimationPrefix>),
+    AnimationDuration(u64, Option<AnimationPrefix>),
     AnimationFps(u64),
-    AnimationStyle(AnimationStyle),
+    AnimationStyle(AnimationStyle, Option<AnimationPrefix>),
     #[serde(alias = "ActiveWindowBorder")]
     Border(bool),
     #[serde(alias = "ActiveWindowBorderColour")]

komorebi/src/lib.rs

@@ -1,7 +1,6 @@
 #![warn(clippy::all)]
 
 pub mod animation;
-pub mod animation_manager;
 pub mod border_manager;
 pub mod com;
 #[macro_use]
@@ -47,8 +46,6 @@ 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 core::*;
 pub use process_command::*;
@@ -216,12 +213,6 @@ 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![]));
@@ -238,8 +229,6 @@ 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);
 
 pub static SLOW_APPLICATION_COMPENSATION_TIME: AtomicU64 = AtomicU64::new(20);
 

komorebi/src/main.rs

@@ -17,6 +17,9 @@ use std::time::Duration;
 use clap::Parser;
 use color_eyre::Result;
 use crossbeam_utils::Backoff;
+use komorebi::animation::AnimationEngine;
+use komorebi::animation::ANIMATION_ENABLED_GLOBAL;
+use komorebi::animation::ANIMATION_ENABLED_PER_ANIMATION;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
@@ -287,7 +290,10 @@ fn main() -> Result<()> {
 
     tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
 
+    ANIMATION_ENABLED_PER_ANIMATION.lock().clear();
+    ANIMATION_ENABLED_GLOBAL.store(false, Ordering::SeqCst);
     wm.lock().restore_all_windows()?;
+    AnimationEngine::wait_for_all_animations();
 
     if WindowsApi::focus_follows_mouse()? {
         WindowsApi::disable_focus_follows_mouse()?;

komorebi/src/process_command.rs

@@ -22,6 +22,10 @@ use schemars::gen::SchemaSettings;
 use schemars::schema_for;
 use uds_windows::UnixStream;
 
+use crate::animation::AnimationEngine;
+use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
+use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
+use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
 use crate::core::config_generation::ApplicationConfiguration;
 use crate::core::config_generation::IdWithIdentifier;
 use crate::core::config_generation::MatchingRule;
@@ -40,6 +44,10 @@ use crate::core::StateQuery;
 use crate::core::WindowContainerBehaviour;
 use crate::core::WindowKind;
 
+use crate::animation::ANIMATION_DURATION_GLOBAL;
+use crate::animation::ANIMATION_ENABLED_GLOBAL;
+use crate::animation::ANIMATION_FPS;
+use crate::animation::ANIMATION_STYLE_GLOBAL;
 use crate::border_manager;
 use crate::border_manager::IMPLEMENTATION;
 use crate::border_manager::STYLE;
@@ -63,10 +71,6 @@ use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::State;
-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;
@@ -889,7 +893,11 @@ impl WindowManager {
                 tracing::info!(
                     "received stop command, restoring all hidden windows and terminating process"
                 );
+
+                ANIMATION_ENABLED_PER_ANIMATION.lock().clear();
+                ANIMATION_ENABLED_GLOBAL.store(false, Ordering::SeqCst);
                 self.restore_all_windows()?;
+                AnimationEngine::wait_for_all_animations();
 
                 if WindowsApi::focus_follows_mouse()? {
                     WindowsApi::disable_focus_follows_mouse()?;
@@ -1532,18 +1540,41 @@ 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::Animation(enable, prefix) => match prefix {
+                Some(prefix) => {
+                    ANIMATION_ENABLED_PER_ANIMATION
+                        .lock()
+                        .insert(prefix, enable);
+                }
+                None => {
+                    ANIMATION_ENABLED_GLOBAL.store(enable, Ordering::SeqCst);
+                    ANIMATION_ENABLED_PER_ANIMATION.lock().clear();
+                }
+            },
+            SocketMessage::AnimationDuration(duration, prefix) => match prefix {
+                Some(prefix) => {
+                    ANIMATION_DURATION_PER_ANIMATION
+                        .lock()
+                        .insert(prefix, duration);
+                }
+                None => {
+                    ANIMATION_DURATION_GLOBAL.store(duration, Ordering::SeqCst);
+                    ANIMATION_DURATION_PER_ANIMATION.lock().clear();
+                }
+            },
             SocketMessage::AnimationFps(fps) => {
                 ANIMATION_FPS.store(fps, Ordering::SeqCst);
             }
-            SocketMessage::AnimationStyle(style) => {
-                *ANIMATION_STYLE.lock() = style;
-            }
+            SocketMessage::AnimationStyle(style, prefix) => match prefix {
+                Some(prefix) => {
+                    ANIMATION_STYLE_PER_ANIMATION.lock().insert(prefix, style);
+                }
+                None => {
+                    let mut animation_style = ANIMATION_STYLE_GLOBAL.lock();
+                    *animation_style = style;
+                    ANIMATION_STYLE_PER_ANIMATION.lock().clear();
+                }
+            },
             SocketMessage::ToggleTransparency => {
                 let current = transparency_manager::TRANSPARENCY_ENABLED.load(Ordering::SeqCst);
                 transparency_manager::TRANSPARENCY_ENABLED.store(!current, Ordering::SeqCst);

komorebi/src/static_config.rs

@@ -1,3 +1,12 @@
+use crate::animation::PerAnimationPrefixConfig;
+use crate::animation::ANIMATION_DURATION_GLOBAL;
+use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
+use crate::animation::ANIMATION_ENABLED_GLOBAL;
+use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
+use crate::animation::ANIMATION_FPS;
+use crate::animation::ANIMATION_STYLE_GLOBAL;
+use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
+use crate::animation::DEFAULT_ANIMATION_FPS;
 use crate::border_manager;
 use crate::border_manager::ZOrder;
 use crate::border_manager::IMPLEMENTATION;
@@ -28,10 +37,6 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::workspace::Workspace;
 use crate::CrossBoundaryBehaviour;
-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;
@@ -374,11 +379,11 @@ pub struct StaticConfig {
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct AnimationsConfig {
     /// Enable or disable animations (default: false)
-    enabled: bool,
+    enabled: PerAnimationPrefixConfig<bool>,
     /// Set the animation duration in ms (default: 250)
-    duration: Option<u64>,
+    duration: Option<PerAnimationPrefixConfig<u64>>,
     /// Set the animation style (default: Linear)
-    style: Option<AnimationStyle>,
+    style: Option<PerAnimationPrefixConfig<AnimationStyle>>,
     /// Set the animation FPS (default: 60)
     fps: Option<u64>,
 }
@@ -654,11 +659,43 @@ impl StaticConfig {
         }
 
         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);
+            match &animations.enabled {
+                PerAnimationPrefixConfig::Prefix(enabled) => {
+                    ANIMATION_ENABLED_PER_ANIMATION.lock().clone_from(enabled);
+                }
+                PerAnimationPrefixConfig::Global(enabled) => {
+                    ANIMATION_ENABLED_GLOBAL.store(*enabled, Ordering::SeqCst);
+                    ANIMATION_ENABLED_PER_ANIMATION.lock().clear();
+                }
+            }
+
+            match &animations.style {
+                Some(PerAnimationPrefixConfig::Prefix(style)) => {
+                    ANIMATION_STYLE_PER_ANIMATION.lock().clone_from(style);
+                }
+                Some(PerAnimationPrefixConfig::Global(style)) => {
+                    let mut animation_style = ANIMATION_STYLE_GLOBAL.lock();
+                    *animation_style = *style;
+                    ANIMATION_STYLE_PER_ANIMATION.lock().clear();
+                }
+                None => {}
+            }
+
+            match &animations.duration {
+                Some(PerAnimationPrefixConfig::Prefix(duration)) => {
+                    ANIMATION_DURATION_PER_ANIMATION.lock().clone_from(duration);
+                }
+                Some(PerAnimationPrefixConfig::Global(duration)) => {
+                    ANIMATION_DURATION_GLOBAL.store(*duration, Ordering::SeqCst);
+                    ANIMATION_DURATION_PER_ANIMATION.lock().clear();
+                }
+                None => {}
+            }
+
+            ANIMATION_FPS.store(
+                animations.fps.unwrap_or(DEFAULT_ANIMATION_FPS),
+                Ordering::SeqCst,
+            );
         }
 
         if let Some(container) = self.default_container_padding {

komorebi/src/window.rs

@@ -1,11 +1,21 @@
+use crate::animation::lerp::Lerp;
+use crate::animation::prefix::new_animation_key;
+use crate::animation::prefix::AnimationPrefix;
+use crate::animation::AnimationEngine;
+use crate::animation::RenderDispatcher;
+use crate::animation::ANIMATION_DURATION_GLOBAL;
+use crate::animation::ANIMATION_DURATION_PER_ANIMATION;
+use crate::animation::ANIMATION_ENABLED_GLOBAL;
+use crate::animation::ANIMATION_ENABLED_PER_ANIMATION;
+use crate::animation::ANIMATION_MANAGER;
+use crate::animation::ANIMATION_STYLE_GLOBAL;
+use crate::animation::ANIMATION_STYLE_PER_ANIMATION;
 use crate::border_manager;
 use crate::com::SetCloak;
 use crate::focus_manager;
 use crate::stackbar_manager;
 use crate::windows_api;
-use crate::ANIMATIONS_IN_PROGRESS;
-use crate::ANIMATION_DURATION;
-use crate::ANIMATION_ENABLED;
+use crate::AnimationStyle;
 use crate::SLOW_APPLICATION_COMPENSATION_TIME;
 use crate::SLOW_APPLICATION_IDENTIFIERS;
 use std::collections::HashMap;
@@ -35,7 +45,6 @@ use crate::core::ApplicationIdentifier;
 use crate::core::HidingBehaviour;
 use crate::core::Rect;
 
-use crate::animation::Animation;
 use crate::styles::ExtendedWindowStyle;
 use crate::styles::WindowStyle;
 use crate::transparency_manager;
@@ -58,16 +67,11 @@ pub static MINIMUM_HEIGHT: AtomicI32 = AtomicI32::new(0);
 #[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema, PartialEq)]
 pub struct Window {
     pub hwnd: isize,
-    #[serde(skip)]
-    animation: Animation,
 }
 
 impl From<isize> for Window {
     fn from(value: isize) -> Self {
-        Self {
-            hwnd: value,
-            animation: Animation::new(value),
-        }
+        Self { hwnd: value }
     }
 }
 
@@ -75,7 +79,6 @@ impl From<HWND> for Window {
     fn from(value: HWND) -> Self {
         Self {
             hwnd: value.0 as isize,
-            animation: Animation::new(value.0 as isize),
         }
     }
 }
@@ -155,6 +158,149 @@ impl Serialize for Window {
     }
 }
 
+struct MovementRenderDispatcher {
+    hwnd: isize,
+    start_rect: Rect,
+    target_rect: Rect,
+    top: bool,
+    style: AnimationStyle,
+}
+
+impl MovementRenderDispatcher {
+    const PREFIX: AnimationPrefix = AnimationPrefix::Movement;
+
+    pub fn new(
+        hwnd: isize,
+        start_rect: Rect,
+        target_rect: Rect,
+        top: bool,
+        style: AnimationStyle,
+    ) -> Self {
+        Self {
+            hwnd,
+            start_rect,
+            target_rect,
+            top,
+            style,
+        }
+    }
+}
+
+impl RenderDispatcher for MovementRenderDispatcher {
+    fn get_animation_key(&self) -> String {
+        new_animation_key(MovementRenderDispatcher::PREFIX, self.hwnd.to_string())
+    }
+
+    fn pre_render(&self) -> Result<()> {
+        border_manager::BORDER_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
+        border_manager::send_notification(Some(self.hwnd));
+
+        stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
+        stackbar_manager::send_notification();
+
+        Ok(())
+    }
+
+    fn render(&self, progress: f64) -> Result<()> {
+        let new_rect = self.start_rect.lerp(self.target_rect, progress, self.style);
+
+        // using MoveWindow because it runs faster than SetWindowPos
+        // so animation have more fps and feel smoother
+        WindowsApi::move_window(self.hwnd, &new_rect, false)?;
+        WindowsApi::invalidate_rect(self.hwnd, None, false);
+
+        Ok(())
+    }
+
+    fn post_render(&self) -> Result<()> {
+        WindowsApi::position_window(self.hwnd, &self.target_rect, self.top)?;
+        if ANIMATION_MANAGER
+            .lock()
+            .count_in_progress(MovementRenderDispatcher::PREFIX)
+            == 0
+        {
+            if WindowsApi::foreground_window().unwrap_or_default() == self.hwnd {
+                focus_manager::send_notification(self.hwnd)
+            }
+
+            border_manager::BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
+            stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
+
+            border_manager::send_notification(Some(self.hwnd));
+            stackbar_manager::send_notification();
+            transparency_manager::send_notification();
+        }
+
+        Ok(())
+    }
+}
+
+struct TransparencyRenderDispatcher {
+    hwnd: isize,
+    start_opacity: u8,
+    target_opacity: u8,
+    style: AnimationStyle,
+    is_opaque: bool,
+}
+
+impl TransparencyRenderDispatcher {
+    const PREFIX: AnimationPrefix = AnimationPrefix::Transparency;
+
+    pub fn new(
+        hwnd: isize,
+        is_opaque: bool,
+        start_opacity: u8,
+        target_opacity: u8,
+        style: AnimationStyle,
+    ) -> Self {
+        Self {
+            hwnd,
+            start_opacity,
+            target_opacity,
+            style,
+            is_opaque,
+        }
+    }
+}
+
+impl RenderDispatcher for TransparencyRenderDispatcher {
+    fn get_animation_key(&self) -> String {
+        new_animation_key(TransparencyRenderDispatcher::PREFIX, self.hwnd.to_string())
+    }
+
+    fn pre_render(&self) -> Result<()> {
+        //transparent
+        if !self.is_opaque {
+            let window = Window::from(self.hwnd);
+            let mut ex_style = window.ex_style()?;
+            ex_style.insert(ExtendedWindowStyle::LAYERED);
+            window.update_ex_style(&ex_style)?;
+        }
+
+        Ok(())
+    }
+
+    fn render(&self, progress: f64) -> Result<()> {
+        WindowsApi::set_transparent(
+            self.hwnd,
+            self.start_opacity
+                .lerp(self.target_opacity, progress, self.style),
+        )
+    }
+
+    fn post_render(&self) -> Result<()> {
+        //opaque
+        if self.is_opaque {
+            let window = Window::from(self.hwnd);
+            let mut ex_style = window.ex_style()?;
+            ex_style.remove(ExtendedWindowStyle::LAYERED);
+            window.update_ex_style(&ex_style)?;
+        }
+
+        Ok(())
+    }
+}
+
 impl Window {
     pub const fn hwnd(self) -> HWND {
         HWND(windows_api::as_ptr!(self.hwnd))
@@ -200,53 +346,6 @@ impl Window {
         )
     }
 
-    pub fn animate_position(&self, start_rect: &Rect, target_rect: &Rect, top: bool) -> Result<()> {
-        let start_rect = *start_rect;
-        let target_rect = *target_rect;
-        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(Some(self.hwnd));
-
-        stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
-        stackbar_manager::send_notification();
-
-        let hwnd = self.hwnd;
-
-        std::thread::spawn(move || {
-            animation.animate(duration, |progress: f64| {
-                let new_rect = Animation::lerp_rect(&start_rect, &target_rect, progress);
-
-                if progress == 1.0 {
-                    WindowsApi::position_window(hwnd, &new_rect, top)?;
-                    if WindowsApi::foreground_window().unwrap_or_default() == hwnd {
-                        focus_manager::send_notification(hwnd)
-                    }
-
-                    if 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(Some(hwnd));
-                        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::invalidate_rect(hwnd, None, false);
-                }
-
-                Ok(())
-            })
-        });
-
-        Ok(())
-    }
-
     pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
         let window_rect = WindowsApi::window_rect(self.hwnd)?;
 
@@ -254,8 +353,27 @@ impl Window {
             return Ok(());
         }
 
-        if ANIMATION_ENABLED.load(Ordering::SeqCst) {
-            self.animate_position(&window_rect, layout, top)
+        let animation_enabled = ANIMATION_ENABLED_PER_ANIMATION.lock();
+        let move_enabled = animation_enabled.get(&MovementRenderDispatcher::PREFIX);
+
+        if move_enabled.is_some_and(|enabled| *enabled)
+            || ANIMATION_ENABLED_GLOBAL.load(Ordering::SeqCst)
+        {
+            let duration = Duration::from_millis(
+                *ANIMATION_DURATION_PER_ANIMATION
+                    .lock()
+                    .get(&MovementRenderDispatcher::PREFIX)
+                    .unwrap_or(&ANIMATION_DURATION_GLOBAL.load(Ordering::SeqCst)),
+            );
+            let style = *ANIMATION_STYLE_PER_ANIMATION
+                .lock()
+                .get(&MovementRenderDispatcher::PREFIX)
+                .unwrap_or(&ANIMATION_STYLE_GLOBAL.lock());
+
+            let render_dispatcher =
+                MovementRenderDispatcher::new(self.hwnd, window_rect, *layout, top, style);
+
+            AnimationEngine::animate(render_dispatcher, duration)
         } else {
             WindowsApi::position_window(self.hwnd, layout, top)
         }
@@ -368,19 +486,76 @@ impl Window {
     }
 
     pub fn transparent(self) -> Result<()> {
-        let mut ex_style = self.ex_style()?;
-        ex_style.insert(ExtendedWindowStyle::LAYERED);
-        self.update_ex_style(&ex_style)?;
-        WindowsApi::set_transparent(
-            self.hwnd,
-            transparency_manager::TRANSPARENCY_ALPHA.load_consume(),
-        )
+        let animation_enabled = ANIMATION_ENABLED_PER_ANIMATION.lock();
+        let transparent_enabled = animation_enabled.get(&TransparencyRenderDispatcher::PREFIX);
+
+        if transparent_enabled.is_some_and(|enabled| *enabled)
+            || ANIMATION_ENABLED_GLOBAL.load(Ordering::SeqCst)
+        {
+            let duration = Duration::from_millis(
+                *ANIMATION_DURATION_PER_ANIMATION
+                    .lock()
+                    .get(&TransparencyRenderDispatcher::PREFIX)
+                    .unwrap_or(&ANIMATION_DURATION_GLOBAL.load(Ordering::SeqCst)),
+            );
+            let style = *ANIMATION_STYLE_PER_ANIMATION
+                .lock()
+                .get(&TransparencyRenderDispatcher::PREFIX)
+                .unwrap_or(&ANIMATION_STYLE_GLOBAL.lock());
+
+            let render_dispatcher = TransparencyRenderDispatcher::new(
+                self.hwnd,
+                false,
+                WindowsApi::get_transparent(self.hwnd).unwrap_or(255),
+                transparency_manager::TRANSPARENCY_ALPHA.load_consume(),
+                style,
+            );
+
+            AnimationEngine::animate(render_dispatcher, duration)
+        } else {
+            let mut ex_style = self.ex_style()?;
+            ex_style.insert(ExtendedWindowStyle::LAYERED);
+            self.update_ex_style(&ex_style)?;
+            WindowsApi::set_transparent(
+                self.hwnd,
+                transparency_manager::TRANSPARENCY_ALPHA.load_consume(),
+            )
+        }
     }
 
     pub fn opaque(self) -> Result<()> {
-        let mut ex_style = self.ex_style()?;
-        ex_style.remove(ExtendedWindowStyle::LAYERED);
-        self.update_ex_style(&ex_style)
+        let animation_enabled = ANIMATION_ENABLED_PER_ANIMATION.lock();
+        let transparent_enabled = animation_enabled.get(&TransparencyRenderDispatcher::PREFIX);
+
+        if transparent_enabled.is_some_and(|enabled| *enabled)
+            || ANIMATION_ENABLED_GLOBAL.load(Ordering::SeqCst)
+        {
+            let duration = Duration::from_millis(
+                *ANIMATION_DURATION_PER_ANIMATION
+                    .lock()
+                    .get(&TransparencyRenderDispatcher::PREFIX)
+                    .unwrap_or(&ANIMATION_DURATION_GLOBAL.load(Ordering::SeqCst)),
+            );
+            let style = *ANIMATION_STYLE_PER_ANIMATION
+                .lock()
+                .get(&TransparencyRenderDispatcher::PREFIX)
+                .unwrap_or(&ANIMATION_STYLE_GLOBAL.lock());
+
+            let render_dispatcher = TransparencyRenderDispatcher::new(
+                self.hwnd,
+                true,
+                WindowsApi::get_transparent(self.hwnd)
+                    .unwrap_or(transparency_manager::TRANSPARENCY_ALPHA.load_consume()),
+                255,
+                style,
+            );
+
+            AnimationEngine::animate(render_dispatcher, duration)
+        } else {
+            let mut ex_style = self.ex_style()?;
+            ex_style.remove(ExtendedWindowStyle::LAYERED);
+            self.update_ex_style(&ex_style)
+        }
     }
 
     pub fn set_accent(self, colour: u32) -> Result<()> {

komorebi/src/windows_api.rs

@@ -77,6 +77,7 @@ use windows::Win32::UI::WindowsAndMessaging::EnumWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
 use windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::GetLayeredWindowAttributes;
 use windows::Win32::UI::WindowsAndMessaging::GetTopWindow;
 use windows::Win32::UI::WindowsAndMessaging::GetWindow;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
@@ -1127,6 +1128,21 @@ impl WindowsApi {
         Ok(())
     }
 
+    pub fn get_transparent(hwnd: isize) -> Result<u8> {
+        unsafe {
+            let mut alpha: u8 = u8::default();
+            let mut color_ref = COLORREF(-1i32 as u32);
+            let mut flags = LWA_ALPHA;
+            GetLayeredWindowAttributes(
+                HWND(as_ptr!(hwnd)),
+                Some(std::ptr::addr_of_mut!(color_ref)),
+                Some(std::ptr::addr_of_mut!(alpha)),
+                Some(std::ptr::addr_of_mut!(flags)),
+            )?;
+            Ok(alpha)
+        }
+    }
+
     pub fn create_hidden_window(name: PCWSTR, instance: isize) -> Result<isize> {
         unsafe {
             CreateWindowExW(

komorebic/src/main.rs

@@ -724,12 +724,18 @@ struct BorderImplementation {
 struct Animation {
     #[clap(value_enum)]
     boolean_state: BooleanState,
+    /// Animation type to apply the state to. If not specified, sets global state
+    #[clap(value_enum, short, long)]
+    animation_type: Option<komorebi_client::AnimationPrefix>,
 }
 
 #[derive(Parser)]
 struct AnimationDuration {
     /// Desired animation durations in ms
     duration: u64,
+    /// Animation type to apply the duration to. If not specified, sets global duration
+    #[clap(value_enum, short, long)]
+    animation_type: Option<komorebi_client::AnimationPrefix>,
 }
 
 #[derive(Parser)]
@@ -743,6 +749,9 @@ struct AnimationStyle {
     /// Desired ease function for animation
     #[clap(value_enum, short, long, default_value = "linear")]
     style: komorebi_client::AnimationStyle,
+    /// Animation type to apply the style to. If not specified, sets global style
+    #[clap(value_enum, short, long)]
+    animation_type: Option<komorebi_client::AnimationPrefix>,
 }
 
 #[derive(Parser)]
@@ -2546,16 +2555,25 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
             send_message(&SocketMessage::ToggleTransparency)?;
         }
         SubCommand::Animation(arg) => {
-            send_message(&SocketMessage::Animation(arg.boolean_state.into()))?;
+            send_message(&SocketMessage::Animation(
+                arg.boolean_state.into(),
+                arg.animation_type,
+            ))?;
         }
         SubCommand::AnimationDuration(arg) => {
-            send_message(&SocketMessage::AnimationDuration(arg.duration))?;
+            send_message(&SocketMessage::AnimationDuration(
+                arg.duration,
+                arg.animation_type,
+            ))?;
         }
         SubCommand::AnimationFps(arg) => {
             send_message(&SocketMessage::AnimationFps(arg.fps))?;
         }
         SubCommand::AnimationStyle(arg) => {
-            send_message(&SocketMessage::AnimationStyle(arg.style))?;
+            send_message(&SocketMessage::AnimationStyle(
+                arg.style,
+                arg.animation_type,
+            ))?;
         }
 
         SubCommand::ResizeDelta(arg) => {