lib.h File Reference

Manage keymappings. More...

#include "config.h"
#include <stdbool.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	BindingInfo
	Info about one keybinding. 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.
#define	MFF_NO_FLAGS   0
	No flags are set.
#define	MFF_DEPRECATED   (1 << 1)
	Redraw the pager.

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.
typedef uint8_t	MenuFuncFlags
	Flags, e.g. MFF_DEPRECATED.

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)
	ARRAY_HEAD (BindingInfoArray, struct BindingInfo)
static void	init_extended_keys (void)
enum CommandResult	km_bind (const char *s, enum MenuType mtype, int op, char *macro, char *desc, struct Buffer *err)
	Set up a key binding.
enum CommandResult	parse_bind (const struct Command *cmd, struct Buffer *line, struct Buffer *err)
	Parse the 'bind' command - Implements Command::parse() -.
enum CommandResult	parse_exec (const struct Command *cmd, struct Buffer *line, struct Buffer *err)
	Parse the 'exec' command - Implements Command::parse() -.
enum CommandResult	parse_macro (const struct Command *cmd, struct Buffer *line, struct Buffer *err)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	parse_push (const struct Command *cmd, struct Buffer *line, struct Buffer *err)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	parse_unbind (const struct Command *cmd, struct Buffer *line, struct Buffer *err)
	Parse the 'unbind' command - Implements Command::parse() -.
void	km_init (void)
	Initialise all the menu keybindings.
int	main_config_observer (struct NotifyCallback *nc)
void	mutt_init_abort_key (void)
	Parse the abort_key config string.
void	mutt_keys_cleanup (void)
	Free the key maps.
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.
void	mutt_flush_macro_to_endcond (void)
	Drop a macro from the input buffer.
bool	km_expand_key (struct Keymap *map, struct Buffer *buf)
	Get the key string bound to a Keymap.
struct Keymap *	km_find_func (enum MenuType menu, int func)
	Find a function's mapping in a Menu.
const struct MenuFuncOp *	km_get_table (enum MenuType mtype)
	Lookup a Menu's functions.
void	km_keyname (int c, struct Buffer *buf)
	Get the human name for a key.
struct Keymap *	alloc_keys (size_t len, keycode_t *keys)
	Allocate space for a sequence of keys.
enum CommandResult	parse_bind_macro (const struct Command *cmd, struct Buffer *line, 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.
struct Keymap *	km_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.
int	parse_fkey (char *s)
	Parse a function key string.
size_t	parsekeys (const char *str, keycode_t *d, size_t max)
	Parse a key string into key codes.
void	km_expand_key_string (char *str, struct Buffer *buf)
	Get a human-readable key string.
struct KeyEvent	mutt_getch (GetChFlags flags)
	Read a character from the input buffer.
void	mutt_flushinp (void)
	Empty all the keyboard buffers.
void	mutt_push_macro_event (int ch, int op)
	Add the character/operation to the macro buffer.
void	mutt_unget_ch (int ch)
	Return a keystroke to the input buffer.
void	mutt_unget_op (int op)
	Return an operation to the input buffer.
void	mutt_unget_string (const char *s)
	Return a string to the input buffer.
int	measure_column (struct BindingInfoArray *bia, int col)
	Measure one column of a table.
void	gather_menu (enum MenuType menu, struct BindingInfoArray *bia_bind, struct BindingInfoArray *bia_macro)
	Gather info about one menu.
int	gather_unbound (const struct MenuFuncOp *funcs, const struct KeymapList *km_menu, const struct KeymapList *km_aux, struct BindingInfoArray *bia_unbound)
	Gather info about unbound functions for one menu.
int	binding_sort (const void *a, const void *b, void *sdata)
	Compare two BindingInfo by their keybinding - Implements sort_t -.

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

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

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 49 of file lib.h.

MUTT_UNMACRO

#define MUTT_UNMACRO   (1 << 1)

Parse 'unmacro' command.

Definition at line 50 of file lib.h.

GETCH_NO_FLAGS

#define GETCH_NO_FLAGS   0

No flags are set.

Definition at line 53 of file lib.h.

GETCH_IGNORE_MACRO

#define GETCH_IGNORE_MACRO   (1 << 0)

Don't use MacroEvents.

Definition at line 54 of file lib.h.

MFF_NO_FLAGS

#define MFF_NO_FLAGS   0

No flags are set.

Definition at line 110 of file lib.h.

MFF_DEPRECATED

#define MFF_DEPRECATED   (1 << 1)

Redraw the pager.

Definition at line 111 of file lib.h.

Typedef Documentation

GetChFlags

typedef uint8_t GetChFlags

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

Definition at line 52 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 57 of file lib.h.

MenuFuncFlags

typedef uint8_t MenuFuncFlags

Flags, e.g. MFF_DEPRECATED.

Definition at line 109 of file lib.h.

Enumeration Type Documentation

NotifyBinding

enum 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 149 of file lib.h.

{
  NT_BINDING_ADD = 1,    
  NT_BINDING_DELETE,     
  NT_BINDING_DELETE_ALL, 
 
  NT_MACRO_ADD,          
  NT_MACRO_DELETE,       
  NT_MACRO_DELETE_ALL,   
};

Function Documentation

STAILQ_HEAD()

STAILQ_HEAD	(	KeymapList	,
		Keymap	)

ARRAY_HEAD() [1/2]

ARRAY_HEAD	(	KeyEventArray	,
		struct KeyEvent	)

ARRAY_HEAD() [2/2]

ARRAY_HEAD	(	BindingInfoArray	,
		struct BindingInfo	)

init_extended_keys()

static void init_extended_keys ( void )

inlinestatic

Definition at line 164 of file lib.h.

{}

km_bind()

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

Set up a key binding.

Parameters

s	Key string
mtype	Menu type, e.g. MENU_EDITOR
op	Operation, e.g. OP_DELETE
macro	Macro string
desc	Description of macro (OPTIONAL)
err	Buffer for error message

Return values

CommandResult

Result 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 56 of file commands.c.

{
  enum CommandResult rc = MUTT_CMD_SUCCESS;
  struct Keymap *last = NULL, *np = NULL, *compare = NULL;
  keycode_t buf[MAX_SEQ];
  size_t pos = 0, lastpos = 0;
 
  size_t len = parsekeys(s, buf, MAX_SEQ);
 
  struct Keymap *map = alloc_keys(len, buf);
  map->op = op;
  map->macro = mutt_str_dup(macro);
  map->desc = mutt_str_dup(desc);
 
  /* find position to place new keymap */
  STAILQ_FOREACH(np, &Keymaps[mtype], entries)
  {
    compare = km_compare_keys(map, np, &pos);
 
    if (compare == map) /* map's keycode is bigger */
    {
      last = np;
      lastpos = pos;
      if (pos > np->eq)
        pos = np->eq;
    }
    else if (compare == np) /* np's keycode is bigger, found insert location */
    {
      map->eq = pos;
      break;
    }
    else /* equal keycodes */
    {
      /* Don't warn on overwriting a 'noop' binding */
      if ((np->len != len) && (np->op != OP_NULL))
      {
        static const char *guide_link = "https://neomutt.org/guide/configuration.html#bind-warnings";
        /* Overwrite with the different lengths, warn */
        struct Buffer *old_binding = buf_pool_get();
        struct Buffer *new_binding = buf_pool_get();
 
        km_expand_key(map, old_binding);
        km_expand_key(np, new_binding);
 
        char *err_msg = _("Binding '%s' will alias '%s'  Before, try: 'bind %s %s noop'");
        if (err)
        {
          /* err was passed, put the string there */
          buf_printf(err, err_msg, buf_string(old_binding), buf_string(new_binding),
                     mutt_map_get_name(mtype, MenuNames), buf_string(new_binding));
          buf_add_printf(err, "  %s", guide_link);
        }
        else
        {
          struct Buffer *tmp = buf_pool_get();
          buf_printf(tmp, err_msg, buf_string(old_binding), buf_string(new_binding),
                     mutt_map_get_name(mtype, MenuNames), buf_string(new_binding));
          buf_add_printf(tmp, "  %s", guide_link);
          mutt_error("%s", buf_string(tmp));
          buf_pool_release(&tmp);
        }
        rc = MUTT_CMD_WARNING;
 
        buf_pool_release(&old_binding);
        buf_pool_release(&new_binding);
      }
 
      map->eq = np->eq;
      STAILQ_REMOVE(&Keymaps[mtype], np, Keymap, entries);
      mutt_keymap_free(&np);
      break;
    }
  }
 
  if (map->op == OP_NULL)
  {
    mutt_keymap_free(&map);
  }
  else
  {
    if (last) /* if queue has at least one entry */
    {
      if (STAILQ_NEXT(last, entries))
        STAILQ_INSERT_AFTER(&Keymaps[mtype], last, map, entries);
      else /* last entry in the queue */
        STAILQ_INSERT_TAIL(&Keymaps[mtype], map, entries);
      last->eq = lastpos;
    }
    else /* queue is empty, so insert from head */
    {
      STAILQ_INSERT_HEAD(&Keymaps[mtype], map, entries);
    }
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_init()

void km_init

(

void

)

Initialise all the menu keybindings.

Definition at line 104 of file init.c.

{
  memset(Keymaps, 0, sizeof(struct KeymapList) * MENU_MAX);
 
  create_bindings(AliasDefaultBindings, MENU_ALIAS);
  create_bindings(AttachmentDefaultBindings, MENU_ATTACHMENT);
#ifdef USE_AUTOCRYPT
  create_bindings(AutocryptDefaultBindings, MENU_AUTOCRYPT);
#endif
  create_bindings(BrowserDefaultBindings, MENU_BROWSER);
  create_bindings(ComposeDefaultBindings, MENU_COMPOSE);
  create_bindings(DialogDefaultBindings, MENU_DIALOG);
  create_bindings(EditorDefaultBindings, MENU_EDITOR);
  create_bindings(GenericDefaultBindings, MENU_GENERIC);
  create_bindings(IndexDefaultBindings, MENU_INDEX);
  create_bindings(PagerDefaultBindings, MENU_PAGER);
  create_bindings(PgpDefaultBindings, MENU_PGP);
  create_bindings(PostponedDefaultBindings, MENU_POSTPONED);
  create_bindings(QueryDefaultBindings, MENU_QUERY);
  create_bindings(SmimeDefaultBindings, MENU_SMIME);
 
  commands_register(&NeoMutt->commands, KeyCommands);
}

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

)

Here is the call 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 181 of file init.c.

{
  keycode_t buf[2];
  const char *const c_abort_key = cs_subset_string(NeoMutt->sub, "abort_key");
  size_t len = parsekeys(c_abort_key, buf, countof(buf));
  if (len == 0)
  {
    mutt_error(_("Abort key is not set, defaulting to Ctrl-G"));
    AbortKey = ctrl('G');
    return;
  }
  if (len > 1)
  {
    mutt_warning(_("Specified abort key sequence (%s) will be truncated to first key"),
                 c_abort_key);
  }
  AbortKey = buf[0];
 
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, key_config_observer, NULL);
}

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 165 of file init.c.

{
  for (enum MenuType i = 1; i < MENU_MAX; i++)
  {
    mutt_keymaplist_free(&Keymaps[i]);
  }
 
  if (NeoMutt && NeoMutt->sub)
    notify_observer_remove(NeoMutt->sub->notify, key_config_observer, NULL);
}

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

mtype	Menu type, e.g. MENU_EDITOR
flags	Flags, e.g. GETCH_IGNORE_MACRO

Return values

>0	Function to execute
OP_NULL	No function bound to key sequence
-1	Error occurred while reading input
-2	A timeout or sigwinch occurred

Definition at line 537 of file get.c.

{
  return km_dokey_event(mtype, flags).op;
}

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

mtype	Menu type, e.g. MENU_EDITOR
flags	Flags, e.g. GETCH_IGNORE_MACRO

Return values

ptr

Event

Definition at line 419 of file get.c.

{
  struct KeyEvent event = { 0, OP_NULL };
  struct Keymap *map = STAILQ_FIRST(&Keymaps[mtype]);
  int pos = 0;
  int n = 0;
 
  if (!map && (mtype != MENU_EDITOR))
    return retry_generic(mtype, NULL, 0, 0, flags);
 
  while (true)
  {
    event = mutt_getch(flags);
 
    // abort, timeout, repaint
    if (event.op < OP_NULL)
      return event;
 
    /* do we have an op already? */
    if (event.op != OP_NULL)
    {
      const char *func = NULL;
      const struct MenuFuncOp *funcs = NULL;
 
      /* is this a valid op for this menu type? */
      if ((funcs = km_get_table(mtype)) && (func = mutt_get_func(funcs, event.op)))
        return event;
 
      if ((mtype != MENU_EDITOR) && (mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
      {
        /* check generic menu type */
        funcs = OpGeneric;
        func = mutt_get_func(funcs, event.op);
        if (func)
          return event;
      }
 
      /* Sigh. Valid function but not in this context.
       * Find the literal string and push it back */
      for (int i = 0; MenuNames[i].name; i++)
      {
        funcs = km_get_table(MenuNames[i].value);
        if (funcs)
        {
          func = mutt_get_func(funcs, event.op);
          if (func)
          {
            mutt_unget_ch('>');
            mutt_unget_string(func);
            mutt_unget_ch('<');
            break;
          }
        }
      }
      /* continue to chew */
      if (func)
        continue;
    }
 
    if (!map)
      return event;
 
    /* Nope. Business as usual */
    while (event.ch > map->keys[pos])
    {
      if ((pos > map->eq) || !STAILQ_NEXT(map, entries))
        return retry_generic(mtype, map->keys, pos, event.ch, flags);
      map = STAILQ_NEXT(map, entries);
    }
 
    if (event.ch != map->keys[pos])
      return retry_generic(mtype, map->keys, pos, event.ch, flags);
 
    if (++pos == map->len)
    {
      if (map->op != OP_MACRO)
        return (struct KeyEvent) { event.ch, map->op };
 
      /* #GETCH_IGNORE_MACRO turns off processing the MacroEvents buffer
       * in mutt_getch().  Generating new macro events during that time would
       * result in undesired behavior once the option is turned off.
       *
       * Originally this returned -1, however that results in an unbuffered
       * username or password prompt being aborted.  Returning OP_NULL allows
       * mw_get_field() to display the keybinding pressed instead.
       *
       * It may be unexpected for a macro's keybinding to be returned,
       * but less so than aborting the prompt.  */
      if (flags & GETCH_IGNORE_MACRO)
      {
        return (struct KeyEvent) { event.ch, OP_NULL };
      }
 
      if (n++ == 10)
      {
        mutt_flushinp();
        mutt_error(_("Macro loop detected"));
        return (struct KeyEvent) { '\0', OP_ABORT };
      }
 
      generic_tokenize_push_string(map->macro);
      map = STAILQ_FIRST(&Keymaps[mtype]);
      pos = 0;
    }
  }
 
  /* not reached */
}

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

mtype

Menu type, e.g. MENU_PAGER

Definition at line 294 of file get.c.

{
  struct Keymap *key = km_find_func(mtype, OP_HELP);
  if (!key && (mtype != MENU_EDITOR) && (mtype != MENU_PAGER))
    key = km_find_func(MENU_GENERIC, OP_HELP);
 
  if (!key)
  {
    mutt_error(_("Key is not bound"));
    return;
  }
 
  struct Buffer *buf = buf_pool_get();
  km_expand_key(key, buf);
  mutt_error(_("Key is not bound.  Press '%s' for help."), buf_string(buf));
  buf_pool_release(&buf);
}

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.

{
  array_to_endcond(&MacroEvents);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_expand_key()

bool km_expand_key	(	struct Keymap *	map,
		struct Buffer *	buf )

Get the key string bound to a Keymap.

Parameters

[in]	map	Keybinding map
[out]	buf	Buffer for the result

Return values

true

Success

Definition at line 437 of file lib.c.

{
  if (!map || !buf)
    return false;
 
  for (int i = 0; i < map->len; i++)
  {
    km_keyname(map->keys[i], buf);
  }
 
  return true;
}

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

mtype	Menu type, e.g. MENU_PAGER
func	Function, e.g. OP_DELETE

Return values

ptr	Keymap for the function

Definition at line 469 of file lib.c.

{
  struct Keymap *np = NULL;
  STAILQ_FOREACH(np, &Keymaps[mtype], entries)
  {
    if (np->op == func)
      break;
  }
  return np;
}

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

mtype

Menu type, e.g. MENU_EDITOR

Return values

ptr	Array of functions

Definition at line 485 of file lib.c.

{
  switch (mtype)
  {
    case MENU_ALIAS:
      return OpAlias;
    case MENU_ATTACHMENT:
      return OpAttachment;
#ifdef USE_AUTOCRYPT
    case MENU_AUTOCRYPT:
      return OpAutocrypt;
#endif
    case MENU_BROWSER:
      return OpBrowser;
    case MENU_COMPOSE:
      return OpCompose;
    case MENU_DIALOG:
      return OpDialog;
    case MENU_EDITOR:
      return OpEditor;
    case MENU_GENERIC:
      return OpGeneric;
    case MENU_INDEX:
      return OpIndex;
    case MENU_PAGER:
      return OpPager;
    case MENU_PGP:
      return OpPgp;
    case MENU_POSTPONED:
      return OpPostponed;
    case MENU_QUERY:
      return OpQuery;
    case MENU_SMIME:
      return OpSmime;
    default:
      return NULL;
  }
}

Here is the caller graph for this function:

km_keyname()

void km_keyname	(	int	c,
		struct Buffer *	buf )

Get the human name for a key.

Parameters

[in]	c	Key code
[out]	buf	Buffer for the result

Definition at line 393 of file lib.c.

{
  const char *name = mutt_map_get_name(c, KeyNames);
  if (name)
  {
    buf_addstr(buf, name);
    return;
  }
 
  if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
  {
    if (c < 0)
      c += 256;
 
    if (c < 128)
    {
      buf_addch(buf, '^');
      buf_addch(buf, (c + '@') & 0x7f);
    }
    else
    {
      buf_add_printf(buf, "\\%d%d%d", c >> 6, (c >> 3) & 7, c & 7);
    }
  }
  else if ((c >= KEY_F0) && (c < KEY_F(256))) /* this maximum is just a guess */
  {
    buf_add_printf(buf, "<F%d>", c - KEY_F0);
  }
  else if ((c < 256) && (c >= -128) && IsPrint(c))
  {
    buf_add_printf(buf, "%c", (unsigned char) c);
  }
  else
  {
    buf_add_printf(buf, "<%ho>", (unsigned short) c);
  }
}

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

len	Number of keys
keys	Array of keys

Return values

ptr	Sequence of keys

Definition at line 150 of file lib.c.

{
  struct Keymap *p = MUTT_MEM_CALLOC(1, struct Keymap);
  p->len = len;
  p->keys = MUTT_MEM_CALLOC(len, keycode_t);
  memcpy(p->keys, keys, len * sizeof(keycode_t));
  return p;
}

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

s	String to push into the key queue

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

Definition at line 348 of file get.c.

{
  char *pp = NULL;
  char *p = s + mutt_str_len(s) - 1;
  size_t l;
  int i, op = OP_NULL;
 
  while (p >= s)
  {
    /* if we see something like "<PageUp>", look to see if it is a real
     * function name and return the corresponding value */
    if (*p == '>')
    {
      for (pp = p - 1; pp >= s && *pp != '<'; pp--)
        ; // do nothing
 
      if (pp >= s)
      {
        i = parse_fkey(pp);
        if (i > 0)
        {
          mutt_push_macro_event(KEY_F(i), 0);
          p = pp - 1;
          continue;
        }
 
        l = p - pp + 1;
        for (i = 0; KeyNames[i].name; i++)
        {
          if (mutt_istrn_equal(pp, KeyNames[i].name, l))
            break;
        }
        if (KeyNames[i].name)
        {
          /* found a match */
          mutt_push_macro_event(KeyNames[i].value, 0);
          p = pp - 1;
          continue;
        }
 
        /* See if it is a valid command
         * skip the '<' and the '>' when comparing */
        for (enum MenuType j = 0; MenuNames[j].name; j++)
        {
          const struct MenuFuncOp *funcs = km_get_table(MenuNames[j].value);
          if (funcs)
          {
            op = get_op(funcs, pp + 1, l - 2);
            if (op != OP_NULL)
              break;
          }
        }
 
        if (op != OP_NULL)
        {
          mutt_push_macro_event(0, op);
          p = pp - 1;
          continue;
        }
      }
    }
    mutt_push_macro_event((unsigned char) *p--, 0); /* independent 8 bits chars */
  }
}

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

funcs	Functions table
start	Name of function to find
len	Length of string to match

Return values

num	Operation, e.g. OP_DELETE

Definition at line 299 of file lib.c.

{
  for (int i = 0; funcs[i].name; i++)
  {
    if (mutt_istrn_equal(start, funcs[i].name, len) && (mutt_str_len(funcs[i].name) == len))
    {
      return funcs[i].op;
    }
  }
 
  return OP_NULL;
}

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

k1	first keymap to compare
k2	second keymap to compare
pos	position where the two keycodes differ

Return values

ptr	Keymap with a bigger ASCII keycode

Definition at line 275 of file lib.c.

{
  *pos = 0;
 
  while (*pos < k1->len && *pos < k2->len)
  {
    if (k1->keys[*pos] < k2->keys[*pos])
      return k2;
    else if (k1->keys[*pos] > k2->keys[*pos])
      return k1;
    else
      *pos = *pos + 1;
  }
 
  return NULL;
}

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

funcs	Functions table
op	Operation, e.g. OP_DELETE

Return values

ptr	Name of function
NULL	Operation not found

Note

This returns a static string.

Definition at line 321 of file lib.c.

{
  if (!funcs)
    return NULL;
 
  for (int i = 0; funcs[i].name; i++)
  {
    if (funcs[i].op == op)
      return funcs[i].name;
  }
 
  return NULL;
}

Here is the caller graph for this function:

mutt_keymap_free()

void mutt_keymap_free

(

struct Keymap **

ptr

)

Free a Keymap.

Parameters

ptr	Keymap to free

Definition at line 131 of file lib.c.

{
  if (!ptr || !*ptr)
    return;
 
  struct Keymap *km = *ptr;
  FREE(&km->macro);
  FREE(&km->desc);
  FREE(&km->keys);
 
  FREE(ptr);
}

Here is the caller graph for this function:

parse_fkey()

int parse_fkey

(

char *

s

)

Parse a function key string.

Parameters

s	String to parse

Return values

num	Number of the key

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

Definition at line 166 of file lib.c.

{
  char *t = NULL;
  int n = 0;
 
  if ((s[0] != '<') || (mutt_tolower(s[1]) != 'f'))
    return -1;
 
  for (t = s + 2; *t && mutt_isdigit(*t); t++)
  {
    n *= 10;
    n += *t - '0';
  }
 
  if (*t != '>')
    return -1;
  return n;
}

Here is the call graph for this function:

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

str	Key string
d	Array for key codes
max	Maximum length of key sequence

Return values

num	Length of key sequence

Definition at line 216 of file lib.c.

{
  int n;
  size_t len = max;
  char buf[128] = { 0 };
  char c;
  char *t = NULL;
 
  mutt_str_copy(buf, str, sizeof(buf));
  char *s = buf;
 
  while (*s && len)
  {
    *d = '\0';
    if ((*s == '<') && (t = strchr(s, '>')))
    {
      t++;
      c = *t;
      *t = '\0';
 
      n = mutt_map_get_value(s, KeyNames);
      if (n != -1)
      {
        s = t;
        *d = n;
      }
      else if ((n = parse_fkey(s)) > 0)
      {
        s = t;
        *d = KEY_F(n);
      }
      else if ((n = parse_keycode(s)) > 0)
      {
        s = t;
        *d = n;
      }
 
      *t = c;
    }
 
    if (!*d)
    {
      *d = (unsigned char) *s;
      s++;
    }
    d++;
    len--;
  }
 
  return max - len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_expand_key_string()

void km_expand_key_string	(	char *	str,
		struct Buffer *	buf )

Get a human-readable key string.

Parameters

[in]	str	Raw key string
[out]	buf	Buffer for the key string

Definition at line 455 of file lib.c.

{
  for (; *str; str++)
  {
    km_keyname(*str, buf);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_getch()

struct KeyEvent mutt_getch

(

GetChFlags

flags

)

Read a character from the input buffer.

Parameters

flags

Flags, e.g. GETCH_IGNORE_MACRO

Return values

obj	KeyEvent to process

The priority for reading events is:

1. UngetKeyEvents buffer
2. MacroEvents buffer
3. Keyboard

This function can return:

• Abort { 0, OP_ABORT }
• Repaint { 0, OP_REPAINT }
• Timeout { 0, OP_TIMEOUT }

Definition at line 210 of file get.c.

{
  static const struct KeyEvent event_abort = { 0, OP_ABORT };
  static const struct KeyEvent event_repaint = { 0, OP_REPAINT };
  static const struct KeyEvent event_timeout = { 0, OP_TIMEOUT };
 
  if (!OptGui)
    return event_abort;
 
  struct KeyEvent *event_key = array_pop(&UngetKeyEvents);
  if (event_key)
    return *event_key;
 
  if (!(flags & GETCH_IGNORE_MACRO))
  {
    event_key = array_pop(&MacroEvents);
    if (event_key)
      return *event_key;
  }
 
  int ch;
  SigInt = false;
  mutt_sig_allow_interrupt(true);
  timeout(1000); // 1 second
#ifdef USE_INOTIFY
  ch = mutt_monitor_getch();
#else
  ch = getch();
#endif
  mutt_sig_allow_interrupt(false);
 
  if (SigInt)
  {
    mutt_query_exit();
    return event_abort;
  }
 
  if (ch == KEY_RESIZE)
  {
    timeout(0);
    while ((ch = getch()) == KEY_RESIZE)
    {
      // do nothing
    }
  }
 
  if (ch == ERR)
  {
    if (!isatty(STDIN_FILENO)) // terminal was lost
      mutt_exit(1);
 
    if (SigWinch)
    {
      SigWinch = false;
      notify_send(NeoMutt->notify_resize, NT_RESIZE, 0, NULL);
      return event_repaint;
    }
 
    notify_send(NeoMutt->notify_timeout, NT_TIMEOUT, 0, NULL);
    return event_timeout;
  }
 
  if (ch == AbortKey)
    return event_abort;
 
  if (ch & 0x80)
  {
    const bool c_meta_key = cs_subset_bool(NeoMutt->sub, "meta_key");
    if (c_meta_key)
    {
      /* send ALT-x as ESC-x */
      ch &= ~0x80;
      mutt_unget_ch(ch);
      return (struct KeyEvent) { '\033', OP_NULL }; // Escape
    }
  }
 
  return (struct KeyEvent) { ch, OP_NULL };
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_flushinp()

void mutt_flushinp

(

void

)

Empty all the keyboard buffers.

Definition at line 58 of file get.c.

{
  ARRAY_SHRINK(&UngetKeyEvents, ARRAY_SIZE(&UngetKeyEvents));
  ARRAY_SHRINK(&MacroEvents, ARRAY_SIZE(&MacroEvents));
  flushinp();
}

Here is the caller graph for this function:

mutt_push_macro_event()

void mutt_push_macro_event	(	int	ch,
		int	op )

Add the character/operation to the macro buffer.

Parameters

ch	Character to add
op	Operation to add

Adds the ch/op to the macro buffer. This should be used for macros, push, and exec commands only.

Definition at line 155 of file get.c.

{
  array_add(&MacroEvents, ch, op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_unget_ch()

void mutt_unget_ch

(

int

ch

)

Return a keystroke to the input buffer.

Parameters

ch

Key press

This puts events into the UngetKeyEvents buffer

Definition at line 115 of file get.c.

{
  array_add(&UngetKeyEvents, ch, OP_NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_unget_op()

void mutt_unget_op

(

int

op

)

Return an operation to the input buffer.

Parameters

op	Operation, e.g. OP_DELETE

This puts events into the UngetKeyEvents buffer

Definition at line 126 of file get.c.

{
  array_add(&UngetKeyEvents, 0, op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_unget_string()

void mutt_unget_string

(

const char *

s

)

Return a string to the input buffer.

Parameters

s	String to return

This puts events into the UngetKeyEvents buffer

Definition at line 137 of file get.c.

{
  const char *p = s + mutt_str_len(s) - 1;
 
  while (p >= s)
  {
    mutt_unget_ch((unsigned char) *p--);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

measure_column()

int measure_column	(	struct BindingInfoArray *	bia,
		int	col )

Measure one column of a table.

Parameters

bia	Array of binding info
col	Column to measure

Return values

num	Width of widest column

Definition at line 414 of file dump.c.

{
  int max_width = 0;
 
  struct BindingInfo *bi = NULL;
  ARRAY_FOREACH(bi, bia)
  {
    const int col_width = mutt_strwidth(bi->a[col]);
    max_width = MAX(max_width, col_width);
  }
 
  return max_width;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gather_menu()

void gather_menu	(	enum MenuType	menu,
		struct BindingInfoArray *	bia_bind,
		struct BindingInfoArray *	bia_macro )

Gather info about one menu.

Parameters

menu	Menu type
bia_bind	Array for bind results (may be NULL)
bia_macro	Array for macro results (may be NULL)

Definition at line 358 of file dump.c.

{
  struct Buffer *key_binding = buf_pool_get();
  struct Buffer *macro = buf_pool_get();
 
  struct Keymap *map = NULL;
  STAILQ_FOREACH(map, &Keymaps[menu], entries)
  {
    struct BindingInfo bi = { 0 };
 
    buf_reset(key_binding);
    km_expand_key(map, key_binding);
 
    if (map->op == OP_MACRO)
    {
      if (!bia_macro || (map->op == OP_NULL))
        continue;
 
      buf_reset(macro);
      escape_macro(map->macro, macro);
      bi.a[0] = buf_strdup(key_binding);
      bi.a[1] = buf_strdup(macro);
      bi.a[2] = map->desc;
      ARRAY_ADD(bia_macro, bi);
    }
    else
    {
      if (!bia_bind)
        continue;
 
      if (map->op == OP_NULL)
      {
        bi.a[0] = buf_strdup(key_binding);
        bi.a[1] = "noop";
        ARRAY_ADD(bia_bind, bi);
        continue;
      }
 
      bi.a[0] = buf_strdup(key_binding);
      bi.a[1] = help_lookup_function(map->op, menu);
      bi.a[2] = _(opcodes_get_description(map->op));
      ARRAY_ADD(bia_bind, bi);
    }
  }
 
  buf_pool_release(&key_binding);
  buf_pool_release(&macro);
}

Here is the call graph for this function:

Here is the caller graph for this function:

gather_unbound()

int gather_unbound	(	const struct MenuFuncOp *	funcs,
		const struct KeymapList *	km_menu,
		const struct KeymapList *	km_aux,
		struct BindingInfoArray *	bia_unbound )

Gather info about unbound functions for one menu.

Parameters

funcs	List of functions
km_menu	Keymaps for the menu
km_aux	Keymaps for generic
bia_unbound	Unbound functions

Return values

num	Number of unbound functions

Definition at line 363 of file lib.c.

{
  if (!funcs)
    return 0;
 
  for (int i = 0; funcs[i].name; i++)
  {
    if (funcs[i].flags & MFF_DEPRECATED)
      continue;
 
    if (!is_bound(km_menu, funcs[i].op) &&
        (!km_aux || !is_bound(km_aux, funcs[i].op)))
    {
      struct BindingInfo bi = { 0 };
      bi.a[0] = NULL;
      bi.a[1] = funcs[i].name;
      bi.a[2] = _(opcodes_get_description(funcs[i].op));
      ARRAY_ADD(bia_unbound, bi);
    }
  }
 
  return ARRAY_SIZE(bia_unbound);
}

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

                            {
  // clang-format off
  { "<PageUp>",      KEY_PPAGE },
  { "<PageDown>",    KEY_NPAGE },
  { "<Up>",          KEY_UP },
  { "<Down>",        KEY_DOWN },
  { "<Right>",       KEY_RIGHT },
  { "<Left>",        KEY_LEFT },
  { "<Delete>",      KEY_DC },
  { "<BackSpace>",   KEY_BACKSPACE },
  { "<Insert>",      KEY_IC },
  { "<Home>",        KEY_HOME },
  { "<End>",         KEY_END },
  { "<Enter>",       '\n' },
  { "<Return>",      '\r' },
#ifdef KEY_ENTER
  { "<KeypadEnter>", KEY_ENTER },
#else
  { "<KeypadEnter>", '\n' },
#endif
  { "<Esc>",         '\033' }, // Escape
  { "<Tab>",         '\t' },
  { "<Space>",       ' ' },
#ifdef KEY_BTAB
  { "<BackTab>",     KEY_BTAB },
#endif
#ifdef KEY_NEXT
  { "<Next>",        KEY_NEXT },
#endif
  /* extensions supported by ncurses.  values are filled in during initialization */
 
  /* CTRL+key */
  { "<C-Up>",    -1 },
  { "<C-Down>",  -1 },
  { "<C-Left>",  -1 },
  { "<C-Right>", -1 },
  { "<C-Home>",  -1 },
  { "<C-End>",   -1 },
  { "<C-Next>",  -1 },
  { "<C-Prev>",  -1 },
 
  /* SHIFT+key */
  { "<S-Up>",    -1 },
  { "<S-Down>",  -1 },
  { "<S-Left>",  -1 },
  { "<S-Right>", -1 },
  { "<S-Home>",  -1 },
  { "<S-End>",   -1 },
  { "<S-Next>",  -1 },
  { "<S-Prev>",  -1 },
 
  /* ALT+key */
  { "<A-Up>",    -1 },
  { "<A-Down>",  -1 },
  { "<A-Left>",  -1 },
  { "<A-Right>", -1 },
  { "<A-Home>",  -1 },
  { "<A-End>",   -1 },
  { "<A-Next>",  -1 },
  { "<A-Prev>",  -1 },
  { NULL, 0 },
  // clang-format off
};

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