Alias Function API

Prototype for a Alias Function. More...

Collaboration diagram for Alias Function API:

Functions
static int	op_create_alias (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	create an alias from a message sender - Implements alias_function_t -
static int	op_delete (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	delete the current entry - Implements alias_function_t -
static int	op_quit (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	Save changes and exit this dialog - Implements alias_function_t -.
static int	op_jump (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	Jump to an index number - Implements alias_function_t -.
static int	op_generic_select_entry (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	select the current entry - Implements alias_function_t -
static int	op_mail (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	mail the selected entries - Implements alias_function_t -
static int	op_main_limit (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	show only messages matching a pattern - Implements alias_function_t -
static int	op_main_tag_pattern (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	Tag messages matching a pattern - Implements alias_function_t -.
static int	op_main_untag_pattern (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	Untag messages matching a pattern - Implements alias_function_t -.
static int	op_query (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	query external program for addresses - Implements alias_function_t -
static int	op_search (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	search for a regular expression - Implements alias_function_t -
static int	op_sort (struct AliasFunctionData *fdata, const struct KeyEvent *event)
	sort aliases - Implements alias_function_t -

Detailed Description

Prototype for a Alias Function.

Parameters

fdata	Alias Function context data
event	Event to process

Return values

enum	FunctionRetval

Precondition

fdata is not NULL

event is not NULL

Function Documentation

op_create_alias()

int op_create_alias ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

create an alias from a message sender - Implements alias_function_t -

Definition at line 148 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  struct Menu *menu = mdata->menu;
 
  if (menu->tag_prefix)
  {
    struct AddressList naddr = TAILQ_HEAD_INITIALIZER(naddr);
 
    struct AliasView *avp = NULL;
    ARRAY_FOREACH(avp, &mdata->ava)
    {
      if (!avp->is_tagged)
        continue;
 
      struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
      if (alias_to_addrlist(&al, avp->alias))
      {
        mutt_addrlist_copy(&naddr, &al, false);
        mutt_addrlist_clear(&al);
      }
    }
 
    alias_create(&naddr, mdata->sub);
    mutt_addrlist_clear(&naddr);
  }
  else
  {
    struct AliasView *av = ARRAY_GET(&mdata->ava, menu_get_index(menu));
    if (!av)
      return FR_NO_ACTION;
 
    struct AddressList al = TAILQ_HEAD_INITIALIZER(al);
    if (alias_to_addrlist(&al, av->alias))
    {
      alias_create(&al, mdata->sub);
      mutt_addrlist_clear(&al);
    }
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_delete()

int op_delete ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

delete the current entry - Implements alias_function_t -

This function handles:

• OP_DELETE
• OP_UNDELETE

Supports repeat-count: 5<delete-entry> deletes the current entry and the next 4. Overruns are silently capped at the end of the visible list.

Definition at line 270 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  struct Menu *menu = mdata->menu;
  const bool deleted = (event->op == OP_DELETE);
 
  struct AliasViewPtrArray avpa = ARRAY_HEAD_INITIALIZER;
  alias_add_selection(&avpa, mdata, menu->tag_prefix, event->count);
  if (ARRAY_EMPTY(&avpa))
  {
    ARRAY_FREE(&avpa);
    return FR_NO_ACTION;
  }
  alias_apply_set_deleted(&avpa, deleted);
  const int num = ARRAY_SIZE(&avpa);
  ARRAY_FREE(&avpa);
 
  if (menu->tag_prefix)
  {
    menu_queue_redraw(menu, MENU_REDRAW_INDEX);
  }
  else
  {
    const int index = menu_get_index(menu);
    menu_queue_redraw(menu, (num > 1) ? MENU_REDRAW_INDEX : MENU_REDRAW_CURRENT);
    const bool c_resolve = cs_subset_bool(mdata->sub, "resolve");
    if (c_resolve && ((index + num) < menu->max))
    {
      menu_set_index(menu, index + num);
      menu_queue_redraw(menu, MENU_REDRAW_INDEX);
    }
  }
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_quit()

int op_quit ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

Save changes and exit this dialog - Implements alias_function_t -.

Definition at line 308 of file functions.c.

{
  return FR_DONE;
}

Here is the caller graph for this function:

op_jump()

int op_jump ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

Jump to an index number - Implements alias_function_t -.

Definition at line 316 of file functions.c.

{
  int num = event->count;
 
  if (num == 0)
    return FR_NO_ACTION;
 
  struct AliasMenuData *mdata = fdata->wdata;
  struct Menu *menu = mdata->menu;
 
  if ((num < 1) || (num > menu->max))
  {
    mutt_warning(_("Invalid message number"));
    return FR_ERROR;
  }
 
  menu_set_index(menu, num - 1); // Num is 1-based
  return FR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_generic_select_entry()

int op_generic_select_entry ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

select the current entry - Implements alias_function_t -

Definition at line 388 of file functions.c.

{
  if (event->count > 0)
    return op_jump(fdata, event);
 
  return alias_select_entries(fdata->wdata, 0);
}

Here is the call graph for this function:

op_mail()

int op_mail ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

mail the selected entries - Implements alias_function_t -

Definition at line 399 of file functions.c.

{
  return alias_select_entries(fdata->wdata, event->count);
}

Here is the call graph for this function:

op_main_limit()

int op_main_limit ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

show only messages matching a pattern - Implements alias_function_t -

Definition at line 407 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  struct Menu *menu = mdata->menu;
  int rc = mutt_pattern_alias_func(_("Limit to addresses matching: "), mdata,
                                   PAA_VISIBLE, menu);
  if (rc != 0)
    return FR_NO_ACTION;
 
  alias_array_sort(&mdata->ava, mdata->sub);
  alias_set_title(mdata->sbar, mdata->title, mdata->limit);
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  window_redraw(NULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_tag_pattern()

int op_main_tag_pattern ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

Tag messages matching a pattern - Implements alias_function_t -.

Definition at line 427 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  struct Menu *menu = mdata->menu;
  int rc = mutt_pattern_alias_func(_("Tag addresses matching: "), mdata, PAA_TAG, menu);
  if (rc != 0)
    return FR_NO_ACTION;
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  window_redraw(NULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_untag_pattern()

int op_main_untag_pattern ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

Untag messages matching a pattern - Implements alias_function_t -.

Definition at line 444 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  struct Menu *menu = mdata->menu;
  int rc = mutt_pattern_alias_func(_("Untag addresses matching: "), mdata, PAA_UNTAG, menu);
  if (rc != 0)
    return FR_NO_ACTION;
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  window_redraw(NULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_query()

int op_query ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

query external program for addresses - Implements alias_function_t -

This function handles:

• OP_QUERY
• OP_QUERY_APPEND

Definition at line 465 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  struct Buffer *buf = mdata->query;
  if ((mw_get_field(_("Query: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(buf))
  {
    return FR_NO_ACTION;
  }
 
  const int op = event->op;
  if (op == OP_QUERY)
  {
    ARRAY_FREE(&mdata->ava);
    aliaslist_clear(mdata->aa);
  }
 
  struct Menu *menu = mdata->menu;
  struct AliasArray aa = ARRAY_HEAD_INITIALIZER;
 
  query_run(buf_string(buf), true, &aa, mdata->sub);
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  char title[256] = { 0 };
  snprintf(title, sizeof(title), "%s%s", _("Query: "), buf_string(buf));
  sbar_set_title(mdata->sbar, title);
 
  if (ARRAY_EMPTY(&aa))
  {
    if (op == OP_QUERY)
      menu->max = 0;
    return FR_NO_ACTION;
  }
 
  struct Alias **ap = NULL;
  ARRAY_FOREACH(ap, &aa)
  {
    alias_array_alias_add(&mdata->ava, *ap);
    ARRAY_ADD(mdata->aa, *ap); // Transfer
  }
  ARRAY_FREE(&aa); // Free the array structure but not the aliases
  alias_array_sort(&mdata->ava, mdata->sub);
  menu->max = ARRAY_SIZE(&mdata->ava);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_search()

int op_search ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

search for a regular expression - Implements alias_function_t -

This function handles:

• OP_SEARCH
• OP_SEARCH_NEXT
• OP_SEARCH_OPPOSITE
• OP_SEARCH_REVERSE

Definition at line 519 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  SearchFlags flags = SEARCH_NONE;
  switch (event->op)
  {
    case OP_SEARCH:
      flags |= SEARCH_PROMPT;
      mdata->search_state->reverse = false;
      break;
    case OP_SEARCH_REVERSE:
      flags |= SEARCH_PROMPT;
      mdata->search_state->reverse = true;
      break;
    case OP_SEARCH_NEXT:
      break;
    case OP_SEARCH_OPPOSITE:
      flags |= SEARCH_OPPOSITE;
      break;
    default:
      break;
  }
 
  struct Menu *menu = mdata->menu;
  int index = menu_get_index(menu);
  index = mutt_search_alias_command(menu, index, mdata->search_state, flags);
  if (index == -1)
    return FR_NO_ACTION;
 
  menu_set_index(menu, index);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_sort()

int op_sort ( struct AliasFunctionData * fdata, const struct KeyEvent * event )

static

sort aliases - Implements alias_function_t -

This function handles:

• OP_SORT
• OP_SORT_REVERSE

Definition at line 559 of file functions.c.

{
  struct AliasMenuData *mdata = fdata->wdata;
  int sort = cs_subset_sort(mdata->sub, "alias_sort");
  bool resort = true;
  const int op = event->op;
  bool reverse = (op == OP_SORT_REVERSE);
 
  switch (mw_multi_choice(reverse ?
                              /* L10N: The highlighted letters must match the "Sort" options */
                              _("Rev-Sort (a)lias, (n)ame, (e)mail or (u)nsorted?") :
                              /* L10N: The highlighted letters must match the "Rev-Sort" options */
                              _("Sort (a)lias, (n)ame, (e)mail or (u)nsorted?"),
                          /* L10N: These must match the highlighted letters from "Sort" and "Rev-Sort" */
                          _("aneu")))
  {
    case -1: /* abort */
      resort = false;
      break;
 
    case 1: /* (a)lias */
      sort = ALIAS_SORT_ALIAS;
      break;
 
    case 2: /* (n)ame */
      sort = ALIAS_SORT_NAME;
      break;
 
    case 3: /* (e)mail */
      sort = ALIAS_SORT_EMAIL;
      break;
 
    case 4: /* (u)nsorted */
      sort = ALIAS_SORT_UNSORTED;
      break;
 
    default:
      resort = false;
      break;
  }
 
  if (resort)
  {
    sort |= reverse ? SORT_REVERSE : 0;
 
    // This will trigger a WA_RECALC
    cs_subset_str_native_set(mdata->sub, "alias_sort", sort, NULL);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function: