vize_fresco 0.61.0

Fresco - Vue TUI framework (Terminal User Interface)
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

//! Input event types.

use compact_str::CompactString;
use serde::{Deserialize, Serialize};

use super::keyboard::KeyEvent;
use super::mouse::MouseEvent;

/// Top-level input event.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum Event {
    /// Keyboard event
    Key(KeyEvent),
    /// Mouse event
    Mouse(MouseEvent),
    /// Terminal resize
    Resize(u16, u16),
    /// Focus gained
    FocusGained,
    /// Focus lost
    FocusLost,
    /// Paste event (bracketed paste)
    Paste(CompactString),
}

impl Event {
    /// Check if this is a key event.
    pub fn is_key(&self) -> bool {
        matches!(self, Event::Key(_))
    }

    /// Check if this is a mouse event.
    pub fn is_mouse(&self) -> bool {
        matches!(self, Event::Mouse(_))
    }

    /// Check if this is a resize event.
    pub fn is_resize(&self) -> bool {
        matches!(self, Event::Resize(_, _))
    }

    /// Get as key event if applicable.
    pub fn as_key(&self) -> Option<&KeyEvent> {
        match self {
            Event::Key(k) => Some(k),
            _ => None,
        }
    }

    /// Get as mouse event if applicable.
    pub fn as_mouse(&self) -> Option<&MouseEvent> {
        match self {
            Event::Mouse(m) => Some(m),
            _ => None,
        }
    }
}

impl From<crossterm::event::Event> for Event {
    fn from(event: crossterm::event::Event) -> Self {
        match event {
            crossterm::event::Event::Key(k) => Event::Key(k.into()),
            crossterm::event::Event::Mouse(m) => Event::Mouse(m.into()),
            crossterm::event::Event::Resize(w, h) => Event::Resize(w, h),
            crossterm::event::Event::FocusGained => Event::FocusGained,
            crossterm::event::Event::FocusLost => Event::FocusLost,
            crossterm::event::Event::Paste(s) => Event::Paste(CompactString::from(s)),
        }
    }
}

/// Poll for events with a timeout.
pub fn poll(timeout_ms: u64) -> std::io::Result<Option<Event>> {
    use crossterm::event::{poll, read};
    use std::time::Duration;

    if poll(Duration::from_millis(timeout_ms))? {
        Ok(Some(read()?.into()))
    } else {
        Ok(None)
    }
}

/// Poll for events without blocking.
pub fn poll_nonblocking() -> std::io::Result<Option<Event>> {
    poll(0)
}

/// Read an event, blocking until one is available.
pub fn read_event() -> std::io::Result<Event> {
    use crossterm::event::read;
    Ok(read()?.into())
}

#[cfg(test)]
mod tests {
    use super::Event;
    use crate::input::keyboard::KeyEvent;

    #[test]
    fn test_event_is_key() {
        use super::super::keyboard::{Key, KeyModifiers};

        let event = Event::Key(KeyEvent {
            key: Key::Char('a'),
            modifiers: KeyModifiers::NONE,
        });
        assert!(event.is_key());
        assert!(!event.is_mouse());
    }

    #[test]
    fn test_event_resize() {
        let event = Event::Resize(80, 24);
        assert!(event.is_resize());
        if let Event::Resize(w, h) = event {
            assert_eq!(w, 80);
            assert_eq!(h, 24);
        }
    }
}