NeoMutt  2024-04-25-127-g771158
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
lib.h File Reference

Manage keymappings. More...

#include "config.h"
#include <stddef.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "menu/lib.h"
+ Include dependency graph for lib.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  Keymap
 A keyboard mapping. More...
 
struct  KeyEvent
 An event such as a keypress. More...
 
struct  MenuFuncOp
 Mapping between a function and an operation. More...
 
struct  MenuOpSeq
 Mapping between an operation and a key sequence. More...
 
struct  EventBinding
 A key binding Event. More...
 

Macros

#define MUTT_UNBIND   (1 << 0)
 Parse 'unbind' command.
 
#define MUTT_UNMACRO   (1 << 1)
 Parse 'unmacro' command.
 
#define GETCH_NO_FLAGS   0
 No flags are set.
 
#define GETCH_IGNORE_MACRO   (1 << 0)
 Don't use MacroEvents.
 

Typedefs

typedef uint8_t GetChFlags
 Flags for mutt_getch(), e.g. GETCH_NO_FLAGS.
 
typedef short keycode_t
 Type for key storage, the rest of neomutt works fine with int type.
 

Enumerations

enum  NotifyBinding {
  NT_BINDING_ADD = 1 , NT_BINDING_DELETE , NT_BINDING_DELETE_ALL , NT_MACRO_ADD ,
  NT_MACRO_DELETE , NT_MACRO_DELETE_ALL
}
 Key Binding notification types. More...
 

Functions

 STAILQ_HEAD (KeymapList, Keymap)
 
 ARRAY_HEAD (KeyEventArray, struct KeyEvent)
 
enum CommandResult mutt_parse_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'bind' command - Implements Command::parse() -.
 
enum CommandResult mutt_parse_exec (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'exec' command - Implements Command::parse() -.
 
enum CommandResult mutt_parse_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'macro' command - Implements Command::parse() -.
 
enum CommandResult mutt_parse_push (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'push' command - Implements Command::parse() -.
 
enum CommandResult mutt_parse_unbind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 Parse the 'unbind' command - Implements Command::parse() -.
 
enum CommandResult mutt_parse_unmacro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
 
enum CommandResult km_bind (char *s, enum MenuType menu, int op, char *macro, char *desc)
 Bind a key to a macro.
 
int km_dokey (enum MenuType menu, GetChFlags flags)
 Determine what a keypress should do.
 
struct KeyEvent km_dokey_event (enum MenuType menu, GetChFlags flags)
 Determine what a keypress should do.
 
void km_error_key (enum MenuType menu)
 Handle an unbound key sequence.
 
int km_expand_key (char *s, size_t len, struct Keymap *map)
 Get the key string bound to a Keymap.
 
int km_expand_key_string (char *str, char *buf, size_t buflen)
 Get a human-readable key string.
 
struct Keymapkm_find_func (enum MenuType menu, int func)
 Find a function's mapping in a Menu.
 
const struct MenuFuncOpkm_get_table (enum MenuType mtype)
 Lookup a Menu's functions.
 
void km_init (void)
 Initialise all the menu keybindings.
 
const char * km_keyname (int c)
 Get the human name for a key.
 
void init_extended_keys (void)
 Initialise map of ncurses extended keys.
 
int main_config_observer (struct NotifyCallback *nc)
 Notification that a Config Variable has changed - Implements observer_t -.
 
void mutt_flush_macro_to_endcond (void)
 Drop a macro from the input buffer.
 
void mutt_init_abort_key (void)
 Parse the abort_key config string.
 
void mutt_keys_cleanup (void)
 Free the key maps.
 
void mw_what_key (void)
 Display the value of a key -.
 
struct Keymapalloc_keys (size_t len, keycode_t *keys)
 Allocate space for a sequence of keys.
 
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() -.
 
void generic_tokenize_push_string (char *s)
 Parse and queue a 'push' command.
 
int get_op (const struct MenuFuncOp *funcs, const char *start, size_t len)
 Get the function by its name.
 
enum CommandResult km_bindkey (const char *s, enum MenuType mtype, int op)
 Bind a key in a Menu to an operation.
 
struct Keymapkm_compare_keys (struct Keymap *k1, struct Keymap *k2, size_t *pos)
 Compare two keymaps' keyscodes and return the bigger one.
 
const char * mutt_get_func (const struct MenuFuncOp *bindings, int op)
 Get the name of a function.
 
void mutt_keymap_free (struct Keymap **ptr)
 Free a Keymap.
 
size_t parsekeys (const char *str, keycode_t *d, size_t max)
 Parse a key string into key codes.
 

Variables

struct KeyEventArray MacroEvents
 These are used for macros and exec/push commands.
 
struct KeymapList Keymaps []
 Array of Keymap keybindings, one for each Menu.
 
struct Mapping KeyNames []
 Key name lookup table.
 
keycode_t AbortKey
 key to abort edits etc, normally Ctrl-G
 
const struct Mapping Menus []
 

Detailed Description

Manage keymappings.

Authors
  • Richard Russon

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 lib.h.

Macro Definition Documentation

◆ MUTT_UNBIND

#define MUTT_UNBIND   (1 << 0)

Parse 'unbind' command.

Definition at line 47 of file lib.h.

◆ MUTT_UNMACRO

#define MUTT_UNMACRO   (1 << 1)

Parse 'unmacro' command.

Definition at line 48 of file lib.h.

◆ GETCH_NO_FLAGS

#define GETCH_NO_FLAGS   0

No flags are set.

Definition at line 51 of file lib.h.

◆ GETCH_IGNORE_MACRO

#define GETCH_IGNORE_MACRO   (1 << 0)

Don't use MacroEvents.

Definition at line 52 of file lib.h.

Typedef Documentation

◆ GetChFlags

typedef uint8_t GetChFlags

Flags for mutt_getch(), e.g. GETCH_NO_FLAGS.

Definition at line 50 of file lib.h.

◆ keycode_t

typedef short keycode_t

Type for key storage, the rest of neomutt works fine with int type.

Definition at line 55 of file lib.h.

Enumeration Type Documentation

◆ NotifyBinding

Key Binding notification types.

Observers of NT_BINDING will be passed an EventBinding.

Note
Notifications are sent after the event.
Enumerator
NT_BINDING_ADD 

Key binding has been added.

NT_BINDING_DELETE 

Key binding has been deleted.

NT_BINDING_DELETE_ALL 

All key bindings have been deleted.

NT_MACRO_ADD 

Key macro has been added.

NT_MACRO_DELETE 

Key macro has been deleted.

NT_MACRO_DELETE_ALL 

All key macros have been deleted.

Definition at line 132 of file lib.h.

133{
134 NT_BINDING_ADD = 1,
137
141};
@ 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

Function Documentation

◆ STAILQ_HEAD()

STAILQ_HEAD ( KeymapList  ,
Keymap   
)

◆ ARRAY_HEAD()

ARRAY_HEAD ( KeyEventArray  ,
struct KeyEvent   
)

◆ mutt_parse_unmacro()

enum CommandResult mutt_parse_unmacro ( struct Buffer buf,
struct Buffer s,
intptr_t  data,
struct Buffer err 
)

◆ 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 160 of file parse.c.

161{
162 return km_bind_err(s, mtype, op, macro, desc, NULL);
163}
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
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_dokey()

int km_dokey ( enum MenuType  mtype,
GetChFlags  flags 
)

Determine what a keypress should do.

Parameters
mtypeMenu type, e.g. MENU_EDITOR
flagsFlags, e.g. GETCH_IGNORE_MACRO
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 464 of file get.c.

465{
466 return km_dokey_event(mtype, flags).op;
467}
struct KeyEvent km_dokey_event(enum MenuType mtype, GetChFlags flags)
Determine what a keypress should do.
Definition: get.c:346
int op
Function opcode, e.g. OP_HELP.
Definition: lib.h:83
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_dokey_event()

struct KeyEvent km_dokey_event ( enum MenuType  mtype,
GetChFlags  flags 
)

Determine what a keypress should do.

Parameters
mtypeMenu type, e.g. MENU_EDITOR
flagsFlags, e.g. GETCH_IGNORE_MACRO
Return values
ptrEvent

Definition at line 346 of file get.c.

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}
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
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
#define mutt_error(...)
Definition: logging2.h:92
const struct MenuFuncOp OpGeneric[]
Functions for the Generic Menu.
Definition: functions.c:68
void generic_tokenize_push_string(char *s)
Parse and queue a 'push' command.
Definition: lib.c:338
struct KeymapList Keymaps[MENU_MAX]
Array of key mappings, one for each MenuType.
Definition: lib.c:125
const char * mutt_get_func(const struct MenuFuncOp *funcs, int op)
Get the name of a function.
Definition: lib.c:321
const struct MenuFuncOp * km_get_table(enum MenuType mtype)
Lookup a Menu's functions.
Definition: lib.c:525
#define GETCH_IGNORE_MACRO
Don't use MacroEvents.
Definition: lib.h:52
#define _(a)
Definition: message.h:28
#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
An event such as a keypress.
Definition: lib.h:81
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
const struct Mapping MenuNames[]
Menu name lookup table.
Definition: type.c:37
@ 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
+ 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 294 of file get.c.

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}
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
+ 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 457 of file lib.c.

458{
459 if (!map)
460 return 0;
461
462 int p = 0;
463
464 while (true)
465 {
466 mutt_str_copy(s, km_keyname(map->keys[p]), len);
467 const size_t l = mutt_str_len(s);
468 len -= l;
469
470 if ((++p >= map->len) || !len)
471 return 1;
472
473 s += l;
474 }
475
476 /* not reached */
477}
const char * km_keyname(int c)
Get the human name for a key.
Definition: lib.c:410
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
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:581
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_expand_key_string()

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

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 486 of file lib.c.

487{
488 size_t len = 0;
489 for (; *str; str++)
490 {
491 const char *key = km_keyname(*str);
492 size_t keylen = mutt_str_len(key);
493
494 mutt_str_copy(buf, key, buflen);
495 buf += keylen;
496 buflen -= keylen;
497 len += keylen;
498 }
499
500 return len;
501}
+ 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 509 of file lib.c.

510{
511 struct Keymap *np = NULL;
512 STAILQ_FOREACH(np, &Keymaps[mtype], entries)
513 {
514 if (np->op == func)
515 break;
516 }
517 return np;
518}
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
+ Here is the caller graph for this function:

◆ km_get_table()

const struct MenuFuncOp * km_get_table ( enum MenuType  mtype)

Lookup a Menu's functions.

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

Definition at line 525 of file lib.c.

526{
527 switch (mtype)
528 {
529 case MENU_ALIAS:
530 return OpAlias;
531 case MENU_ATTACHMENT:
532 return OpAttachment;
533#ifdef USE_AUTOCRYPT
534 case MENU_AUTOCRYPT:
535 return OpAutocrypt;
536#endif
537 case MENU_COMPOSE:
538 return OpCompose;
539 case MENU_DIALOG:
540 return OpDialog;
541 case MENU_EDITOR:
542 return OpEditor;
543 case MENU_FOLDER:
544 return OpBrowser;
545 case MENU_GENERIC:
546 return OpGeneric;
547 case MENU_INDEX:
548 return OpIndex;
549#ifdef CRYPT_BACKEND_GPGME
551 return OpPgp;
553 return OpSmime;
554#endif
555 case MENU_PAGER:
556 return OpPager;
557 case MENU_PGP:
558 return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
559 case MENU_POSTPONED:
560 return OpPostponed;
561 case MENU_QUERY:
562 return OpQuery;
563 default:
564 return NULL;
565 }
566}
const struct MenuFuncOp OpDialog[]
Functions for Simple Dialogs.
Definition: functions.c:60
const struct MenuFuncOp OpQuery[]
Functions for the external Query Menu.
Definition: functions.c:73
const struct MenuFuncOp OpPostponed[]
Functions for the Postpone Menu.
Definition: functions.c:52
const struct MenuFuncOp OpIndex[]
Functions for the Index Menu.
Definition: functions.c:94
const struct MenuFuncOp OpCompose[]
Functions for the Compose Menu.
Definition: functions.c:87
const struct MenuFuncOp OpSmime[]
Functions for the Smime Menu.
Definition: functions.c:52
const struct MenuFuncOp OpBrowser[]
Functions for the file Browser Menu.
Definition: functions.c:74
const struct MenuFuncOp OpAutocrypt[]
Functions for the Autocrypt Account.
Definition: functions.c:52
const struct MenuFuncOp OpPager[]
Functions for the Pager Menu.
Definition: functions.c:71
const struct MenuFuncOp OpEditor[]
Functions for the Editor Menu.
Definition: functions.c:53
const struct MenuFuncOp OpAttachment[]
Functions for the Attachment Menu.
Definition: functions.c:64
const struct MenuFuncOp OpPgp[]
Functions for the Pgp Menu.
Definition: functions.c:42
const struct MenuFuncOp OpAlias[]
Functions for the Alias Menu.
Definition: functions.c:59
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90
#define WithCrypto
Definition: lib.h:116
@ MENU_KEY_SELECT_PGP
Select a PGP key.
Definition: type.h:48
@ MENU_INDEX
Index panel (list of emails)
Definition: type.h:51
@ MENU_DIALOG
Simple Dialog.
Definition: type.h:43
@ MENU_KEY_SELECT_SMIME
Select a SMIME key.
Definition: type.h:49
@ MENU_QUERY
Select from results of external query.
Definition: type.h:55
@ MENU_AUTOCRYPT
Autocrypt Account menu.
Definition: type.h:40
@ MENU_COMPOSE
Compose an email.
Definition: type.h:42
@ MENU_ATTACHMENT
Select an attachment.
Definition: type.h:38
@ MENU_PGP
PGP encryption menu.
Definition: type.h:53
@ MENU_ALIAS
Select an email address by its alias.
Definition: type.h:37
@ MENU_FOLDER
General file/mailbox browser.
Definition: type.h:45
@ MENU_POSTPONED
Select a postponed email.
Definition: type.h:54
+ Here is the caller graph for this function:

◆ km_init()

void km_init ( void  )

Initialise all the menu keybindings.

Definition at line 177 of file init.c.

178{
179 memset(Keymaps, 0, sizeof(struct KeymapList) * MENU_MAX);
180
183#ifdef USE_AUTOCRYPT
185#endif
195
200
201#ifdef CRYPT_BACKEND_GPGME
204#endif
205}
const struct MenuOpSeq GenericDefaultBindings[]
Key bindings for the Generic Menu.
Definition: functions.c:138
const struct MenuOpSeq DialogDefaultBindings[]
Key bindings for Simple Dialogs.
Definition: functions.c:130
const struct MenuOpSeq AttachmentDefaultBindings[]
Key bindings for the Attachment Menu.
Definition: functions.c:100
const struct MenuOpSeq EditorDefaultBindings[]
Key bindings for the Editor Menu.
Definition: functions.c:88
const struct MenuOpSeq QueryDefaultBindings[]
Key bindings for the external Query Menu.
Definition: functions.c:103
const struct MenuOpSeq PostponedDefaultBindings[]
Key bindings for the Postpone Menu.
Definition: functions.c:62
const struct MenuOpSeq BrowserDefaultBindings[]
Key bindings for the file Browser Menu.
Definition: functions.c:108
const struct MenuOpSeq AliasDefaultBindings[]
Key bindings for the Alias Menu.
Definition: functions.c:88
const struct MenuOpSeq PagerDefaultBindings[]
Key bindings for the Pager Menu.
Definition: functions.c:229
const struct MenuOpSeq IndexDefaultBindings[]
Key bindings for the Index Menu.
Definition: functions.c:239
const struct MenuOpSeq AutocryptDefaultBindings[]
Key bindings for the Autocrypt Account.
Definition: functions.c:66
static void create_bindings(const struct MenuOpSeq *map, enum MenuType mtype)
Attach a set of keybindings to a Menu.
Definition: init.c:165
const struct MenuOpSeq PgpDefaultBindings[]
Key bindings for the Pgp Menu.
Definition: functions.c:64
const struct MenuOpSeq ComposeDefaultBindings[]
Key bindings for the Compose Menu.
Definition: functions.c:153
const struct MenuOpSeq SmimeDefaultBindings[]
Key bindings for the Smime Menu.
Definition: functions.c:74
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91
@ MENU_SMIME
SMIME encryption menu.
Definition: type.h:56
@ MENU_MAX
Definition: type.h:57
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_keyname()

const char * km_keyname ( int  c)

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 410 of file lib.c.

411{
412 static char buf[35];
413
414 const char *p = mutt_map_get_name(c, KeyNames);
415 if (p)
416 return p;
417
418 if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
419 {
420 if (c < 0)
421 c += 256;
422
423 if (c < 128)
424 {
425 buf[0] = '^';
426 buf[1] = (c + '@') & 0x7f;
427 buf[2] = '\0';
428 }
429 else
430 {
431 snprintf(buf, sizeof(buf), "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
432 }
433 }
434 else if ((c >= KEY_F0) && (c < KEY_F(256))) /* this maximum is just a guess */
435 {
436 snprintf(buf, sizeof(buf), "<F%d>", c - KEY_F0);
437 }
438 else if ((c < 256) && (c >= -128) && IsPrint(c))
439 {
440 snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
441 }
442 else
443 {
444 snprintf(buf, sizeof(buf), "<%ho>", (unsigned short) c);
445 }
446 return buf;
447}
struct Mapping KeyNames[]
Key name lookup table.
Definition: lib.c:60
const char * mutt_map_get_name(int val, const struct Mapping *map)
Lookup a string for a constant.
Definition: mapping.c:42
#define IsPrint(ch)
Definition: mbyte.h:40
+ Here is the call graph for this function:
+ 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 mutt_tigetstr() fails. 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 134 of file init.c.

135{
136#ifdef HAVE_USE_EXTENDED_NAMES
137 use_extended_names(true);
138
139 for (int j = 0; KeyNames[j].name; j++)
140 {
141 if (KeyNames[j].value == -1)
142 {
143 const char *keyname = find_ext_name(KeyNames[j].name);
144
145 if (keyname)
146 {
147 const char *s = mutt_tigetstr((char *) keyname);
148 if (s && ((long) (s) != -1))
149 {
150 int code = key_defined(s);
151 if (code > 0)
152 KeyNames[j].value = code;
153 }
154 }
155 }
156 }
157#endif
158}
static const char * find_ext_name(const char *key)
Find the curses name for a key.
Definition: init.c:114
int value
Integer value.
Definition: mapping.h:35
const char * mutt_tigetstr(const char *name)
Get terminal capabilities.
Definition: terminal.c:57
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_flush_macro_to_endcond()

void mutt_flush_macro_to_endcond ( void  )

Drop a macro from the input buffer.

All the macro text is deleted until an OP_END_COND command, or the buffer is empty.

Definition at line 166 of file get.c.

167{
169}
struct KeyEventArray MacroEvents
These are used for macros and exec/push commands.
Definition: get.c:49
static void array_to_endcond(struct KeyEventArray *a)
Clear the array until an OP_END_COND.
Definition: get.c:98
+ 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 237 of file init.c.

238{
239 keycode_t buf[2];
240 const char *const c_abort_key = cs_subset_string(NeoMutt->sub, "abort_key");
241 size_t len = parsekeys(c_abort_key, buf, mutt_array_size(buf));
242 if (len == 0)
243 {
244 mutt_error(_("Abort key is not set, defaulting to Ctrl-G"));
245 AbortKey = ctrl('G');
246 return;
247 }
248 if (len > 1)
249 {
250 mutt_warning(_("Specified abort key sequence (%s) will be truncated to first key"),
251 c_abort_key);
252 }
253 AbortKey = buf[0];
254}
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
#define mutt_warning(...)
Definition: logging2.h:90
keycode_t AbortKey
code of key to abort prompts, normally Ctrl-G
Definition: lib.c:122
size_t parsekeys(const char *str, keycode_t *d, size_t max)
Parse a key string into key codes.
Definition: lib.c:216
short keycode_t
Type for key storage, the rest of neomutt works fine with int type.
Definition: lib.h:55
#define mutt_array_size(x)
Definition: memory.h:38
#define ctrl(ch)
Definition: mutt_curses.h:52
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mutt_keys_cleanup()

void mutt_keys_cleanup ( void  )

Free the key maps.

Definition at line 224 of file init.c.

225{
226 for (enum MenuType i = 1; i < MENU_MAX; i++)
227 {
229 }
230}
static void mutt_keymaplist_free(struct KeymapList *km_list)
Free a List of Keymaps.
Definition: init.c:211
MenuType
Types of GUI selections.
Definition: type.h:36
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ alloc_keys()

struct Keymap * alloc_keys ( size_t  len,
keycode_t keys 
)

Allocate space for a sequence of keys.

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

Definition at line 150 of file lib.c.

151{
152 struct Keymap *p = mutt_mem_calloc(1, sizeof(struct Keymap));
153 p->len = len;
154 p->keys = mutt_mem_calloc(len, sizeof(keycode_t));
155 memcpy(p->keys, keys, len * sizeof(keycode_t));
156 return p;
157}
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:51
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ generic_tokenize_push_string()

void generic_tokenize_push_string ( char *  s)

Parse and queue a 'push' command.

Parameters
sString to push into the key queue

Parses s for <function> syntax and adds the whole sequence the macro buffer.

Definition at line 338 of file lib.c.

339{
340 char *pp = NULL;
341 char *p = s + mutt_str_len(s) - 1;
342 size_t l;
343 int i, op = OP_NULL;
344
345 while (p >= s)
346 {
347 /* if we see something like "<PageUp>", look to see if it is a real
348 * function name and return the corresponding value */
349 if (*p == '>')
350 {
351 for (pp = p - 1; pp >= s && *pp != '<'; pp--)
352 ; // do nothing
353
354 if (pp >= s)
355 {
356 i = parse_fkey(pp);
357 if (i > 0)
358 {
359 mutt_push_macro_event(KEY_F(i), 0);
360 p = pp - 1;
361 continue;
362 }
363
364 l = p - pp + 1;
365 for (i = 0; KeyNames[i].name; i++)
366 {
367 if (mutt_istrn_equal(pp, KeyNames[i].name, l))
368 break;
369 }
370 if (KeyNames[i].name)
371 {
372 /* found a match */
373 mutt_push_macro_event(KeyNames[i].value, 0);
374 p = pp - 1;
375 continue;
376 }
377
378 /* See if it is a valid command
379 * skip the '<' and the '>' when comparing */
380 for (enum MenuType j = 0; MenuNames[j].name; j++)
381 {
382 const struct MenuFuncOp *funcs = km_get_table(MenuNames[j].value);
383 if (funcs)
384 {
385 op = get_op(funcs, pp + 1, l - 2);
386 if (op != OP_NULL)
387 break;
388 }
389 }
390
391 if (op != OP_NULL)
392 {
394 p = pp - 1;
395 continue;
396 }
397 }
398 }
399 mutt_push_macro_event((unsigned char) *p--, 0); /* independent 8 bits chars */
400 }
401}
void mutt_push_macro_event(int ch, int op)
Add the character/operation to the macro buffer.
Definition: get.c:155
int get_op(const struct MenuFuncOp *funcs, const char *start, size_t len)
Get the function by its name.
Definition: lib.c:299
static int parse_fkey(char *s)
Parse a function key string.
Definition: lib.c:166
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:453
int op
Operation, e.g. OP_DELETE.
Definition: lib.h:103
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_op()

int get_op ( const struct MenuFuncOp funcs,
const char *  start,
size_t  len 
)

Get the function by its name.

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

Definition at line 299 of file lib.c.

300{
301 for (int i = 0; funcs[i].name; i++)
302 {
303 if (mutt_istrn_equal(start, funcs[i].name, len) && (mutt_str_len(funcs[i].name) == len))
304 {
305 return funcs[i].op;
306 }
307 }
308
309 return OP_NULL;
310}
const char * name
Name of the function.
Definition: lib.h:102
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_bindkey()

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

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 186 of file parse.c.

187{
188 return km_bindkey_err(s, mtype, op, NULL);
189}
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
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ km_compare_keys()

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

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 275 of file lib.c.

276{
277 *pos = 0;
278
279 while (*pos < k1->len && *pos < k2->len)
280 {
281 if (k1->keys[*pos] < k2->keys[*pos])
282 return k2;
283 else if (k1->keys[*pos] > k2->keys[*pos])
284 return k1;
285 else
286 *pos = *pos + 1;
287 }
288
289 return NULL;
290}
+ Here is the caller graph for this function:

◆ mutt_get_func()

const char * mutt_get_func ( const struct MenuFuncOp funcs,
int  op 
)

Get the name of a function.

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

Definition at line 321 of file lib.c.

322{
323 for (int i = 0; funcs[i].name; i++)
324 {
325 if (funcs[i].op == op)
326 return funcs[i].name;
327 }
328
329 return NULL;
330}
+ Here is the caller graph for this function:

◆ mutt_keymap_free()

void mutt_keymap_free ( struct Keymap **  ptr)

Free a Keymap.

Parameters
ptrKeymap to free

Definition at line 131 of file lib.c.

132{
133 if (!ptr || !*ptr)
134 return;
135
136 struct Keymap *km = *ptr;
137 FREE(&km->macro);
138 FREE(&km->desc);
139 FREE(&km->keys);
140
141 FREE(ptr);
142}
#define FREE(x)
Definition: memory.h:45
char * desc
Description of a macro for the help menu.
Definition: lib.h:67
+ Here is the caller graph for this function:

◆ parsekeys()

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

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 216 of file lib.c.

217{
218 int n;
219 size_t len = max;
220 char buf[128] = { 0 };
221 char c;
222 char *t = NULL;
223
224 mutt_str_copy(buf, str, sizeof(buf));
225 char *s = buf;
226
227 while (*s && len)
228 {
229 *d = '\0';
230 if ((*s == '<') && (t = strchr(s, '>')))
231 {
232 t++;
233 c = *t;
234 *t = '\0';
235
237 if (n != -1)
238 {
239 s = t;
240 *d = n;
241 }
242 else if ((n = parse_fkey(s)) > 0)
243 {
244 s = t;
245 *d = KEY_F(n);
246 }
247 else if ((n = parse_keycode(s)) > 0)
248 {
249 s = t;
250 *d = n;
251 }
252
253 *t = c;
254 }
255
256 if (!*d)
257 {
258 *d = (unsigned char) *s;
259 s++;
260 }
261 d++;
262 len--;
263 }
264
265 return max - len;
266}
static int parse_keycode(const char *s)
Parse a numeric keycode.
Definition: lib.c:193
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:

Variable Documentation

◆ MacroEvents

struct KeyEventArray MacroEvents
extern

These are used for macros and exec/push commands.

They can be temporarily ignored by passing GETCH_IGNORE_MACRO

Definition at line 49 of file get.c.

◆ Keymaps

struct KeymapList Keymaps[]
extern

Array of Keymap keybindings, one for each Menu.

Array of Keymap keybindings, one for each Menu.

Definition at line 125 of file lib.c.

◆ KeyNames

struct Mapping KeyNames[]
extern

Key name lookup table.

Definition at line 60 of file lib.c.

◆ AbortKey

keycode_t AbortKey
extern

key to abort edits etc, normally Ctrl-G

key to abort edits etc, normally Ctrl-G

Definition at line 122 of file lib.c.

◆ Menus

const struct Mapping Menus[]
extern