ratatui-which-key 0.4.0

A which-key popup widget for ratatui applications
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

// Copyright (C) 2026 Jayson Lennon
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use crate::WhichKeyState;
use crossterm::event::{Event, KeyEvent};

use super::event_result::EventResult;
use super::keymap_ext::CrosstermKeymapExt;

/// Extension trait for WhichKeyState to handle crossterm events.
pub trait CrosstermStateExt<S, A, C> {
    /// Handle a crossterm event.
    fn handle_event(&mut self, event: Event) -> EventResult<A>;
}

impl<S, A, C> CrosstermStateExt<S, A, C> for WhichKeyState<KeyEvent, S, A, C>
where
    S: Clone + Ord + PartialEq + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    C: Clone + std::fmt::Display + 'static,
{
    fn handle_event(&mut self, event: Event) -> EventResult<A> {
        match event {
            Event::Key(key) => {
                let result = self.handle_key(key);
                EventResult::Key(result)
            }
            Event::Mouse(mouse) => {
                let action = self
                    .keymap()
                    .mouse_handler()
                    .and_then(|h| h(mouse, self.scope()));
                EventResult::Mouse(action)
            }
            Event::Resize(cols, rows) => {
                let action = self
                    .keymap()
                    .resize_handler()
                    .and_then(|h| h(cols, rows, self.scope()));
                EventResult::Resize(action)
            }
            Event::FocusGained => {
                let action = self
                    .keymap()
                    .focus_gained_handler()
                    .and_then(|h| h(self.scope()));
                EventResult::FocusGained(action)
            }
            Event::FocusLost => {
                let action = self
                    .keymap()
                    .focus_lost_handler()
                    .and_then(|h| h(self.scope()));
                EventResult::FocusLost(action)
            }
            _ => EventResult::Unhandled,
        }
    }
}