NeoMutt  2024-04-25-89-g194907
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
parse.c
Go to the documentation of this file.
1
29#include "config.h"
30#include <stdbool.h>
31#include <stdint.h>
32#include <stdio.h>
33#include <string.h>
34#include "mutt/lib.h"
35#include "core/lib.h"
36#include "gui/lib.h"
37#include "mutt.h"
38#include "key/lib.h"
39#include "menu/lib.h"
40#include "parse/lib.h"
41
43#define MAX_SEQ 8
44
58static enum CommandResult km_bind_err(const char *s, enum MenuType mtype, int op,
59 char *macro, char *desc, struct Buffer *err)
60{
62 struct Keymap *last = NULL, *np = NULL, *compare = NULL;
63 keycode_t buf[MAX_SEQ];
64 size_t pos = 0, lastpos = 0;
65
66 size_t len = parsekeys(s, buf, MAX_SEQ);
67
68 struct Keymap *map = alloc_keys(len, buf);
69 map->op = op;
70 map->macro = mutt_str_dup(macro);
71 map->desc = mutt_str_dup(desc);
72
73 /* find position to place new keymap */
74 STAILQ_FOREACH(np, &Keymaps[mtype], entries)
75 {
76 compare = km_compare_keys(map, np, &pos);
77
78 if (compare == map) /* map's keycode is bigger */
79 {
80 last = np;
81 lastpos = pos;
82 if (pos > np->eq)
83 pos = np->eq;
84 }
85 else if (compare == np) /* np's keycode is bigger, found insert location */
86 {
87 map->eq = pos;
88 break;
89 }
90 else /* equal keycodes */
91 {
92 /* Don't warn on overwriting a 'noop' binding */
93 if ((np->len != len) && (np->op != OP_NULL))
94 {
95 static const char *guide_link = "https://neomutt.org/guide/configuration.html#bind-warnings";
96 /* Overwrite with the different lengths, warn */
97 char old_binding[128] = { 0 };
98 char new_binding[128] = { 0 };
99 km_expand_key(old_binding, sizeof(old_binding), map);
100 km_expand_key(new_binding, sizeof(new_binding), np);
101 char *err_msg = _("Binding '%s' will alias '%s' Before, try: 'bind %s %s noop'");
102 if (err)
103 {
104 /* err was passed, put the string there */
105 buf_printf(err, err_msg, old_binding, new_binding,
106 mutt_map_get_name(mtype, MenuNames), new_binding);
107 buf_add_printf(err, " %s", guide_link);
108 }
109 else
110 {
111 struct Buffer *tmp = buf_pool_get();
112 buf_printf(tmp, err_msg, old_binding, new_binding,
113 mutt_map_get_name(mtype, MenuNames), new_binding);
114 buf_add_printf(tmp, " %s", guide_link);
115 mutt_error("%s", buf_string(tmp));
116 buf_pool_release(&tmp);
117 }
118 rc = MUTT_CMD_WARNING;
119 }
120
121 map->eq = np->eq;
122 STAILQ_REMOVE(&Keymaps[mtype], np, Keymap, entries);
123 mutt_keymap_free(&np);
124 break;
125 }
126 }
127
128 if (map->op == OP_NULL)
129 {
130 mutt_keymap_free(&map);
131 }
132 else
133 {
134 if (last) /* if queue has at least one entry */
135 {
136 if (STAILQ_NEXT(last, entries))
137 STAILQ_INSERT_AFTER(&Keymaps[mtype], last, map, entries);
138 else /* last entry in the queue */
139 STAILQ_INSERT_TAIL(&Keymaps[mtype], map, entries);
140 last->eq = lastpos;
141 }
142 else /* queue is empty, so insert from head */
143 {
144 STAILQ_INSERT_HEAD(&Keymaps[mtype], map, entries);
145 }
146 }
147
148 return rc;
149}
150
160enum CommandResult km_bind(char *s, enum MenuType mtype, int op, char *macro, char *desc)
161{
162 return km_bind_err(s, mtype, op, macro, desc, NULL);
163}
164
173static enum CommandResult km_bindkey_err(const char *s, enum MenuType mtype,
174 int op, struct Buffer *err)
175{
176 return km_bind_err(s, mtype, op, NULL, NULL, err);
177}
178
186enum CommandResult km_bindkey(const char *s, enum MenuType mtype, int op)
187{
188 return km_bindkey_err(s, mtype, op, NULL);
189}
190
198static void km_unbind_all(struct KeymapList *km_list, unsigned long mode)
199{
200 struct Keymap *np = NULL, *tmp = NULL;
201
202 STAILQ_FOREACH_SAFE(np, km_list, entries, tmp)
203 {
204 if (((mode & MUTT_UNBIND) && !np->macro) || ((mode & MUTT_UNMACRO) && np->macro))
205 {
206 STAILQ_REMOVE(km_list, np, Keymap, entries);
207 mutt_keymap_free(&np);
208 }
209 }
210}
211
226static char *parse_keymap(enum MenuType *mtypes, struct Buffer *s, int max_menus,
227 int *num_menus, struct Buffer *err, bool bind)
228{
229 struct Buffer *buf = buf_pool_get();
230 int i = 0;
231 char *q = NULL;
232 char *result = NULL;
233
234 /* menu name */
236 char *p = buf->data;
237 if (MoreArgs(s))
238 {
239 while (i < max_menus)
240 {
241 q = strchr(p, ',');
242 if (q)
243 *q = '\0';
244
245 int val = mutt_map_get_value(p, MenuNames);
246 if (val == -1)
247 {
248 buf_printf(err, _("%s: no such menu"), p);
249 goto done;
250 }
251 mtypes[i] = val;
252 i++;
253 if (q)
254 p = q + 1;
255 else
256 break;
257 }
258 *num_menus = i;
259 /* key sequence */
261
262 if (buf_at(buf, 0) == '\0')
263 {
264 buf_printf(err, _("%s: null key sequence"), bind ? "bind" : "macro");
265 }
266 else if (MoreArgs(s))
267 {
268 result = buf_strdup(buf);
269 goto done;
270 }
271 }
272 else
273 {
274 buf_printf(err, _("%s: too few arguments"), bind ? "bind" : "macro");
275 }
276done:
277 buf_pool_release(&buf);
278 return result;
279}
280
290static void *parse_menu(bool *menus, char *s, struct Buffer *err)
291{
292 char *menu_names_dup = mutt_str_dup(s);
293 char *marker = menu_names_dup;
294 char *menu_name = NULL;
295
296 while ((menu_name = mutt_str_sep(&marker, ",")))
297 {
298 int value = mutt_map_get_value(menu_name, MenuNames);
299 if (value == -1)
300 {
301 buf_printf(err, _("%s: no such menu"), menu_name);
302 break;
303 }
304 else
305 {
306 menus[value] = true;
307 }
308 }
309
310 FREE(&menu_names_dup);
311 return NULL;
312}
313
323static enum CommandResult try_bind(char *key, enum MenuType mtype, char *func,
324 const struct MenuFuncOp *funcs, struct Buffer *err)
325{
326 for (int i = 0; funcs[i].name; i++)
327 {
328 if (mutt_str_equal(func, funcs[i].name))
329 {
330 return km_bindkey_err(key, mtype, funcs[i].op, err);
331 }
332 }
333 if (err)
334 {
335 buf_printf(err, _("Function '%s' not available for menu '%s'"), func,
337 }
338 return MUTT_CMD_ERROR; /* Couldn't find an existing function with this name */
339}
340
344enum CommandResult mutt_parse_push(struct Buffer *buf, struct Buffer *s,
345 intptr_t data, struct Buffer *err)
346{
348 if (MoreArgs(s))
349 {
350 buf_printf(err, _("%s: too many arguments"), "push");
351 return MUTT_CMD_ERROR;
352 }
353
355 return MUTT_CMD_SUCCESS;
356}
357
363enum CommandResult mutt_parse_bind(struct Buffer *buf, struct Buffer *s,
364 intptr_t data, struct Buffer *err)
365{
366 if (StartupComplete)
367 {
368 // Save and restore the offset in `s` because dump_bind_macro() might change it
369 char *dptr = s->dptr;
370 if (dump_bind_macro(buf, s, data, err) == MUTT_CMD_SUCCESS)
371 return MUTT_CMD_SUCCESS;
372 if (!buf_is_empty(err))
373 return MUTT_CMD_ERROR;
374 s->dptr = dptr;
375 }
376
377 const struct MenuFuncOp *funcs = NULL;
378 enum MenuType mtypes[MenuNamesLen];
379 int num_menus = 0;
381
382 char *key = parse_keymap(mtypes, s, mutt_array_size(mtypes), &num_menus, err, true);
383 if (!key)
384 return MUTT_CMD_ERROR;
385
386 /* function to execute */
388 if (MoreArgs(s))
389 {
390 buf_printf(err, _("%s: too many arguments"), "bind");
391 rc = MUTT_CMD_ERROR;
392 }
393 else if (mutt_istr_equal("noop", buf->data))
394 {
395 for (int i = 0; i < num_menus; i++)
396 {
397 km_bindkey(key, mtypes[i], OP_NULL); /* the 'unbind' command */
398 funcs = km_get_table(mtypes[i]);
399 if (funcs)
400 {
401 char keystr[32] = { 0 };
402 km_expand_key_string(key, keystr, sizeof(keystr));
403 const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
404 mutt_debug(LL_NOTIFY, "NT_BINDING_DELETE: %s %s\n", mname, keystr);
405
406 int op = get_op(OpGeneric, buf->data, mutt_str_len(buf->data));
407 struct EventBinding ev_b = { mtypes[i], key, op };
409 }
410 }
411 }
412 else
413 {
414 for (int i = 0; i < num_menus; i++)
415 {
416 /* The pager and editor menus don't use the generic map,
417 * however for other menus try generic first. */
418 if ((mtypes[i] != MENU_PAGER) && (mtypes[i] != MENU_EDITOR) && (mtypes[i] != MENU_GENERIC))
419 {
420 rc = try_bind(key, mtypes[i], buf->data, OpGeneric, err);
421 if (rc == MUTT_CMD_SUCCESS)
422 {
423 char keystr[32] = { 0 };
424 km_expand_key_string(key, keystr, sizeof(keystr));
425 const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
426 mutt_debug(LL_NOTIFY, "NT_BINDING_NEW: %s %s\n", mname, keystr);
427
428 int op = get_op(OpGeneric, buf->data, mutt_str_len(buf->data));
429 struct EventBinding ev_b = { mtypes[i], key, op };
431 continue;
432 }
433 if (rc == MUTT_CMD_WARNING)
434 break;
435 }
436
437 /* Clear any error message, we're going to try again */
438 err->data[0] = '\0';
439 funcs = km_get_table(mtypes[i]);
440 if (funcs)
441 {
442 rc = try_bind(key, mtypes[i], buf->data, funcs, err);
443 if (rc == MUTT_CMD_SUCCESS)
444 {
445 char keystr[32] = { 0 };
446 km_expand_key_string(key, keystr, sizeof(keystr));
447 const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
448 mutt_debug(LL_NOTIFY, "NT_BINDING_NEW: %s %s\n", mname, keystr);
449
450 int op = get_op(funcs, buf->data, mutt_str_len(buf->data));
451 struct EventBinding ev_b = { mtypes[i], key, op };
453 continue;
454 }
455 }
456 }
457 }
458 FREE(&key);
459 return rc;
460}
461
472enum CommandResult mutt_parse_unbind(struct Buffer *buf, struct Buffer *s,
473 intptr_t data, struct Buffer *err)
474{
475 bool menu_matches[MENU_MAX] = { 0 };
476 bool all_keys = false;
477 char *key = NULL;
478
480 if (mutt_str_equal(buf->data, "*"))
481 {
482 for (enum MenuType i = 1; i < MENU_MAX; i++)
483 menu_matches[i] = true;
484 }
485 else
486 {
487 parse_menu(menu_matches, buf->data, err);
488 }
489
490 if (MoreArgs(s))
491 {
493 key = buf->data;
494 }
495 else
496 {
497 all_keys = true;
498 }
499
500 if (MoreArgs(s))
501 {
502 const char *cmd = (data & MUTT_UNMACRO) ? "unmacro" : "unbind";
503
504 buf_printf(err, _("%s: too many arguments"), cmd);
505 return MUTT_CMD_ERROR;
506 }
507
508 for (enum MenuType i = 1; i < MENU_MAX; i++)
509 {
510 if (!menu_matches[i])
511 continue;
512 if (all_keys)
513 {
514 km_unbind_all(&Keymaps[i], data);
515 km_bindkey("<enter>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
516 km_bindkey("<return>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
517 km_bindkey("<enter>", MENU_INDEX, OP_DISPLAY_MESSAGE);
518 km_bindkey("<return>", MENU_INDEX, OP_DISPLAY_MESSAGE);
519 km_bindkey("<backspace>", MENU_EDITOR, OP_EDITOR_BACKSPACE);
520 km_bindkey("\177", MENU_EDITOR, OP_EDITOR_BACKSPACE);
521 km_bindkey(":", MENU_GENERIC, OP_ENTER_COMMAND);
522 km_bindkey(":", MENU_PAGER, OP_ENTER_COMMAND);
523 if (i != MENU_EDITOR)
524 {
525 km_bindkey("?", i, OP_HELP);
526 km_bindkey("q", i, OP_EXIT);
527 }
528
529 const char *mname = mutt_map_get_name(i, MenuNames);
530 mutt_debug(LL_NOTIFY, "NT_MACRO_DELETE_ALL: %s\n", mname);
531
532 struct EventBinding ev_b = { i, NULL, OP_NULL };
535 &ev_b);
536 }
537 else
538 {
539 char keystr[32] = { 0 };
540 km_expand_key_string(key, keystr, sizeof(keystr));
541 const char *mname = mutt_map_get_name(i, MenuNames);
542 mutt_debug(LL_NOTIFY, "NT_MACRO_DELETE: %s %s\n", mname, keystr);
543
544 km_bindkey(key, i, OP_NULL);
545 struct EventBinding ev_b = { i, key, OP_NULL };
548 }
549 }
550
551 return MUTT_CMD_SUCCESS;
552}
553
559enum CommandResult mutt_parse_macro(struct Buffer *buf, struct Buffer *s,
560 intptr_t data, struct Buffer *err)
561{
562 if (StartupComplete)
563 {
564 // Save and restore the offset in `s` because dump_bind_macro() might change it
565 char *dptr = s->dptr;
566 if (dump_bind_macro(buf, s, data, err) == MUTT_CMD_SUCCESS)
567 return MUTT_CMD_SUCCESS;
568 if (!buf_is_empty(err))
569 return MUTT_CMD_ERROR;
570 s->dptr = dptr;
571 }
572
573 enum MenuType mtypes[MenuNamesLen];
574 int num_menus = 0;
576
577 char *key = parse_keymap(mtypes, s, mutt_array_size(mtypes), &num_menus, err, false);
578 if (!key)
579 return MUTT_CMD_ERROR;
580
582 /* make sure the macro sequence is not an empty string */
583 if (buf->data[0] == '\0')
584 {
585 buf_strcpy(err, _("macro: empty key sequence"));
586 }
587 else
588 {
589 if (MoreArgs(s))
590 {
591 char *seq = mutt_str_dup(buf->data);
593
594 if (MoreArgs(s))
595 {
596 buf_printf(err, _("%s: too many arguments"), "macro");
597 }
598 else
599 {
600 for (int i = 0; i < num_menus; i++)
601 {
602 rc = km_bind(key, mtypes[i], OP_MACRO, seq, buf->data);
603 if (rc == MUTT_CMD_SUCCESS)
604 {
605 char keystr[32] = { 0 };
606 km_expand_key_string(key, keystr, sizeof(keystr));
607 const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
608 mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", mname, keystr);
609
610 struct EventBinding ev_b = { mtypes[i], key, OP_MACRO };
612 continue;
613 }
614 }
615 }
616
617 FREE(&seq);
618 }
619 else
620 {
621 for (int i = 0; i < num_menus; i++)
622 {
623 rc = km_bind(key, mtypes[i], OP_MACRO, buf->data, NULL);
624 if (rc == MUTT_CMD_SUCCESS)
625 {
626 char keystr[32] = { 0 };
627 km_expand_key_string(key, keystr, sizeof(keystr));
628 const char *mname = mutt_map_get_name(mtypes[i], MenuNames);
629 mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", mname, keystr);
630
631 struct EventBinding ev_b = { mtypes[i], key, OP_MACRO };
633 continue;
634 }
635 }
636 }
637 }
638 FREE(&key);
639 return rc;
640}
641
645enum CommandResult mutt_parse_exec(struct Buffer *buf, struct Buffer *s,
646 intptr_t data, struct Buffer *err)
647{
648 int ops[128];
649 int nops = 0;
650 const struct MenuFuncOp *funcs = NULL;
651 char *function = NULL;
652
653 if (!MoreArgs(s))
654 {
655 buf_strcpy(err, _("exec: no arguments"));
656 return MUTT_CMD_ERROR;
657 }
658
659 do
660 {
662 function = buf->data;
663
664 const enum MenuType mtype = menu_get_current_type();
665 funcs = km_get_table(mtype);
666 if (!funcs && (mtype != MENU_PAGER))
667 funcs = OpGeneric;
668
669 ops[nops] = get_op(funcs, function, mutt_str_len(function));
670 if ((ops[nops] == OP_NULL) && (mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
671 {
672 ops[nops] = get_op(OpGeneric, function, mutt_str_len(function));
673 }
674
675 if (ops[nops] == OP_NULL)
676 {
678 mutt_error(_("%s: no such function"), function);
679 return MUTT_CMD_ERROR;
680 }
681 nops++;
682 } while (MoreArgs(s) && nops < mutt_array_size(ops));
683
684 while (nops)
685 mutt_push_macro_event(0, ops[--nops]);
686
687 return MUTT_CMD_SUCCESS;
688}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:204
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291
char buf_at(const struct Buffer *buf, size_t offset)
Return the character at the given offset.
Definition: buffer.c:670
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
char * buf_strdup(const struct Buffer *buf)
Copy a Buffer's string.
Definition: buffer.c:571
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
CommandResult
Error codes for command_t parse functions.
Definition: command.h:36
@ MUTT_CMD_SUCCESS
Success: Command worked.
Definition: command.h:39
@ MUTT_CMD_ERROR
Error: Can't help the user.
Definition: command.h:37
@ MUTT_CMD_WARNING
Warning: Help given to the user.
Definition: command.h:38
bool StartupComplete
When the config has been read.
Definition: main.c:192
Convenience wrapper for the core headers.
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: get.c:58
void mutt_push_macro_event(int ch, int op)
Add the character/operation to the macro buffer.
Definition: get.c:155
int parse_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: extract.c:50
#define TOKEN_CONDENSE
^(char) to control chars (macros)
Definition: extract.h:48
#define MoreArgs(buf)
Definition: extract.h:32
#define TOKEN_NO_FLAGS
No flags are set.
Definition: extract.h:46
enum CommandResult mutt_parse_bind(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'bind' command - Implements Command::parse() -.
Definition: parse.c:363
enum CommandResult mutt_parse_unbind(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'unbind' command - Implements Command::parse() -.
Definition: parse.c:472
enum CommandResult mutt_parse_macro(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'macro' command - Implements Command::parse() -.
Definition: parse.c:559
enum CommandResult mutt_parse_push(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'push' command - Implements Command::parse() -.
Definition: parse.c:344
enum CommandResult mutt_parse_exec(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'exec' command - Implements Command::parse() -.
Definition: parse.c:645
enum CommandResult dump_bind_macro(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse 'bind' and 'macro' commands - Implements Command::parse() -.
Definition: dump.c:172
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
const struct MenuFuncOp OpGeneric[]
Functions for the Generic Menu.
Definition: functions.c:68
Convenience wrapper for the gui headers.
void generic_tokenize_push_string(char *s)
Parse and queue a 'push' command.
Definition: lib.c:341
struct Keymap * km_compare_keys(struct Keymap *k1, struct Keymap *k2, size_t *pos)
Compare two keymaps' keyscodes and return the bigger one.
Definition: lib.c:278
struct Keymap * alloc_keys(size_t len, keycode_t *keys)
Allocate space for a sequence of keys.
Definition: lib.c:153
void mutt_keymap_free(struct Keymap **ptr)
Free a Keymap.
Definition: lib.c:134
struct KeymapList Keymaps[MENU_MAX]
Array of key mappings, one for each MenuType.
Definition: lib.c:128
size_t parsekeys(const char *str, keycode_t *d, size_t max)
Parse a key string into key codes.
Definition: lib.c:219
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: lib.c:460
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:528
int get_op(const struct MenuFuncOp *funcs, const char *start, size_t len)
Get the function by its name.
Definition: lib.c:302
int km_expand_key_string(char *str, char *buf, size_t buflen)
Get a human-readable key string.
Definition: lib.c:489
Manage keymappings.
@ NT_MACRO_ADD
Key macro has been added.
Definition: lib.h:138
@ NT_MACRO_DELETE
Key macro has been deleted.
Definition: lib.h:139
@ NT_MACRO_DELETE_ALL
All key macros have been deleted.
Definition: lib.h:140
@ NT_BINDING_DELETE
Key binding has been deleted.
Definition: lib.h:135
@ NT_BINDING_ADD
Key binding has been added.
Definition: lib.h:134
@ NT_BINDING_DELETE_ALL
All key bindings have been deleted.
Definition: lib.h:136
#define MUTT_UNBIND
Parse 'unbind' command.
Definition: lib.h:47
#define MUTT_UNMACRO
Parse 'unmacro' command.
Definition: lib.h:48
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: lib.h:55
static void * parse_menu(bool *menus, char *s, struct Buffer *err)
Parse menu-names into an array.
Definition: parse.c:290
enum CommandResult km_bind(char *s, enum MenuType mtype, int op, char *macro, char *desc)
Bind a key to a macro.
Definition: parse.c:160
static enum CommandResult km_bind_err(const char *s, enum MenuType mtype, int op, char *macro, char *desc, struct Buffer *err)
Set up a key binding.
Definition: parse.c:58
static enum CommandResult km_bindkey_err(const char *s, enum MenuType mtype, int op, struct Buffer *err)
Bind a key in a Menu to an operation (with error message)
Definition: parse.c:173
static void km_unbind_all(struct KeymapList *km_list, unsigned long mode)
Free all the keys in the supplied Keymap.
Definition: parse.c:198
enum CommandResult km_bindkey(const char *s, enum MenuType mtype, int op)
Bind a key in a Menu to an operation.
Definition: parse.c:186
static char * parse_keymap(enum MenuType *mtypes, struct Buffer *s, int max_menus, int *num_menus, struct Buffer *err, bool bind)
Parse a user-config key binding.
Definition: parse.c:226
static enum CommandResult try_bind(char *key, enum MenuType mtype, char *func, const struct MenuFuncOp *funcs, struct Buffer *err)
Try to make a key binding.
Definition: parse.c:323
#define MAX_SEQ
Maximum length of a key binding sequence used for buffer in km_bindkey.
Definition: parse.c:43
@ LL_NOTIFY
Log of notifications.
Definition: logging2.h:48
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
#define FREE(x)
Definition: memory.h:45
#define mutt_array_size(x)
Definition: memory.h:38
GUI present the user with a selectable list.
enum MenuType menu_get_current_type(void)
Get the type of the current Window.
Definition: menu.c:89
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
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
char * mutt_str_sep(char **stringp, const char *delim)
Find first occurrence of any of delim characters in *stringp.
Definition: string.c:186
Many unsorted constants and some structs.
@ NT_BINDING
Key binding has changed, NotifyBinding, EventBinding.
Definition: notify_type.h:40
Text parsing functions.
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:402
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:389
#define STAILQ_INSERT_HEAD(head, elm, field)
Definition: queue.h:383
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:362
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
#define STAILQ_INSERT_AFTER(head, tqelm, elm, field)
Definition: queue.h:377
String manipulation buffer.
Definition: buffer.h:36
char * dptr
Current read/write position.
Definition: buffer.h:38
char * data
Pointer to data.
Definition: buffer.h:37
A key binding Event.
Definition: lib.h:119
const char * key
Key string being bound (for new bind/macro)
Definition: lib.h:121
int op
Operation the key's bound to (for bind), e.g. OP_DELETE.
Definition: lib.h:122
A keyboard mapping.
Definition: lib.h:65
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
char * desc
Description of a macro for the help menu.
Definition: lib.h:67
short len
Length of key sequence (unit: sizeof (keycode_t))
Definition: lib.h:70
short op
Operation to perform.
Definition: lib.h:68
Mapping between a function and an operation.
Definition: lib.h:101
const char * name
Name of the function.
Definition: lib.h:102
int op
Operation, e.g. OP_DELETE.
Definition: lib.h:103
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct Notify * notify
Notifications handler.
Definition: neomutt.h:43
const int MenuNamesLen
Number of entries in the MenuNames array.
Definition: type.c:67
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:37
MenuType
Types of GUI selections.
Definition: type.h:36
@ MENU_INDEX
Index panel (list of emails)
Definition: type.h:51
@ MENU_GENERIC
Generic selection list.
Definition: type.h:46
@ MENU_PAGER
Pager pager (email viewer)
Definition: type.h:55
@ MENU_MAX
Definition: type.h:60
@ MENU_EDITOR
Text entry area.
Definition: type.h:44