NeoMutt  2024-04-25-97-g7d2481
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
get.c
Go to the documentation of this file.
1
29#include "config.h"
30#include <stdbool.h>
31#include <stddef.h>
32#include <unistd.h>
33#include "mutt/lib.h"
34#include "config/lib.h"
35#include "core/lib.h"
36#include "gui/lib.h"
37#include "key/lib.h"
38#include "menu/lib.h"
39#include "globals.h"
40#ifdef USE_INOTIFY
41#include "monitor.h"
42#endif
43
44// It's not possible to unget more than one char under some curses libs,
45// so roll our own input buffering routines.
46
49struct KeyEventArray MacroEvents = ARRAY_HEAD_INITIALIZER;
50
53static struct KeyEventArray UngetKeyEvents = ARRAY_HEAD_INITIALIZER;
54
58void mutt_flushinp(void)
59{
62 flushinp();
63}
64
70static struct KeyEvent *array_pop(struct KeyEventArray *a)
71{
72 if (ARRAY_EMPTY(a))
73 {
74 return NULL;
75 }
76
77 struct KeyEvent *event = ARRAY_LAST(a);
78 ARRAY_SHRINK(a, 1);
79 return event;
80}
81
88static void array_add(struct KeyEventArray *a, int ch, int op)
89{
90 struct KeyEvent event = { ch, op };
91 ARRAY_ADD(a, event);
92}
93
98static void array_to_endcond(struct KeyEventArray *a)
99{
100 while (!ARRAY_EMPTY(a))
101 {
102 if (array_pop(a)->op == OP_END_COND)
103 {
104 return;
105 }
106 }
107}
108
116{
117 array_add(&UngetKeyEvents, ch, OP_NULL);
118}
119
127{
129}
130
137void mutt_unget_string(const char *s)
138{
139 const char *p = s + mutt_str_len(s) - 1;
140
141 while (p >= s)
142 {
143 mutt_unget_ch((unsigned char) *p--);
144 }
145}
146
156{
158}
159
167{
169}
170
171#ifdef USE_INOTIFY
177static int mutt_monitor_getch(void)
178{
179 /* ncurses has its own internal buffer, so before we perform a poll,
180 * we need to make sure there isn't a character waiting */
181 timeout(0);
182 int ch = getch();
183 timeout(1000); // 1 second
184 if (ch == ERR)
185 {
186 if (mutt_monitor_poll() != 0)
187 ch = ERR;
188 else
189 ch = getch();
190 }
191 return ch;
192}
193#endif /* USE_INOTIFY */
194
211{
212 static const struct KeyEvent event_abort = { 0, OP_ABORT };
213 static const struct KeyEvent event_repaint = { 0, OP_REPAINT };
214 static const struct KeyEvent event_timeout = { 0, OP_TIMEOUT };
215
216 if (OptNoCurses)
217 return event_abort;
218
219 struct KeyEvent *event_key = array_pop(&UngetKeyEvents);
220 if (event_key)
221 return *event_key;
222
223 if (!(flags & GETCH_IGNORE_MACRO))
224 {
225 event_key = array_pop(&MacroEvents);
226 if (event_key)
227 return *event_key;
228 }
229
230 int ch;
231 SigInt = false;
233 timeout(1000); // 1 second
234#ifdef USE_INOTIFY
236#else
237 ch = getch();
238#endif
240
241 if (SigInt)
242 {
244 return event_abort;
245 }
246
247 if (ch == KEY_RESIZE)
248 {
249 timeout(0);
250 while ((ch = getch()) == KEY_RESIZE)
251 {
252 // do nothing
253 }
254 }
255
256 if (ch == ERR)
257 {
258 if (!isatty(0)) // terminal was lost
259 mutt_exit(1);
260
261 if (SigWinch)
262 {
263 SigWinch = false;
265 return event_repaint;
266 }
267
269 return event_timeout;
270 }
271
272 if (ch == AbortKey)
273 return event_abort;
274
275 if (ch & 0x80)
276 {
277 const bool c_meta_key = cs_subset_bool(NeoMutt->sub, "meta_key");
278 if (c_meta_key)
279 {
280 /* send ALT-x as ESC-x */
281 ch &= ~0x80;
283 return (struct KeyEvent){ '\033', OP_NULL }; // Escape
284 }
285 }
286
287 return (struct KeyEvent){ ch, OP_NULL };
288}
289
294void km_error_key(enum MenuType mtype)
295{
296 struct Keymap *key = km_find_func(mtype, OP_HELP);
297 if (!key && (mtype != MENU_EDITOR) && (mtype != MENU_PAGER))
298 key = km_find_func(MENU_GENERIC, OP_HELP);
299 if (!key)
300 {
301 mutt_error(_("Key is not bound"));
302 return;
303 }
304
305 char buf[128] = { 0 };
306 km_expand_key(buf, sizeof(buf), key);
307 mutt_error(_("Key is not bound. Press '%s' for help."), buf);
308}
309
319static struct KeyEvent retry_generic(enum MenuType mtype, keycode_t *keys,
320 int keyslen, int lastkey, GetChFlags flags)
321{
322 if (lastkey)
323 mutt_unget_ch(lastkey);
324 for (; keyslen; keyslen--)
325 mutt_unget_ch(keys[keyslen - 1]);
326
327 if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC) && (mtype != MENU_PAGER))
328 {
329 return km_dokey_event(MENU_GENERIC, flags);
330 }
331 if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC))
332 {
333 /* probably a good idea to flush input here so we can abort macros */
335 }
336
337 return (struct KeyEvent){ mutt_getch(flags).ch, OP_NULL };
338}
339
347{
348 struct KeyEvent event = { 0, OP_NULL };
349 struct Keymap *map = STAILQ_FIRST(&Keymaps[mtype]);
350 int pos = 0;
351 int n = 0;
352
353 if (!map && (mtype != MENU_EDITOR))
354 return retry_generic(mtype, NULL, 0, 0, flags);
355
356 while (true)
357 {
358 event = mutt_getch(flags);
359
360 // abort, timeout, repaint
361 if (event.op < OP_NULL)
362 return event;
363
364 /* do we have an op already? */
365 if (event.op != OP_NULL)
366 {
367 const char *func = NULL;
368 const struct MenuFuncOp *funcs = NULL;
369
370 /* is this a valid op for this menu type? */
371 if ((funcs = km_get_table(mtype)) && (func = mutt_get_func(funcs, event.op)))
372 return event;
373
374 if ((mtype != MENU_EDITOR) && (mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
375 {
376 /* check generic menu type */
377 funcs = OpGeneric;
378 func = mutt_get_func(funcs, event.op);
379 if (func)
380 return event;
381 }
382
383 /* Sigh. Valid function but not in this context.
384 * Find the literal string and push it back */
385 for (int i = 0; MenuNames[i].name; i++)
386 {
387 funcs = km_get_table(MenuNames[i].value);
388 if (funcs)
389 {
390 func = mutt_get_func(funcs, event.op);
391 if (func)
392 {
393 mutt_unget_ch('>');
394 mutt_unget_string(func);
395 mutt_unget_ch('<');
396 break;
397 }
398 }
399 }
400 /* continue to chew */
401 if (func)
402 continue;
403 }
404
405 if (!map)
406 return event;
407
408 /* Nope. Business as usual */
409 while (event.ch > map->keys[pos])
410 {
411 if ((pos > map->eq) || !STAILQ_NEXT(map, entries))
412 return retry_generic(mtype, map->keys, pos, event.ch, flags);
413 map = STAILQ_NEXT(map, entries);
414 }
415
416 if (event.ch != map->keys[pos])
417 return retry_generic(mtype, map->keys, pos, event.ch, flags);
418
419 if (++pos == map->len)
420 {
421 if (map->op != OP_MACRO)
422 return (struct KeyEvent){ event.ch, map->op };
423
424 /* #GETCH_IGNORE_MACRO turns off processing the MacroEvents buffer
425 * in mutt_getch(). Generating new macro events during that time would
426 * result in undesired behavior once the option is turned off.
427 *
428 * Originally this returned -1, however that results in an unbuffered
429 * username or password prompt being aborted. Returning OP_NULL allows
430 * mw_get_field() to display the keybinding pressed instead.
431 *
432 * It may be unexpected for a macro's keybinding to be returned,
433 * but less so than aborting the prompt. */
434 if (flags & GETCH_IGNORE_MACRO)
435 {
436 return (struct KeyEvent){ event.ch, OP_NULL };
437 }
438
439 if (n++ == 10)
440 {
442 mutt_error(_("Macro loop detected"));
443 return (struct KeyEvent){ '\0', OP_ABORT };
444 }
445
447 map = STAILQ_FIRST(&Keymaps[mtype]);
448 pos = 0;
449 }
450 }
451
452 /* not reached */
453}
454
464int km_dokey(enum MenuType mtype, GetChFlags flags)
465{
466 return km_dokey_event(mtype, flags).op;
467}
#define ARRAY_SHRINK(head, num)
Mark a number of slots at the end of the array as unused.
Definition: array.h:172
#define ARRAY_ADD(head, elem)
Add an element at the end of the array.
Definition: array.h:156
#define ARRAY_LAST(head)
Convenience method to get the last element.
Definition: array.h:144
#define ARRAY_EMPTY(head)
Check if an array is empty.
Definition: array.h:74
#define ARRAY_SIZE(head)
The number of elements stored.
Definition: array.h:87
#define ARRAY_HEAD_INITIALIZER
Static initializer for arrays.
Definition: array.h:58
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
Convenience wrapper for the config headers.
Convenience wrapper for the core headers.
void mutt_query_exit(void)
Ask the user if they want to leave NeoMutt.
Definition: curs_lib.c:137
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:58
void mutt_unget_string(const char *s)
Return a string to the input buffer.
Definition: get.c:137
struct KeyEvent mutt_getch(GetChFlags flags)
Read a character from the input buffer.
Definition: get.c:210
void mutt_unget_ch(int ch)
Return a keystroke to the input buffer.
Definition: get.c:115
struct KeyEvent km_dokey_event(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:346
struct KeyEventArray MacroEvents
These are used for macros and exec/push commands.
Definition: get.c:49
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:58
static struct KeyEventArray UngetKeyEvents
These are used in all other "normal" situations, and are not ignored when passing GETCH_IGNORE_MACRO.
Definition: get.c:53
int km_dokey(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:464
static void array_add(struct KeyEventArray *a, int ch, int op)
Add an event to the end of the array.
Definition: get.c:88
static void array_to_endcond(struct KeyEventArray *a)
Clear the array until an OP_END_COND.
Definition: get.c:98
void mutt_unget_string(const char *s)
Return a string to the input buffer.
Definition: get.c:137
void mutt_push_macro_event(int ch, int op)
Add the character/operation to the macro buffer.
Definition: get.c:155
struct KeyEvent mutt_getch(GetChFlags flags)
Read a character from the input buffer.
Definition: get.c:210
static struct KeyEvent * array_pop(struct KeyEventArray *a)
Remove an event from the array.
Definition: get.c:70
void mutt_unget_op(int op)
Return an operation to the input buffer.
Definition: get.c:126
void mutt_flush_macro_to_endcond(void)
Drop a macro from the input buffer.
Definition: get.c:166
static int mutt_monitor_getch(void)
Get a character and poll the filesystem monitor.
Definition: get.c:177
void mutt_unget_ch(int ch)
Return a keystroke to the input buffer.
Definition: get.c:115
void km_error_key(enum MenuType mtype)
Handle an unbound key sequence.
Definition: get.c:294
static struct KeyEvent retry_generic(enum MenuType mtype, keycode_t *keys, int keyslen, int lastkey, GetChFlags flags)
Try to find the key in the generic menu bindings.
Definition: get.c:319
bool OptNoCurses
(pseudo) when sending in batch mode
Definition: globals.c:72
#define mutt_error(...)
Definition: logging2.h:92
const struct MenuFuncOp OpGeneric[]
Functions for the Generic Menu.
Definition: functions.c:68
Convenience wrapper for the gui headers.
struct Keymap * km_find_func(enum MenuType mtype, int func)
Find a function's mapping in a Menu.
Definition: lib.c:509
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: lib.c:457
Manage keymappings.
uint8_t GetChFlags
Flags for mutt_getch(), e.g. GETCH_NO_FLAGS.
Definition: lib.h:50
struct KeyEventArray MacroEvents
These are used for macros and exec/push commands.
Definition: get.c:49
void generic_tokenize_push_string(char *s)
Parse and queue a 'push' command.
Definition: lib.c:338
keycode_t AbortKey
key to abort edits etc, normally Ctrl-G
Definition: lib.c:122
#define GETCH_IGNORE_MACRO
Don't use MacroEvents.
Definition: lib.h:52
const char * mutt_get_func(const struct MenuFuncOp *bindings, int op)
Get the name of a function.
Definition: lib.c:321
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: lib.h:55
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:525
struct KeymapList Keymaps[]
Array of Keymap keybindings, one for each Menu.
Definition: lib.c:125
void mutt_exit(int code)
Leave NeoMutt NOW.
Definition: main.c:269
GUI present the user with a selectable list.
int mutt_monitor_poll(void)
Check for filesystem changes.
Definition: monitor.c:401
Monitor files for changes.
Convenience wrapper for the library headers.
#define _(a)
Definition: message.h:28
bool notify_send(struct Notify *notify, enum NotifyType event_type, int event_subtype, void *event_data)
Send out a notification message.
Definition: notify.c:173
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
@ NT_TIMEOUT
Timeout has occurred.
Definition: notify_type.h:56
@ NT_RESIZE
Window has been resized.
Definition: notify_type.h:52
#define OP_TIMEOUT
1 second with no events
Definition: opcodes.h:36
#define OP_REPAINT
Repaint is needed.
Definition: opcodes.h:34
#define OP_ABORT
$abort_key pressed (Ctrl-G)
Definition: opcodes.h:37
#define STAILQ_FIRST(head)
Definition: queue.h:350
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
volatile sig_atomic_t SigWinch
true after SIGWINCH is received
Definition: signal.c:67
volatile sig_atomic_t SigInt
true after SIGINT is received
Definition: signal.c:66
void mutt_sig_allow_interrupt(bool allow)
Allow/disallow Ctrl-C (SIGINT)
Definition: signal.c:300
An event such as a keypress.
Definition: lib.h:81
int op
Function opcode, e.g. OP_HELP.
Definition: lib.h:83
int ch
Raw key pressed.
Definition: lib.h:82
A keyboard mapping.
Definition: lib.h:65
keycode_t * keys
key sequence
Definition: lib.h:71
char * macro
Macro expansion (op == OP_MACRO)
Definition: lib.h:66
short eq
Number of leading keys equal to next entry.
Definition: lib.h:69
short len
Length of key sequence (unit: sizeof (keycode_t))
Definition: lib.h:70
short op
Operation to perform.
Definition: lib.h:68
const char * name
String value.
Definition: mapping.h:34
Mapping between a function and an operation.
Definition: lib.h:101
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct Notify * notify_timeout
Timeout notifications handler.
Definition: neomutt.h:45
struct Notify * notify_resize
Window resize notifications handler.
Definition: neomutt.h:44
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:37
MenuType
Types of GUI selections.
Definition: type.h:36
@ MENU_GENERIC
Generic selection list.
Definition: type.h:46
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:52
@ MENU_EDITOR
Text entry area.
Definition: type.h:44