Separate Footer widget; refresh display before event loop

Sebastian Thiel · Sebastian Thiel · commit 4112a9b971f3 · 2019-06-03T10:13:29.000+05:30
diff --git a/src/interactive/app.rs b/src/interactive/app.rs
@@ -186,17 +186,32 @@ impl Traversal {
 }
 
 /// State and methods representing the interactive disk usage analyser for the terminal
-#[derive(Default, Debug)]
 pub struct TerminalApp {
     pub traversal: Traversal,
+    pub display: DisplayOptions,
 }
 
 const GUI_REFRESH_RATE: Duration = Duration::from_millis(100);
 
 impl TerminalApp {
+    fn draw<B>(&self, terminal: &mut Terminal<B>) -> Result<(), Error>
+    where
+        B: Backend,
+    {
+        let Self { traversal, display } = self;
+        terminal.draw(|mut f| {
+            let full_screen = f.size();
+            super::widgets::MainWindow {
+                traversal,
+                display: *display,
+            }
+            .render(&mut f, full_screen)
+        })?;
+        Ok(())
+    }
     pub fn process_events<B, R>(
         &mut self,
-        _terminal: &mut Terminal<B>,
+        terminal: &mut Terminal<B>,
         keys: Keys<R>,
     ) -> Result<WalkResult, Error>
     where
@@ -205,11 +220,13 @@ impl TerminalApp {
     {
         use termion::event::Key::{Char, Ctrl};
 
+        self.draw(terminal)?;
         for key in keys.filter_map(Result::ok) {
             match key {
                 Ctrl('c') | Char('\n') | Char('q') => break,
-                _ => dbg!(&key),
+                _ => {}
             };
+            self.draw(terminal)?;
         }
         Ok(WalkResult {
             num_errors: self.traversal.io_errors,
@@ -226,10 +243,11 @@ impl TerminalApp {
     {
         let display_options: DisplayOptions = options.clone().into();
         Ok(TerminalApp {
+            display: display_options,
             traversal: Traversal::from_walk(options, input, move |traversal| {
                 terminal.draw(|mut f| {
                     let full_screen = f.size();
-                    super::widgets::InitWindow {
+                    super::widgets::MainWindow {
                         traversal,
                         display: display_options,
                     }
diff --git a/src/interactive/widgets.rs b/src/interactive/widgets.rs
@@ -1,4 +1,5 @@
 use super::{DisplayOptions, Traversal, Tree, TreeIndex};
+use crate::ByteFormat;
 use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Style};
 use tui::{
@@ -13,56 +14,78 @@ pub struct Entries<'a> {
     pub display: DisplayOptions,
 }
 
-pub struct InitWindow<'a> {
+pub struct MainWindow<'a> {
     pub traversal: &'a Traversal,
     pub display: DisplayOptions,
 }
 
+pub struct Footer {
+    pub total_bytes: u64,
+    pub entries_traversed: u64,
+    pub format: ByteFormat,
+}
+
+impl Widget for Footer {
+    fn draw(&mut self, area: Rect, buf: &mut Buffer) {
+        assert!(area.height == 1, "The footer must be a line");
+        let bg_color = Color::White;
+        let text_color = Color::Black;
+        let margin = 1;
+        self.background(area, buf, bg_color);
+        buf.set_stringn(
+            area.x + margin,
+            area.y,
+            format!(
+                "Total disk usage: {}  Entries: {}",
+                format!("{}", self.format.display(self.total_bytes)).trim(),
+                self.entries_traversed
+            ),
+            (area.width - margin) as usize,
+            Style {
+                fg: text_color,
+                bg: bg_color,
+                ..Default::default()
+            },
+        )
+    }
+}
+
 fn get_size_or_panic(tree: &Tree, node_idx: TreeIndex) -> u64 {
     tree.node_weight(node_idx)
         .expect("node should always be retrievable with valid index")
         .size
 }
 
-impl<'a> Widget for InitWindow<'a> {
+impl<'a> Widget for MainWindow<'a> {
     fn draw(&mut self, area: Rect, buf: &mut Buffer) {
+        let Self {
+            traversal:
+                Traversal {
+                    tree,
+                    root_index,
+                    entries_traversed,
+                    ..
+                },
+            display,
+        } = *self;
         let regions = Layout::default()
             .direction(Direction::Vertical)
             .constraints([Constraint::Max(256), Constraint::Length(1)].as_ref())
             .split(area);
         let (entries, footer) = (regions[0], regions[1]);
         Entries {
-            tree: &self.traversal.tree,
-            root: self.traversal.root_index,
-            display: self.display,
+            tree: &tree,
+            root: *root_index,
+            display: display,
         }
         .draw(entries, buf);
 
-        let bg_color = Color::White;
-        let text_color = Color::Black;
-        let margin = 1;
-        self.background(footer, buf, bg_color);
-        buf.set_stringn(
-            footer.x + margin,
-            footer.y,
-            format!(
-                "Total disk usage: {}",
-                format!(
-                    "{}",
-                    self.display.byte_format.display(get_size_or_panic(
-                        &self.traversal.tree,
-                        self.traversal.root_index
-                    ))
-                )
-                .trim()
-            ),
-            (footer.width - margin) as usize,
-            Style {
-                fg: text_color,
-                bg: bg_color,
-                ..Default::default()
-            },
-        )
+        Footer {
+            total_bytes: get_size_or_panic(&tree, *root_index),
+            entries_traversed: *entries_traversed,
+            format: display.byte_format,
+        }
+        .draw(footer, buf);
     }
 }
 
