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.

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)
	ARRAY_HEAD (BindingInfoArray, struct BindingInfo)
void	km_init (void)
	Initialise all the menu keybindings.
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_init_abort_key (void)
	Parse the abort_key config string.
void	mutt_keys_cleanup (void)
	Free the key maps.
enum CommandResult	km_bind (char *s, enum MenuType menu, int op, char *macro, char *desc)
	Bind a key to a macro.
enum CommandResult	parse_bind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'bind' command - Implements Command::parse() -.
enum CommandResult	parse_exec (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'exec' command - Implements Command::parse() -.
enum CommandResult	parse_macro (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	parse_push (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	parse_unbind (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'unbind' command - Implements Command::parse() -.
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.
void	km_expand_key_string (char *str, struct Buffer *buf)
	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_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	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.
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.
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 48 of file lib.h.

MUTT_UNMACRO

#define MUTT_UNMACRO   (1 << 1)

Parse 'unmacro' command.

Definition at line 49 of file lib.h.

GETCH_NO_FLAGS

#define GETCH_NO_FLAGS   0

No flags are set.

Definition at line 52 of file lib.h.

GETCH_IGNORE_MACRO

#define GETCH_IGNORE_MACRO   (1 << 0)

Don't use MacroEvents.

Definition at line 53 of file lib.h.

Typedef Documentation

GetChFlags

typedef uint8_t GetChFlags

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

Definition at line 51 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 56 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 143 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
	)

km_init()

void km_init

(

void

)

Initialise all the menu keybindings.

Definition at line 176 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(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);
}

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 133 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_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 228 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 215 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:

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 165 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 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 509 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_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 527 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:

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 541 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 557 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;
    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 465 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 149 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 298 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 191 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 274 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 320 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 130 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 165 of file lib.c.

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

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

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 419 of file lib.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 624 of file lib.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 441 of file lib.c.

{
  for (int i = 0; funcs[i].name; i++)
  {
    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 124 of file lib.c.

KeyNames

struct Mapping KeyNames[]

extern

Key name lookup table.

Definition at line 59 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 121 of file lib.c.

Menus

const struct Mapping Menus[]

extern