How to animate the terminal in Rust - rust

Question

I need to profile several variables like frames per second being rendered in my app. Therefore I need a simple way to update variables in the terminal.
I've searched and found ascii_table for generating tables, and termion for updating the terminal. But I suspect termion here is simply being used to clear the terminal.
Anyways, I was able to draw a simple table and update its contents every 200 miliseconds:
use ascii_table::{Align, AsciiTable, Column};
extern crate termion;
use termion::{clear, color, cursor};
use std::fmt::Display;
use std::{thread, time};
fn main() {
let mut ascii_table = AsciiTable::default();
ascii_table.max_width = 40;
let mut column = Column::default();
column.header = "H1".into();
column.align = Align::Left;
ascii_table.columns.insert(0, column);
let mut column = Column::default();
column.header = "H2".into();
column.align = Align::Center;
ascii_table.columns.insert(1, column);
let mut column = Column::default();
column.header = "H3".into();
column.align = Align::Right;
ascii_table.columns.insert(2, column);
let mut i = 0;
while (true) {
let data: Vec<Vec<&dyn Display>> = vec![
vec![&i, &"hello", &789],
];
let s = ascii_table.format(data.clone());
println!(
"\n{}{}{}{}",
cursor::Hide,
clear::All,
cursor::Goto(1, 1),
s
);
println!("Hello");//couldn't make this appear on top.
i = i+1;
std::thread::sleep(std::time::Duration::from_millis(200));
}
}
Is this the way programs like top update data on the terminal? Or is there a better way? It'd be nice to have more complex structures.

Answer 1

There isn't a fundamentally better way to format complex data on a terminal than you're doing. There are some individual refinements that can be made to improve display quality.
In particular, in order to reduce flickering, it is best to overwrite text rather than clearing the entire terminal first, and only clear the parts that either need to become blank or are already blank, using narrower clear operations such as clear to end of line, which you would use when you're replacing a line and it might become shorter — by putting this clear at the end of the text, so that if the text is unchanged it doesn't disappear briefly.
Since you're starting with code that generates multiline text, you'll need to edit the string:
// Insert clear-to-end-of-line into the table
let s = ascii_table.format(data.clone())
.replace("\n", &format!("{}\n", clear::UntilNewline));
println!(
"\n{}{}{}{}",
cursor::Hide,
cursor::Goto(1, 1),
s,
clear::AfterCursor,
);
Notice that I have reordered the operations: first, we go to (1, 1) and draw the text (clearing to end of line as we go). Then when everything is done, we clear from cursor to end of screen. This way, we're never clearing any of the text we want to be still present, so there will be no flicker.
I notice you have another wish:
println!("Hello");//couldn't make this appear on top.
All you need to do here is do it after the goto and before the table, and include clearing, and it'll work as you'd like.
// Move cursor to top. This always goes first.
// Note print!, not println!, since we don't want to move down
// after the goto.
print!("{}{}", cursor::Hide, cursor::Goto(1, 1));
// Use clear::UntilNewline on intermediate things
println!("Hello{}", clear::UntilNewline);
// ...even if they are blank lines
println!("{}", clear::UntilNewline);
// Use clear::AfterCursor on the *last* thing printed
// Note print!, not println!, since if we are filling the entire terminal
// we don't want to cause it to scroll down.
print!("{}{}", s, clear::AfterCursor);
One thing I haven't covered is that you can also use termion::cursor::Goto to move to specific areas on the terminal to update them, instead of writing entire lines top-to-bottom. This is of course more complex since your program has to comprehend the entire layout to know what cursor position to go to, and know which parts need to be redrawn. In the days of actual serial terminals and modems that had very low data rates, this was a very important optimization to avoid wasting transmission time on characters that were the same — today, it's less critical.