rtlibs-tui 0.1.4

rtools library: ratatui widgets
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

use std::marker::PhantomData;

use crossterm::event::KeyCode;
use crossterm::event::KeyModifiers;
use ratatui::buffer::Buffer;
use ratatui::layout::Alignment;
use ratatui::layout::Position;
use ratatui::layout::Rect;
use ratatui::widgets::Paragraph;
use ratatui::widgets::Widget;
use ratatui::widgets::Wrap;

use crate::widgets::Modal;
use crate::widgets::ModalConfig;
use crate::Result;

pub trait ModalConfirmResponse<EVENT>
{
    fn bool(
        event: EVENT,
        value: bool,
    ) -> Self;
    fn waiting_input() -> Self;
}

#[derive(Debug)]
pub struct ModalConfirm<RESPONSE, EVENT>
{
    pub message: String,
    phantom_r: PhantomData<RESPONSE>,
    phantom_e: PhantomData<EVENT>,
}

impl<RESPONSE, EVENT> ModalConfirm<RESPONSE, EVENT>
{
    pub fn new<S>(message: S) -> Self
    where
        S: AsRef<str>,
    {
        Self {
            message: message
                .as_ref()
                .to_string(),
            phantom_r: PhantomData,
            phantom_e: PhantomData,
        }
    }
}

impl<RESPONSE, EVENT> Modal<RESPONSE, EVENT> for ModalConfirm<RESPONSE, EVENT>
where
    EVENT: std::fmt::Debug,
    RESPONSE: std::fmt::Debug + ModalConfirmResponse<EVENT>,
{
    fn config(&self) -> ModalConfig
    {
        ModalConfig::new().title(" CONFIRM ")
    }

    fn render(
        &mut self,
        area: Rect,
        buf: &mut Buffer,
    )
    {
        let mut area = area;
        area.y += 1;
        area.height -= 1;

        Paragraph::new(
            self.message
                .as_str(),
        )
        .alignment(Alignment::Center)
        .wrap(Wrap { trim: true })
        .render(
            area, buf,
        );

        let mut commands_area = area;
        commands_area.y = commands_area.y + commands_area.height - 2;
        commands_area.height = 1;

        Paragraph::new("[Y]es   [N]o")
            .alignment(Alignment::Center)
            .render(
                commands_area,
                buf,
            );
    }

    fn handle_key_event(
        &mut self,
        code: KeyCode,
        _modifiers: KeyModifiers,
        event: EVENT,
    ) -> Result<RESPONSE>
    {
        let response = match code
        {
            KeyCode::Char('n') | KeyCode::Esc => RESPONSE::bool(
                event, false,
            ),
            KeyCode::Char('y') | KeyCode::Enter => RESPONSE::bool(
                event, true,
            ),
            _ => RESPONSE::waiting_input(),
        };

        Ok(response)
    }

    fn cursor(&self) -> Option<Position>
    {
        None
    }
}