tagging.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "color/lib.h"
#include "key/lib.h"

static void menu_set_prefix(struct Menu *menu)
{
  const bool c_auto_tag = cs_subset_bool(menu->sub, "auto_tag");
  if ((menu->num_tagged != 0) && c_auto_tag)
    menu->tag_prefix = true;
 
  mutt_debug(LL_DEBUG1, "tag_prefix = %d\n", menu->tag_prefix);
 
  // Don't overwrite error messages
  const char *msg_text = msgwin_get_text(NULL);
  if (msg_text && (msg_text[0] != '\0') && !mutt_str_equal(msg_text, "tag-"))
    return;
 
  if (menu->tag_prefix)
  {
    msgwin_set_text(NULL, "tag-", MT_COLOR_NORMAL);
  }
  else
  {
    msgwin_clear_text(NULL);
  }
}

static int op_end_cond(struct Menu *menu, int op)
{
  menu->tag_prefix = false;
  menu_set_prefix(menu);
  return FR_SUCCESS;
}

static int op_tag(struct Menu *menu, int op, int count)
{
  const bool c_auto_tag = cs_subset_bool(menu->sub, "auto_tag");
  int rc = FR_SUCCESS;
 
  if ((menu->num_tagged != 0) && c_auto_tag)
    menu->tag_prefix = true;
 
  if (!menu->tag)
  {
    mutt_error(_("Tagging is not supported"));
    return FR_ERROR;
  }
 
  if (menu->tag_prefix && !c_auto_tag)
  {
    for (int i = 0; i < menu->max; i++)
      menu->num_tagged += menu->tag(menu, i, 0);
 
    menu->redraw |= MENU_REDRAW_INDEX;
  }
  else if (menu->max != 0)
  {
    int tag_count = MAX(count, 1);
    for (int i = 0; (i < tag_count) && ((menu->current + i) < menu->max); i++)
    {
      int num = menu->tag(menu, menu->current + i, -1);
      menu->num_tagged += num;
    }
 
    const bool c_resolve = cs_subset_bool(menu->sub, "resolve");
    if (c_resolve)
    {
      int next_index = menu->current + tag_count;
      if (next_index >= menu->max)
        next_index = menu->max - 1;
      menu_set_index(menu, next_index);
      menu->redraw |= MENU_REDRAW_INDEX;
    }
    else
    {
      menu->redraw |= MENU_REDRAW_INDEX;
    }
  }
  else
  {
    mutt_error(_("No entries"));
    rc = FR_ERROR;
  }
 
  menu->tag_prefix = ((menu->num_tagged != 0) && c_auto_tag);
 
  /* give visual indication that the next command is a tag- command */
  if (menu->tag_prefix)
  {
    msgwin_set_text(NULL, "tag-", MT_COLOR_NORMAL);
  }
 
  menu->win->actions |= WA_REPAINT;
  return rc;
}

static int op_tag_prefix(struct Menu *menu, int op)
{
  if (menu->tag_prefix)
  {
    menu->tag_prefix = false;
    menu_set_prefix(menu);
  }
  else if (menu->num_tagged == 0)
  {
    mutt_warning(_("No tagged entries"));
  }
  else
  {
    menu->tag_prefix = true;
    menu_set_prefix(menu);
  }
 
  return FR_SUCCESS;
}

static int op_tag_prefix_cond(struct Menu *menu, int op)
{
  if (menu->tag_prefix)
  {
    menu->tag_prefix = false;
  }
  else if (menu->num_tagged == 0)
  {
    mutt_flush_macro_to_endcond();
    mutt_debug(LL_DEBUG1, "nothing to do\n");
  }
  else
  {
    menu->tag_prefix = true;
  }
 
  menu_set_prefix(menu);
  return FR_SUCCESS;
}

static int menu_abort(struct Menu *menu)
{
  menu->tag_prefix = false;
  menu_set_prefix(menu);
  return FR_SUCCESS;
}

static int menu_timeout(struct Menu *menu)
{
  menu_set_prefix(menu);
  return FR_SUCCESS;
}

static int menu_other(struct Menu *menu)
{
  menu->tag_prefix = false;
  menu_set_prefix(menu);
  return FR_SUCCESS;
}

int menu_tagging_dispatcher(struct MuttWindow *win, const struct KeyEvent *event)
{
  if (!win || !win->wdata || !event)
  {
    dispatcher_flush_on_error(FR_ERROR);
    return FR_ERROR;
  }
 
  struct Menu *menu = win->wdata;
  const int op = event->op;
  int rc = FR_UNKNOWN;
 
  switch (op)
  {
    case OP_END_COND:
      rc = op_end_cond(menu, op);
      break;
    case OP_TAG:
      rc = op_tag(menu, op, event->count);
      break;
    case OP_TAG_PREFIX:
      rc = op_tag_prefix(menu, op);
      break;
    case OP_TAG_PREFIX_COND:
      rc = op_tag_prefix_cond(menu, op);
      break;
    case OP_ABORT:
      rc = menu_abort(menu);
      break;
    case OP_TIMEOUT:
      rc = menu_timeout(menu);
      break;
    default:
      rc = menu_other(menu);
      break;
  }
 
  dispatcher_flush_on_error(rc);
  return rc;
}