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 "init.h"
#include "keymap.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[MAX_SEQ] = { 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, MAX_SEQ);
 
  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 */
    {
      /* Don't warn on overwriting a 'noop' binding */
      if ((np->len != len) && (np->op != OP_NULL))
      {
        static const char *guide_link = "https://neomutt.org/guide/configuration.html#bind-warnings";
        /* Overwrite with the different lengths, warn */
        struct Buffer *old_binding = buf_pool_get();
        struct Buffer *new_binding = buf_pool_get();
 
        keymap_expand_key(map, old_binding);
        keymap_expand_key(np, new_binding);
 
        char *err_msg = _("Binding '%s' will alias '%s'  Before, try: 'bind %s %s noop'");
        if (err)
        {
          /* err was passed, put the string there */
          buf_printf(err, err_msg, buf_string(old_binding),
                     buf_string(new_binding), md->name, buf_string(new_binding));
          buf_add_printf(err, "  %s", guide_link);
        }
        else
        {
          struct Buffer *tmp = buf_pool_get();
          buf_printf(tmp, err_msg, buf_string(old_binding),
                     buf_string(new_binding), md->name, buf_string(new_binding));
          buf_add_printf(tmp, "  %s", guide_link);
          mutt_error("%s", buf_string(tmp));
          buf_pool_release(&tmp);
        }
        rc = MUTT_CMD_WARNING;
 
        buf_pool_release(&old_binding);
        buf_pool_release(&new_binding);
      }
 
      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 MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &MenuDefs)
  {
    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 MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &MenuDefs)
  {
    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 MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &MenuDefs)
  {
    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 MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &MenuDefs)
  {
    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;
}