init.c File Reference

Set up the key bindings. More...

#include "config.h"
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "init.h"
#include "commands.h"
#include "get.h"
#include "keymap.h"
#include "menu.h"

Include dependency graph for init.c:

Go to the source code of this file.

Functions
struct SubMenu *	km_register_submenu (const struct MenuFuncOp functions[])
	Register a submenu.
struct MenuDefinition *	km_register_menu (int menu, const char *name)
	Register a menu.
void	km_menu_add_submenu (struct MenuDefinition *md, struct SubMenu *sm)
	Add a SubMenu to a Menu Definition.
void	km_menu_add_bindings (struct MenuDefinition *md, const struct MenuOpSeq bindings[])
	Add Keybindings to a Menu.
int	km_config_observer (struct NotifyCallback *nc)
	Notification that a Config Variable has changed - Implements observer_t -.
void	km_init (void)
	Initialise all the menu keybindings.
static int	menu_defs_sort (const void *a, const void *b, void *sdata)
	Compare two MenuDefinitions by their names - Implements sort_t -.
void	km_sort (void)
	Sort all the menu keybindings.
void	km_cleanup (void)
	Free the key maps.
void	km_set_abort_key (void)
	Parse the abort_key config string.

Variables
struct MenuDefinitionArray	MenuDefs
	All the registered Menus.
struct SubMenuArray	SubMenus
	All the registered SubMenus.
keycode_t	AbortKey
	code of key to abort prompts, normally Ctrl-G
const struct Command	KeyCommands []
	Key Binding Commands.

Detailed Description

Set up the key bindings.

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

Function Documentation

km_register_submenu()

struct SubMenu * km_register_submenu

(

const struct MenuFuncOp

functions[]

)

Register a submenu.

Parameters

functions

Function definitions

Return values

ptr

SubMenu

Register a set of functions. The result can be used in multiple Menus.

Definition at line 91 of file init.c.

{
  struct SubMenu sm = { 0 };
  sm.functions = functions;
  ARRAY_INIT(&sm.keymaps);
 
  ARRAY_ADD(&SubMenus, sm);
  return ARRAY_LAST(&SubMenus);
}

Here is the caller graph for this function:

km_register_menu()

struct MenuDefinition * km_register_menu	(	int	menu,
		const char *	name )

Register a menu.

Parameters

menu	Menu Type, e.g. MENU_INDEX
name	Menu name, e.g. "index"

Return values

ptr	Menu Definition

Definition at line 107 of file init.c.

{
  struct MenuDefinition *md = MUTT_MEM_CALLOC(1, struct MenuDefinition);
  md->id = menu;
  md->name = mutt_str_dup(name);
  ARRAY_INIT(&md->submenus);
 
  ARRAY_ADD(&MenuDefs, md);
  return *ARRAY_LAST(&MenuDefs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_menu_add_submenu()

void km_menu_add_submenu	(	struct MenuDefinition *	md,
		struct SubMenu *	sm )

Add a SubMenu to a Menu Definition.

Parameters

md	Menu Definition
sm	SubMenu to add

Definition at line 123 of file init.c.

{
  if (!sm->parent)
    sm->parent = md;
 
  ARRAY_ADD(&md->submenus, sm);
}

Here is the caller graph for this function:

km_menu_add_bindings()

void km_menu_add_bindings	(	struct MenuDefinition *	md,
		const struct MenuOpSeq	bindings[] )

Add Keybindings to a Menu.

Parameters

md	Menu Definition
bindings	Keybindings to add

Definition at line 136 of file init.c.

{
  for (int i = 0; bindings[i].op != OP_NULL; i++)
  {
    if (bindings[i].seq)
    {
      km_bind(md, bindings[i].seq, bindings[i].op, NULL, NULL, NULL);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_init()

void km_init

(

void

)

Initialise all the menu keybindings.

Definition at line 170 of file init.c.

{
  ARRAY_INIT(&MenuDefs);
  ARRAY_INIT(&SubMenus);
 
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, km_config_observer, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_sort()

void km_sort

(

void

)

Sort all the menu keybindings.

Definition at line 192 of file init.c.

{
  ARRAY_SORT(&MenuDefs, menu_defs_sort, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_cleanup()

void km_cleanup

(

void

)

Free the key maps.

Definition at line 200 of file init.c.

{
  if (NeoMutt && NeoMutt->sub)
    notify_observer_remove(NeoMutt->sub->notify, km_config_observer, NULL);
 
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &MenuDefs)
  {
    struct MenuDefinition *md = *mdp;
 
    FREE(&md->name);
    ARRAY_FREE(&md->submenus);
    FREE(&md);
  }
  ARRAY_FREE(&MenuDefs);
 
  struct SubMenu *sm = NULL;
  ARRAY_FOREACH(sm, &SubMenus)
  {
    keymaplist_free(&sm->keymaps);
  }
  ARRAY_FREE(&SubMenus);
 
  ARRAY_FREE(&MacroEvents);
  ARRAY_FREE(&UngetKeyEvents);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_set_abort_key()

void km_set_abort_key

(

void

)

Parse the abort_key config string.

Parse the string into $abort_key and put the keycode into AbortKey.

Definition at line 232 of file init.c.

{
  keycode_t buf[4] = { 0 };
  const char *const c_abort_key = cs_subset_string(NeoMutt->sub, "abort_key");
 
  size_t len = parse_keys(c_abort_key, buf, countof(buf));
  if (len == 0)
  {
    mutt_error(_("Abort key is not set, defaulting to Ctrl-G"));
    AbortKey = ctrl('G');
    return;
  }
 
  if (len > 1)
  {
    mutt_warning(_("Specified abort key sequence (%s) will be truncated to first key"),
                 c_abort_key);
  }
  AbortKey = buf[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MenuDefs

struct MenuDefinitionArray MenuDefs

All the registered Menus.

Definition at line 42 of file init.c.

SubMenus

struct SubMenuArray SubMenus

All the registered SubMenus.

Definition at line 45 of file init.c.

AbortKey

keycode_t AbortKey

code of key to abort prompts, normally Ctrl-G

key to abort edits etc, normally Ctrl-G

Definition at line 47 of file init.c.

KeyCommands

const struct Command KeyCommands[]

Initial value:

= {
  
  { "bind", CMD_BIND, parse_bind,
        N_("Bind a key to a function"),
        N_("bind <map>[,<map> ... ] <key> <function>"),
        "configuration.html#bind" },
  { "exec", CMD_EXEC, parse_exec,
        N_("Execute a function"),
        N_("exec <function> [ <function> ... ]"),
        "configuration.html#exec" },
  { "macro", CMD_MACRO, parse_macro,
        N_("Define a keyboard macro"),
        N_("macro <map>[,<map> ... ] <key> <sequence> [ <description> ]"),
        "configuration.html#macro" },
  { "push", CMD_PUSH, parse_push,
        N_("Push a string into NeoMutt's input queue (simulate typing)"),
        N_("push <string>"),
        "configuration.html#push" },
  { "unbind", CMD_UNBIND, parse_unbind,
        N_("Remove a key binding"),
        N_("unbind { * | <map>[,<map> ... ] } [ <key> ]"),
        "configuration.html#unbind" },
  { "unmacro", CMD_UNMACRO, parse_unbind,
        N_("Remove a keyboard `macro`"),
        N_("unmacro { * | <map>[,<map> ... ] } [ <key> ]"),
        "configuration.html#unmacro" },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NO_FLAGS },
  
}

Key Binding Commands.

Definition at line 52 of file init.c.

                                     {
  // clang-format off
  { "bind", CMD_BIND, parse_bind,
        N_("Bind a key to a function"),
        N_("bind <map>[,<map> ... ] <key> <function>"),
        "configuration.html#bind" },
  { "exec", CMD_EXEC, parse_exec,
        N_("Execute a function"),
        N_("exec <function> [ <function> ... ]"),
        "configuration.html#exec" },
  { "macro", CMD_MACRO, parse_macro,
        N_("Define a keyboard macro"),
        N_("macro <map>[,<map> ... ] <key> <sequence> [ <description> ]"),
        "configuration.html#macro" },
  { "push", CMD_PUSH, parse_push,
        N_("Push a string into NeoMutt's input queue (simulate typing)"),
        N_("push <string>"),
        "configuration.html#push" },
  { "unbind", CMD_UNBIND, parse_unbind,
        N_("Remove a key binding"),
        N_("unbind { * | <map>[,<map> ... ] } [ <key> ]"),
        "configuration.html#unbind" },
  { "unmacro", CMD_UNMACRO, parse_unbind,
        N_("Remove a keyboard `macro`"),
        N_("unmacro { * | <map>[,<map> ... ] } [ <key> ]"),
        "configuration.html#unmacro" },
 
  { NULL, CMD_NONE, NULL, NULL, NULL, NULL, CF_NO_FLAGS },
  // clang-format on
};