menu.c

Go to the documentation of this file.

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

enum CommandResult km_bind(struct MenuDefinition *md, const char *key_str,
                           int op, char *macro, char *desc, struct Buffer *err)
{
  if (!md || ARRAY_EMPTY(&md->submenus))
    return MUTT_CMD_ERROR;
 
  enum CommandResult rc = MUTT_CMD_SUCCESS;
  struct Keymap *last = NULL;
  struct Keymap *np = NULL;
  struct Keymap *compare = NULL;
  keycode_t buf[KEY_SEQ_MAX_LEN] = { 0 };
  size_t pos = 0;
  size_t lastpos = 0;
 
  struct SubMenu *sm = *ARRAY_FIRST(&md->submenus);
  struct KeymapList *kml = &sm->keymaps;
 
  size_t len = parse_keys(key_str, buf, KEY_SEQ_MAX_LEN);
 
  struct Keymap *map = keymap_alloc(len, buf);
  map->op = op;
  map->macro = mutt_str_dup(macro);
  map->desc = mutt_str_dup(desc);
 
  /* find position to place new keymap */
  STAILQ_FOREACH(np, kml, entries)
  {
    compare = keymap_compare(map, np, &pos);
 
    if (compare == map) /* map's keycode is bigger */
    {
      last = np;
      lastpos = pos;
      if (pos > np->eq)
        pos = np->eq;
    }
    else if (compare == np) /* np's keycode is bigger, found insert location */
    {
      map->eq = pos;
      break;
    }
    else /* equal keycodes */
    {
      if (np->len < len)
      {
        // Prefix-compatible binding, continue looking for insertion point.
        last = np;
        lastpos = np->len;
        if (pos > np->eq)
          pos = np->eq;
        continue;
      }
      else if (np->len > len)
      {
        // Prefix-compatible binding, insert before the longer sequence.
        map->eq = len;
        break;
      }
 
      // Exact same key sequence: replace existing mapping.
      map->eq = np->eq;
      STAILQ_REMOVE(kml, np, Keymap, entries);
      keymap_free(&np);
      break;
    }
  }
 
  if (last) /* if queue has at least one entry */
  {
    if (STAILQ_NEXT(last, entries))
      STAILQ_INSERT_AFTER(kml, last, map, entries);
    else /* last entry in the queue */
      STAILQ_INSERT_TAIL(kml, map, entries);
    last->eq = lastpos;
  }
  else /* queue is empty, so insert from head */
  {
    STAILQ_INSERT_HEAD(kml, map, entries);
  }
 
  return rc;
}

struct Keymap *km_find_func(const struct MenuDefinition *md, int func)
{
  if (!md)
    return NULL;
 
  struct SubMenu **smp = NULL;
 
  ARRAY_FOREACH(smp, &md->submenus)
  {
    struct SubMenu *sm = *smp;
 
    struct Keymap *map = NULL;
    STAILQ_FOREACH(map, &sm->keymaps, entries)
    {
      if (map->op == func)
        return map;
    }
  }
 
  return NULL;
}

int km_get_op(const char *func)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
    struct SubMenu **smp = NULL;
 
    ARRAY_FOREACH(smp, &md->submenus)
    {
      struct SubMenu *sm = *smp;
 
      for (int i = 0; sm->functions[i].name; i++)
      {
        if (mutt_str_equal(sm->functions[i].name, func))
          return sm->functions[i].op;
      }
    }
  }
 
  return OP_NULL;
}

int km_get_op_menu(int mtype, const char *func)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
 
    if (md->id != mtype)
      continue;
 
    struct SubMenu **smp = NULL;
 
    ARRAY_FOREACH(smp, &md->submenus)
    {
      struct SubMenu *sm = *smp;
 
      for (int i = 0; sm->functions[i].name; i++)
      {
        if (mutt_str_equal(sm->functions[i].name, func))
          return sm->functions[i].op;
      }
    }
  }
 
  return OP_NULL;
}

struct MenuDefinition *menu_find(int menu)
{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
 
    if (md->id == menu)
      return md;
  }
 
  return NULL;
}

struct MenuDefinition *menu_find_by_name(const char *name)
{
  if (!name)
    return NULL;
 
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
 
    if (mutt_str_equal(md->name, name))
      return md;
  }
 
  return NULL;
}

bool is_bound(const struct MenuDefinition *md, int op)
{
  struct SubMenu **smp = NULL;
 
  ARRAY_FOREACH(smp, &md->submenus)
  {
    struct SubMenu *sm = *smp;
 
    struct Keymap *map = NULL;
    STAILQ_FOREACH(map, &sm->keymaps, entries)
    {
      if (map->op == op)
        return true;
    }
  }
 
  return false;
}