init.c

Go to the documentation of this file.

 
#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 "keymap.h"
#include "menu.h"
#include "module_data.h"


const struct Command KeyCommands[] = {
  // 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_NONE },
  // clang-format on
};

struct SubMenu *km_register_submenu(const struct MenuFuncOp functions[])
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  struct SubMenu sm = { 0 };
  sm.functions = functions;
  ARRAY_INIT(&sm.keymaps);
 
  ARRAY_ADD(&mod_data->sub_menus, sm);
  return ARRAY_LAST(&mod_data->sub_menus);
}

struct MenuDefinition *km_register_menu(int menu, const char *name)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  struct MenuDefinition *md = MUTT_MEM_CALLOC(1, struct MenuDefinition);
  md->id = menu;
  md->name = mutt_str_dup(name);
  ARRAY_INIT(&md->submenus);
 
  ARRAY_ADD(&mod_data->menu_defs, md);
  return *ARRAY_LAST(&mod_data->menu_defs);
}

void km_menu_add_submenu(struct MenuDefinition *md, struct SubMenu *sm)
{
  if (!sm->parent)
    sm->parent = md;
 
  ARRAY_ADD(&md->submenus, sm);
}

void km_menu_add_bindings(struct MenuDefinition *md, const struct MenuOpSeq bindings[])
{
  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);
    }
  }
}

int km_config_observer(struct NotifyCallback *nc)
{
  if (nc->event_type != NT_CONFIG)
    return 0;
  if (!nc->event_data)
    return -1;
 
  struct EventConfig *ev_c = nc->event_data;
 
  if (!mutt_str_equal(ev_c->name, "abort_key"))
    return 0;
 
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  km_set_abort_key(&mod_data->abort_key);
  mutt_debug(LL_DEBUG5, "config done\n");
  return 0;
}

void km_init(struct KeyModuleData *mod_data)
{
  ARRAY_INIT(&mod_data->menu_defs);
  ARRAY_INIT(&mod_data->sub_menus);
  mod_data->key_names = keymap_get_key_names();
 
  notify_observer_add(NeoMutt->sub->notify, NT_CONFIG, km_config_observer, NULL);
}

static int menu_defs_sort(const void *a, const void *b, void *sdata)
{
  const struct MenuDefinition *md_a = *(const struct MenuDefinition **) a;
  const struct MenuDefinition *md_b = *(const struct MenuDefinition **) b;
 
  return mutt_str_cmp(md_a->name, md_b->name);
}

void km_sort(void)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  ARRAY_SORT(&mod_data->menu_defs, menu_defs_sort, NULL);
}

void km_cleanup(struct KeyModuleData *mod_data)
{
  if (NeoMutt && NeoMutt->sub)
    notify_observer_remove(NeoMutt->sub->notify, km_config_observer, NULL);
 
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
 
    FREE(&md->name);
    ARRAY_FREE(&md->submenus);
    FREE(&md);
  }
  ARRAY_FREE(&mod_data->menu_defs);
 
  struct SubMenu *sm = NULL;
  ARRAY_FOREACH(sm, &mod_data->sub_menus)
  {
    keymaplist_free(&sm->keymaps);
  }
  ARRAY_FREE(&mod_data->sub_menus);
 
  ARRAY_FREE(&mod_data->macro_events);
  ARRAY_FREE(&mod_data->unget_key_events);
}

void km_set_abort_key(keycode_t *abort_key)
{
  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"));
    *abort_key = ctrl('G');
    return;
  }
 
  if (len > 1)
  {
    mutt_warning(_("Specified abort key sequence (%s) will be truncated to first key"),
                 c_abort_key);
  }
  *abort_key = buf[0];
}