alf_tui 0.5.0

A smolderingly-nimble Rust TUI to rediscover your custom shell.
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
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

//! Normal mode keybinds (vim-style navigation and control).

use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

use crate::tui::app::{App, ExitAction};
use crate::tui::state::EntryFilter;

/// Handle key events in Normal (vim navigation) mode
pub fn handle_normal_mode(
   app: &mut App,
   key: KeyEvent,
) {
   // Check for pending multi-key sequences first
   if let Some(pending) = app.pending_key() {
      handle_pending_key(app, pending, key);
      return;
   }

   match key.code {
      // Quit
      KeyCode::Char('q') => app.should_quit = true,

      // Clear pending key state
      KeyCode::Esc => app.clear_pending_key(),

      // Toggle help modal
      KeyCode::Char('?') => {
         app.toggle_help();
         app.clear_pending_key();
      },

      // Scrolling with modifiers (check these first before plain keys)
      KeyCode::Char('f') if key.modifiers.contains(KeyModifiers::CONTROL) => {
         app.scroll_down(20);
      },
      KeyCode::Char('b') if key.modifiers.contains(KeyModifiers::CONTROL) => {
         app.scroll_up(20);
      },
      KeyCode::Char('j') if key.modifiers.contains(KeyModifiers::CONTROL) => {
         app.scroll_down(10);
      },
      KeyCode::Char('k') if key.modifiers.contains(KeyModifiers::CONTROL) => {
         app.scroll_up(10);
      },
      KeyCode::Char('g') if key.modifiers.contains(KeyModifiers::CONTROL) => {
         app.cycle_group_mode();
      },
      KeyCode::Char('s') if key.modifiers.contains(KeyModifiers::CONTROL) => {
         app.toggle_sort_order();
      },

      // Navigation (single line - plain keys, respects active panel)
      KeyCode::Char('j') | KeyCode::Down => app.scroll_down(1),
      KeyCode::Char('k') | KeyCode::Up => app.scroll_up(1),
      KeyCode::Char('G') => app.move_bottom(),
      KeyCode::Char('g') => app.move_top(),

      // Start of 'og', 'oG', 'os' sequences
      KeyCode::Char('o') => {
         app.set_pending_key('o');
      },

      // Start of 'tj', 'tk' sequences (theme cycling)
      KeyCode::Char('t') => {
         app.set_pending_key('t');
      },

      // Enter search mode
      KeyCode::Char('/') | KeyCode::Char('i') => app.enter_search_mode(),

      // Panel cycling
      KeyCode::Char('n') => app.cycle_panel(),
      KeyCode::Char('p') => app.cycle_panel_backward(),

      // Filter cycling
      KeyCode::Char('l') => app.cycle_filter(),
      KeyCode::Char('h') => app.cycle_filter_backward(),

      // Filter direct selection
      KeyCode::Char('1') => app.set_filter(EntryFilter::Aliases),
      KeyCode::Char('2') => app.set_filter(EntryFilter::Functions),
      KeyCode::Char('3') => app.set_filter(EntryFilter::All),

      // Enter - select entry and execute
      KeyCode::Enter => app.select_entry(ExitAction::Execute),
      // Tab - select entry and populate (without executing)
      KeyCode::Tab => app.select_entry(ExitAction::Populate),

      _ => {},
   }
}

/// Handle the second key in a multi-key sequence
fn handle_pending_key(
   app: &mut App,
   pending: char,
   key: KeyEvent,
) {
   // Determine if the key sequence is valid
   let _handled = match (pending, key.code) {
      // Clear pending on Esc (always)
      (_, KeyCode::Esc) => {
         app.clear_pending_key();
         true
      },

      // 'gg' sequence - go to top
      ('g', KeyCode::Char('g')) => {
         app.move_top();
         app.clear_pending_key();
         true
      },

      // 'og' sequence - cycle group mode forward
      ('o', KeyCode::Char('g')) => {
         app.cycle_group_mode();
         app.clear_pending_key();
         true
      },

      // 'oG' sequence - cycle group mode backward
      ('o', KeyCode::Char('G')) => {
         app.cycle_group_mode_backward();
         app.clear_pending_key();
         true
      },

      // 'os' sequence - toggle sort order
      ('o', KeyCode::Char('s')) => {
         app.toggle_sort_order();
         app.clear_pending_key();
         true
      },

      // 'tj' sequence - cycle to next theme
      ('t', KeyCode::Char('j')) => {
         app.cycle_theme_next();
         app.clear_pending_key();
         true
      },

      // 'tk' sequence - cycle to previous theme
      ('t', KeyCode::Char('k')) => {
         app.cycle_theme_prev();
         app.clear_pending_key();
         true
      },

      // Any other key - invalid sequence, clear pending
      _ => {
         app.clear_pending_key();
         false
      },
   };
}