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 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_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 Keymap *	alloc_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 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.
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

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 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

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 132 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()

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

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

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 160 of file parse.c.

{
  return km_bind_err(s, mtype, op, macro, desc, 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 464 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 346 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;
  }
 
  char buf[128] = { 0 };
  km_expand_key(buf, sizeof(buf), key);
  mutt_error(_("Key is not bound.  Press '%s' for help."), buf);
}

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

s	Buffer for the key string
len	Length of buffer
map	Keybinding map

Return values

1	Success
0	Error

Definition at line 457 of file lib.c.

{
  if (!map)
    return 0;
 
  int p = 0;
 
  while (true)
  {
    mutt_str_copy(s, km_keyname(map->keys[p]), len);
    const size_t l = mutt_str_len(s);
    len -= l;
 
    if ((++p >= map->len) || !len)
      return 1;
 
    s += l;
  }
 
  /* not reached */
}

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

str	Raw key string
buf	Buffer for the key string
buflen	Length of buffer

Return values

num	Length of string

Definition at line 486 of file lib.c.

{
  size_t len = 0;
  for (; *str; str++)
  {
    const char *key = km_keyname(*str);
    size_t keylen = mutt_str_len(key);
 
    mutt_str_copy(buf, key, buflen);
    buf += keylen;
    buflen -= keylen;
    len += keylen;
  }
 
  return len;
}

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 509 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 525 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_COMPOSE:
      return OpCompose;
    case MENU_DIALOG:
      return OpDialog;
    case MENU_EDITOR:
      return OpEditor;
    case MENU_FOLDER:
      return OpBrowser;
    case MENU_GENERIC:
      return OpGeneric;
    case MENU_INDEX:
      return OpIndex;
#ifdef CRYPT_BACKEND_GPGME
    case MENU_KEY_SELECT_PGP:
      return OpPgp;
    case MENU_KEY_SELECT_SMIME:
      return OpSmime;
#endif
    case MENU_PAGER:
      return OpPager;
    case MENU_PGP:
      return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
    case MENU_POSTPONED:
      return OpPostponed;
    case MENU_QUERY:
      return OpQuery;
    default:
      return NULL;
  }
}

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.

{
  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_FOLDER);
  create_bindings(DialogDefaultBindings, MENU_DIALOG);
  create_bindings(ComposeDefaultBindings, MENU_COMPOSE);
  create_bindings(EditorDefaultBindings, MENU_EDITOR);
  create_bindings(GenericDefaultBindings, MENU_GENERIC);
  create_bindings(IndexDefaultBindings, MENU_INDEX);
  create_bindings(PagerDefaultBindings, MENU_PAGER);
  create_bindings(PostponedDefaultBindings, MENU_POSTPONED);
  create_bindings(QueryDefaultBindings, MENU_QUERY);
 
  if (WithCrypto & APPLICATION_PGP)
    create_bindings(PgpDefaultBindings, MENU_PGP);
  if (WithCrypto & APPLICATION_SMIME)
    create_bindings(SmimeDefaultBindings, MENU_SMIME);
 
#ifdef CRYPT_BACKEND_GPGME
  create_bindings(PgpDefaultBindings, MENU_KEY_SELECT_PGP);
  create_bindings(SmimeDefaultBindings, MENU_KEY_SELECT_SMIME);
#endif
}

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

c

Key code

Return values

ptr	Name of the key

Note

This returns a pointer to a static buffer.

Definition at line 410 of file lib.c.

{
  static char buf[35];
 
  const char *p = mutt_map_get_name(c, KeyNames);
  if (p)
    return p;
 
  if ((c < 256) && (c > -128) && iscntrl((unsigned char) c))
  {
    if (c < 0)
      c += 256;
 
    if (c < 128)
    {
      buf[0] = '^';
      buf[1] = (c + '@') & 0x7f;
      buf[2] = '\0';
    }
    else
    {
      snprintf(buf, sizeof(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 */
  {
    snprintf(buf, sizeof(buf), "<F%d>", c - KEY_F0);
  }
  else if ((c < 256) && (c >= -128) && IsPrint(c))
  {
    snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
  }
  else
  {
    snprintf(buf, sizeof(buf), "<%ho>", (unsigned short) c);
  }
  return buf;
}

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.

{
#ifdef HAVE_USE_EXTENDED_NAMES
  use_extended_names(true);
 
  for (int j = 0; KeyNames[j].name; j++)
  {
    if (KeyNames[j].value == -1)
    {
      const char *keyname = find_ext_name(KeyNames[j].name);
 
      if (keyname)
      {
        const char *s = mutt_tigetstr((char *) keyname);
        if (s && ((long) (s) != -1))
        {
          int code = key_defined(s);
          if (code > 0)
            KeyNames[j].value = code;
        }
      }
    }
  }
#endif
}

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:

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.

{
  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, mutt_array_size(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];
}

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.

{
  for (enum MenuType i = 1; i < MENU_MAX; i++)
  {
    mutt_keymaplist_free(&Keymaps[i]);
  }
}

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 338 of file lib.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_bindkey()

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

Bind a key in a Menu to an operation.

Parameters

s	Key string
mtype	Menu type, e.g. MENU_PAGER
op	Operation, e.g. OP_DELETE

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Definition at line 186 of file parse.c.

{
  return km_bindkey_err(s, mtype, 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.

{
  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:

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:

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