tui 0.3.0

A library to build rich terminal user interfaces or dashboards
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

extern crate failure;
extern crate termion;
extern crate tui;

#[allow(dead_code)]
mod util;

use std::io;

use termion::event::Key;
use termion::input::MouseTerminal;
use termion::raw::IntoRawMode;
use termion::screen::AlternateScreen;
use tui::backend::TermionBackend;
use tui::layout::{Constraint, Direction, Layout, Rect};
use tui::style::{Color, Style};
use tui::widgets::{Block, Borders, Sparkline, Widget};
use tui::Terminal;

use util::event::{Event, Events};
use util::RandomSignal;

struct App {
    size: Rect,
    signal: RandomSignal,
    data1: Vec<u64>,
    data2: Vec<u64>,
    data3: Vec<u64>,
}

impl App {
    fn new() -> App {
        let mut signal = RandomSignal::new(0, 100);
        let data1 = signal.by_ref().take(200).collect::<Vec<u64>>();
        let data2 = signal.by_ref().take(200).collect::<Vec<u64>>();
        let data3 = signal.by_ref().take(200).collect::<Vec<u64>>();
        App {
            size: Rect::default(),
            signal,
            data1,
            data2,
            data3,
        }
    }

    fn update(&mut self) {
        let value = self.signal.next().unwrap();
        self.data1.pop();
        self.data1.insert(0, value);
        let value = self.signal.next().unwrap();
        self.data2.pop();
        self.data2.insert(0, value);
        let value = self.signal.next().unwrap();
        self.data3.pop();
        self.data3.insert(0, value);
    }
}

fn main() -> Result<(), failure::Error> {
    // Terminal initialization
    let stdout = io::stdout().into_raw_mode()?;
    let stdout = MouseTerminal::from(stdout);
    let stdout = AlternateScreen::from(stdout);
    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;
    terminal.hide_cursor()?;

    // Setup event handlers
    let events = Events::new();

    // Create default app state
    let mut app = App::new();

    loop {
        let size = terminal.size()?;
        if size != app.size {
            terminal.resize(size)?;
            app.size = size;
        }

        terminal.draw(|mut f| {
            let chunks = Layout::default()
                .direction(Direction::Vertical)
                .margin(2)
                .constraints(
                    [
                        Constraint::Length(3),
                        Constraint::Length(3),
                        Constraint::Length(7),
                        Constraint::Min(0),
                    ]
                        .as_ref(),
                ).split(app.size);
            Sparkline::default()
                .block(
                    Block::default()
                        .title("Data1")
                        .borders(Borders::LEFT | Borders::RIGHT),
                ).data(&app.data1)
                .style(Style::default().fg(Color::Yellow))
                .render(&mut f, chunks[0]);
            Sparkline::default()
                .block(
                    Block::default()
                        .title("Data2")
                        .borders(Borders::LEFT | Borders::RIGHT),
                ).data(&app.data2)
                .style(Style::default().bg(Color::Green))
                .render(&mut f, chunks[1]);
            // Multiline
            Sparkline::default()
                .block(
                    Block::default()
                        .title("Data3")
                        .borders(Borders::LEFT | Borders::RIGHT),
                ).data(&app.data3)
                .style(Style::default().fg(Color::Red))
                .render(&mut f, chunks[2]);
        })?;

        match events.next()? {
            Event::Input(input) => if input == Key::Char('q') {
                break;
            },
            Event::Tick => {
                app.update();
            }
        }
    }

    Ok(())
}