fix: are_transitions_ongoing condition and border fade implementation

Author: busyoGG

src/layout/focus_ring.rs

@@ -67,6 +67,7 @@ impl FocusRing {
         alpha: f32,
         exponent: f32,
         gradient_angle_offset: f32,
+        mix_ratio: f32,
     ) {
         let width = self.config.width;
         self.full_size = win_size + Size::from((width, width)).upscale(2.);
@@ -86,6 +87,24 @@ impl FocusRing {
 
         let radius = radius.fit_to(self.full_size.w as f32, self.full_size.h as f32);
 
+        fn mix_color(active: Gradient, inactive: Gradient, mix_ratio: f32) -> Gradient {
+            let t = mix_ratio;
+            let inv = 1. - mix_ratio;
+
+            let mut new = active.clone();
+            new.from.r = active.from.r * t + inactive.from.r * inv;
+            new.from.g = active.from.g * t + inactive.from.g * inv;
+            new.from.b = active.from.b * t + inactive.from.b * inv;
+            new.from.a = active.from.a * t + inactive.from.a * inv;
+
+            new.to.r = active.to.r * t + inactive.to.r * inv;
+            new.to.g = active.to.g * t + inactive.to.g * inv;
+            new.to.b = active.to.b * t + inactive.to.b * inv;
+            new.to.a = active.to.a * t + inactive.to.a * inv;
+
+            new
+        }
+
         let gradient = if is_urgent {
             self.config.urgent_gradient
         } else if is_active {
@@ -97,7 +116,38 @@ impl FocusRing {
         self.use_border_shader = radius != CornerRadius::default() || gradient.is_some();
 
         // Set the defaults for solid color + rounded corners.
-        let gradient = gradient.unwrap_or_else(|| Gradient::from(color));
+        // let gradient = gradient.unwrap_or_else(|| Gradient::from(color));
+        let gradient = if is_urgent {
+            mix_color(
+                self.config
+                    .urgent_gradient
+                    .unwrap_or_else(|| Gradient::from(self.config.urgent_color)),
+                self.config
+                    .inactive_gradient
+                    .unwrap_or_else(|| Gradient::from(self.config.inactive_color)),
+                mix_ratio,
+            )
+        } else if is_active {
+            mix_color(
+                self.config
+                    .active_gradient
+                    .unwrap_or_else(|| Gradient::from(self.config.active_color)),
+                self.config
+                    .inactive_gradient
+                    .unwrap_or_else(|| Gradient::from(self.config.inactive_color)),
+                mix_ratio,
+            )
+        } else {
+            mix_color(
+                self.config
+                    .active_gradient
+                    .unwrap_or_else(|| Gradient::from(self.config.active_color)),
+                self.config
+                    .inactive_gradient
+                    .unwrap_or_else(|| Gradient::from(self.config.inactive_color)),
+                mix_ratio,
+            )
+        };
 
         let full_rect = Rectangle::new(Point::from((-width, -width)), self.full_size);
         let gradient_area = match gradient.relative_to {

src/layout/insert_hint_element.rs

@@ -56,7 +56,7 @@ impl InsertHintElement {
         scale: f64,
     ) {
         self.inner.update_render_elements(
-            size, true, false, false, view_rect, radius, scale, 1., 2.8, 0.,
+            size, true, false, false, view_rect, radius, scale, 1., 2.8, 0., 1.,
         );
     }
 

src/layout/tile.rs

@@ -481,8 +481,12 @@ impl<W: LayoutElement> Tile<W> {
                 .focus_ring_anim
                 .as_ref()
                 .is_some_and(|anim| !anim.is_done())
-            || (self.was_focus_active && self.options.layout.focus_ring.gradient_spin_speed > 0.)
-            || (self.was_focus_active && self.options.layout.border.gradient_spin_speed > 0.)
+            || (self.was_focus_active
+                && !self.options.layout.focus_ring.off
+                && self.options.layout.focus_ring.gradient_spin_speed > 0.)
+            || (self.was_focus_active
+                && !self.options.layout.border.off
+                && self.options.layout.border.gradient_spin_speed > 0.)
     }
 
     pub fn update_render_elements(&mut self, is_active: bool, view_rect: Rectangle<f64, Logical>) {
@@ -549,7 +553,13 @@ impl<W: LayoutElement> Tile<W> {
         };
         let radius = radius.expanded_by(self.focus_ring.width() as f32);
 
-        let fade_ms = self.options.layout.focus_ring.fade_duration_ms;
+        let fade_ms = if !self.options.layout.focus_ring.off {
+            self.options.layout.focus_ring.fade_duration_ms
+        } else if !self.options.layout.border.off {
+            self.options.layout.border.fade_duration_ms
+        } else {
+            0
+        };
 
         // Animate focus ring fade in/out on focus change.
         if is_active != self.was_focus_active {
@@ -619,6 +629,7 @@ impl<W: LayoutElement> Tile<W> {
             focus_ring_alpha * (1. - expanded_progress as f32),
             exponent,
             gradient_angle_offset,
+            1.,
         );
 
         self.border.update_render_elements(
@@ -635,6 +646,7 @@ impl<W: LayoutElement> Tile<W> {
             1. - expanded_progress as f32,
             exponent,
             gradient_angle_offset,
+            focus_ring_alpha * (1. - expanded_progress as f32),
         );
 
         self.fullscreen_backdrop.resize(animated_tile_size);

src/ui/mru.rs

@@ -546,6 +546,7 @@ impl Thumbnail {
                 0.5,
                 exponent,
                 0.,
+                1.,
             );
             background.render(ctx.renderer, loc, &mut |elem| {
                 push(WindowMruUiRenderElement::FocusRing(elem))
@@ -569,6 +570,7 @@ impl Thumbnail {
                 1.,
                 exponent,
                 0.,
+                1.,
             );
 
             border.render(ctx.renderer, loc, &mut |elem| {