/*
* Copyright (C) 1996-2000,2002,2010-2011 Michael R. Elkins <me@mutt.org>
*
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#if HAVE_CONFIG_H
# include "config.h"
#endif
#include "mutt.h"
#include "mutt_menu.h"
#include "mutt_curses.h"
#include "keymap.h"
#include "mapping.h"
#include "mutt_crypt.h"
#ifdef USE_IMAP
#include "imap/imap.h"
#endif
#ifdef USE_INOTIFY
#include "monitor.h"
#endif
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "functions.h"
const struct mapping_t Menus[] = {
{ "alias", MENU_ALIAS },
{ "attach", MENU_ATTACH },
{ "browser", MENU_FOLDER },
{ "compose", MENU_COMPOSE },
{ "editor", MENU_EDITOR },
{ "list", MENU_LIST },
{ "index", MENU_MAIN },
{ "pager", MENU_PAGER },
{ "postpone", MENU_POST },
{ "pgp", MENU_PGP },
{ "smime", MENU_SMIME },
#ifdef CRYPT_BACKEND_GPGME
{ "key_select_pgp", MENU_KEY_SELECT_PGP },
{ "key_select_smime", MENU_KEY_SELECT_SMIME },
#endif
#ifdef MIXMASTER
{ "mix", MENU_MIX },
#endif
{ "query", MENU_QUERY },
{ "generic", MENU_GENERIC },
{ NULL, 0 }
};
#define mutt_check_menu(s) mutt_getvaluebyname(s, Menus)
static struct mapping_t KeyNames[] = {
{ "<PageUp>", KEY_PPAGE },
{ "<PageDown>", KEY_NPAGE },
{ "<Up>", KEY_UP },
{ "<Down>", KEY_DOWN },
{ "<Right>", KEY_RIGHT },
{ "<Left>", KEY_LEFT },
{ "<Delete>", KEY_DC },
{ "<BackSpace>",KEY_BACKSPACE },
{ "<Insert>", KEY_IC },
{ "<Home>", KEY_HOME },
{ "<End>", KEY_END },
{ "<Enter>", '\n' },
{ "<Return>", '\r' },
#ifdef KEY_ENTER
{ "<KeypadEnter>", KEY_ENTER },
#else
{ "<KeypadEnter>", '\n' },
#endif
{ "<Esc>", '\033' },
{ "<Tab>", '\t' },
{ "<Space>", ' ' },
#ifdef KEY_BTAB
{ "<BackTab>", KEY_BTAB },
#endif
#ifdef KEY_NEXT
{ "<Next>", KEY_NEXT },
#endif
#ifdef NCURSES_VERSION
/* extensions supported by ncurses. values are filled in during initialization */
/* CTRL+key */
{ "<C-Up>", -1 },
{ "<C-Down>", -1 },
{ "<C-Left>", -1 },
{ "<C-Right>", -1 },
{ "<C-Home>", -1 },
{ "<C-End>", -1 },
{ "<C-Next>", -1 },
{ "<C-Prev>", -1 },
/* SHIFT+key */
{ "<S-Up>", -1 },
{ "<S-Down>", -1 },
{ "<S-Left>", -1 },
{ "<S-Right>", -1 },
{ "<S-Home>", -1 },
{ "<S-End>", -1 },
{ "<S-Next>", -1 },
{ "<S-Prev>", -1 },
/* ALT+key */
{ "<A-Up>", -1 },
{ "<A-Down>", -1 },
{ "<A-Left>", -1 },
{ "<A-Right>", -1 },
{ "<A-Home>", -1 },
{ "<A-End>", -1 },
{ "<A-Next>", -1 },
{ "<A-Prev>", -1 },
#endif /* NCURSES_VERSION */
{ NULL, 0 }
};
/* contains the last key the user pressed */
int LastKey;
struct keymap_t *Keymaps[MENU_MAX];
static struct keymap_t *allocKeys (int len, keycode_t *keys)
{
struct keymap_t *p;
p = safe_calloc (1, sizeof (struct keymap_t));
p->len = len;
p->keys = safe_malloc (len * sizeof (keycode_t));
memcpy (p->keys, keys, len * sizeof (keycode_t));
return (p);
}
static int parse_fkey(char *s)
{
char *t;
int n = 0;
if (s[0] != '<' || ascii_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;
}
/*
* This function parses the string <NNN> and uses the octal value as the key
* to bind.
*/
static int parse_keycode (const char *s)
{
char *endChar;
long int result = strtol(s+1, &endChar, 8);
/* allow trailing whitespace, eg. < 1001 > */
while (ISSPACE(*endChar))
++endChar;
/* negative keycodes don't make sense, also detect overflow */
if (*endChar != '>' || result < 0 || result == LONG_MAX)
{
return -1;
}
return result;
}
static int parsekeys (const char *str, keycode_t *d, int max)
{
int n, len = max;
char buff[SHORT_STRING];
char c;
char *s, *t;
strfcpy(buff, str, sizeof(buff));
s = buff;
while (*s && len)
{
*d = '\0';
if (*s == '<' && (t = strchr(s, '>')))
{
t++; c = *t; *t = '\0';
if ((n = mutt_getvaluebyname (s, KeyNames)) != -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);
}
/* insert a key sequence into the specified map. the map is sorted by ASCII
* value (lowest to highest)
*/
void km_bind (char *s, int menu, int op, char *macro, char *descr)
{
struct keymap_t *map, *tmp, *last = NULL, *next;
keycode_t buf[MAX_SEQ];
int len, pos = 0, lastpos = 0;
len = parsekeys (s, buf, MAX_SEQ);
map = allocKeys (len, buf);
map->op = op;
map->macro = safe_strdup (macro);
map->descr = safe_strdup (descr);
tmp = Keymaps[menu];
while (tmp)
{
if (pos >= len || pos >= tmp->len)
{
/* map and tmp match, but have different lengths, so overwrite */
do
{
len = tmp->eq;
next = tmp->next;
FREE (&tmp->macro);
FREE (&tmp->keys);
FREE (&tmp->descr);
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;
}
void km_bindkey (char *s, int menu, int op)
{
km_bind (s, menu, op, NULL, NULL);
}
static int get_op (const struct menu_func_op_t *bindings, const char *start, size_t len)
{
int i;
for (i = 0; bindings[i].name; i++)
{
if (!ascii_strncasecmp (start, bindings[i].name, len) &&
mutt_strlen (bindings[i].name) == len)
return bindings[i].op;
}
return OP_NULL;
}
static char *get_func (const struct menu_func_op_t *bindings, int op)
{
int i;
for (i = 0; bindings[i].name; i++)
{
if (bindings[i].op == op)
return bindings[i].name;
}
return NULL;
}
/* 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.
*/
static void generic_tokenize_push_string (char *s, void (*generic_push) (int, int))
{
char *pp, *p = s + mutt_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)
{
if ((i = parse_fkey (pp)) > 0)
{
generic_push (KEY_F (i), 0);
p = pp - 1;
continue;
}
l = p - pp + 1;
for (i = 0; KeyNames[i].name; i++)
{
if (!ascii_strncasecmp (pp, KeyNames[i].name, l))
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 menu_func_op_t *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 */
}
}
/* This should be used for macros, push, and exec commands only. */
#define tokenize_push_macro_string(s) generic_tokenize_push_string (s, mutt_push_macro_event)
/* This should be used for other unget operations. */
#define tokenize_unget_string(s) generic_tokenize_push_string (s, mutt_unget_event)
static int retry_generic (int menu, keycode_t *keys, int keyslen, int lastkey)
{
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;
}
/* 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
*/
int km_dokey (int menu)
{
event_t tmp;
struct keymap_t *map = Keymaps[menu];
int pos = 0;
int n = 0;
int i;
if (!map)
return (retry_generic (menu, NULL, 0, 0));
FOREVER
{
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)
{
char *func = NULL;
const struct menu_func_op_t *bindings;
/* 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 && menu != MENU_GENERIC)
{
/* check generic menu */
bindings = OpGeneric;
if ((func = get_func (bindings, tmp.op)))
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;
/* OPTIGNOREMACROEVENTS 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
* _mutt_enter_string() 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 (option (OPTIGNOREMACROEVENTS))
{
return OP_NULL;
}
if (n++ == 10)
{
mutt_flushinp ();
mutt_error _("Macro loop detected.");
return -1;
}
tokenize_push_macro_string (map->macro);
map = Keymaps[menu];
pos = 0;
}
}
/* not reached */
}
static void create_bindings (const struct menu_op_seq_t *map, int menu)
{
int i;
for (i = 0 ; map[i].op ; i++)
if (map[i].seq)
km_bindkey (map[i].seq, menu, map[i].op);
}
static const char *km_keyname (int c)
{
static char buf[10];
const char *p;
if ((p = mutt_getnamebyvalue (c, KeyNames)))
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 (c < 256 && c >= -128 && IsPrint (c))
snprintf (buf, sizeof (buf), "%c", (unsigned char) c);
else
snprintf (buf, sizeof (buf), "<%ho>", (unsigned short) c);
return (buf);
}
int km_expand_key (char *s, size_t len, struct keymap_t *map)
{
size_t l;
int p = 0;
if (!map)
return (0);
FOREVER
{
strfcpy (s, km_keyname (map->keys[p]), len);
len -= (l = mutt_strlen (s));
if (++p >= map->len || !len)
return (1);
s += l;
}
/* not reached */
}
struct keymap_t *km_find_func (int menu, int func)
{
struct keymap_t *map = Keymaps[menu];
for (; map; map = map->next)
if (map->op == func)
break;
return (map);
}
#ifdef NCURSES_VERSION
struct extkey {
const char *name;
const char *sym;
};
static const struct extkey ExtKeys[] = {
{ "<c-up>", "kUP5" },
{ "<s-up>", "kUP" },
{ "<a-up>", "kUP3" },
{ "<s-down>", "kDN" },
{ "<a-down>", "kDN3" },
{ "<c-down>", "kDN5" },
{ "<c-right>", "kRIT5" },
{ "<s-right>", "kRIT" },
{ "<a-right>", "kRIT3" },
{ "<s-left>", "kLFT" },
{ "<a-left>", "kLFT3" },
{ "<c-left>", "kLFT5" },
{ "<s-home>", "kHOM" },
{ "<a-home>", "kHOM3" },
{ "<c-home>", "kHOM5" },
{ "<s-end>", "kEND" },
{ "<a-end>", "kEND3" },
{ "<c-end>", "kEND5" },
{ "<s-next>", "kNXT" },
{ "<a-next>", "kNXT3" },
{ "<c-next>", "kNXT5" },
{ "<s-prev>", "kPRV" },
{ "<a-prev>", "kPRV3" },
{ "<c-prev>", "kPRV5" },
{ 0, 0 }
};
/* Look up Mutt's name for a key and find the ncurses extended name for it */
static const char *find_ext_name(const char *key)
{
int j;
for (j = 0; ExtKeys[j].name; ++j)
{
if (strcasecmp(key, ExtKeys[j].name) == 0)
return ExtKeys[j].sym;
}
return 0;
}
#endif /* NCURSES_VERSION */
/* 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.
*/
void init_extended_keys(void)
{
#ifdef NCURSES_VERSION
int j;
use_extended_names(TRUE);
for (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 (keyname);
if (s && (long)(s) != -1)
{
int code = key_defined(s);
if (code > 0)
KeyNames[j].value = code;
}
}
}
}
#endif
}
void km_init (void)
{
memset (Keymaps, 0, sizeof (struct keymap_t *) * MENU_MAX);
create_bindings (AttachDefaultBindings, MENU_ATTACH);
create_bindings (BrowserDefaultBindings, MENU_FOLDER);
create_bindings (ComposeDefaultBindings, MENU_COMPOSE);
create_bindings (ListDefaultBindings, MENU_LIST);
create_bindings (MainDefaultBindings, MENU_MAIN);
create_bindings (PagerDefaultBindings, MENU_PAGER);
create_bindings (PostDefaultBindings, MENU_POST);
create_bindings (QueryDefaultBindings, MENU_QUERY);
create_bindings (AliasDefaultBindings, MENU_ALIAS);
if ((WithCrypto & APPLICATION_PGP))
create_bindings (PgpDefaultBindings, MENU_PGP);
if ((WithCrypto & APPLICATION_SMIME))
create_bindings (SmimeDefaultBindings, MENU_SMIME);
#ifdef CRYPT_BACKEND_GPGME
create_bindings (PgpDefaultBindings, MENU_KEY_SELECT_PGP);
create_bindings (SmimeDefaultBindings, MENU_KEY_SELECT_SMIME);
#endif
#ifdef MIXMASTER
create_bindings (MixDefaultBindings, MENU_MIX);
#endif
#ifdef USE_AUTOCRYPT
create_bindings (AutocryptAcctDefaultBindings, MENU_AUTOCRYPT_ACCT);
#endif
create_bindings (EditorDefaultBindings, MENU_EDITOR);
create_bindings (GenericDefaultBindings, MENU_GENERIC);
}
void km_error_key (int menu)
{
char buf[SHORT_STRING];
struct keymap_t *key;
int p, op;
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);
return;
}
int mutt_parse_push (BUFFER *buf, BUFFER *s, union pointer_long_t udata, BUFFER *err)
{
int r = 0;
mutt_extract_token (buf, s, MUTT_TOKEN_CONDENSE);
if (MoreArgs (s))
{
strfcpy (err->data, _("push: too many arguments"), err->dsize);
r = -1;
}
else
tokenize_push_macro_string (buf->data);
return (r);
}
/* expects to see: <menu-string>,<menu-string>,... <key-string> */
static char *parse_keymap (int *menu, BUFFER *s, int maxmenus, int *nummenus, BUFFER *err)
{
BUFFER buf;
int i=0;
char *p, *q;
mutt_buffer_init (&buf);
mutt_buffer_increase_size (&buf, STRING);
/* menu name */
mutt_extract_token (&buf, s, 0);
p = buf.data;
if (MoreArgs (s))
{
while (i < maxmenus)
{
q = strchr(p,',');
if (q)
*q = '\0';
if ((menu[i] = mutt_check_menu (p)) == -1)
{
snprintf (err->data, err->dsize, _("%s: no such menu"), p);
goto error;
}
++i;
if (q)
p = q+1;
else
break;
}
*nummenus=i;
/* key sequence */
mutt_extract_token (&buf, s, MUTT_TOKEN_NOLISP);
if (!*buf.data)
{
strfcpy (err->data, _("null key sequence"), err->dsize);
}
else if (MoreArgs (s))
return (buf.data);
}
else
{
strfcpy (err->data, _("too few arguments"), err->dsize);
}
error:
FREE (&buf.data);
return (NULL);
}
static int
try_bind (char *key, int menu, char *func, const struct menu_func_op_t *bindings)
{
int i;
for (i = 0; bindings[i].name; i++)
if (mutt_strcmp (func, bindings[i].name) == 0)
{
km_bindkey (key, menu, bindings[i].op);
return (0);
}
return (-1);
}
const struct menu_func_op_t *km_get_table (int menu)
{
switch (menu)
{
case MENU_MAIN:
return OpMain;
case MENU_GENERIC:
return OpGeneric;
case MENU_COMPOSE:
return OpCompose;
case MENU_PAGER:
return OpPager;
case MENU_POST:
return OpPost;
case MENU_FOLDER:
return OpBrowser;
case MENU_ALIAS:
return OpAlias;
case MENU_ATTACH:
return OpAttach;
case MENU_EDITOR:
return OpEditor;
case MENU_QUERY:
return OpQuery;
case MENU_LIST:
return OpList;
case MENU_PGP:
return (WithCrypto & APPLICATION_PGP)? OpPgp:NULL;
#ifdef CRYPT_BACKEND_GPGME
case MENU_KEY_SELECT_PGP:
return OpPgp;
case MENU_KEY_SELECT_SMIME:
return OpSmime;
#endif
#ifdef MIXMASTER
case MENU_MIX:
return OpMix;
#endif
#ifdef USE_AUTOCRYPT
case MENU_AUTOCRYPT_ACCT:
return OpAutocryptAcct;
#endif
}
return NULL;
}
/* bind menu-name '<key_sequence>' function-name */
int mutt_parse_bind (BUFFER *buf, BUFFER *s, union pointer_long_t udata, BUFFER *err)
{
const struct menu_func_op_t *bindings = NULL;
char *key;
int menu[sizeof(Menus)/sizeof(struct mapping_t)-1], r = 0, nummenus, i;
if ((key = parse_keymap (menu, s, sizeof (menu)/sizeof (menu[0]),
&nummenus, err)) == NULL)
return (-1);
/* function to execute */
mutt_extract_token (buf, s, 0);
if (MoreArgs (s))
{
strfcpy (err->data, _("bind: too many arguments"), err->dsize);
r = -1;
}
else if (ascii_strcasecmp ("noop", buf->data) == 0)
{
for (i = 0; i < nummenus; ++i)
{
km_bindkey (key, menu[i], OP_NULL); /* the `unbind' command */
}
}
else
{
for (i = 0; i < nummenus; ++i)
{
/* First check the "generic" list of commands */
if (menu[i] == MENU_PAGER || menu[i] == MENU_EDITOR ||
menu[i] == MENU_GENERIC ||
try_bind (key, menu[i], buf->data, OpGeneric) != 0)
{
/* Now check the menu-specific list of commands (if they exist) */
bindings = km_get_table (menu[i]);
if (bindings && try_bind (key, menu[i], buf->data, bindings) != 0)
{
snprintf (err->data, err->dsize, _("%s: no such function in map"), buf->data);
r = -1;
}
}
}
}
FREE (&key);
return (r);
}
/* macro <menu> <key> <macro> <description> */
int mutt_parse_macro (BUFFER *buf, BUFFER *s, union pointer_long_t udata, BUFFER *err)
{
int menu[sizeof(Menus)/sizeof(struct mapping_t)-1], r = -1, nummenus, i;
char *seq = NULL;
char *key;
if ((key = parse_keymap (menu, s, sizeof (menu) / sizeof (menu[0]), &nummenus, err)) == NULL)
return (-1);
mutt_extract_token (buf, s, MUTT_TOKEN_CONDENSE);
/* make sure the macro sequence is not an empty string */
if (!*buf->data)
{
strfcpy (err->data, _("macro: empty key sequence"), err->dsize);
}
else
{
if (MoreArgs (s))
{
seq = safe_strdup (buf->data);
mutt_extract_token (buf, s, MUTT_TOKEN_CONDENSE);
if (MoreArgs (s))
{
strfcpy (err->data, _("macro: too many arguments"), err->dsize);
}
else
{
for (i = 0; i < nummenus; ++i)
{
km_bind (key, menu[i], OP_MACRO, seq, buf->data);
r = 0;
}
}
FREE (&seq);
}
else
{
for (i = 0; i < nummenus; ++i)
{
km_bind (key, menu[i], OP_MACRO, buf->data, NULL);
r = 0;
}
}
}
FREE (&key);
return (r);
}
/* exec function-name */
int mutt_parse_exec (BUFFER *buf, BUFFER *s, union pointer_long_t udata, BUFFER *err)
{
int ops[128];
int nops = 0;
const struct menu_func_op_t *bindings = NULL;
char *function;
if (!MoreArgs (s))
{
strfcpy (err->data, _("exec: no arguments"), err->dsize);
return (-1);
}
do
{
mutt_extract_token (buf, s, 0);
function = buf->data;
if ((bindings = km_get_table (CurrentMenu)) == NULL
&& CurrentMenu != MENU_PAGER)
bindings = OpGeneric;
ops[nops] = get_op (bindings, function, mutt_strlen(function));
if (ops[nops] == OP_NULL &&
CurrentMenu != MENU_PAGER &&
CurrentMenu != MENU_GENERIC)
{
ops[nops] = get_op (OpGeneric, function, mutt_strlen(function));
}
if (ops[nops] == OP_NULL)
{
mutt_flushinp ();
mutt_error (_("%s: no such function"), function);
return (-1);
}
nops++;
}
while (MoreArgs(s) && nops < sizeof(ops)/sizeof(ops[0]));
while (nops)
mutt_push_macro_event (0, ops[--nops]);
return 0;
}
/*
* prompts the user to enter a keystroke, and displays the octal value back
* to the user.
*/
void mutt_what_key (void)
{
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();
}