NeoMutt  2021-02-05-666-ge300cd
Teaching an old dog new tricks
DOXYGEN
keymap.c File Reference

Manage keymappings. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "keymap.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "functions.h"
#include "init.h"
#include "mutt_commands.h"
#include "mutt_globals.h"
#include "mutt_logging.h"
#include "opcodes.h"
#include "options.h"
#include <strings.h>
#include "imap/lib.h"
#include "monitor.h"
+ Include dependency graph for keymap.c:

Go to the source code of this file.

Functions

static void mutt_keymap_free (struct Keymap **km)
 Free a Keymap. More...
 
static void mutt_keymaplist_free (struct KeymapList *km_list)
 Free a List of Keymaps. More...
 
static struct Keymapalloc_keys (size_t len, keycode_t *keys)
 Allocate space for a sequence of keys. More...
 
static int parse_fkey (char *s)
 Parse a function key string. More...
 
static int parse_keycode (const char *s)
 Parse a numeric keycode. More...
 
static size_t parsekeys (const char *str, keycode_t *d, size_t max)
 Parse a key string into key codes. More...
 
static struct Keymapkm_compare_keys (struct Keymap *k1, struct Keymap *k2, size_t *pos)
 Compare two keymaps' keyscodes and return the bigger one. More...
 
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. More...
 
enum CommandResult km_bind (char *s, enum MenuType mtype, int op, char *macro, char *desc)
 Bind a key to a macro. More...
 
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) More...
 
static enum CommandResult km_bindkey (const char *s, enum MenuType mtype, int op)
 Bind a key in a Menu to an operation. More...
 
static int get_op (const struct Binding *bindings, const char *start, size_t len)
 Get the function by its name. More...
 
const char * mutt_get_func (const struct Binding *bindings, int op)
 Get the name of a function. More...
 
static void generic_tokenize_push_string (char *s, void(*generic_push)(int, int))
 Parse and queue a 'push' command. More...
 
static int retry_generic (enum MenuType mtype, keycode_t *keys, int keyslen, int lastkey)
 Try to find the key in the generic menu bindings. More...
 
int km_dokey (enum MenuType mtype)
 Determine what a keypress should do. More...
 
static void create_bindings (const struct Binding *map, enum MenuType mtype)
 Attach a set of keybindings to a Menu. More...
 
static const char * km_keyname (int c)
 Get the human name for a key. More...
 
void mutt_init_abort_key (void)
 Parse the abort_key config string. More...
 
int main_config_observer (struct NotifyCallback *nc)
 Notification that a Config Variable has changed - Implements observer_t. More...
 
static int km_expand_key_string (char *str, char *buf, size_t buflen)
 Get a human-readable key string. More...
 
int km_expand_key (char *s, size_t len, struct Keymap *map)
 Get the key string bound to a Keymap. More...
 
struct Keymapkm_find_func (enum MenuType mtype, int func)
 Find a function's mapping in a Menu. More...
 
void init_extended_keys (void)
 Initialise map of ncurses extended keys. More...
 
void km_init (void)
 Initialise all the menu keybindings. More...
 
void km_error_key (enum MenuType mtype)
 Handle an unbound key sequence. More...
 
enum CommandResult mutt_parse_push (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'push' command - Implements Command::parse() -. More...
 
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. More...
 
static enum CommandResult try_bind (char *key, enum MenuType mtype, char *func, const struct Binding *bindings, struct Buffer *err)
 Try to make a key binding. More...
 
const struct Bindingkm_get_table (enum MenuType mtype)
 Lookup a menu's keybindings. More...
 
enum CommandResult mutt_parse_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'bind' command - Implements Command::parse() -bind menu-name <key_sequence> function-name. More...
 
static void * parse_menu (bool *menus, char *s, struct Buffer *err)
 Parse menu-names into an array. More...
 
static void km_unbind_all (struct KeymapList *km_list, unsigned long mode)
 Free all the keys in the supplied Keymap. More...
 
enum CommandResult mutt_parse_unbind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unbind' command - Implements Command::parse() -Command unbinds: More...
 
enum CommandResult mutt_parse_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'macro' command - Implements Command::parse() -macro <menu> <key> <macro> <description> More...
 
enum CommandResult mutt_parse_exec (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'exec' command - Implements Command::parse() -. More...
 
void mutt_what_key (void)
 Ask the user to press a key. More...
 
void mutt_keys_free (void)
 Free the key maps. More...
 

Variables

static struct Mapping KeyNames []
 Key name lookup table. More...
 
int LastKey
 contains the last key the user pressed More...
 
keycode_t AbortKey
 code of key to abort prompts, normally Ctrl-G More...
 
struct KeymapList Keymaps [MENU_MAX]
 Array of Keymap keybindings, one for each Menu. More...
 

Detailed Description

Manage keymappings.

Authors
  • Michael R. Elkins

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 General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file keymap.c.

Function Documentation

◆ mutt_keymap_free()

static void mutt_keymap_free ( struct Keymap **  km)
static

Free a Keymap.

Parameters
kmKeymap to free

Definition at line 179 of file keymap.c.

180 {
181  if (!km || !*km)
182  return;
183 
184  FREE(&(*km)->macro);
185  FREE(&(*km)->desc);
186  FREE(&(*km)->keys);
187  FREE(km);
188 }
#define FREE(x)
Definition: memory.h:40
+ Here is the caller graph for this function:

◆ mutt_keymaplist_free()

static void mutt_keymaplist_free ( struct KeymapList *  km_list)
static

Free a List of Keymaps.

Parameters
km_listList of Keymaps to free

Definition at line 194 of file keymap.c.

195 {
196  struct Keymap *np = NULL, *tmp = NULL;
197  STAILQ_FOREACH_SAFE(np, km_list, entries, tmp)
198  {
199  STAILQ_REMOVE(km_list, np, Keymap, entries);
200  mutt_keymap_free(&np);
201  }
202 }
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:402
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:362
A keyboard mapping.
Definition: keymap.h:48
static void mutt_keymap_free(struct Keymap **km)
Free a Keymap.
Definition: keymap.c:179
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ alloc_keys()

static struct Keymap* alloc_keys ( size_t  len,
keycode_t keys 
)
static

Allocate space for a sequence of keys.

Parameters
lenNumber of keys
keysArray of keys
Return values
ptrSequence of keys

Definition at line 210 of file keymap.c.

211 {
212  struct Keymap *p = mutt_mem_calloc(1, sizeof(struct Keymap));
213  p->len = len;
214  p->keys = mutt_mem_calloc(len, sizeof(keycode_t));
215  memcpy(p->keys, keys, len * sizeof(keycode_t));
216  return p;
217 }
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
keycode_t * keys
key sequence
Definition: keymap.h:55
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: keymap.h:39
A keyboard mapping.
Definition: keymap.h:48
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ parse_fkey()

static int parse_fkey ( char *  s)
static

Parse a function key string.

Parameters
sString to parse
Return values
numNumber of the key

Given "<f8>", it will return 8.

Definition at line 226 of file keymap.c.

227 {
228  char *t = NULL;
229  int n = 0;
230 
231  if ((s[0] != '<') || (tolower(s[1]) != 'f'))
232  return -1;
233 
234  for (t = s + 2; *t && isdigit((unsigned char) *t); t++)
235  {
236  n *= 10;
237  n += *t - '0';
238  }
239 
240  if (*t != '>')
241  return -1;
242  return n;
243 }
+ Here is the caller graph for this function:

◆ parse_keycode()

static int parse_keycode ( const char *  s)
static

Parse a numeric keycode.

Parameters
sString to parse
Return values
numNumber of the key

This function parses the string <NNN> and uses the octal value as the key to bind.

Definition at line 253 of file keymap.c.

254 {
255  char *end_char = NULL;
256  long int result = strtol(s + 1, &end_char, 8);
257  /* allow trailing whitespace, eg. < 1001 > */
258  while (IS_SPACE(*end_char))
259  end_char++;
260  /* negative keycodes don't make sense, also detect overflow */
261  if ((*end_char != '>') || (result < 0) || (result == LONG_MAX))
262  {
263  return -1;
264  }
265 
266  return result;
267 }
#define IS_SPACE(ch)
Definition: string2.h:38
+ Here is the caller graph for this function:

◆ parsekeys()

static size_t parsekeys ( const char *  str,
keycode_t d,
size_t  max 
)
static

Parse a key string into key codes.

Parameters
strKey string
dArray for key codes
maxMaximum length of key sequence
Return values
numLength of key sequence

Definition at line 276 of file keymap.c.

277 {
278  int n;
279  size_t len = max;
280  char buf[128];
281  char c;
282  char *t = NULL;
283 
284  mutt_str_copy(buf, str, sizeof(buf));
285  char *s = buf;
286 
287  while (*s && len)
288  {
289  *d = '\0';
290  if ((*s == '<') && (t = strchr(s, '>')))
291  {
292  t++;
293  c = *t;
294  *t = '\0';
295 
297  if (n != -1)
298  {
299  s = t;
300  *d = n;
301  }
302  else if ((n = parse_fkey(s)) > 0)
303  {
304  s = t;
305  *d = KEY_F(n);
306  }
307  else if ((n = parse_keycode(s)) > 0)
308  {
309  s = t;
310  *d = n;
311  }
312 
313  *t = c;
314  }
315 
316  if (!*d)
317  {
318  *d = (unsigned char) *s;
319  s++;
320  }
321  d++;
322  len--;
323  }
324 
325  return max - len;
326 }
static int parse_keycode(const char *s)
Parse a numeric keycode.
Definition: keymap.c:253
static struct Mapping KeyNames[]
Key name lookup table.
Definition: keymap.c:64
static int parse_fkey(char *s)
Parse a function key string.
Definition: keymap.c:226
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:749
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_compare_keys()

static struct Keymap* km_compare_keys ( struct Keymap k1,
struct Keymap k2,
size_t *  pos 
)
static

Compare two keymaps' keyscodes and return the bigger one.

Parameters
k1first keymap to compare
k2second keymap to compare
posposition where the two keycodes differ
Return values
ptrKeymap with a bigger ASCII keycode

Definition at line 335 of file keymap.c.

336 {
337  while (*pos < k1->len && *pos < k2->len)
338  {
339  if (k1->keys[*pos] < k2->keys[*pos])
340  return k2;
341  else if (k1->keys[*pos] > k2->keys[*pos])
342  return k1;
343  else
344  *pos = *pos + 1;
345  }
346 
347  return NULL;
348 }
keycode_t * keys
key sequence
Definition: keymap.h:55
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
+ Here is the caller graph for this function:

◆ km_bind_err()

static enum CommandResult km_bind_err ( const char *  s,
enum MenuType  mtype,
int  op,
char *  macro,
char *  desc,
struct Buffer err 
)
static

Set up a key binding.

Parameters
sKey string
mtypeMenu type, e.g. MENU_EDITOR
opOperation, e.g. OP_DELETE
macroMacro string
descDescription of macro (OPTIONAL)
errBuffer for error message
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Insert a key sequence into the specified map. The map is sorted by ASCII value (lowest to highest)

Definition at line 363 of file keymap.c.

365 {
367  struct Keymap *last = NULL, *np = NULL, *compare = NULL;
368  keycode_t buf[MAX_SEQ];
369  size_t pos = 0, lastpos = 0;
370 
371  size_t len = parsekeys(s, buf, MAX_SEQ);
372 
373  struct Keymap *map = alloc_keys(len, buf);
374  map->op = op;
375  map->macro = mutt_str_dup(macro);
376  map->desc = mutt_str_dup(desc);
377 
378  /* find position to place new keymap */
379  STAILQ_FOREACH(np, &Keymaps[mtype], entries)
380  {
381  compare = km_compare_keys(map, np, &pos);
382 
383  if (compare == map) /* map's keycode is bigger */
384  {
385  last = np;
386  lastpos = pos;
387  if (pos > np->eq)
388  pos = np->eq;
389  }
390  else if (compare == np) /* np's keycode is bigger, found insert location */
391  {
392  map->eq = pos;
393  break;
394  }
395  else /* equal keycodes */
396  {
397  /* Don't warn on overwriting a 'noop' binding */
398  if ((np->len != len) && (np->op != OP_NULL))
399  {
400  /* Overwrite with the different lengths, warn */
401  /* TODO: MAX_SEQ here is wrong */
402  char old_binding[MAX_SEQ];
403  char new_binding[MAX_SEQ];
404  km_expand_key(old_binding, MAX_SEQ, map);
405  km_expand_key(new_binding, MAX_SEQ, np);
406  char *err_msg =
407  _("Binding '%s' will alias '%s' Before, try: 'bind %s %s noop' "
408  "https://neomutt.org/guide/configuration.html#bind-warnings");
409  if (err)
410  {
411  /* err was passed, put the string there */
412  snprintf(err->data, err->dsize, err_msg, old_binding, new_binding,
413  mutt_map_get_name(mtype, MenuNames), new_binding);
414  }
415  else
416  {
417  mutt_error(err_msg, old_binding, new_binding,
418  mutt_map_get_name(mtype, MenuNames), new_binding);
419  }
420  rc = MUTT_CMD_WARNING;
421  }
422 
423  map->eq = np->eq;
424  STAILQ_REMOVE(&Keymaps[mtype], np, Keymap, entries);
425  mutt_keymap_free(&np);
426  break;
427  }
428  }
429 
430  if (last) /* if queue has at least one entry */
431  {
432  if (STAILQ_NEXT(last, entries))
433  STAILQ_INSERT_AFTER(&Keymaps[mtype], last, map, entries);
434  else /* last entry in the queue */
435  STAILQ_INSERT_TAIL(&Keymaps[mtype], map, entries);
436  last->eq = lastpos;
437  }
438  else /* queue is empty, so insert from head */
439  {
440  STAILQ_INSERT_HEAD(&Keymaps[mtype], map, entries);
441  }
442 
443  return rc;
444 }
short eq
number of leading keys equal to next entry
Definition: keymap.h:53
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:402
CommandResult
Error codes for command_t parse functions.
Definition: mutt_commands.h:34
struct KeymapList Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:126
#define mutt_error(...)
Definition: logging.h:88
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370
#define _(a)
Definition: message.h:28
#define STAILQ_INSERT_TAIL(head, elm, field)
Definition: queue.h:389
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
size_t dsize
Length of data.
Definition: buffer.h:37
static size_t parsekeys(const char *str, keycode_t *d, size_t max)
Parse a key string into key codes.
Definition: keymap.c:276
short op
operation to perform
Definition: keymap.h:52
static struct Keymap * alloc_keys(size_t len, keycode_t *keys)
Allocate space for a sequence of keys.
Definition: keymap.c:210
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: keymap.c:918
char * macro
macro expansion (op == OP_MACRO)
Definition: keymap.h:50
char * data
Pointer to data.
Definition: buffer.h:35
#define STAILQ_INSERT_HEAD(head, elm, field)
Definition: queue.h:383
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: keymap.h:39
char * desc
description of a macro for the help menu
Definition: keymap.h:51
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
A keyboard mapping.
Definition: keymap.h:48
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
Success: Command worked.
Definition: mutt_commands.h:38
Warning: Help given to the user.
Definition: mutt_commands.h:37
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:31
static void mutt_keymap_free(struct Keymap **km)
Free a Keymap.
Definition: keymap.c:179
static struct Keymap * km_compare_keys(struct Keymap *k1, struct Keymap *k2, size_t *pos)
Compare two keymaps&#39; keyscodes and return the bigger one.
Definition: keymap.c:335
#define MAX_SEQ
Definition: keymap.h:36
#define STAILQ_INSERT_AFTER(head, tqelm, elm, field)
Definition: queue.h:377
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_bind()

enum CommandResult km_bind ( char *  s,
enum MenuType  mtype,
int  op,
char *  macro,
char *  desc 
)

Bind a key to a macro.

Parameters
sKey string
mtypeMenu type, e.g. MENU_EDITOR
opOperation, e.g. OP_DELETE
macroMacro string
descDescription of macro (OPTIONAL)
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 455 of file keymap.c.

456 {
457  return km_bind_err(s, mtype, op, macro, desc, NULL);
458 }
short op
operation to perform
Definition: keymap.h:52
char * macro
macro expansion (op == OP_MACRO)
Definition: keymap.h:50
char * desc
description of a macro for the help menu
Definition: keymap.h:51
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: keymap.c:363
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_bindkey_err()

static enum CommandResult km_bindkey_err ( const char *  s,
enum MenuType  mtype,
int  op,
struct Buffer err 
)
static

Bind a key in a Menu to an operation (with error message)

Parameters
sKey string
mtypeMenu type, e.g. MENU_PAGER
opOperation, e.g. OP_DELETE
errBuffer for error message
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 468 of file keymap.c.

470 {
471  return km_bind_err(s, mtype, op, NULL, NULL, err);
472 }
short op
operation to perform
Definition: keymap.h:52
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: keymap.c:363
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_bindkey()

static enum CommandResult km_bindkey ( const char *  s,
enum MenuType  mtype,
int  op 
)
static

Bind a key in a Menu to an operation.

Parameters
sKey string
mtypeMenu type, e.g. MENU_PAGER
opOperation, e.g. OP_DELETE
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 481 of file keymap.c.

482 {
483  return km_bindkey_err(s, mtype, op, NULL);
484 }
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: keymap.c:468
short op
operation to perform
Definition: keymap.h:52
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_op()

static int get_op ( const struct Binding bindings,
const char *  start,
size_t  len 
)
static

Get the function by its name.

Parameters
bindingsKey bindings table
startName of function to find
lenLength of string to match
Return values
numOperation, e.g. OP_DELETE

Definition at line 493 of file keymap.c.

494 {
495  for (int i = 0; bindings[i].name; i++)
496  {
497  if (mutt_istrn_equal(start, bindings[i].name, len) &&
498  (mutt_str_len(bindings[i].name) == len))
499  {
500  return bindings[i].op;
501  }
502  }
503 
504  return OP_NULL;
505 }
int op
function id number
Definition: keymap.h:94
bool mutt_istrn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings ignoring case (to a maximum), safely.
Definition: string.c:621
const char * name
name of the function
Definition: keymap.h:93
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:664
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_get_func()

const char* mutt_get_func ( const struct Binding bindings,
int  op 
)

Get the name of a function.

Parameters
bindingsKey bindings table
opOperation, e.g. OP_DELETE
Return values
ptrName of function
NULLOperation not found
Note
This returns a static string.

Definition at line 516 of file keymap.c.

517 {
518  for (int i = 0; bindings[i].name; i++)
519  {
520  if (bindings[i].op == op)
521  return bindings[i].name;
522  }
523 
524  return NULL;
525 }
const char * name
name of the function
Definition: keymap.h:93
short op
operation to perform
Definition: keymap.h:52
+ Here is the caller graph for this function:

◆ generic_tokenize_push_string()

static void generic_tokenize_push_string ( char *  s,
void(*)(int, int)  generic_push 
)
static

Parse and queue a 'push' command.

Parameters
sString to push into the key queue
generic_pushCallback function to add events to macro queue

Parses s for <function> syntax and adds the whole sequence to either the macro or unget buffer. This function is invoked by the next two defines below.

Definition at line 536 of file keymap.c.

537 {
538  char *pp = NULL;
539  char *p = s + mutt_str_len(s) - 1;
540  size_t l;
541  int i, op = OP_NULL;
542 
543  while (p >= s)
544  {
545  /* if we see something like "<PageUp>", look to see if it is a real
546  * function name and return the corresponding value */
547  if (*p == '>')
548  {
549  for (pp = p - 1; pp >= s && *pp != '<'; pp--)
550  ; // do nothing
551 
552  if (pp >= s)
553  {
554  i = parse_fkey(pp);
555  if (i > 0)
556  {
557  generic_push(KEY_F(i), 0);
558  p = pp - 1;
559  continue;
560  }
561 
562  l = p - pp + 1;
563  for (i = 0; KeyNames[i].name; i++)
564  {
565  if (mutt_istrn_equal(pp, KeyNames[i].name, l))
566  break;
567  }
568  if (KeyNames[i].name)
569  {
570  /* found a match */
571  generic_push(KeyNames[i].value, 0);
572  p = pp - 1;
573  continue;
574  }
575 
576  /* See if it is a valid command
577  * skip the '<' and the '>' when comparing */
578  for (enum MenuType j = 0; MenuNames[j].name; j++)
579  {
580  const struct Binding *binding = km_get_table(MenuNames[j].value);
581  if (binding)
582  {
583  op = get_op(binding, pp + 1, l - 2);
584  if (op != OP_NULL)
585  break;
586  }
587  }
588 
589  if (op != OP_NULL)
590  {
591  generic_push(0, op);
592  p = pp - 1;
593  continue;
594  }
595  }
596  }
597  generic_push((unsigned char) *p--, 0); /* independent 8 bits chars */
598  }
599 }
MenuType
Types of GUI selections.
Definition: type.h:35
bool mutt_istrn_equal(const char *a, const char *b, size_t num)
Check for equality of two strings ignoring case (to a maximum), safely.
Definition: string.c:621
short op
operation to perform
Definition: keymap.h:52
static struct Mapping KeyNames[]
Key name lookup table.
Definition: keymap.c:64
static int parse_fkey(char *s)
Parse a function key string.
Definition: keymap.c:226
const struct Binding * km_get_table(enum MenuType mtype)
Lookup a menu&#39;s keybindings.
Definition: keymap.c:1313
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:664
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:31
const char * name
Definition: mapping.h:33
static int get_op(const struct Binding *bindings, const char *start, size_t len)
Get the function by its name.
Definition: keymap.c:493
Mapping between a user key and a function.
Definition: keymap.h:91
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ retry_generic()

static int retry_generic ( enum MenuType  mtype,
keycode_t keys,
int  keyslen,
int  lastkey 
)
static

Try to find the key in the generic menu bindings.

Parameters
mtypeMenu type, e.g. MENU_PAGER
keysArray of keys to return to the input queue
keyslenNumber of keys in the array
lastkeyLast key pressed (to return to input queue)
Return values
numOperation, e.g. OP_DELETE

Definition at line 609 of file keymap.c.

610 {
611  if ((mtype != MENU_EDITOR) && (mtype != MENU_GENERIC) && (mtype != MENU_PAGER))
612  {
613  if (lastkey)
614  mutt_unget_event(lastkey, 0);
615  for (; keyslen; keyslen--)
616  mutt_unget_event(keys[keyslen - 1], 0);
617  return km_dokey(MENU_GENERIC);
618  }
619  if (mtype != MENU_EDITOR)
620  {
621  /* probably a good idea to flush input here so we can abort macros */
622  mutt_flushinp();
623  }
624  return OP_NULL;
625 }
Generic selection list.
Definition: type.h:45
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: curs_lib.c:668
void mutt_unget_event(int ch, int op)
Return a keystroke to the input buffer.
Definition: curs_lib.c:583
Pager pager (email viewer)
Definition: type.h:54
Text entry area.
Definition: type.h:43
int km_dokey(enum MenuType mtype)
Determine what a keypress should do.
Definition: keymap.c:635
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_dokey()

int km_dokey ( enum MenuType  mtype)

Determine what a keypress should do.

Parameters
mtypeMenu type, e.g. MENU_EDITOR
Return values
>0Function to execute
OP_NULLNo function bound to key sequence
-1Error occurred while reading input
-2A timeout or sigwinch occurred

Definition at line 635 of file keymap.c.

636 {
637  struct KeyEvent tmp;
638  struct Keymap *map = STAILQ_FIRST(&Keymaps[mtype]);
639  int pos = 0;
640  int n = 0;
641 
642  if (!map && (mtype != MENU_EDITOR))
643  return retry_generic(mtype, NULL, 0, 0);
644 
645 #ifdef USE_IMAP
646  const short c_imap_keepalive =
647  cs_subset_number(NeoMutt->sub, "imap_keepalive");
648 #endif
649 
650  while (true)
651  {
652  const short c_timeout = cs_subset_number(NeoMutt->sub, "timeout");
653  int i = (c_timeout > 0) ? c_timeout : 60;
654 #ifdef USE_IMAP
655  /* keepalive may need to run more frequently than `$timeout` allows */
656  if (c_imap_keepalive)
657  {
658  if (c_imap_keepalive >= i)
659  imap_keepalive();
660  else
661  {
662  while (c_imap_keepalive && (c_imap_keepalive < i))
663  {
664  mutt_getch_timeout(c_imap_keepalive * 1000);
665  tmp = mutt_getch();
666  mutt_getch_timeout(-1);
667  /* If a timeout was not received, or the window was resized, exit the
668  * loop now. Otherwise, continue to loop until reaching a total of
669  * $timeout seconds. */
670  if ((tmp.ch != -2) || SigWinch)
671  goto gotkey;
672 #ifdef USE_INOTIFY
674  goto gotkey;
675 #endif
676  i -= c_imap_keepalive;
677  imap_keepalive();
678  }
679  }
680  }
681 #endif
682 
683  mutt_getch_timeout(i * 1000);
684  tmp = mutt_getch();
685  mutt_getch_timeout(-1);
686 
687 #ifdef USE_IMAP
688  gotkey:
689 #endif
690  /* hide timeouts, but not window resizes, from the line editor. */
691  if ((mtype == MENU_EDITOR) && (tmp.ch == -2) && !SigWinch)
692  continue;
693 
694  LastKey = tmp.ch;
695  if (LastKey < 0)
696  return LastKey;
697 
698  /* do we have an op already? */
699  if (tmp.op)
700  {
701  const char *func = NULL;
702  const struct Binding *bindings = NULL;
703 
704  /* is this a valid op for this menu type? */
705  if ((bindings = km_get_table(mtype)) && (func = mutt_get_func(bindings, tmp.op)))
706  return tmp.op;
707 
708  if ((mtype == MENU_EDITOR) && mutt_get_func(OpEditor, tmp.op))
709  return tmp.op;
710 
711  if ((mtype != MENU_EDITOR) && (mtype != MENU_PAGER))
712  {
713  /* check generic menu type */
714  bindings = OpGeneric;
715  func = mutt_get_func(bindings, tmp.op);
716  if (func)
717  return tmp.op;
718  }
719 
720  /* Sigh. Valid function but not in this context.
721  * Find the literal string and push it back */
722  for (i = 0; MenuNames[i].name; i++)
723  {
724  bindings = km_get_table(MenuNames[i].value);
725  if (bindings)
726  {
727  func = mutt_get_func(bindings, tmp.op);
728  if (func)
729  {
730  mutt_unget_event('>', 0);
731  mutt_unget_string(func);
732  mutt_unget_event('<', 0);
733  break;
734  }
735  }
736  }
737  /* continue to chew */
738  if (func)
739  continue;
740  }
741 
742  if (!map)
743  return tmp.op;
744 
745  /* Nope. Business as usual */
746  while (LastKey > map->keys[pos])
747  {
748  if ((pos > map->eq) || !STAILQ_NEXT(map, entries))
749  return retry_generic(mtype, map->keys, pos, LastKey);
750  map = STAILQ_NEXT(map, entries);
751  }
752 
753  if (LastKey != map->keys[pos])
754  return retry_generic(mtype, map->keys, pos, LastKey);
755 
756  if (++pos == map->len)
757  {
758  if (map->op != OP_MACRO)
759  return map->op;
760 
761  /* OptIgnoreMacroEvents turns off processing the MacroEvents buffer
762  * in mutt_getch(). Generating new macro events during that time would
763  * result in undesired behavior once the option is turned off.
764  *
765  * Originally this returned -1, however that results in an unbuffered
766  * username or password prompt being aborted. Returning OP_NULL allows
767  * mutt_enter_string_full() to display the keybinding pressed instead.
768  *
769  * It may be unexpected for a macro's keybinding to be returned,
770  * but less so than aborting the prompt. */
772  {
773  return OP_NULL;
774  }
775 
776  if (n++ == 10)
777  {
778  mutt_flushinp();
779  mutt_error(_("Macro loop detected"));
780  return -1;
781  }
782 
784  map = STAILQ_FIRST(&Keymaps[mtype]);
785  pos = 0;
786  }
787  }
788 
789  /* not reached */
790 }
short eq
number of leading keys equal to next entry
Definition: keymap.h:53
struct KeymapList Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:126
#define mutt_error(...)
Definition: logging.h:88
void mutt_push_macro_event(int ch, int op)
Add the character/operation to the macro buffer.
Definition: curs_lib.c:620
int op
function id number
Definition: keymap.h:94
void imap_keepalive(void)
poll the current folder to keep the connection alive
Definition: util.c:948
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: curs_lib.c:668
keycode_t * keys
key sequence
Definition: keymap.h:55
void mutt_unget_event(int ch, int op)
Return a keystroke to the input buffer.
Definition: curs_lib.c:583
#define _(a)
Definition: message.h:28
WHERE bool OptIgnoreMacroEvents
(pseudo) don&#39;t process macro/push/exec events while set
Definition: options.h:37
bool MonitorFilesChanged
true after a monitored file has changed
Definition: monitor.c:51
short cs_subset_number(const struct ConfigSubset *sub, const char *name)
Get a number config item by name.
Definition: helpers.c:169
Container for Accounts, Notifications.
Definition: neomutt.h:36
Pager pager (email viewer)
Definition: type.h:54
const char * mutt_get_func(const struct Binding *bindings, int op)
Get the name of a function.
Definition: keymap.c:516
Text entry area.
Definition: type.h:43
const struct Binding OpGeneric[]
Key bindings for the generic menu.
Definition: functions.c:53
int LastKey
contains the last key the user pressed
Definition: keymap.c:123
short op
operation to perform
Definition: keymap.h:52
char * macro
macro expansion (op == OP_MACRO)
Definition: keymap.h:50
static void generic_tokenize_push_string(char *s, void(*generic_push)(int, int))
Parse and queue a &#39;push&#39; command.
Definition: keymap.c:536
static int retry_generic(enum MenuType mtype, keycode_t *keys, int keyslen, int lastkey)
Try to find the key in the generic menu bindings.
Definition: keymap.c:609
An event such as a keypress.
Definition: keymap.h:64
struct KeyEvent mutt_getch(void)
Read a character from the input buffer.
Definition: curs_lib.c:196
#define STAILQ_NEXT(elm, field)
Definition: queue.h:400
const struct Binding * km_get_table(enum MenuType mtype)
Lookup a menu&#39;s keybindings.
Definition: keymap.c:1313
A keyboard mapping.
Definition: keymap.h:48
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
void mutt_getch_timeout(int delay)
Set the getch() timeout.
Definition: curs_lib.c:153
const struct Binding OpEditor[]
Key bindings for the editor menu.
Definition: functions.c:615
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:31
void mutt_unget_string(const char *s)
Return a string to the input buffer.
Definition: curs_lib.c:602
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
const char * name
Definition: mapping.h:33
WHERE SIG_ATOMIC_VOLATILE_T SigWinch
true after SIGWINCH is received
Definition: mutt_globals.h:68
#define STAILQ_FIRST(head)
Definition: queue.h:350
Mapping between a user key and a function.
Definition: keymap.h:91
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ create_bindings()

static void create_bindings ( const struct Binding map,
enum MenuType  mtype 
)
static

Attach a set of keybindings to a Menu.

Parameters
mapKey bindings
mtypeMenu type, e.g. MENU_PAGER

Definition at line 797 of file keymap.c.

798 {
799  STAILQ_INIT(&Keymaps[mtype]);
800 
801  for (int i = 0; map[i].name; i++)
802  if (map[i].seq)
803  km_bindkey(map[i].seq, mtype, map[i].op);
804 }
struct KeymapList Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:126
int op
function id number
Definition: keymap.h:94
#define STAILQ_INIT(head)
Definition: queue.h:372
static enum CommandResult km_bindkey(const char *s, enum MenuType mtype, int op)
Bind a key in a Menu to an operation.
Definition: keymap.c:481
const char * name
name of the function
Definition: keymap.h:93
const char * seq
default key binding
Definition: keymap.h:95
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_keyname()

static const char* km_keyname ( int  c)
static

Get the human name for a key.

Parameters
cKey code
Return values
ptrName of the key
Note
This returns a pointer to a static buffer.

Definition at line 813 of file keymap.c.

814 {
815  static char buf[35];
816 
817  const char *p = mutt_map_get_name(c, KeyNames);
818  if (p)
819  return p;
820 
821  if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
822  {
823  if (c < 0)
824  c += 256;
825 
826  if (c < 128)
827  {
828  buf[0] = '^';
829  buf[1] = (c + '@') & 0x7f;
830  buf[2] = '\0';
831  }
832  else
833  snprintf(buf, sizeof(buf), "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
834  }
835  else if ((c >= KEY_F0) && (c < KEY_F(256))) /* this maximum is just a guess */
836  sprintf(buf, "<F%d>", c - KEY_F0);
837  else if (IsPrint(c))
838  snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
839  else
840  snprintf(buf, sizeof(buf), "\\x%hx", (unsigned short) c);
841  return buf;
842 }
#define IsPrint(ch)
Definition: mbyte.h:38
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
static struct Mapping KeyNames[]
Key name lookup table.
Definition: keymap.c:64
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_init_abort_key()

void mutt_init_abort_key ( void  )

Parse the abort_key config string.

Parse the string into $abort_key and put the keycode into AbortKey.

Definition at line 849 of file keymap.c.

850 {
851  keycode_t buf[2];
852  const char *const c_abort_key = cs_subset_string(NeoMutt->sub, "abort_key");
853  size_t len = parsekeys(c_abort_key, buf, mutt_array_size(buf));
854  if (len == 0)
855  {
856  mutt_error(_("Abort key is not set, defaulting to Ctrl-G"));
857  AbortKey = ctrl('G');
858  return;
859  }
860  if (len > 1)
861  {
862  mutt_warning(
863  _("Specified abort key sequence (%s) will be truncated to first key"), c_abort_key);
864  }
865  AbortKey = buf[0];
866 }
#define mutt_error(...)
Definition: logging.h:88
#define _(a)
Definition: message.h:28
Container for Accounts, Notifications.
Definition: neomutt.h:36
#define mutt_array_size(x)
Definition: memory.h:33
static size_t parsekeys(const char *str, keycode_t *d, size_t max)
Parse a key string into key codes.
Definition: keymap.c:276
#define ctrl(ch)
Definition: mutt_curses.h:66
#define mutt_warning(...)
Definition: logging.h:86
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:317
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: keymap.h:39
keycode_t AbortKey
code of key to abort prompts, normally Ctrl-G
Definition: keymap.c:124
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:39
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ main_config_observer()

int main_config_observer ( struct NotifyCallback nc)

Notification that a Config Variable has changed - Implements observer_t.

Definition at line 871 of file keymap.c.

872 {
873  if ((nc->event_type != NT_CONFIG) || !nc->event_data)
874  return -1;
875 
876  struct EventConfig *ev_c = nc->event_data;
877 
878  if (!mutt_str_equal(ev_c->name, "abort_key"))
879  return 0;
880 
882  mutt_debug(LL_DEBUG5, "config done\n");
883  return 0;
884 }
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:904
A config-change event.
Definition: subset.h:69
enum NotifyType event_type
Send: Event type, e.g. NT_ACCOUNT.
Definition: observer.h:42
void mutt_init_abort_key(void)
Parse the abort_key config string.
Definition: keymap.c:849
#define mutt_debug(LEVEL,...)
Definition: logging.h:85
void * event_data
Data from notify_send()
Definition: observer.h:44
Config has changed, NotifyConfig, EventConfig.
Definition: notify_type.h:42
Log at debug level 5.
Definition: logging.h:44
const char * name
Name of config item that changed.
Definition: subset.h:72
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_expand_key_string()

static int km_expand_key_string ( char *  str,
char *  buf,
size_t  buflen 
)
static

Get a human-readable key string.

Parameters
strRaw key string
bufBuffer for the key string
buflenLength of buffer
Return values
numLength of string

Definition at line 893 of file keymap.c.

894 {
895  size_t len = 0;
896  for (; *str; str++)
897  {
898  const char *key = km_keyname(*str);
899  size_t keylen = mutt_str_len(key);
900 
901  mutt_str_copy(buf, key, buflen);
902  buf += keylen;
903  buflen -= keylen;
904  len += keylen;
905  }
906 
907  return len;
908 }
static const char * km_keyname(int c)
Get the human name for a key.
Definition: keymap.c:813
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:664
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:749
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_expand_key()

int km_expand_key ( char *  s,
size_t  len,
struct Keymap map 
)

Get the key string bound to a Keymap.

Parameters
sBuffer for the key string
lenLength of buffer
mapKeybinding map
Return values
1Success
0Error

Definition at line 918 of file keymap.c.

919 {
920  if (!map)
921  return 0;
922 
923  int p = 0;
924 
925  while (true)
926  {
927  mutt_str_copy(s, km_keyname(map->keys[p]), len);
928  const size_t l = mutt_str_len(s);
929  len -= l;
930 
931  if ((++p >= map->len) || !len)
932  return 1;
933 
934  s += l;
935  }
936 
937  /* not reached */
938 }
static const char * km_keyname(int c)
Get the human name for a key.
Definition: keymap.c:813
keycode_t * keys
key sequence
Definition: keymap.h:55
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:664
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:749
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_find_func()

struct Keymap* km_find_func ( enum MenuType  mtype,
int  func 
)

Find a function's mapping in a Menu.

Parameters
mtypeMenu type, e.g. MENU_PAGER
funcFunction, e.g. OP_DELETE
Return values
ptrKeymap for the function

Definition at line 946 of file keymap.c.

947 {
948  struct Keymap *np = NULL;
949  STAILQ_FOREACH(np, &Keymaps[mtype], entries)
950  {
951  if (np->op == func)
952  break;
953  }
954  return np;
955 }
struct KeymapList Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:126
short op
operation to perform
Definition: keymap.h:52
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
A keyboard mapping.
Definition: keymap.h:48
+ Here is the caller graph for this function:

◆ init_extended_keys()

void init_extended_keys ( void  )

Initialise map of ncurses extended keys.

Determine the keycodes for ncurses extended keys and fill in the KeyNames array.

This function must be called after initscr(), or tigetstr() returns -1. This creates a bit of a chicken-and-egg problem because km_init() is called prior to start_curses(). This means that the default keybindings can't include any of the extended keys because they won't be defined until later.

Definition at line 988 of file keymap.c.

989 {
990 #ifdef NCURSES_VERSION
991  use_extended_names(true);
992 
993  for (int j = 0; KeyNames[j].name; j++)
994  {
995  if (KeyNames[j].value == -1)
996  {
997  const char *keyname = find_ext_name(KeyNames[j].name);
998 
999  if (keyname)
1000  {
1001  char *s = tigetstr((char *) keyname);
1002  if (s && ((long) (s) != -1))
1003  {
1004  int code = key_defined(s);
1005  if (code > 0)
1006  KeyNames[j].value = code;
1007  }
1008  }
1009  }
1010  }
1011 #endif
1012 }
int value
Definition: mapping.h:34
static struct Mapping KeyNames[]
Key name lookup table.
Definition: keymap.c:64
const char * name
Definition: mapping.h:33
+ Here is the caller graph for this function:

◆ km_init()

void km_init ( void  )

Initialise all the menu keybindings.

Definition at line 1017 of file keymap.c.

1018 {
1019  memset(Keymaps, 0, sizeof(struct KeymapList) * MENU_MAX);
1020 
1029 
1032 
1035 
1036 #ifdef CRYPT_BACKEND_GPGME
1039 #endif
1040 
1041 #ifdef MIXMASTER
1043 
1044  km_bindkey("<space>", MENU_MIX, OP_GENERIC_SELECT_ENTRY);
1045  km_bindkey("h", MENU_MIX, OP_MIX_CHAIN_PREV);
1046  km_bindkey("l", MENU_MIX, OP_MIX_CHAIN_NEXT);
1047 #endif
1048 
1049 #ifdef USE_AUTOCRYPT
1051 #endif
1052 
1053  /* bindings for the line editor */
1055 
1056  km_bindkey("<up>", MENU_EDITOR, OP_EDITOR_HISTORY_UP);
1057  km_bindkey("<down>", MENU_EDITOR, OP_EDITOR_HISTORY_DOWN);
1058  km_bindkey("<left>", MENU_EDITOR, OP_EDITOR_BACKWARD_CHAR);
1059  km_bindkey("<right>", MENU_EDITOR, OP_EDITOR_FORWARD_CHAR);
1060  km_bindkey("<home>", MENU_EDITOR, OP_EDITOR_BOL);
1061  km_bindkey("<end>", MENU_EDITOR, OP_EDITOR_EOL);
1062  km_bindkey("<backspace>", MENU_EDITOR, OP_EDITOR_BACKSPACE);
1063  km_bindkey("<delete>", MENU_EDITOR, OP_EDITOR_DELETE_CHAR);
1064  km_bindkey("\177", MENU_EDITOR, OP_EDITOR_BACKSPACE);
1065 
1066  /* generic menu keymap */
1068 
1069  km_bindkey("<home>", MENU_GENERIC, OP_FIRST_ENTRY);
1070  km_bindkey("<end>", MENU_GENERIC, OP_LAST_ENTRY);
1071  km_bindkey("<pagedown>", MENU_GENERIC, OP_NEXT_PAGE);
1072  km_bindkey("<pageup>", MENU_GENERIC, OP_PREV_PAGE);
1073  km_bindkey("<right>", MENU_GENERIC, OP_NEXT_PAGE);
1074  km_bindkey("<left>", MENU_GENERIC, OP_PREV_PAGE);
1075  km_bindkey("<up>", MENU_GENERIC, OP_PREV_ENTRY);
1076  km_bindkey("<down>", MENU_GENERIC, OP_NEXT_ENTRY);
1077  km_bindkey("1", MENU_GENERIC, OP_JUMP);
1078  km_bindkey("2", MENU_GENERIC, OP_JUMP);
1079  km_bindkey("3", MENU_GENERIC, OP_JUMP);
1080  km_bindkey("4", MENU_GENERIC, OP_JUMP);
1081  km_bindkey("5", MENU_GENERIC, OP_JUMP);
1082  km_bindkey("6", MENU_GENERIC, OP_JUMP);
1083  km_bindkey("7", MENU_GENERIC, OP_JUMP);
1084  km_bindkey("8", MENU_GENERIC, OP_JUMP);
1085  km_bindkey("9", MENU_GENERIC, OP_JUMP);
1086 
1087  km_bindkey("<return>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
1088  km_bindkey("<enter>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
1089 
1090  /* Miscellaneous extra bindings */
1091 
1092  km_bindkey(" ", MENU_MAIN, OP_DISPLAY_MESSAGE);
1093  km_bindkey("<up>", MENU_MAIN, OP_MAIN_PREV_UNDELETED);
1094  km_bindkey("<down>", MENU_MAIN, OP_MAIN_NEXT_UNDELETED);
1095  km_bindkey("J", MENU_MAIN, OP_NEXT_ENTRY);
1096  km_bindkey("K", MENU_MAIN, OP_PREV_ENTRY);
1097  km_bindkey("x", MENU_MAIN, OP_EXIT);
1098 
1099  km_bindkey("<return>", MENU_MAIN, OP_DISPLAY_MESSAGE);
1100  km_bindkey("<enter>", MENU_MAIN, OP_DISPLAY_MESSAGE);
1101 
1102  km_bindkey("x", MENU_PAGER, OP_EXIT);
1103  km_bindkey("i", MENU_PAGER, OP_EXIT);
1104  km_bindkey("<backspace>", MENU_PAGER, OP_PREV_LINE);
1105  km_bindkey("<pagedown>", MENU_PAGER, OP_NEXT_PAGE);
1106  km_bindkey("<pageup>", MENU_PAGER, OP_PREV_PAGE);
1107  km_bindkey("<up>", MENU_PAGER, OP_MAIN_PREV_UNDELETED);
1108  km_bindkey("<right>", MENU_PAGER, OP_MAIN_NEXT_UNDELETED);
1109  km_bindkey("<down>", MENU_PAGER, OP_MAIN_NEXT_UNDELETED);
1110  km_bindkey("<left>", MENU_PAGER, OP_MAIN_PREV_UNDELETED);
1111  km_bindkey("<home>", MENU_PAGER, OP_PAGER_TOP);
1112  km_bindkey("<end>", MENU_PAGER, OP_PAGER_BOTTOM);
1113  km_bindkey("1", MENU_PAGER, OP_JUMP);
1114  km_bindkey("2", MENU_PAGER, OP_JUMP);
1115  km_bindkey("3", MENU_PAGER, OP_JUMP);
1116  km_bindkey("4", MENU_PAGER, OP_JUMP);
1117  km_bindkey("5", MENU_PAGER, OP_JUMP);
1118  km_bindkey("6", MENU_PAGER, OP_JUMP);
1119  km_bindkey("7", MENU_PAGER, OP_JUMP);
1120  km_bindkey("8", MENU_PAGER, OP_JUMP);
1121  km_bindkey("9", MENU_PAGER, OP_JUMP);
1122 
1123  km_bindkey("<return>", MENU_PAGER, OP_NEXT_LINE);
1124  km_bindkey("<enter>", MENU_PAGER, OP_NEXT_LINE);
1125 
1126  km_bindkey("<return>", MENU_ALIAS, OP_GENERIC_SELECT_ENTRY);
1127  km_bindkey("<enter>", MENU_ALIAS, OP_GENERIC_SELECT_ENTRY);
1128  km_bindkey("<space>", MENU_ALIAS, OP_TAG);
1129 
1130  km_bindkey("<return>", MENU_ATTACH, OP_VIEW_ATTACH);
1131  km_bindkey("<enter>", MENU_ATTACH, OP_VIEW_ATTACH);
1132  km_bindkey("<return>", MENU_COMPOSE, OP_VIEW_ATTACH);
1133  km_bindkey("<enter>", MENU_COMPOSE, OP_VIEW_ATTACH);
1134 
1135  /* edit-to (default "t") hides generic tag-entry in Compose menu
1136  * This will bind tag-entry to "T" in the Compose menu */
1137  km_bindkey("T", MENU_COMPOSE, OP_TAG);
1138 }
const struct Binding OpPager[]
Key bindings for the pager menu.
Definition: functions.c:263
#define WithCrypto
Definition: lib.h:113
const struct Binding OpPgp[]
Key bindings for the pgp menu.
Definition: functions.c:647
struct KeymapList Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:126
PGP encryption menu.
Definition: type.h:55
static void create_bindings(const struct Binding *map, enum MenuType mtype)
Attach a set of keybindings to a Menu.
Definition: keymap.c:797
Generic selection list.
Definition: type.h:45
Compose an email.
Definition: type.h:42
const struct Binding OpCompose[]
Key bindings for the compose menu.
Definition: functions.c:457
const struct Binding OpSmime[]
Key bindings for the smime menu.
Definition: functions.c:656
Definition: type.h:59
Pager pager (email viewer)
Definition: type.h:54
const struct Binding OpMix[]
Key bindings for the mixmaster menu.
Definition: functions.c:668
Text entry area.
Definition: type.h:43
static enum CommandResult km_bindkey(const char *s, enum MenuType mtype, int op)
Bind a key in a Menu to an operation.
Definition: keymap.c:481
const struct Binding OpAlias[]
Key bindings for the alias menu.
Definition: functions.c:536
const struct Binding OpGeneric[]
Key bindings for the generic menu.
Definition: functions.c:53
Select a PGP key.
Definition: type.h:47
Select an attachment.
Definition: type.h:38
Select from results of external query.
Definition: type.h:57
const struct Binding OpPost[]
Key bindings for the postpone menu.
Definition: functions.c:527
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:88
Select a postponed email.
Definition: type.h:56
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:87
Create/edit a Mixmaster chain.
Definition: type.h:52
Index panel (list of emails)
Definition: type.h:50
const struct Binding OpQuery[]
Key bindings for the external query menu.
Definition: functions.c:601
Autocrypt Account menu.
Definition: type.h:40
General file/mailbox browser.
Definition: type.h:44
Select a SMIME key.
Definition: type.h:48
const struct Binding OpEditor[]
Key bindings for the editor menu.
Definition: functions.c:615
const struct Binding OpMain[]
Key bindings for the index menu.
Definition: functions.c:102
SMIME encryption menu.
Definition: type.h:58
Select an email address by its alias.
Definition: type.h:37
const struct Binding OpAutocryptAcct[]
Key bindings for the autocrypt account.
Definition: functions.c:684
const struct Binding OpBrowser[]
Key bindings for the file browser menu.
Definition: functions.c:548
const struct Binding OpAttach[]
Key bindings for the attachment menu.
Definition: functions.c:420
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_error_key()

void km_error_key ( enum MenuType  mtype)

Handle an unbound key sequence.

Parameters
mtypeMenu type, e.g. MENU_PAGER

Definition at line 1144 of file keymap.c.

1145 {
1146  char buf[128];
1147  int p, op;
1148 
1149  struct Keymap *key = km_find_func(mtype, OP_HELP);
1150  if (!key && (mtype != MENU_EDITOR) && (mtype != MENU_PAGER))
1151  key = km_find_func(MENU_GENERIC, OP_HELP);
1152  if (!key)
1153  {
1154  mutt_error(_("Key is not bound"));
1155  return;
1156  }
1157 
1158  /* Make sure the key is really the help key in this menu.
1159  *
1160  * OP_END_COND is used as a barrier to ensure nothing extra
1161  * is left in the unget buffer.
1162  *
1163  * Note that km_expand_key() + tokenize_unget_string() should
1164  * not be used here: control sequences are expanded to a form
1165  * (e.g. "^H") not recognized by km_dokey(). */
1166  mutt_unget_event(0, OP_END_COND);
1167  p = key->len;
1168  while (p--)
1169  mutt_unget_event(key->keys[p], 0);
1170 
1171  /* Note, e.g. for the index menu:
1172  * bind generic ? noop
1173  * bind generic ,a help
1174  * bind index ,ab quit
1175  * The index keybinding shadows the generic binding.
1176  * OP_END_COND will be read and returned as the op.
1177  *
1178  * bind generic ? noop
1179  * bind generic dq help
1180  * bind index d delete-message
1181  * OP_DELETE will be returned as the op, leaving "q" + OP_END_COND
1182  * in the unget buffer.
1183  */
1184  op = km_dokey(mtype);
1185  if (op != OP_END_COND)
1187  if (op != OP_HELP)
1188  {
1189  mutt_error(_("Key is not bound"));
1190  return;
1191  }
1192 
1193  km_expand_key(buf, sizeof(buf), key);
1194  mutt_error(_("Key is not bound. Press '%s' for help."), buf);
1195 }
struct Keymap * km_find_func(enum MenuType mtype, int func)
Find a function&#39;s mapping in a Menu.
Definition: keymap.c:946
#define mutt_error(...)
Definition: logging.h:88
Generic selection list.
Definition: type.h:45
keycode_t * keys
key sequence
Definition: keymap.h:55
void mutt_unget_event(int ch, int op)
Return a keystroke to the input buffer.
Definition: curs_lib.c:583
#define _(a)
Definition: message.h:28
Pager pager (email viewer)
Definition: type.h:54
Text entry area.
Definition: type.h:43
short op
operation to perform
Definition: keymap.h:52
int km_expand_key(char *s, size_t len, struct Keymap *map)
Get the key string bound to a Keymap.
Definition: keymap.c:918
A keyboard mapping.
Definition: keymap.h:48
short len
length of key sequence (unit: sizeof (keycode_t))
Definition: keymap.h:54
void mutt_flush_unget_to_endcond(void)
Clear entries from UngetKeyEvents.
Definition: curs_lib.c:656
int km_dokey(enum MenuType mtype)
Determine what a keypress should do.
Definition: keymap.c:635
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ parse_keymap()

static char* parse_keymap ( enum MenuType mtypes,
struct Buffer s,
int  max_menus,
int *  num_menus,
struct Buffer err,
bool  bind 
)
static

Parse a user-config key binding.

Parameters
mtypesArray for results
sBuffer containing config string
max_menusTotal number of menus
num_menusNumber of menus this config applies to
errBuffer for error messages
bindIf true 'bind', otherwise 'macro'
Return values
ptrKey string for the binding

Expects to see: <menu-string>,<menu-string>,... <key-string>

Note
Caller needs to free the returned string

Definition at line 1228 of file keymap.c.

1230 {
1231  struct Buffer buf;
1232  int i = 0;
1233  char *q = NULL;
1234 
1235  mutt_buffer_init(&buf);
1236 
1237  /* menu name */
1239  char *p = buf.data;
1240  if (MoreArgs(s))
1241  {
1242  while (i < max_menus)
1243  {
1244  q = strchr(p, ',');
1245  if (q)
1246  *q = '\0';
1247 
1248  int val = mutt_map_get_value(p, MenuNames);
1249  if (val == -1)
1250  {
1251  mutt_buffer_printf(err, _("%s: no such menu"), p);
1252  goto error;
1253  }
1254  mtypes[i] = val;
1255  i++;
1256  if (q)
1257  p = q + 1;
1258  else
1259  break;
1260  }
1261  *num_menus = i;
1262  /* key sequence */
1264 
1265  if (buf.data[0] == '\0')
1266  {
1267  mutt_buffer_printf(err, _("%s: null key sequence"), bind ? "bind" : "macro");
1268  }
1269  else if (MoreArgs(s))
1270  return buf.data;
1271  }
1272  else
1273  {
1274  mutt_buffer_printf(err, _("%s: too few arguments"), bind ? "bind" : "macro");
1275  }
1276 error:
1277  FREE(&buf.data);
1278  return NULL;
1279 }
String manipulation buffer.
Definition: buffer.h:33
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
#define MoreArgs(buf)
Definition: buffer.h:40
int mutt_extract_token(struct Buffer *dest, struct Buffer *tok, TokenFlags flags)
Extract one token from a string.
Definition: init.c:395
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:31
#define FREE(x)
Definition: memory.h:40
struct Buffer * mutt_buffer_init(struct Buffer *buf)
Initialise a new Buffer.
Definition: buffer.c:46
#define MUTT_TOKEN_NO_FLAGS
No flags are set.
Definition: mutt.h:66
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ try_bind()

static enum CommandResult try_bind ( char *  key,
enum MenuType  mtype,
char *  func,
const struct Binding bindings,
struct Buffer err 
)
static

Try to make a key binding.

Parameters
keyKey name
mtypeMenu type, e.g. MENU_PAGER
funcFunction name
bindingsKey bindings table
errBuffer for error message
Return values
CommandResultResult e.g. MUTT_CMD_SUCCESS

Definition at line 1290 of file keymap.c.

1292 {
1293  for (int i = 0; bindings[i].name; i++)
1294  {
1295  if (mutt_str_equal(func, bindings[i].name))
1296  {
1297  return km_bindkey_err(key, mtype, bindings[i].op, err);
1298  }
1299  }
1300  if (err)
1301  {
1302  mutt_buffer_printf(err, _("Function '%s' not available for menu '%s'"),
1303  func, mutt_map_get_name(mtype, MenuNames));
1304  }
1305  return MUTT_CMD_ERROR; /* Couldn't find an existing function with this name */
1306 }
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:904
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: keymap.c:468
Error: Can&#39;t help the user.
Definition: mutt_commands.h:36
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
const char * name
name of the function
Definition: keymap.h:93
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:31
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_get_table()

const struct Binding* km_get_table ( enum MenuType  mtype)

Lookup a menu's keybindings.

Parameters
mtypeMenu type, e.g. MENU_EDITOR
Return values
ptrArray of keybindings

Definition at line 1313 of file keymap.c.

1314 {
1315  switch (mtype)
1316  {
1317  case MENU_ALIAS:
1318  return OpAlias;
1319  case MENU_ATTACH:
1320  return OpAttach;
1321 #ifdef USE_AUTOCRYPT
1322  case MENU_AUTOCRYPT_ACCT:
1323  return OpAutocryptAcct;
1324 #endif
1325  case MENU_COMPOSE:
1326  return OpCompose;
1327  case MENU_EDITOR:
1328  return OpEditor;
1329  case MENU_FOLDER:
1330  return OpBrowser;
1331  case MENU_GENERIC:
1332  return OpGeneric;
1333 #ifdef CRYPT_BACKEND_GPGME
1334  case MENU_KEY_SELECT_PGP:
1335  return OpPgp;
1336  case MENU_KEY_SELECT_SMIME:
1337  return OpSmime;
1338 #endif
1339  case MENU_MAIN:
1340  return OpMain;
1341 #ifdef MIXMASTER
1342  case MENU_MIX:
1343  return OpMix;
1344 #endif
1345  case MENU_PAGER:
1346  return OpPager;
1347  case MENU_PGP:
1348  return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
1349  case MENU_POSTPONE:
1350  return OpPost;
1351  case MENU_QUERY:
1352  return OpQuery;
1353  default:
1354  return NULL;
1355  }
1356 }
const struct Binding OpPager[]
Key bindings for the pager menu.
Definition: functions.c:263
#define WithCrypto
Definition: lib.h:113
const struct Binding OpPgp[]
Key bindings for the pgp menu.
Definition: functions.c:647
PGP encryption menu.
Definition: type.h:55
Generic selection list.
Definition: type.h:45
Compose an email.
Definition: type.h:42
const struct Binding OpCompose[]
Key bindings for the compose menu.
Definition: functions.c:457
const struct Binding OpSmime[]
Key bindings for the smime menu.
Definition: functions.c:656
Pager pager (email viewer)
Definition: type.h:54
const struct Binding OpMix[]
Key bindings for the mixmaster menu.
Definition: functions.c:668
Text entry area.
Definition: type.h:43
const struct Binding OpAlias[]
Key bindings for the alias menu.
Definition: functions.c:536
const struct Binding OpGeneric[]
Key bindings for the generic menu.
Definition: functions.c:53
Select a PGP key.
Definition: type.h:47
Select an attachment.
Definition: type.h:38
Select from results of external query.
Definition: type.h:57
const struct Binding OpPost[]
Key bindings for the postpone menu.
Definition: functions.c:527
Select a postponed email.
Definition: type.h:56
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:87
Create/edit a Mixmaster chain.
Definition: type.h:52
Index panel (list of emails)
Definition: type.h:50
const struct Binding OpQuery[]
Key bindings for the external query menu.
Definition: functions.c:601
Autocrypt Account menu.
Definition: type.h:40
General file/mailbox browser.
Definition: type.h:44
Select a SMIME key.
Definition: type.h:48
const struct Binding OpEditor[]
Key bindings for the editor menu.
Definition: functions.c:615
const struct Binding OpMain[]
Key bindings for the index menu.
Definition: functions.c:102
Select an email address by its alias.
Definition: type.h:37
const struct Binding OpAutocryptAcct[]
Key bindings for the autocrypt account.
Definition: functions.c:684
const struct Binding OpBrowser[]
Key bindings for the file browser menu.
Definition: functions.c:548
const struct Binding OpAttach[]
Key bindings for the attachment menu.
Definition: functions.c:420
+ Here is the caller graph for this function:

◆ parse_menu()

static void* parse_menu ( bool *  menus,
char *  s,
struct Buffer err 
)
static

Parse menu-names into an array.

Parameters
menusArray for results
sString containing menu-names
errBuffer for error messages

Expects to see: <menu-string>[,<menu-string>]

Definition at line 1459 of file keymap.c.

1460 {
1461  char *menu_names_dup = mutt_str_dup(s);
1462  char *marker = menu_names_dup;
1463  char *menu_name = NULL;
1464 
1465  while ((menu_name = strsep(&marker, ",")))
1466  {
1467  int value = mutt_map_get_value(menu_name, MenuNames);
1468  if (value == -1)
1469  {
1470  mutt_buffer_printf(err, _("%s: no such menu"), menu_name);
1471  break;
1472  }
1473  else
1474  menus[value] = true;
1475  }
1476 
1477  FREE(&menu_names_dup);
1478  return NULL;
1479 }
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370
#define _(a)
Definition: message.h:28
int mutt_buffer_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:160
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:31
#define FREE(x)
Definition: memory.h:40
int mutt_map_get_value(const char *name, const struct Mapping *map)
Lookup the constant for a string.
Definition: mapping.c:85
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_unbind_all()

static void km_unbind_all ( struct KeymapList *  km_list,
unsigned long  mode 
)
static

Free all the keys in the supplied Keymap.

Parameters
km_listKeymap mapping
modeUndo bind or macro, e.g. MUTT_UNBIND, MUTT_UNMACRO

Iterate through Keymap and free keys defined either by "macro" or "bind".

Definition at line 1488 of file keymap.c.

1489 {
1490  struct Keymap *np = NULL, *tmp = NULL;
1491 
1492  STAILQ_FOREACH_SAFE(np, km_list, entries, tmp)
1493  {
1494  if (((mode & MUTT_UNBIND) && !np->macro) || ((mode & MUTT_UNMACRO) && np->macro))
1495  {
1496  STAILQ_REMOVE(km_list, np, Keymap, entries);
1497  mutt_keymap_free(&np);
1498  }
1499  }
1500 }
#define STAILQ_REMOVE(head, elm, type, field)
Definition: queue.h:402
#define MUTT_UNMACRO
Definition: keymap.h:34
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
Definition: queue.h:362
char * macro
macro expansion (op == OP_MACRO)
Definition: keymap.h:50
A keyboard mapping.
Definition: keymap.h:48
static void mutt_keymap_free(struct Keymap **km)
Free a Keymap.
Definition: keymap.c:179
#define MUTT_UNBIND
Definition: keymap.h:33
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_what_key()

void mutt_what_key ( void  )

Ask the user to press a key.

Displays the octal value back to the user.

Definition at line 1718 of file keymap.c.

1719 {
1720  int ch;
1721 
1722  struct MuttWindow *win = msgwin_get_window();
1723  if (!win)
1724  return;
1725 
1726  mutt_window_mvprintw(win, 0, 0, _("Enter keys (%s to abort): "), km_keyname(AbortKey));
1727  do
1728  {
1729  ch = getch();
1730  if ((ch != ERR) && (ch != AbortKey))
1731  {
1732  mutt_message(_("Char = %s, Octal = %o, Decimal = %d"), km_keyname(ch), ch, ch);
1733  }
1734  } while (ch != ERR && ch != AbortKey);
1735 
1736  mutt_flushinp();
1737  mutt_clear_error();
1738 }
static const char * km_keyname(int c)
Get the human name for a key.
Definition: keymap.c:813
void mutt_flushinp(void)
Empty all the keyboard buffers.
Definition: curs_lib.c:668
#define _(a)
Definition: message.h:28
struct MuttWindow * msgwin_get_window(void)
Get the Message Window pointer.
Definition: msgwin.c:253
void mutt_clear_error(void)
Clear the message line (bottom line of screen)
Definition: mutt_logging.c:112
keycode_t AbortKey
code of key to abort prompts, normally Ctrl-G
Definition: keymap.c:124
#define mutt_message(...)
Definition: logging.h:87
int mutt_window_mvprintw(struct MuttWindow *win, int col, int row, const char *fmt,...)
Move the cursor and write a formatted string to a Window.
Definition: mutt_window.c:343
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_keys_free()

void mutt_keys_free ( void  )

Free the key maps.

Definition at line 1743 of file keymap.c.

1744 {
1745  for (int i = 0; i < MENU_MAX; i++)
1746  {
1748  }
1749 }
struct KeymapList Keymaps[MENU_MAX]
Array of Keymap keybindings, one for each Menu.
Definition: keymap.c:126
Definition: type.h:59
static void mutt_keymaplist_free(struct KeymapList *km_list)
Free a List of Keymaps.
Definition: keymap.c:194
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ KeyNames

struct Mapping KeyNames[]
static

Key name lookup table.

Definition at line 64 of file keymap.c.

◆ LastKey

int LastKey

contains the last key the user pressed

Last real key pressed, recorded by dokey()

Definition at line 123 of file keymap.c.

◆ AbortKey

keycode_t AbortKey

code of key to abort prompts, normally Ctrl-G

key to abort edits etc, normally Ctrl-G

Definition at line 124 of file keymap.c.

◆ Keymaps

struct KeymapList Keymaps[MENU_MAX]

Array of Keymap keybindings, one for each Menu.

Definition at line 126 of file keymap.c.