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_commands.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 enum CommandResult	km_bind_err (const char s, int menu, int op, char macro, char desc, struct Buffer err)
	Set up a key binding. More...

enum CommandResult	km_bind (char s, int menu, int op, char macro, char *desc)
	Bind a key to a macro. More...

static enum CommandResult	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 enum CommandResult	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...

const char *	mutt_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...

enum CommandResult	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 enum CommandResult	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...

enum CommandResult	mutt_parse_bind (struct Buffer buf, struct Buffer s, unsigned long data, struct Buffer *err)
	Parse the 'bind' command - Implements command_t. More...

enum CommandResult	mutt_parse_macro (struct Buffer buf, struct Buffer s, unsigned long data, struct Buffer *err)
	Parse the 'macro' command - Implements command_t. More...

enum CommandResult	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 155 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 171 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 199 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 222 of file keymap.c.

 {
   int n;
   size_t len = max;
   char buf[128];
   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 enum CommandResult 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

enum	e.g. MUTT_CMD_SUCCESS

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

Definition at line 287 of file keymap.c.

 {
   enum CommandResult rc = MUTT_CMD_SUCCESS;
   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);
           }
           rc = MUTT_CMD_WARNING;
         }
         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 rc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

enum	e.g. MUTT_CMD_SUCCESS

Definition at line 392 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 enum CommandResult 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

enum	e.g. MUTT_CMD_SUCCESS

Definition at line 405 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 enum CommandResult 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

enum	e.g. MUTT_CMD_SUCCESS

Definition at line 417 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 429 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:

const char* mutt_get_func	(	const struct Binding *	bindings,
		int	op
	)

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 452 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 472 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 543 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 569 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 = C_Timeout > 0 ? C_Timeout : 60;
 #ifdef USE_IMAP
     /* keepalive may need to run more frequently than C_Timeout allows */
     if (C_ImapKeepalive)
     {
       if (C_ImapKeepalive >= i)
         imap_keepalive();
       else
       {
         while (C_ImapKeepalive && C_ImapKeepalive < i)
         {
           mutt_getch_timeout(C_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 -= C_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 = mutt_get_func(bindings, tmp.op)))
         return tmp.op;
 
       if ((menu == MENU_EDITOR) && mutt_get_func(OpEditor, tmp.op))
         return tmp.op;
 
       if ((menu != MENU_EDITOR) && (menu != MENU_PAGER))
       {
         /* check generic menu */
         bindings = OpGeneric;
         func = mutt_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 = mutt_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 713 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 727 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 766 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 794 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 880 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 910 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 1033 of file keymap.c.

 {
   char buf[128];
   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:

enum CommandResult 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 1089 of file keymap.c.

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

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 1117 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[0] == '\0')
     {
       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 enum CommandResult 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

enum	e.g. MUTT_CMD_SUCCESS

Definition at line 1178 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 MUTT_CMD_ERROR; /* 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 1201 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;
     case MENU_SUMMARY:
       return OpSummary;
   }
   return NULL;
 }

Here is the caller graph for this function:

enum CommandResult 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 1248 of file keymap.c.

 {
   const struct Binding *bindings = NULL;
   int menu[sizeof(Menus) / sizeof(struct Mapping) - 1], nummenus;
   enum CommandResult rc = MUTT_CMD_SUCCESS;
 
   char *key = parse_keymap(menu, s, mutt_array_size(menu), &nummenus, err, true);
   if (!key)
     return MUTT_CMD_ERROR;
 
   /* function to execute */
   mutt_extract_token(buf, s, 0);
   if (MoreArgs(s))
   {
     mutt_buffer_printf(err, _("%s: too many arguments"), "bind");
     rc = MUTT_CMD_ERROR;
   }
   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))
       {
         rc = try_bind(key, menu[i], buf->data, OpGeneric, err);
         if (rc == 0)
           continue;
         if (rc == -2)
           break;
       }
 
       /* Clear any error message, we're going to try again */
       err->data[0] = '\0';
       bindings = km_get_table(menu[i]);
       if (bindings)
       {
         rc = try_bind(key, menu[i], buf->data, bindings, err);
       }
     }
   }
   FREE(&key);
   return rc;
 }

Here is the call graph for this function:

enum CommandResult 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 1306 of file keymap.c.

 {
   int menu[sizeof(Menus) / sizeof(struct Mapping) - 1], nummenus;
   enum CommandResult rc = MUTT_CMD_ERROR;
   char *seq = NULL;
 
   char *key = parse_keymap(menu, s, mutt_array_size(menu), &nummenus, err, false);
   if (!key)
     return MUTT_CMD_ERROR;
 
   mutt_extract_token(buf, s, MUTT_TOKEN_CONDENSE);
   /* make sure the macro sequence is not an empty string */
   if (buf->data[0] == '\0')
   {
     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++)
         {
           rc = km_bind(key, menu[i], OP_MACRO, seq, buf->data);
         }
       }
 
       FREE(&seq);
     }
     else
     {
       for (int i = 0; i < nummenus; i++)
       {
         rc = km_bind(key, menu[i], OP_MACRO, buf->data, NULL);
       }
     }
   }
   FREE(&key);
   return rc;
 }

Here is the call graph for this function:

enum CommandResult 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 1359 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 MUTT_CMD_ERROR;
   }
 
   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 MUTT_CMD_ERROR;
     }
     nops++;
   } while (MoreArgs(s) && nops < mutt_array_size(ops));
 
   while (nops)
     mutt_push_macro_event(0, ops[--nops]);
 
   return MUTT_CMD_SUCCESS;
 }

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 1406 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 1427 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 60 of file keymap.c.

struct Mapping KeyNames[]

static

Key name lookup table.

Definition at line 86 of file keymap.c.

int LastKey

contains the last key the user pressed

Last real key pressed, recorded by dokey()

Definition at line 145 of file keymap.c.

struct Keymap* Keymaps[MENU_MAX]

Array of Keymap keybindings, one for each Menu.

Definition at line 147 of file keymap.c.

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation