cocotte 0.1.1

A convenient way to make a Ratatui
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

//! Main application orchestration and terminal lifecycle management.

use crate::sub_app::SubApp;
use crossterm::{
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use eyre::Result;
use ratatui::Frame;
use ratatui::Terminal;
use ratatui::backend::CrosstermBackend;
use ratatui::layout::{Constraint, Direction, Layout};
use std::io::Stdout;

struct RawModeGuard;

impl RawModeGuard {
    fn enter() -> eyre::Result<Self> {
        enable_raw_mode()?;
        Ok(Self)
    }
}

impl Drop for RawModeGuard {
    fn drop(&mut self) {
        let _ = disable_raw_mode();
    }
}

struct AlternateScreenGuard;

impl AlternateScreenGuard {
    fn enter() -> eyre::Result<Self> {
        execute!(std::io::stdout(), EnterAlternateScreen)?;
        Ok(Self)
    }
}

impl Drop for AlternateScreenGuard {
    fn drop(&mut self) {
        let _ = execute!(std::io::stdout(), LeaveAlternateScreen);
    }
}

struct TerminalModeGuard {
    _raw: RawModeGuard,
    _alt: AlternateScreenGuard,
}

impl TerminalModeGuard {
    fn enter() -> eyre::Result<(Self, Terminal<CrosstermBackend<Stdout>>)> {
        let raw = RawModeGuard::enter()?;
        let alt = AlternateScreenGuard::enter()?;

        let stdout = std::io::stdout();
        let backend = CrosstermBackend::new(stdout);
        let terminal = Terminal::new(backend)?;

        Ok((
            Self {
                _raw: raw,
                _alt: alt,
            },
            terminal,
        ))
    }
}

/// A terminal application composed of multiple [`SubApp`] views.
///
/// `App` owns the terminal lifecycle and forwards input and rendering to each
/// sub-app in order.
pub struct App<E, V, S>
where
    V: SubApp<E, S>,
{
    _terminal_guard: TerminalModeGuard,
    terminal: Terminal<CrosstermBackend<Stdout>>,
    sub_apps: Vec<V>,
    _phantom: std::marker::PhantomData<(E, S)>,
}

impl<E, V, S> App<E, V, S>
where
    V: SubApp<E, S>,
{
    /// Creates a new application and enters terminal raw mode and the
    /// alternate screen.
    pub fn new(sub_apps: Vec<V>) -> Result<Self> {
        let (_terminal_guard, terminal) = TerminalModeGuard::enter()?;
        Ok(Self {
            _terminal_guard,
            sub_apps,
            _phantom: std::marker::PhantomData,
            terminal,
        })
    }

    /// Forwards an event to each sub-app.
    pub fn handle_input(&mut self, event: &mut E, state: &mut S) {
        for sub_app in &mut self.sub_apps {
            sub_app.handle_input(event, state);
        }
    }

    /// Draws all sub-apps using their declared layout constraints.
    pub fn draw(&mut self, state: &mut S) -> Result<()> {
        let sub_apps = &self.sub_apps;
        self.terminal
            .draw(|frame| render_app::<V, E, S>(sub_apps, state, frame))?;
        Ok(())
    }
}

fn render_app<V, E, S>(sub_apps: &[V], state: &mut S, frame: &mut Frame)
where
    V: SubApp<E, S>,
{
    let area = frame.area();
    let constraints: Vec<Constraint> = sub_apps.iter().map(|v| v.constraints()).collect();
    let areas = Layout::default()
        .direction(Direction::Vertical)
        .constraints(constraints)
        .split(area);

    for (sub_app, area) in sub_apps.iter().zip(areas.iter().copied()) {
        sub_app.render(frame, area, state);
    }
}