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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use super::{Input, Key};
use termion::event::{Event, Key as KeyEvent, MouseButton, MouseEvent};

impl From<Event> for Input {
    /// Convert [`termion::event::Event`] into [`Input`].
    fn from(event: Event) -> Self {
        match event {
            Event::Key(key) => Self::from(key),
            Event::Mouse(mouse) => Self::from(mouse),
            _ => Self::default(),
        }
    }
}

impl From<KeyEvent> for Input {
    /// Convert [`termion::event::Key`] into [`Input`].
    fn from(key: KeyEvent) -> Self {
        let mut ctrl = false;
        let mut alt = false;
        let key = match key {
            KeyEvent::Char('\n' | '\r') => Key::Enter,
            KeyEvent::Char(c) => Key::Char(c),
            KeyEvent::Ctrl(c) => {
                ctrl = true;
                Key::Char(c)
            }
            KeyEvent::Alt(c) => {
                alt = true;
                Key::Char(c)
            }
            KeyEvent::Backspace => Key::Backspace,
            KeyEvent::Left => Key::Left,
            KeyEvent::Right => Key::Right,
            KeyEvent::Up => Key::Up,
            KeyEvent::Down => Key::Down,
            KeyEvent::Home => Key::Home,
            KeyEvent::End => Key::End,
            KeyEvent::PageUp => Key::PageUp,
            KeyEvent::PageDown => Key::PageDown,
            KeyEvent::BackTab => Key::Tab,
            KeyEvent::Delete => Key::Delete,
            KeyEvent::Esc => Key::Esc,
            KeyEvent::F(x) => Key::F(x),
            _ => Key::Null,
        };

        Input {
            key,
            ctrl,
            alt,
            shift: false,
        }
    }
}

impl From<MouseButton> for Key {
    /// Convert [`termion::event::MouseButton`] into [`Key`].
    fn from(button: MouseButton) -> Self {
        match button {
            MouseButton::WheelUp => Key::MouseScrollUp,
            MouseButton::WheelDown => Key::MouseScrollDown,
            _ => Key::Null,
        }
    }
}

impl From<MouseEvent> for Input {
    /// Convert [`termion::event::MouseEvent`] into [`Input`].
    fn from(mouse: MouseEvent) -> Self {
        let key = if let MouseEvent::Press(button, ..) = mouse {
            Key::from(button)
        } else {
            Key::Null
        };
        Self {
            key,
            ctrl: false,
            alt: false,
            shift: false,
        }
    }
}

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

    #[test]
    fn key_to_input() {
        for (from, to) in [
            (
                KeyEvent::Char('a'),
                input(Key::Char('a'), false, false, false),
            ),
            (
                KeyEvent::Ctrl('a'),
                input(Key::Char('a'), true, false, false),
            ),
            (
                KeyEvent::Alt('a'),
                input(Key::Char('a'), false, true, false),
            ),
            (KeyEvent::Char('\n'), input(Key::Enter, false, false, false)),
            (KeyEvent::Char('\r'), input(Key::Enter, false, false, false)),
            (KeyEvent::F(1), input(Key::F(1), false, false, false)),
            (KeyEvent::BackTab, input(Key::Tab, false, false, false)),
            (KeyEvent::Null, input(Key::Null, false, false, false)),
        ] {
            assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
        }
    }

    #[test]
    fn mouse_to_input() {
        for (from, to) in [
            (
                MouseEvent::Press(MouseButton::WheelDown, 1, 1),
                input(Key::MouseScrollDown, false, false, false),
            ),
            (
                MouseEvent::Press(MouseButton::WheelUp, 1, 1),
                input(Key::MouseScrollUp, false, false, false),
            ),
            (
                MouseEvent::Press(MouseButton::Left, 1, 1),
                input(Key::Null, false, false, false),
            ),
            (
                MouseEvent::Release(1, 1),
                input(Key::Null, false, false, false),
            ),
            (
                MouseEvent::Hold(1, 1),
                input(Key::Null, false, false, false),
            ),
        ] {
            assert_eq!(Input::from(from), to, "{:?} -> {:?}", from, to);
        }
    }

    #[test]
    fn event_to_input() {
        for (from, to) in [
            (
                Event::Key(KeyEvent::Char('a')),
                input(Key::Char('a'), false, false, false),
            ),
            (
                Event::Mouse(MouseEvent::Press(MouseButton::WheelDown, 1, 1)),
                input(Key::MouseScrollDown, false, false, false),
            ),
            (
                Event::Unsupported(vec![]),
                input(Key::Null, false, false, false),
            ),
        ] {
            assert_eq!(Input::from(from.clone()), to, "{:?} -> {:?}", from, to);
        }
    }
}