feat(dashboard): adding wipe to tabs

Author: grampelberg

src/fx.rs

@@ -1,4 +1,4 @@
-use bon::Builder;
+use bon::{builder, Builder};
 use eyre::Result;
 use ndarray::{s, ArrayViewMut2};
 use ratatui::{buffer::Buffer, layout::Rect, Frame};
@@ -46,29 +46,44 @@ impl Widget for Animated {
     }
 }
 
-/// Wipes content in from right to left, uses `previous` as the source and then
+#[derive(Clone, Default)]
+pub enum Start {
+    Left,
+    #[default]
+    Right,
+}
+
+/// Wipes content in from the start edge, uses `previous` as the source and then
 /// the current buffer as the destination.
 #[derive(Builder, Clone)]
-pub struct Slider {
+pub struct Wipe {
     #[builder(into)]
     timer: EffectTimer,
+    #[builder(default)]
+    start: Start,
     previous: Buffer,
     #[builder(default)]
     done: bool,
 }
 
-pub fn right_to_left<T: Into<EffectTimer>>(timer: T, previous: Buffer) -> Effect {
+#[builder]
+pub fn horizontal_wipe<T: Into<EffectTimer>>(
+    timer: T,
+    buffer: Buffer,
+    #[builder(default)] start: Start,
+) -> Effect {
     Effect::new(
-        Slider::builder()
+        Wipe::builder()
             .timer(timer.into())
-            .previous(previous)
+            .previous(buffer)
+            .start(start)
             .build(),
     )
 }
 
 // This assumes that the area from the original buffer to the new one doesn't
 // change. If it is unable to create a slice correctly, it'll just give up.
-impl Shader for Slider {
+impl Shader for Wipe {
     fn name(&self) -> &'static str {
         "slider"
     }
@@ -87,36 +102,40 @@ impl Shader for Slider {
         let y = area.y as usize;
         let width = area.width as usize;
         let height = area.height as usize;
+        let buffer_width = self.previous.area.width as usize;
+        let buffer_height = self.previous.area.height as usize;
 
         let window = ((width as f32 * alpha).round() as usize).clamp(0, width);
 
         if window == width {
             self.done = true;
         }
 
-        let Ok(previous) = ArrayViewMut2::from_shape(
-            (area.height as usize, area.width as usize),
-            &mut self.previous.content,
-        ) else {
+        let Ok(previous) =
+            ArrayViewMut2::from_shape((buffer_height, buffer_width), &mut self.previous.content)
+        else {
             tracing::debug!(area = ?area, "unable to create view from previous buffer");
 
             self.done = true;
             return overflow;
         };
 
-        let Ok(mut next) = ArrayViewMut2::from_shape(
-            (area.height as usize, area.width as usize),
-            &mut buf.content,
-        ) else {
+        let Ok(mut next) =
+            ArrayViewMut2::from_shape((buffer_height, buffer_width), &mut buf.content)
+        else {
             tracing::debug!(area = ?area, "unable to create view from next buffer");
 
             self.done = true;
             return overflow;
         };
 
-        let slice = s![y..y + height, x..x + width - window];
+        let slice = match self.start {
+            Start::Left => s![y..height, x + window..x + width],
+            Start::Right => s![y..y + height, x..x + width - window],
+        };
 
         let previous_section = previous.slice(slice);
+
         next.slice_mut(slice).assign(&previous_section);
 
         overflow

src/widget/log.rs

@@ -85,10 +85,12 @@ impl Log {
     // TODO: This should be a macro. Ideally, it'd be a trait with a default impl
     // but I don't think it is possible to do generically.
     pub fn tab(name: String, client: kube::Client, pod: Arc<Pod>) -> Tab {
-        Tab::new(
-            name,
-            Box::new(move || Box::new(Log::new(client.clone(), pod.clone()))),
-        )
+        Tab::builder()
+            .name(name)
+            .constructor(Box::new(move || {
+                Log::new(client.clone(), pod.clone()).boxed()
+            }))
+            .build()
     }
 
     fn update(&mut self) -> u16 {

src/widget/pod.rs

@@ -107,12 +107,13 @@ impl Detail {
     fn new(client: &kube::Client, pod: Arc<Pod>) -> Self {
         WIDGET_VIEWS.pod.detail.inc();
 
-        let view = TabbedView::new(vec![
-            Yaml::tab("Overview".to_string(), pod.clone()),
-            Log::tab("Logs".to_string(), client.clone(), pod.clone()),
-            Shell::tab("Shell".to_string(), client.clone(), pod.clone()).no_margin(),
-        ])
-        .unwrap();
+        let view = TabbedView::builder()
+            .tabs(vec![
+                Yaml::tab("Overview".to_string(), pod.clone()),
+                Log::tab("Logs".to_string(), client.clone(), pod.clone()),
+                Shell::tab("Shell".to_string(), client.clone(), pod.clone()),
+            ])
+            .build();
 
         Self { pod, view }
     }

src/widget/pod/shell.rs

@@ -71,17 +71,16 @@ impl Shell {
     }
 
     pub fn tab(name: String, client: kube::Client, pod: Arc<Pod>) -> Tab {
-        Tab::new(
-            name,
-            Box::new(move || {
-                Box::new(
-                    Self::builder()
-                        .client(client.clone())
-                        .pod(pod.clone())
-                        .build(),
-                )
-            }),
-        )
+        Tab::builder()
+            .name(name)
+            .constructor(Box::new(move || {
+                Self::builder()
+                    .client(client.clone())
+                    .pod(pod.clone())
+                    .build()
+                    .boxed()
+            }))
+            .build()
     }
 }
 

src/widget/table.rs

@@ -22,7 +22,7 @@ use super::{
 };
 use crate::{
     events::{Broadcast, Event, Keypress},
-    fx::{right_to_left, Animated},
+    fx::Animated,
 };
 
 lazy_static! {
@@ -238,14 +238,11 @@ impl Filtered {
         let widget = (self.constructor)(idx, self.filter.borrow().clone())?;
 
         let detail = Animated::builder()
-            .maybe_effect(frame.map(|buffer| {
-                fx::parallel(&[
-                    fx::coalesce(EffectTimer::from_ms(500, Interpolation::SineInOut)),
-                    right_to_left(
-                        EffectTimer::from_ms(500, Interpolation::SineInOut),
-                        buffer.clone(),
-                    ),
-                ])
+            .maybe_effect(frame.map(|_| {
+                fx::parallel(&[fx::coalesce(EffectTimer::from_ms(
+                    500,
+                    Interpolation::SineInOut,
+                ))])
             }))
             .widget(widget)
             .build();