keymap.c File Reference

Manage keymappings. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include "mutt/mutt.h"
#include "mutt.h"
#include "keymap.h"
#include "curs_lib.h"
#include "functions.h"
#include "globals.h"
#include "mutt_curses.h"
#include "mutt_logging.h"
#include "mutt_window.h"
#include "ncrypt/ncrypt.h"
#include "opcodes.h"
#include "options.h"
#include "imap/imap.h"

Include dependency graph for keymap.c:

Go to the source code of this file.

Functions
static struct Keymap *	alloc_keys (size_t len, keycode_t *keys)
	Allocate space for a sequence of keys. More...
static int	parse_fkey (char *s)
	Parse a function key string. More...
static int	parse_keycode (const char *s)
	Parse a numeric keycode. More...
static size_t	parsekeys (const char *str, keycode_t *d, size_t max)
	Parse a key string into key codes. More...
static int	km_bind_err (const char *s, int menu, int op, char *macro, char *desc, struct Buffer *err)
	Set up a key binding. More...
int	km_bind (char *s, int menu, int op, char *macro, char *desc)
	Bind a key to a macro. More...
static int	km_bindkey_err (const char *s, int menu, int op, struct Buffer *err)
	Bind a key in a Menu to an operation (with error message) More...
static int	km_bindkey (const char *s, int menu, int op)
	Bind a key in a Menu to an operation. More...
static int	get_op (const struct Binding *bindings, const char *start, size_t len)
	Get the function by its name. More...
static const char *	get_func (const struct Binding *bindings, int op)
	Get the name of a function. More...
static void	generic_tokenize_push_string (char *s, void(*generic_push)(int, int))
	Parse and queue a 'push' command. More...
static int	retry_generic (int menu, keycode_t *keys, int keyslen, int lastkey)
	Try to find the key in the generic menu bindings. More...
int	km_dokey (int menu)
	Determine what a keypress should do. More...
static void	create_bindings (const struct Binding *map, int menu)
	Attach a set of keybindings to a Menu. More...
static const char *	km_keyname (int c)
	Get the human name for a key. More...
int	km_expand_key (char *s, size_t len, struct Keymap *map)
	Get the key string bound to a Keymap. More...
struct Keymap *	km_find_func (int menu, int func)
	Find a function's mapping in a Menu. More...
void	init_extended_keys (void)
	Initialise map of ncurses extended keys. More...
void	km_init (void)
	Initialise all the menu keybindings. More...
void	km_error_key (int menu)
	Handle an unbound key sequence. More...
int	mutt_parse_push (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'push' command - Implements command_t. More...
static char *	parse_keymap (int *menu, struct Buffer *s, int maxmenus, int *nummenus, struct Buffer *err, bool bind)
	Parse a user-config key binding. More...
static int	try_bind (char *key, int menu, char *func, const struct Binding *bindings, struct Buffer *err)
	Try to make a key binding. More...
const struct Binding *	km_get_table (int menu)
	Lookup a menu's keybindings. More...
int	mutt_parse_bind (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'bind' command - Implements command_t. More...
int	mutt_parse_macro (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'macro' command - Implements command_t. More...
int	mutt_parse_exec (struct Buffer *buf, struct Buffer *s, unsigned long data, struct Buffer *err)
	Parse the 'exec' command - Implements command_t. More...
void	mutt_what_key (void)
	Ask the user to press a key. More...
void	mutt_free_keys (void)
	Free the key maps. More...

Variables
const struct Mapping	Menus []
	Menu name lookup table. More...
static struct Mapping	KeyNames []
	Key name lookup table. More...
int	LastKey
	contains the last key the user pressed More...
struct Keymap *	Keymaps [MENU_MAX]
	Array of Keymap keybindings, one for each Menu. More...

Detailed Description

Manage keymappings.

Authors

• Michael R. Elkins

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 keymap.c.

Function Documentation

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

static

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 154 of file keymap.c.

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

Here is the call graph for this function:

Here is the caller graph for this function:

static int parse_fkey ( char *  s )

static

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 170 of file keymap.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;
  else
    return n;
}

Here is the caller graph for this function:

static int parse_keycode ( const char *  s )

static

Parse a numeric keycode.

Parameters

s	String to parse

Return values

num	Number of the key

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

Definition at line 198 of file keymap.c.

{
  char *end_char = NULL;
  long int result = strtol(s + 1, &end_char, 8);
  /* allow trailing whitespace, eg.  < 1001 > */
  while (ISSPACE(*end_char))
    end_char++;
  /* negative keycodes don't make sense, also detect overflow */
  if (*end_char != '>' || result < 0 || result == LONG_MAX)
  {
    return -1;
  }

  return result;
}

Here is the caller graph for this function:

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

static

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 221 of file keymap.c.

{
  int n;
  size_t len = max;
  char buf[SHORT_STRING];
  char c;
  char *t = NULL;

  mutt_str_strfcpy(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:

static int km_bind_err ( const char *  s, int  menu, int  op, char *  macro, char *  desc, struct Buffer *  err  )

static

Set up a key binding.

Parameters

s	Key string
menu	Menu id, 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

0	Success
-2	Error

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

Definition at line 287 of file keymap.c.

{
  int retval = 0;
  struct Keymap *last = NULL, *next = 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_strdup(macro);
  map->desc = mutt_str_strdup(desc);

  struct Keymap *tmp = Keymaps[menu];

  while (tmp)
  {
    if (pos >= len || pos >= tmp->len)
    {
      /* map and tmp match so overwrite */
      do
      {
        /* Don't warn on overwriting a 'noop' binding */
        if (tmp->len != len && tmp->op != OP_NULL)
        {
          /* Overwrite with the different lengths, warn */
          /* TODO: MAX_SEQ here is wrong */
          char old_binding[MAX_SEQ];
          char new_binding[MAX_SEQ];
          km_expand_key(old_binding, MAX_SEQ, map);
          km_expand_key(new_binding, MAX_SEQ, tmp);
          if (err)
          {
            /* err was passed, put the string there */
            snprintf(
                err->data, err->dsize,
                _("Binding '%s' will alias '%s'  Before, try: 'bind %s %s "
                  "noop'  "
                  "https://neomutt.org/guide/configuration.html#bind-warnings"),
                old_binding, new_binding, mutt_map_get_name(menu, Menus), new_binding);
          }
          else
          {
            mutt_error(
                _("Binding '%s' will alias '%s'  Before, try: 'bind %s %s "
                  "noop'  "
                  "https://neomutt.org/guide/configuration.html#bind-warnings"),
                old_binding, new_binding, mutt_map_get_name(menu, Menus), new_binding);
          }
          retval = -2;
        }
        len = tmp->eq;
        next = tmp->next;
        FREE(&tmp->macro);
        FREE(&tmp->keys);
        FREE(&tmp->desc);
        FREE(&tmp);
        tmp = next;
      } while (tmp && len >= pos);
      map->eq = len;
      break;
    }
    else if (buf[pos] == tmp->keys[pos])
      pos++;
    else if (buf[pos] < tmp->keys[pos])
    {
      /* found location to insert between last and tmp */
      map->eq = pos;
      break;
    }
    else /* buf[pos] > tmp->keys[pos] */
    {
      last = tmp;
      lastpos = pos;
      if (pos > tmp->eq)
        pos = tmp->eq;
      tmp = tmp->next;
    }
  }

  map->next = tmp;
  if (last)
  {
    last->next = map;
    last->eq = lastpos;
  }
  else
  {
    Keymaps[menu] = map;
  }

  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int km_bind	(	char *	s,
		int	menu,
		int	op,
		char *	macro,
		char *	desc
	)

Bind a key to a macro.

Parameters

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

Return values

0	Success
-2	Error

Definition at line 393 of file keymap.c.

{
  return km_bind_err(s, menu, op, macro, desc, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int km_bindkey_err ( const char *  s, int  menu, int  op, struct Buffer *  err  )

static

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

Parameters

s	Key string
menu	Menu id, e.g. MENU_PAGER
op	Operation, e.g. OP_DELETE
err	Buffer for error message

Return values

0	Success
-2	Error

Definition at line 407 of file keymap.c.

{
  return km_bind_err(s, menu, op, NULL, NULL, err);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int km_bindkey ( const char *  s, int  menu, int  op  )

static

Bind a key in a Menu to an operation.

Parameters

s	Key string
menu	Menu id, e.g. MENU_PAGER
op	Operation, e.g. OP_DELETE

Return values

0	Success
-2	Error

Definition at line 420 of file keymap.c.

{
  return km_bindkey_err(s, menu, op, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Get the function by its name.

Parameters

bindings	Key bindings table
start	Name of function to find
len	Length of string to match

Return values

num	Operation, e.g. OP_DELETE

Definition at line 432 of file keymap.c.

{
  for (int i = 0; bindings[i].name; i++)
  {
    if ((mutt_str_strncasecmp(start, bindings[i].name, len) == 0) &&
        mutt_str_strlen(bindings[i].name) == len)
    {
      return bindings[i].op;
    }
  }

  return OP_NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* get_func ( const struct Binding *  bindings, int  op  )

static

Get the name of a function.

Parameters

bindings	Key bindings 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 455 of file keymap.c.

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

  return NULL;
}

Here is the caller graph for this function:

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

static

Parse and queue a 'push' command.

Parameters

s	String to push into the key queue
generic_push	Callback function to add events to macro queue

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

Definition at line 475 of file keymap.c.

{
  char *pp = NULL, *p = s + mutt_str_strlen(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--)
        ;
      if (pp >= s)
      {
        i = parse_fkey(pp);
        if (i > 0)
        {
          generic_push(KEY_F(i), 0);
          p = pp - 1;
          continue;
        }

        l = p - pp + 1;
        for (i = 0; KeyNames[i].name; i++)
        {
          if (mutt_str_strncasecmp(pp, KeyNames[i].name, l) == 0)
            break;
        }
        if (KeyNames[i].name)
        {
          /* found a match */
          generic_push(KeyNames[i].value, 0);
          p = pp - 1;
          continue;
        }

        /* See if it is a valid command
         * skip the '<' and the '>' when comparing */
        for (i = 0; Menus[i].name; i++)
        {
          const struct Binding *binding = km_get_table(Menus[i].value);
          if (binding)
          {
            op = get_op(binding, pp + 1, l - 2);
            if (op != OP_NULL)
              break;
          }
        }

        if (op != OP_NULL)
        {
          generic_push(0, op);
          p = pp - 1;
          continue;
        }
      }
    }
    generic_push((unsigned char) *p--, 0); /* independent 8 bits chars */
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int retry_generic ( int  menu, keycode_t *  keys, int  keyslen, int  lastkey  )

static

Try to find the key in the generic menu bindings.

Parameters

menu	Menu id, e.g. MENU_PAGER
keys	Array of keys to return to the input queue
keyslen	Number of keys in the array
lastkey	Last key pressed (to return to input queue)

Return values

num	Operation, e.g. OP_DELETE

Definition at line 546 of file keymap.c.

{
  if (menu != MENU_EDITOR && menu != MENU_GENERIC && menu != MENU_PAGER)
  {
    if (lastkey)
      mutt_unget_event(lastkey, 0);
    for (; keyslen; keyslen--)
      mutt_unget_event(keys[keyslen - 1], 0);
    return km_dokey(MENU_GENERIC);
  }
  if (menu != MENU_EDITOR)
  {
    /* probably a good idea to flush input here so we can abort macros */
    mutt_flushinp();
  }
  return OP_NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int km_dokey

(

int

menu

)

Determine what a keypress should do.

Parameters

menu	Menu ID, e.g. MENU_EDITOR

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 572 of file keymap.c.

{
  struct Event tmp;
  struct Keymap *map = Keymaps[menu];
  int pos = 0;
  int n = 0;

  if (!map)
    return retry_generic(menu, NULL, 0, 0);

  while (true)
  {
    int i = Timeout > 0 ? Timeout : 60;
#ifdef USE_IMAP
    /* keepalive may need to run more frequently than Timeout allows */
    if (ImapKeepalive)
    {
      if (ImapKeepalive >= i)
        imap_keepalive();
      else
      {
        while (ImapKeepalive && ImapKeepalive < i)
        {
          mutt_getch_timeout(ImapKeepalive * 1000);
          tmp = mutt_getch();
          mutt_getch_timeout(-1);
          /* If a timeout was not received, or the window was resized, exit the
           * loop now.  Otherwise, continue to loop until reaching a total of
           * $timeout seconds.
           */
#ifdef USE_INOTIFY
          if (tmp.ch != -2 || SigWinch || MonitorFilesChanged)
#else
          if (tmp.ch != -2 || SigWinch)
#endif
            goto gotkey;
          i -= ImapKeepalive;
          imap_keepalive();
        }
      }
    }
#endif

    mutt_getch_timeout(i * 1000);
    tmp = mutt_getch();
    mutt_getch_timeout(-1);

#ifdef USE_IMAP
  gotkey:
#endif
    /* hide timeouts, but not window resizes, from the line editor. */
    if (menu == MENU_EDITOR && tmp.ch == -2 && !SigWinch)
      continue;

    LastKey = tmp.ch;
    if (LastKey < 0)
      return LastKey;

    /* do we have an op already? */
    if (tmp.op)
    {
      const char *func = NULL;
      const struct Binding *bindings = NULL;

      /* is this a valid op for this menu? */
      if ((bindings = km_get_table(menu)) && (func = get_func(bindings, tmp.op)))
        return tmp.op;

      if (menu == MENU_EDITOR && get_func(OpEditor, tmp.op))
        return tmp.op;

      if (menu != MENU_EDITOR && menu != MENU_PAGER)
      {
        /* check generic menu */
        bindings = OpGeneric;
        func = get_func(bindings, tmp.op);
        if (func)
          return tmp.op;
      }

      /* Sigh. Valid function but not in this context.
       * Find the literal string and push it back */
      for (i = 0; Menus[i].name; i++)
      {
        bindings = km_get_table(Menus[i].value);
        if (bindings)
        {
          func = get_func(bindings, tmp.op);
          if (func)
          {
            mutt_unget_event('>', 0);
            mutt_unget_string(func);
            mutt_unget_event('<', 0);
            break;
          }
        }
      }
      /* continue to chew */
      if (func)
        continue;
    }

    /* Nope. Business as usual */
    while (LastKey > map->keys[pos])
    {
      if (pos > map->eq || !map->next)
        return retry_generic(menu, map->keys, pos, LastKey);
      map = map->next;
    }

    if (LastKey != map->keys[pos])
      return retry_generic(menu, map->keys, pos, LastKey);

    if (++pos == map->len)
    {
      if (map->op != OP_MACRO)
        return map->op;

      if (OptIgnoreMacroEvents)
      {
        mutt_error(_("Macros are currently disabled"));
        return -1;
      }

      if (n++ == 10)
      {
        mutt_flushinp();
        mutt_error(_("Macro loop detected"));
        return -1;
      }

      generic_tokenize_push_string(map->macro, mutt_push_macro_event);
      map = Keymaps[menu];
      pos = 0;
    }
  }

  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void create_bindings ( const struct Binding *  map, int  menu  )

static

Attach a set of keybindings to a Menu.

Parameters

map	Key bindings
menu	Menu id, e.g. MENU_PAGER

Definition at line 717 of file keymap.c.

{
  for (int i = 0; map[i].name; i++)
    if (map[i].seq)
      km_bindkey(map[i].seq, menu, map[i].op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* km_keyname ( int  c )

static

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 731 of file keymap.c.

{
  static char buf[10];

  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 */
    sprintf(buf, "<F%d>", c - KEY_F0);
  else if (IsPrint(c))
    snprintf(buf, sizeof(buf), "%c", (unsigned char) c);
  else
    snprintf(buf, sizeof(buf), "\\x%hx", (unsigned short) c);
  return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 770 of file keymap.c.

{
  int p = 0;

  if (!map)
    return 0;

  while (true)
  {
    mutt_str_strfcpy(s, km_keyname(map->keys[p]), len);
    const size_t l = mutt_str_strlen(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:

struct Keymap* km_find_func	(	int	menu,
		int	func
	)

Find a function's mapping in a Menu.

Parameters

menu	Menu id, e.g. MENU_PAGER
func	Function, e.g. OP_DELETE

Return values

ptr	Keymap for the function

Definition at line 798 of file keymap.c.

{
  struct Keymap *map = Keymaps[menu];

  for (; map; map = map->next)
    if (map->op == func)
      break;
  return map;
}

Here is the caller graph for this function:

void init_extended_keys

(

void

)

Initialise map of ncurses extended keys.

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

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

Definition at line 884 of file keymap.c.

{
#ifdef NCURSES_VERSION

  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)
      {
        char *s = tigetstr((char *) keyname);
        if (s && (long) (s) != -1)
        {
          int code = key_defined(s);
          if (code > 0)
            KeyNames[j].value = code;
        }
      }
    }
  }
#endif
}

Here is the caller graph for this function:

void km_init

(

void

)

Initialise all the menu keybindings.

Definition at line 914 of file keymap.c.

{
  memset(Keymaps, 0, sizeof(struct Keymap *) * MENU_MAX);

  create_bindings(OpAttach, MENU_ATTACH);
  create_bindings(OpBrowser, MENU_FOLDER);
  create_bindings(OpCompose, MENU_COMPOSE);
  create_bindings(OpMain, MENU_MAIN);
  create_bindings(OpPager, MENU_PAGER);
  create_bindings(OpPost, MENU_POST);
  create_bindings(OpQuery, MENU_QUERY);
  create_bindings(OpAlias, MENU_ALIAS);

  if (WithCrypto & APPLICATION_PGP)
    create_bindings(OpPgp, MENU_PGP);

  if (WithCrypto & APPLICATION_SMIME)
    create_bindings(OpSmime, MENU_SMIME);

#ifdef CRYPT_BACKEND_GPGME
  create_bindings(OpPgp, MENU_KEY_SELECT_PGP);
  create_bindings(OpSmime, MENU_KEY_SELECT_SMIME);
#endif

#ifdef MIXMASTER
  create_bindings(OpMix, MENU_MIX);

  km_bindkey("<space>", MENU_MIX, OP_GENERIC_SELECT_ENTRY);
  km_bindkey("h", MENU_MIX, OP_MIX_CHAIN_PREV);
  km_bindkey("l", MENU_MIX, OP_MIX_CHAIN_NEXT);
#endif

  /* bindings for the line editor */
  create_bindings(OpEditor, MENU_EDITOR);

  km_bindkey("<up>", MENU_EDITOR, OP_EDITOR_HISTORY_UP);
  km_bindkey("<down>", MENU_EDITOR, OP_EDITOR_HISTORY_DOWN);
  km_bindkey("<left>", MENU_EDITOR, OP_EDITOR_BACKWARD_CHAR);
  km_bindkey("<right>", MENU_EDITOR, OP_EDITOR_FORWARD_CHAR);
  km_bindkey("<home>", MENU_EDITOR, OP_EDITOR_BOL);
  km_bindkey("<end>", MENU_EDITOR, OP_EDITOR_EOL);
  km_bindkey("<backspace>", MENU_EDITOR, OP_EDITOR_BACKSPACE);
  km_bindkey("<delete>", MENU_EDITOR, OP_EDITOR_DELETE_CHAR);
  km_bindkey("\177", MENU_EDITOR, OP_EDITOR_BACKSPACE);

  /* generic menu keymap */
  create_bindings(OpGeneric, MENU_GENERIC);

  km_bindkey("<home>", MENU_GENERIC, OP_FIRST_ENTRY);
  km_bindkey("<end>", MENU_GENERIC, OP_LAST_ENTRY);
  km_bindkey("<pagedown>", MENU_GENERIC, OP_NEXT_PAGE);
  km_bindkey("<pageup>", MENU_GENERIC, OP_PREV_PAGE);
  km_bindkey("<right>", MENU_GENERIC, OP_NEXT_PAGE);
  km_bindkey("<left>", MENU_GENERIC, OP_PREV_PAGE);
  km_bindkey("<up>", MENU_GENERIC, OP_PREV_ENTRY);
  km_bindkey("<down>", MENU_GENERIC, OP_NEXT_ENTRY);
  km_bindkey("1", MENU_GENERIC, OP_JUMP);
  km_bindkey("2", MENU_GENERIC, OP_JUMP);
  km_bindkey("3", MENU_GENERIC, OP_JUMP);
  km_bindkey("4", MENU_GENERIC, OP_JUMP);
  km_bindkey("5", MENU_GENERIC, OP_JUMP);
  km_bindkey("6", MENU_GENERIC, OP_JUMP);
  km_bindkey("7", MENU_GENERIC, OP_JUMP);
  km_bindkey("8", MENU_GENERIC, OP_JUMP);
  km_bindkey("9", MENU_GENERIC, OP_JUMP);

  km_bindkey("<return>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);
  km_bindkey("<enter>", MENU_GENERIC, OP_GENERIC_SELECT_ENTRY);

  /* Miscellaneous extra bindings */

  km_bindkey(" ", MENU_MAIN, OP_DISPLAY_MESSAGE);
  km_bindkey("<up>", MENU_MAIN, OP_MAIN_PREV_UNDELETED);
  km_bindkey("<down>", MENU_MAIN, OP_MAIN_NEXT_UNDELETED);
  km_bindkey("J", MENU_MAIN, OP_NEXT_ENTRY);
  km_bindkey("K", MENU_MAIN, OP_PREV_ENTRY);
  km_bindkey("x", MENU_MAIN, OP_EXIT);

  km_bindkey("<return>", MENU_MAIN, OP_DISPLAY_MESSAGE);
  km_bindkey("<enter>", MENU_MAIN, OP_DISPLAY_MESSAGE);

  km_bindkey("x", MENU_PAGER, OP_EXIT);
  km_bindkey("i", MENU_PAGER, OP_EXIT);
  km_bindkey("<backspace>", MENU_PAGER, OP_PREV_LINE);
  km_bindkey("<pagedown>", MENU_PAGER, OP_NEXT_PAGE);
  km_bindkey("<pageup>", MENU_PAGER, OP_PREV_PAGE);
  km_bindkey("<up>", MENU_PAGER, OP_MAIN_PREV_UNDELETED);
  km_bindkey("<right>", MENU_PAGER, OP_MAIN_NEXT_UNDELETED);
  km_bindkey("<down>", MENU_PAGER, OP_MAIN_NEXT_UNDELETED);
  km_bindkey("<left>", MENU_PAGER, OP_MAIN_PREV_UNDELETED);
  km_bindkey("<home>", MENU_PAGER, OP_PAGER_TOP);
  km_bindkey("<end>", MENU_PAGER, OP_PAGER_BOTTOM);
  km_bindkey("1", MENU_PAGER, OP_JUMP);
  km_bindkey("2", MENU_PAGER, OP_JUMP);
  km_bindkey("3", MENU_PAGER, OP_JUMP);
  km_bindkey("4", MENU_PAGER, OP_JUMP);
  km_bindkey("5", MENU_PAGER, OP_JUMP);
  km_bindkey("6", MENU_PAGER, OP_JUMP);
  km_bindkey("7", MENU_PAGER, OP_JUMP);
  km_bindkey("8", MENU_PAGER, OP_JUMP);
  km_bindkey("9", MENU_PAGER, OP_JUMP);

  km_bindkey("<return>", MENU_PAGER, OP_NEXT_LINE);
  km_bindkey("<enter>", MENU_PAGER, OP_NEXT_LINE);

  km_bindkey("<return>", MENU_ALIAS, OP_GENERIC_SELECT_ENTRY);
  km_bindkey("<enter>", MENU_ALIAS, OP_GENERIC_SELECT_ENTRY);
  km_bindkey("<space>", MENU_ALIAS, OP_TAG);

  km_bindkey("<return>", MENU_ATTACH, OP_VIEW_ATTACH);
  km_bindkey("<enter>", MENU_ATTACH, OP_VIEW_ATTACH);
  km_bindkey("<return>", MENU_COMPOSE, OP_VIEW_ATTACH);
  km_bindkey("<enter>", MENU_COMPOSE, OP_VIEW_ATTACH);

  /* edit-to (default "t") hides generic tag-entry in Compose menu
     This will bind tag-entry to  "T" in the Compose menu */
  km_bindkey("T", MENU_COMPOSE, OP_TAG);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void km_error_key

(

int

menu

)

Handle an unbound key sequence.

Parameters

menu	Menu id, e.g. MENU_PAGER

Definition at line 1037 of file keymap.c.

{
  char buf[SHORT_STRING];
  int p, op;

  struct Keymap *key = km_find_func(menu, OP_HELP);
  if (!key && (menu != MENU_EDITOR) && (menu != MENU_PAGER))
    key = km_find_func(MENU_GENERIC, OP_HELP);
  if (!key)
  {
    mutt_error(_("Key is not bound"));
    return;
  }

  /* Make sure the key is really the help key in this menu.
   *
   * OP_END_COND is used as a barrier to ensure nothing extra
   * is left in the unget buffer.
   *
   * Note that km_expand_key() + tokenize_unget_string() should
   * not be used here: control sequences are expanded to a form
   * (e.g. "^H") not recognized by km_dokey(). */
  mutt_unget_event(0, OP_END_COND);
  p = key->len;
  while (p--)
    mutt_unget_event(key->keys[p], 0);

  /* Note, e.g. for the index menu:
   *   bind generic ?   noop
   *   bind generic ,a  help
   *   bind index   ,ab quit
   * The index keybinding shadows the generic binding.
   * OP_END_COND will be read and returned as the op.
   *
   *   bind generic ?   noop
   *   bind generic dq  help
   *   bind index   d   delete-message
   * OP_DELETE will be returned as the op, leaving "q" + OP_END_COND
   * in the unget buffer.
   */
  op = km_dokey(menu);
  if (op != OP_END_COND)
    mutt_flush_unget_to_endcond();
  if (op != OP_HELP)
  {
    mutt_error(_("Key is not bound"));
    return;
  }

  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:

int mutt_parse_push	(	struct Buffer *	buf,
		struct Buffer *	s,
		unsigned long	data,
		struct Buffer *	err
	)

Parse the 'push' command - Implements command_t.

Definition at line 1093 of file keymap.c.

{
  int r = 0;

  mutt_extract_token(buf, s, MUTT_TOKEN_CONDENSE);
  if (MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too many arguments"), "push");
    r = -1;
  }
  else
    generic_tokenize_push_string(buf->data, mutt_push_macro_event);
  return r;
}

Here is the call graph for this function:

static char* parse_keymap ( int *  menu, struct Buffer *  s, int  maxmenus, int *  nummenus, struct Buffer *  err, bool  bind  )

static

Parse a user-config key binding.

Parameters

menu	Array for results
s	Buffer containing config string
maxmenus	Total number of menus
nummenus	Number of menus this config applies to
err	Buffer for error messages
bind	If true 'bind', otherwise 'macro'

Return values

ptr	Key string for the binding

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

Note

Caller needs to free the returned string

Definition at line 1123 of file keymap.c.

{
  struct Buffer buf;
  int i = 0;
  char *q = NULL;

  mutt_buffer_init(&buf);

  /* menu name */
  mutt_extract_token(&buf, s, 0);
  char *p = buf.data;
  if (MoreArgs(s))
  {
    while (i < maxmenus)
    {
      q = strchr(p, ',');
      if (q)
        *q = '\0';

      menu[i] = mutt_map_get_value(p, Menus);
      if (menu[i] == -1)
      {
        mutt_buffer_printf(err, _("%s: no such menu"), p);
        goto error;
      }
      i++;
      if (q)
        p = q + 1;
      else
        break;
    }
    *nummenus = i;
    /* key sequence */
    mutt_extract_token(&buf, s, 0);

    if (!*buf.data)
    {
      mutt_buffer_printf(err, _("%s: null key sequence"), bind ? "bind" : "macro");
    }
    else if (MoreArgs(s))
      return buf.data;
  }
  else
  {
    mutt_buffer_printf(err, _("%s: too few arguments"), bind ? "bind" : "macro");
  }
error:
  FREE(&buf.data);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int try_bind ( char *  key, int  menu, char *  func, const struct Binding *  bindings, struct Buffer *  err  )

static

Try to make a key binding.

Parameters

key	Key name
menu	Menu id, e.g. MENU_PAGER
func	Function name
bindings	Key bindings table
err	Buffer for error message

Return values

0	Success
-1	Unknown function
-2	Error

Definition at line 1186 of file keymap.c.

{
  for (int i = 0; bindings[i].name; i++)
  {
    if (mutt_str_strcmp(func, bindings[i].name) == 0)
    {
      return km_bindkey_err(key, menu, bindings[i].op, err);
    }
  }
  if (err)
  {
    mutt_buffer_printf(err, _("Function '%s' not available for menu '%s'"),
                       func, mutt_map_get_name(menu, Menus));
  }
  return -1; /* Couldn't find an existing function with this name */
}

Here is the call graph for this function:

Here is the caller graph for this function:

const struct Binding* km_get_table

(

int

menu

)

Lookup a menu's keybindings.

Parameters

menu	Menu id, e.g. MENU_EDITOR

Return values

ptr	Array of keybindings

Definition at line 1209 of file keymap.c.

{
  switch (menu)
  {
    case MENU_ALIAS:
      return OpAlias;
    case MENU_ATTACH:
      return OpAttach;
    case MENU_COMPOSE:
      return OpCompose;
    case MENU_EDITOR:
      return OpEditor;
    case MENU_FOLDER:
      return OpBrowser;
    case MENU_GENERIC:
      return OpGeneric;
#ifdef CRYPT_BACKEND_GPGME
    case MENU_KEY_SELECT_PGP:
      return OpPgp;
    case MENU_KEY_SELECT_SMIME:
      return OpSmime;
#endif
    case MENU_MAIN:
      return OpMain;
#ifdef MIXMASTER
    case MENU_MIX:
      return OpMix;
#endif
    case MENU_PAGER:
      return OpPager;
    case MENU_PGP:
      return (WithCrypto & APPLICATION_PGP) ? OpPgp : NULL;
    case MENU_POST:
      return OpPost;
    case MENU_QUERY:
      return OpQuery;
  }
  return NULL;
}

Here is the caller graph for this function:

int mutt_parse_bind	(	struct Buffer *	buf,
		struct Buffer *	s,
		unsigned long	data,
		struct Buffer *	err
	)

Parse the 'bind' command - Implements command_t.

bind menu-name <key_sequence> function-name

Definition at line 1254 of file keymap.c.

{
  const struct Binding *bindings = NULL;
  int menu[sizeof(Menus) / sizeof(struct Mapping) - 1], r = 0, nummenus;

  char *key = parse_keymap(menu, s, mutt_array_size(menu), &nummenus, err, true);
  if (!key)
    return -1;

  /* function to execute */
  mutt_extract_token(buf, s, 0);
  if (MoreArgs(s))
  {
    mutt_buffer_printf(err, _("%s: too many arguments"), "bind");
    r = -1;
  }
  else if (mutt_str_strcasecmp("noop", buf->data) == 0)
  {
    for (int i = 0; i < nummenus; ++i)
    {
      km_bindkey(key, menu[i], OP_NULL); /* the `unbind' command */
    }
  }
  else
  {
    for (int i = 0; i < nummenus; ++i)
    {
      /* The pager and editor menus don't use the generic map,
       * however for other menus try generic first. */
      if ((menu[i] != MENU_PAGER) && (menu[i] != MENU_EDITOR) && (menu[i] != MENU_GENERIC))
      {
        r = try_bind(key, menu[i], buf->data, OpGeneric, err);
        if (r == 0)
          continue;
        if (r == -2)
          break;
      }

      /* Clear any error message, we're going to try again */
      err->data[0] = '\0';
      bindings = km_get_table(menu[i]);
      if (bindings)
      {
        r = try_bind(key, menu[i], buf->data, bindings, err);
      }
    }
  }
  FREE(&key);
  return r;
}

Here is the call graph for this function:

int mutt_parse_macro	(	struct Buffer *	buf,
		struct Buffer *	s,
		unsigned long	data,
		struct Buffer *	err
	)

Parse the 'macro' command - Implements command_t.

macro <menu> <key> <macro> <description>

Definition at line 1311 of file keymap.c.

{
  int menu[sizeof(Menus) / sizeof(struct Mapping) - 1], r = -1, nummenus;
  char *seq = NULL;

  char *key = parse_keymap(menu, s, mutt_array_size(menu), &nummenus, err, false);
  if (!key)
    return -1;

  mutt_extract_token(buf, s, MUTT_TOKEN_CONDENSE);
  /* make sure the macro sequence is not an empty string */
  if (!*buf->data)
  {
    mutt_buffer_strcpy(err, _("macro: empty key sequence"));
  }
  else
  {
    if (MoreArgs(s))
    {
      seq = mutt_str_strdup(buf->data);
      mutt_extract_token(buf, s, MUTT_TOKEN_CONDENSE);

      if (MoreArgs(s))
      {
        mutt_buffer_printf(err, _("%s: too many arguments"), "macro");
      }
      else
      {
        for (int i = 0; i < nummenus; ++i)
        {
          r = km_bind(key, menu[i], OP_MACRO, seq, buf->data);
        }
      }

      FREE(&seq);
    }
    else
    {
      for (int i = 0; i < nummenus; ++i)
      {
        r = km_bind(key, menu[i], OP_MACRO, buf->data, NULL);
      }
    }
  }
  FREE(&key);
  return r;
}

Here is the call graph for this function:

int mutt_parse_exec	(	struct Buffer *	buf,
		struct Buffer *	s,
		unsigned long	data,
		struct Buffer *	err
	)

Parse the 'exec' command - Implements command_t.

Definition at line 1363 of file keymap.c.

{
  int ops[128];
  int nops = 0;
  const struct Binding *bindings = NULL;
  char *function = NULL;

  if (!MoreArgs(s))
  {
    mutt_buffer_strcpy(err, _("exec: no arguments"));
    return -1;
  }

  do
  {
    mutt_extract_token(buf, s, 0);
    function = buf->data;

    bindings = km_get_table(CurrentMenu);
    if (!bindings && (CurrentMenu != MENU_PAGER))
      bindings = OpGeneric;

    ops[nops] = get_op(bindings, function, mutt_str_strlen(function));
    if (ops[nops] == OP_NULL && CurrentMenu != MENU_PAGER)
      ops[nops] = get_op(OpGeneric, function, mutt_str_strlen(function));

    if (ops[nops] == OP_NULL)
    {
      mutt_flushinp();
      mutt_error(_("%s: no such function"), function);
      return -1;
    }
    nops++;
  } while (MoreArgs(s) && nops < mutt_array_size(ops));

  while (nops)
    mutt_push_macro_event(0, ops[--nops]);

  return 0;
}

Here is the call graph for this function:

void mutt_what_key

(

void

)

Ask the user to press a key.

Displays the octal value back to the user.

Definition at line 1410 of file keymap.c.

{
  int ch;

  mutt_window_mvprintw(MuttMessageWindow, 0, 0, _("Enter keys (^G to abort): "));
  do
  {
    ch = getch();
    if (ch != ERR && ch != ctrl('G'))
    {
      mutt_message(_("Char = %s, Octal = %o, Decimal = %d"), km_keyname(ch), ch, ch);
    }
  } while (ch != ERR && ch != ctrl('G'));

  mutt_flushinp();
  mutt_clear_error();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mutt_free_keys

(

void

)

Free the key maps.

Definition at line 1431 of file keymap.c.

{
  struct Keymap *map = NULL;
  struct Keymap *next = NULL;

  for (int i = 0; i < MENU_MAX; i++)
  {
    for (map = Keymaps[i]; map; map = next)
    {
      next = map->next;

      FREE(&map->macro);
      FREE(&map->desc);
      FREE(&map->keys);
      FREE(&map);
    }

    Keymaps[i] = NULL;
  }
}

Here is the caller graph for this function:

Variable Documentation

const struct Mapping Menus[]

Initial value:

= {
  { "alias", MENU_ALIAS },
  { "attach", MENU_ATTACH },
  { "browser", MENU_FOLDER },
  { "compose", MENU_COMPOSE },
  { "editor", MENU_EDITOR },
  { "index", MENU_MAIN },
  { "pager", MENU_PAGER },
  { "postpone", MENU_POST },
  { "pgp", MENU_PGP },
  { "smime", MENU_SMIME },







  { "query", MENU_QUERY },
  { "generic", MENU_GENERIC },
  { NULL, 0 },
}

Menu name lookup table.

Definition at line 59 of file keymap.c.

struct Mapping KeyNames[]

static

Key name lookup table.

Definition at line 85 of file keymap.c.

int LastKey

contains the last key the user pressed

Last real key pressed, recorded by dokey()

Definition at line 144 of file keymap.c.

struct Keymap* Keymaps[MENU_MAX]

Array of Keymap keybindings, one for each Menu.

Definition at line 146 of file keymap.c.