commands.c File Reference

Parse key binding commands. More...

#include "config.h"
#include <stdbool.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "commands.h"
#include "editor/lib.h"
#include "index/lib.h"
#include "menu/lib.h"
#include "pager/lib.h"
#include "parse/lib.h"
#include "dump.h"
#include "get.h"
#include "keymap.h"
#include "menu.h"
#include "module_data.h"
#include "notify.h"

Include dependency graph for commands.c:

Go to the source code of this file.

Data Structures
struct	ParseUnbind
	Parsed 'unbind' or 'unmacro' command. More...

Functions
enum CommandResult	parse_dump (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse 'bind' and 'macro' commands - Implements Command::parse() -.
char *	parse_keymap (const struct Command *cmd, struct MenuDefinitionArray *mda, struct Buffer *line, struct Buffer *err)
	Parse a user-config key binding.
void	parse_menu (struct MenuDefinitionArray *menus, const char *s, struct Buffer *err)
	Parse menu-names into an array.
enum CommandResult	parse_push (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	parse_bind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'bind' command - Implements Command::parse() -.
void	set_default_bindings (const struct MenuDefinition *md)
	Set some safe default keybindings.
const char *	notify_binding_name (enum NotifyBinding ev)
	Get the name for a NotifyBinding.
bool	parse_unbind_args (const struct Command *cmd, struct Buffer *line, struct Buffer *err, struct ParseUnbind *args)
	Parse the 'unbind' and 'unmacro' commands.
bool	parse_unbind_exec (const struct Command *cmd, struct ParseUnbind *args, struct Buffer *err)
	Execute the 'unbind' or 'unmacro' command.
enum CommandResult	parse_unbind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unbind' and 'unmacro' commands - Implements Command::parse() -.
enum CommandResult	parse_macro (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	parse_exec (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'exec' command - Implements Command::parse() -.

Detailed Description

Parse key binding commands.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file commands.c.

Function Documentation

parse_keymap()

char * parse_keymap	(	const struct Command *	cmd,
		struct MenuDefinitionArray *	mda,
		struct Buffer *	line,
		struct Buffer *	err )

Parse a user-config key binding.

Parameters

cmd	Command being processed
mda	Array for results
line	Buffer containing config string
err	Buffer for error messages

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 115 of file commands.c.

{
  struct Buffer *token = buf_pool_get();
  char *q = NULL;
  char *result = NULL;
 
  /* menu name */
  parse_extract_token(token, line, TOKEN_NONE);
  char *p = token->data;
  if (MoreArgs(line))
  {
    while (true)
    {
      q = strchr(p, ',');
      if (q)
        *q = '\0';
 
      struct MenuDefinition *md = menu_find_by_name(p);
      if (!md)
      {
        buf_printf(err, _("%s: no such menu"), p);
        goto done;
      }
      ARRAY_ADD(mda, md);
      if (q)
        p = q + 1;
      else
        break;
    }
    /* key sequence */
    parse_extract_token(token, line, TOKEN_NONE);
 
    if (buf_at(token, 0) == '\0')
    {
      buf_printf(err, _("%s: null key sequence"), cmd->name);
    }
    else if (MoreArgs(line))
    {
      result = buf_strdup(token);
      goto done;
    }
  }
  else
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
  }
done:
  buf_pool_release(&token);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_menu()

void parse_menu	(	struct MenuDefinitionArray *	menus,
		const char *	s,
		struct Buffer *	err )

Parse menu-names into an array.

Parameters

menus	Array for results
s	String containing menu-names
err	Buffer for error messages

Expects to see: <menu-string>[,<menu-string>]

Definition at line 175 of file commands.c.

{
  char *menu_names_dup = mutt_str_dup(s);
  char *marker = menu_names_dup;
  char *menu_name = NULL;
 
  while ((menu_name = mutt_str_sep(&marker, ",")))
  {
    struct MenuDefinition *md = menu_find_by_name(menu_name);
    if (!md)
    {
      buf_printf(err, _("%s: no such menu"), menu_name);
      break;
    }
    else
    {
      ARRAY_ADD(menus, md);
    }
  }
 
  FREE(&menu_names_dup);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_default_bindings()

void set_default_bindings

(

const struct MenuDefinition *

md

)

Set some safe default keybindings.

Parameters

md	Menu Definition to update

Definition at line 360 of file commands.c.

{
  bool success = false;
 
  if (!md || (md == MdGeneric))
  {
    km_bind(MdGeneric, "<enter>", OP_GENERIC_SELECT_ENTRY, NULL, NULL, NULL);
    km_bind(MdGeneric, "<return>", OP_GENERIC_SELECT_ENTRY, NULL, NULL, NULL);
    km_bind(MdGeneric, ":", OP_ENTER_COMMAND, NULL, NULL, NULL);
    km_bind(MdGeneric, "?", OP_HELP, NULL, NULL, NULL);
    km_bind(MdGeneric, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  if (!md || (md == MdIndex))
  {
    km_bind(MdIndex, "<enter>", OP_DISPLAY_MESSAGE, NULL, NULL, NULL);
    km_bind(MdIndex, "<return>", OP_DISPLAY_MESSAGE, NULL, NULL, NULL);
    km_bind(MdIndex, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  if (!md || (md == MdEditor))
  {
    km_bind(MdEditor, "<backspace>", OP_EDITOR_BACKSPACE, NULL, NULL, NULL);
    km_bind(MdEditor, "\177", OP_EDITOR_BACKSPACE, NULL, NULL, NULL);
    success = true;
  }
 
  if (!md || (md == MdPager))
  {
    km_bind(MdPager, ":", OP_ENTER_COMMAND, NULL, NULL, NULL);
    km_bind(MdPager, "?", OP_HELP, NULL, NULL, NULL);
    km_bind(MdPager, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  if (!md || (md == MdDialog))
  {
    km_bind(MdDialog, ":", OP_ENTER_COMMAND, NULL, NULL, NULL);
    km_bind(MdDialog, "?", OP_HELP, NULL, NULL, NULL);
    km_bind(MdDialog, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  if (success)
  {
    mutt_debug(LL_NOTIFY, "NT_BINDING_ADD set defaults\n");
    struct EventBinding ev_b = { md, NULL, OP_NULL };
    notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_ADD, &ev_b);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

notify_binding_name()

const char * notify_binding_name

(

enum NotifyBinding

ev

)

Get the name for a NotifyBinding.

Parameters

ev	Event type

Return values

str	Name of the NotifyBinding

Definition at line 418 of file commands.c.

{
  switch (ev)
  {
    case NT_BINDING_ADD:
      return "NT_BINDING_ADD";
    case NT_BINDING_DELETE:
      return "NT_BINDING_DELETE";
    case NT_MACRO_ADD:
      return "NT_MACRO_ADD";
    case NT_MACRO_DELETE:
      return "NT_MACRO_DELETE";
    default:
      return "UNKNOWN";
  }
}

Here is the caller graph for this function:

parse_unbind_args()

bool parse_unbind_args	(	const struct Command *	cmd,
		struct Buffer *	line,
		struct Buffer *	err,
		struct ParseUnbind *	args )

Parse the 'unbind' and 'unmacro' commands.

Parameters

[in]	cmd	Command being parsed
[in]	line	Text to parse
[out]	err	Buffer for error messages
[out]	args	Parsed args

Return values

true

Success

Command unbinds:

• all bindings in all menu-names
  • unbind *
• all bindings in one/many menu-names
  • unbind index *
  • unbind index
  • unbind index,pager *
  • unbind index,pager
• one binding in one/many/all menu-names
  • unbind index j
  • unbind index,pager j
  • unbind * j

The same applies to unmacro.

Definition at line 458 of file commands.c.

{
  if (!cmd || !line || !err || !args)
    return false;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return false;
  }
 
  struct Buffer *token = buf_pool_get();
  bool rc = false;
 
  parse_extract_token(token, line, TOKEN_NONE);
  if (mutt_str_equal(buf_string(token), "*"))
  {
    args->all_menus = true;
 
    if (MoreArgs(line))
    {
      // `unbind * key`
      // `unmacro * key`
      parse_extract_token(token, line, TOKEN_NONE);
      args->key = buf_strdup(token);
    }
    else
    {
      // `unbind *`
      // `unmacro *`
      args->all_keys = true;
    }
  }
  else
  {
    parse_menu(&args->mda, buf_string(token), err);
    if (!buf_is_empty(err))
      goto done;
 
    if (MoreArgs(line))
    {
      parse_extract_token(token, line, TOKEN_NONE);
      if (mutt_str_equal(buf_string(token), "*"))
      {
        // `unbind  menu *`
        // `unmacro menu *`
        args->all_keys = true;
      }
      else
      {
        // `unbind  menu key`
        // `unmacro menu key`
        args->key = buf_strdup(token);
      }
    }
    else
    {
      // `unbind  menu`
      // `unmacro menu`
      args->all_keys = true;
    }
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  rc = true;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unbind_exec()

bool parse_unbind_exec	(	const struct Command *	cmd,
		struct ParseUnbind *	args,
		struct Buffer *	err )

Execute the 'unbind' or 'unmacro' command.

Parameters

[in]	cmd	Command being executed
[in]	args	Parsed arguments
[out]	err	Buffer for error messages

Return values

true

Success

The user is trying to remove a binding or a macro. We choose not to distinguish the two, since a key can only be bound to one or the other. i.e. unbind will also clear macros, unmacro will also clear bindings

Definition at line 546 of file commands.c.

{
  if (!cmd || !args || !err)
    return false;
 
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  keycode_t key_bytes[KEY_SEQ_MAX_LEN] = { 0 };
  int key_len = 0;
  if (args->key)
  {
    key_len = parse_keys(args->key, key_bytes, KEY_SEQ_MAX_LEN);
    if (key_len == 0)
      return false;
  }
 
  bool success = false;
  struct Buffer *keystr = buf_pool_get();
  enum NotifyBinding nb = (cmd->id == CMD_UNBIND) ? NT_BINDING_DELETE : NT_MACRO_DELETE;
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
 
    if (!args->all_menus)
    {
      bool found = false;
      struct MenuDefinition **mdp2 = NULL;
      ARRAY_FOREACH(mdp2, &args->mda)
      {
        if ((*mdp2)->id == md->id)
        {
          found = true;
          break;
        }
      }
      if (!found)
        continue;
    }
 
    struct SubMenu **smp = ARRAY_GET(&md->submenus, 0);
    if (!smp || !*smp)
      continue;
 
    struct SubMenu *sm = *smp;
 
    struct Keymap *km = NULL;
    struct Keymap *km_tmp = NULL;
    STAILQ_FOREACH_SAFE(km, &sm->keymaps, entries, km_tmp)
    {
      if (args->all_keys ||
          ((key_len == km->len) && (memcmp(km->keys, key_bytes, km->len) == 0)))
      {
        STAILQ_REMOVE(&sm->keymaps, km, Keymap, entries);
        keymap_free(&km);
        success = true;
 
        if (!args->all_keys && !args->all_menus)
        {
          buf_reset(keystr);
          keymap_expand_string(args->key, keystr);
          mutt_debug(LL_NOTIFY, "%s: %s %s\n", notify_binding_name(nb),
                     md->name, buf_string(keystr));
 
          struct EventBinding ev_b = { md, args->key, OP_NULL };
          notify_send(NeoMutt->notify, NT_BINDING, nb, &ev_b);
        }
      }
    }
 
    if (args->all_keys && !args->all_menus && success)
    {
      buf_reset(keystr);
      keymap_expand_string(args->key, keystr);
      mutt_debug(LL_NOTIFY, "%s: %s %s\n", notify_binding_name(nb), md->name,
                 buf_string(keystr));
 
      struct EventBinding ev_b = { md, args->key, OP_NULL };
      notify_send(NeoMutt->notify, NT_BINDING, nb, &ev_b);
 
      // restore some bindings for this menu
      set_default_bindings(md);
    }
  }
 
  if (args->all_menus && success)
  {
    buf_reset(keystr);
    keymap_expand_string(args->key, keystr);
    mutt_debug(LL_NOTIFY, "%s: ALL %s\n", notify_binding_name(nb), buf_string(keystr));
 
    struct EventBinding ev_b = { NULL, args->key, OP_NULL };
    notify_send(NeoMutt->notify, NT_BINDING, nb, &ev_b);
 
    // restore some bindings for all menus
    set_default_bindings(NULL);
  }
 
  buf_pool_release(&keystr);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: