Index functions. More...

#include "config.h"
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "functions.h"
#include "lib.h"
#include "attach/lib.h"
#include "browser/lib.h"
#include "editor/lib.h"
#include "history/lib.h"
#include "hooks/lib.h"
#include "imap/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "mlist/lib.h"
#include "ncrypt/lib.h"
#include "nntp/lib.h"
#include "pager/lib.h"
#include "pattern/lib.h"
#include "pop/lib.h"
#include "progress/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "sidebar/lib.h"
#include "external.h"
#include "globals.h"
#include "module_data.h"
#include "mutt_mailbox.h"
#include "muttlib.h"
#include "mx.h"
#include "nntp/mdata.h"
#include "nntp/module_data.h"
#include "private_data.h"
#include "shared_data.h"
#include "autocrypt/lib.h"
#include "notmuch/lib.h"
#include <libintl.h>

Include dependency graph for functions.c:

Go to the source code of this file.

Enumerations
enum	ResolveMethod { RESOLVE_NEXT_EMAIL , RESOLVE_NEXT_UNDELETED , RESOLVE_NEXT_THREAD , RESOLVE_NEXT_SUBTHREAD }
	How to advance the cursor. More...

Functions
static int	op_jump (struct IndexFunctionData fdata, const struct KeyEvent event)
	Jump to an index number - Implements index_function_t -.

void	index_init_keys (struct NeoMutt n, struct SubMenu sm_generic)
	Initialise the Index Keybindings - Implements ::init_keys_api.

struct SubMenu *	index_get_submenu (void)
	Get the Index SubMenu.

static bool	resolve_email (struct IndexPrivateData priv, struct IndexSharedData shared, enum ResolveMethod rm, int count)
	Pick the next Email to advance the cursor to.

bool	index_next_undeleted (struct MuttWindow *win_index)
	Select the next undeleted Email (if possible)

static int	ea_add_selection (struct EmailArray ea, struct MailboxView mv, struct Email *e, bool use_tagged, int count)
	Build a working set of Emails for an action.

static struct MuttThread *	thread_target (struct Email *e, bool subthread)
	Get the thread/subthread target for an email.

static bool	ea_contains_thread_target (struct EmailArray ea, struct Email e, bool subthread)
	Does the array already include this thread target?

static int	ea_add_selection_threads (struct EmailArray ea, struct MailboxView mv, struct Email *e, bool use_tagged, bool subthread, int count)
	Build a working set of threads/subthreads.

static int	op_alias_dialog (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open the aliases dialog - Implements index_function_t -.

static int	op_attach_edit_type (struct IndexFunctionData fdata, const struct KeyEvent event)
	Edit attachment content type - Implements index_function_t -.

static int	op_bounce_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Remail a message to another user - Implements index_function_t -.

static int	op_check_traditional (struct IndexFunctionData fdata, const struct KeyEvent event)
	Check for classic PGP - Implements index_function_t -.

static int	op_compose_to_sender (struct IndexFunctionData fdata, const struct KeyEvent event)
	Compose new message to the current message sender - Implements index_function_t -.

static int	op_create_alias (struct IndexFunctionData fdata, const struct KeyEvent event)
	Create an alias from a message sender - Implements index_function_t -.

static int	op_delete (struct IndexFunctionData fdata, const struct KeyEvent event)
	Delete the current entry - Implements index_function_t -.

static void	update_thread_email (struct IndexPrivateData priv, struct Email email)
	Focus a visible email in the current thread.

static int	op_main_change_thread (struct IndexFunctionData fdata, struct EmailArray ea, enum CollapseMode mode)
	Open/close/collapse a working set of threads.

static int	op_delete_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Delete all messages in thread - Implements index_function_t -.

static int	op_display_address (struct IndexFunctionData fdata, const struct KeyEvent event)
	Display full address of sender - Implements index_function_t -.

static int	op_display_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Display a message - Implements index_function_t -.

static int	op_edit_label (struct IndexFunctionData fdata, const struct KeyEvent event)
	Add, change, or delete a message's label - Implements index_function_t -.

static int	op_edit_raw_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Edit the raw message (edit and edit-raw-message are synonyms) - Implements index_function_t -.

static int	op_end_cond (struct IndexFunctionData fdata, const struct KeyEvent event)
	End of conditional execution (noop) - Implements index_function_t -.

static int	op_exit (struct IndexFunctionData fdata, const struct KeyEvent event)
	Exit this menu - Implements index_function_t -.

static int	op_extract_keys (struct IndexFunctionData fdata, const struct KeyEvent event)
	Extract supported public keys - Implements index_function_t -.

static int	op_flag_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Toggle a message's 'important' flag - Implements index_function_t -.

static int	op_forward_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Forward a message with comments - Implements index_function_t -.

static int	op_group_reply (struct IndexFunctionData fdata, const struct KeyEvent event)
	Reply to all recipients - Implements index_function_t -.

static int	op_list_action (struct IndexFunctionData fdata, const struct KeyEvent event)
	Show mailing-list actions - Implements index_function_t -.

static int	op_list_reply (struct IndexFunctionData fdata, const struct KeyEvent event)
	Reply to specified mailing list - Implements index_function_t -.

static int	op_list_subscribe (struct IndexFunctionData fdata, const struct KeyEvent event)
	Subscribe to a mailing list - Implements index_function_t -.

static int	op_list_unsubscribe (struct IndexFunctionData fdata, const struct KeyEvent event)
	Unsubscribe from mailing list - Implements index_function_t -.

static int	op_mail (struct IndexFunctionData fdata, const struct KeyEvent event)
	Compose a new mail message - Implements index_function_t -.

static int	op_mailbox_list (struct IndexFunctionData fdata, const struct KeyEvent event)
	List mailboxes with new mail - Implements index_function_t -.

static int	op_mail_key (struct IndexFunctionData fdata, const struct KeyEvent event)
	Mail a PGP public key - Implements index_function_t -.

static int	op_main_break_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Break the thread in two - Implements index_function_t -.

static int	op_main_change_folder (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open a different folder - Implements index_function_t -.

static int	op_main_collapse_all (struct IndexFunctionData fdata, const struct KeyEvent event)
	Collapse/uncollapse all threads - Implements index_function_t -.

static int	op_main_close_all_threads (struct IndexFunctionData fdata, const struct KeyEvent event)
	Collapse all threads - Implements index_function_t -.

static int	op_main_close_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Collapse current thread - Implements index_function_t -.

static int	op_main_collapse_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Collapse/uncollapse current thread - Implements index_function_t -.

static int	op_main_open_all_threads (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open all threads - Implements index_function_t -.

static int	op_main_open_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open current thread - Implements index_function_t -.

static int	op_main_delete_pattern (struct IndexFunctionData fdata, const struct KeyEvent event)
	Delete messages matching a pattern - Implements index_function_t -.

static int	op_main_limit (struct IndexFunctionData fdata, const struct KeyEvent event)
	Limit view to a pattern/thread - Implements index_function_t -.

static int	op_main_link_threads (struct IndexFunctionData fdata, const struct KeyEvent event)
	Link tagged message to the current one - Implements index_function_t -.

static int	op_main_modify_tags (struct IndexFunctionData fdata, const struct KeyEvent event)
	Modify (notmuch/imap) tags - Implements index_function_t -.

static int	find_next_new_email (struct Mailbox *m, int start, bool forwards, int op)
	Jump to next new message - Implements index_function_t -.

static int	op_main_next_new (struct IndexFunctionData fdata, const struct KeyEvent event)

static int	op_main_next_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Jump to the next thread - Implements index_function_t -.

static int	op_main_next_undeleted (struct IndexFunctionData fdata, const struct KeyEvent event)
	Move to the next undeleted message - Implements index_function_t -.

static int	op_main_next_unread_mailbox (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open next mailbox with unread mail - Implements index_function_t -.

static int	op_main_prev_unread_mailbox (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open previous mailbox with unread mail - Implements index_function_t -.

static int	op_main_prev_undeleted (struct IndexFunctionData fdata, const struct KeyEvent event)
	Move to the previous undeleted message - Implements index_function_t -.

static int	op_main_quasi_delete (struct IndexFunctionData fdata, const struct KeyEvent event)
	Delete from NeoMutt, don't touch on disk - Implements index_function_t -.

static int	op_main_read_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Mark the current thread as read - Implements index_function_t -.

static int	op_main_root_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Jump to root message in thread - Implements index_function_t -.

static int	op_main_set_flag (struct IndexFunctionData fdata, const struct KeyEvent event)
	Set a status flag on a message - Implements index_function_t -.

static int	op_main_show_limit (struct IndexFunctionData fdata, const struct KeyEvent event)
	Show currently active limit pattern - Implements index_function_t -.

static int	op_main_sync_folder (struct IndexFunctionData fdata, const struct KeyEvent event)
	Save changes to mailbox - Implements index_function_t -.

static int	op_main_tag_pattern (struct IndexFunctionData fdata, const struct KeyEvent event)
	Tag messages matching a pattern - Implements index_function_t -.

static int	op_main_undelete_pattern (struct IndexFunctionData fdata, const struct KeyEvent event)
	Undelete messages matching a pattern - Implements index_function_t -.

static int	op_main_untag_pattern (struct IndexFunctionData fdata, const struct KeyEvent event)
	Untag messages matching a pattern - Implements index_function_t -.

static int	op_mark_msg (struct IndexFunctionData fdata, const struct KeyEvent event)
	Create a hotkey macro for the current message - Implements index_function_t -.

static int	op_next_entry (struct IndexFunctionData fdata, const struct KeyEvent event)
	Move to the next entry - Implements index_function_t -.

static int	op_pipe (struct IndexFunctionData fdata, const struct KeyEvent event)
	Pipe message/attachment to a shell command - Implements index_function_t -.

static int	op_prev_entry (struct IndexFunctionData fdata, const struct KeyEvent event)
	Move to the previous entry - Implements index_function_t -.

static int	op_print (struct IndexFunctionData fdata, const struct KeyEvent event)
	Print the current entry - Implements index_function_t -.

static int	op_query (struct IndexFunctionData fdata, const struct KeyEvent event)
	Query external program for addresses - Implements index_function_t -.

static int	op_quit (struct IndexFunctionData fdata, const struct KeyEvent event)
	Save changes to mailbox and quit - Implements index_function_t -.

static int	op_recall_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Recall a postponed message - Implements index_function_t -.

static int	op_reply (struct IndexFunctionData fdata, const struct KeyEvent event)
	Reply to a message - Implements index_function_t -.

static int	op_resend (struct IndexFunctionData fdata, const struct KeyEvent event)
	Use the current message as a template for a new one - Implements index_function_t -.

static int	op_save (struct IndexFunctionData fdata, const struct KeyEvent event)
	Make decrypted copy - Implements index_function_t -.

static int	op_search (struct IndexFunctionData fdata, const struct KeyEvent event)
	Search for a regular expression - Implements index_function_t -.

static int	op_sort (struct IndexFunctionData fdata, const struct KeyEvent event)
	Sort messages - Implements index_function_t -.

static int	op_tag (struct IndexFunctionData fdata, const struct KeyEvent event)
	Tag the current entry - Implements index_function_t -.

static int	op_tag_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Tag the current thread - Implements index_function_t -.

static int	op_toggle_new (struct IndexFunctionData fdata, const struct KeyEvent event)
	Toggle a message's 'new' flag - Implements index_function_t -.

static int	op_toggle_write (struct IndexFunctionData fdata, const struct KeyEvent event)
	Toggle whether the mailbox will be rewritten - Implements index_function_t -.

static int	op_undelete (struct IndexFunctionData fdata, const struct KeyEvent event)
	Undelete the current entry - Implements index_function_t -.

static int	op_undelete_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Undelete all messages in thread - Implements index_function_t -.

static int	op_view_attachments (struct IndexFunctionData fdata, const struct KeyEvent event)
	Show MIME attachments - Implements index_function_t -.

static int	op_autocrypt_acct_menu (struct IndexFunctionData fdata, const struct KeyEvent event)
	Manage autocrypt accounts - Implements index_function_t -.

static int	op_main_imap_fetch (struct IndexFunctionData fdata, const struct KeyEvent event)
	Force retrieval of mail from IMAP server - Implements index_function_t -.

static int	op_main_imap_logout_all (struct IndexFunctionData fdata, const struct KeyEvent event)
	Logout from all IMAP servers - Implements index_function_t -.

static int	op_catchup (struct IndexFunctionData fdata, const struct KeyEvent event)
	Mark all articles in newsgroup as read - Implements index_function_t -.

static int	op_get_children (struct IndexFunctionData fdata, const struct KeyEvent event)
	Get all children of the current message - Implements index_function_t -.

static int	op_get_message (struct IndexFunctionData fdata, const struct KeyEvent event)
	Get parent of the current message - Implements index_function_t -.

static int	op_main_change_group (struct IndexFunctionData fdata, const struct KeyEvent event)
	Open a different newsgroup - Implements index_function_t -.

static int	op_post (struct IndexFunctionData fdata, const struct KeyEvent event)
	Followup to newsgroup - Implements index_function_t -.

static int	op_main_entire_thread (struct IndexFunctionData fdata, const struct KeyEvent event)
	Read entire thread of the current message - Implements index_function_t -.

static int	op_main_vfolder_from_query (struct IndexFunctionData fdata, const struct KeyEvent event)
	Generate virtual folder from query - Implements index_function_t -.

static int	op_main_windowed_vfolder (struct IndexFunctionData fdata, const struct KeyEvent event)
	Shifts virtual folder time window - Implements index_function_t -.

static int	op_main_fetch_mail (struct IndexFunctionData fdata, const struct KeyEvent event)
	Retrieve mail from POP server - Implements index_function_t -.

static bool	prereq (struct IndexSharedData shared, struct Menu menu, CheckFlags checks)
	Check the pre-requisites for a function.

int	index_function_dispatcher (struct MuttWindow win, const struct KeyEvent event)
	Perform an Index function - Implements function_dispatcher_t -.

struct MenuDefinition *	index_get_menu_definition (void)
	Get the Index Menu Definition.

Variables
static const struct MenuFuncOp	OpIndex []
	Functions for the Index Menu.

static const struct MenuOpSeq	IndexDefaultBindings []
	Key bindings for the Index Menu.

static const struct IndexFunction	IndexFunctions []
	All the NeoMutt functions that the Index supports.

Detailed Description

Index functions.

Authors

Pietro Cerutti
Richard Russon
Dennis Schön

Copyright: This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file functions.c.

Enumeration Type Documentation

◆ ResolveMethod

enum ResolveMethod

How to advance the cursor.

Enumerator
RESOLVE_NEXT_EMAIL	Next email, whatever its state.
RESOLVE_NEXT_UNDELETED	Next undeleted email.
RESOLVE_NEXT_THREAD	Next top-level thread.
RESOLVE_NEXT_SUBTHREAD	Next sibling sub-thread.

Definition at line 316 of file functions.c.

{
  RESOLVE_NEXT_EMAIL,     
  RESOLVE_NEXT_UNDELETED, 
  RESOLVE_NEXT_THREAD,    
  RESOLVE_NEXT_SUBTHREAD, 
};

Function Documentation

◆ index_init_keys()

void index_init_keys	(	struct NeoMutt *	n,
		struct SubMenu *	sm_generic )

Initialise the Index Keybindings - Implements ::init_keys_api.

Definition at line 327 of file functions.c.

{
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm_index = NULL;
  struct SubMenu *sm_sidebar = sidebar_get_submenu();
 
  sm_index = km_register_submenu(OpIndex);
  md = km_register_menu(MENU_INDEX, "index");
  km_menu_add_submenu(md, sm_index);
  km_menu_add_submenu(md, sm_sidebar);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, IndexDefaultBindings);
 
  struct IndexModuleData *mod_data = neomutt_get_module_data(n, MODULE_ID_INDEX);
  ASSERT(mod_data);
  mod_data->md_index = md;
  mod_data->sm_index = sm_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ index_get_submenu()

struct SubMenu * index_get_submenu ( void )

Get the Index SubMenu.

Return values

ptr	Index SubMenu

Definition at line 350 of file functions.c.

{
  struct IndexModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_INDEX);
  ASSERT(mod_data);
 
  return mod_data->sm_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_email()

static bool resolve_email	(	struct IndexPrivateData *	priv,
		struct IndexSharedData *	shared,
		enum ResolveMethod	rm,
		int	count )

static

Pick the next Email to advance the cursor to.

Parameters

priv	Private Index data
shared	Shared Index data
rm	How to advance the cursor, e.g. RESOLVE_NEXT_EMAIL
count	How many steps to advance (default 1)

Return values

true	Resolve succeeded

Definition at line 366 of file functions.c.

{
  if (!priv || !priv->menu || !shared || !shared->mailbox || !shared->email)
    return false;
 
  const bool c_resolve = cs_subset_bool(shared->sub, "resolve");
  if (!c_resolve)
    return false;
 
  count = MAX(count, 1);
  int index = menu_get_index(priv->menu);
 
  switch (rm)
  {
    case RESOLVE_NEXT_EMAIL:
      index = index + count;
      break;
 
    case RESOLVE_NEXT_UNDELETED:
    {
      const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
      for (int i = 0; i < count; i++)
      {
        int next = find_next_undeleted(shared->mailbox_view, index, uncollapse);
        if (next < 0)
          break;
        index = next;
      }
      break;
    }
 
    case RESOLVE_NEXT_THREAD:
      for (int i = 0; i < count; i++)
      {
        struct Email *e = mutt_get_virt_email(shared->mailbox, index);
        if (!e)
          break;
        int next = mutt_next_thread(e);
        if (next < 0)
          break;
        index = next;
      }
      break;
 
    case RESOLVE_NEXT_SUBTHREAD:
      for (int i = 0; i < count; i++)
      {
        struct Email *e = mutt_get_virt_email(shared->mailbox, index);
        if (!e)
          break;
        int next = mutt_next_subthread(e);
        if (next < 0)
          break;
        index = next;
      }
      break;
  }
 
  if (index < 0)
    index = 0;
  if (index >= shared->mailbox->vcount)
    index = shared->mailbox->vcount - 1;
 
  menu_set_index(priv->menu, index);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ index_next_undeleted()

bool index_next_undeleted ( struct MuttWindow * win_index )

Select the next undeleted Email (if possible)

Parameters

win_index Index Window

Return values

true	Selection succeeded

Definition at line 439 of file functions.c.

{
  struct MuttWindow *dlg = dialog_find(win_index);
  if (!dlg)
    return false;
 
  struct Menu *menu = win_index->wdata;
  struct IndexSharedData *shared = dlg->wdata;
  if (!shared)
    return false;
 
  struct IndexPrivateData *priv = win_index->parent->wdata;
  const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
 
  int index = find_next_undeleted(shared->mailbox_view, menu_get_index(menu), uncollapse);
  if ((index < 0) || (index >= shared->mailbox->vcount))
  {
    // Selection failed
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    return false;
  }
 
  menu_set_index(menu, index);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ea_add_selection()

static int ea_add_selection	(	struct EmailArray *	ea,
		struct MailboxView *	mv,
		struct Email *	e,
		bool	use_tagged,
		int	count )

static

Build a working set of Emails for an action.

Parameters

ea	Empty EmailArray to populate
mv	Current MailboxView
e	Current Email
use_tagged	Use tagged emails
count	Repeat-count (0 or 1 == just the current selection)

Return values

num	Number of selected emails
-1	Error

Definition at line 475 of file functions.c.

{
  if (!ea)
    return -1;
 
  if (use_tagged)
    return ea_add_tagged(ea, mv, e, true);
 
  if (!mv || !mv->mailbox || !e)
    return -1;
 
  const int index = e->vnum;
  if ((index < 0) || (index >= mv->mailbox->vcount))
    return -1;
 
  int n = (count > 1) ? count : 1;
  if ((index + n) > mv->mailbox->vcount)
    n = mv->mailbox->vcount - index;
 
  for (int i = 0; i < n; i++)
  {
    struct Email *sel = mutt_get_virt_email(mv->mailbox, index + i);
    if (sel)
      ea_add_tagged(ea, mv, sel, false);
  }
 
  return ARRAY_SIZE(ea);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ thread_target()

static struct MuttThread * thread_target	(	struct Email *	e,
		bool	subthread )

static

Get the thread/subthread target for an email.

Parameters

e	Email
subthread	If true, use the current subthread

Return values

ptr	Thread/subthread target

Definition at line 511 of file functions.c.

{
  if (!e || !e->thread)
    return NULL;
 
  struct MuttThread *thread = e->thread;
  if (!subthread)
  {
    while (thread->parent)
      thread = thread->parent;
  }
 
  return thread;
}

Here is the caller graph for this function:

◆ ea_contains_thread_target()

static bool ea_contains_thread_target	(	struct EmailArray *	ea,
		struct Email *	e,
		bool	subthread )

static

Does the array already include this thread target?

Parameters

ea	Selected emails
e	Candidate email
subthread	If true, compare subthreads instead of top-level threads

Return values

true	The target is already represented in the array

Definition at line 533 of file functions.c.

{
  if (!ea || !e)
    return false;
 
  struct MuttThread *target = thread_target(e, subthread);
  if (!target)
    return false;
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, ea)
  {
    if (thread_target(*ep, subthread) == target)
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ea_add_selection_threads()

static int ea_add_selection_threads	(	struct EmailArray *	ea,
		struct MailboxView *	mv,
		struct Email *	e,
		bool	use_tagged,
		bool	subthread,
		int	count )

static

Build a working set of threads/subthreads.

Parameters

ea	Empty EmailArray to populate
mv	Current MailboxView
e	Current Email
use_tagged	Use tagged emails
subthread	If true, act on subthreads
count	Repeat-count (0 or 1 == just the current thread/subthread)

Return values

num	Number of selected threads/subthreads
-1	Error

Definition at line 563 of file functions.c.

{
  if (!ea)
    return -1;
 
  if (!use_tagged)
  {
    if (!mv || !mv->mailbox || !e)
      return -1;
 
    const int index = e->vnum;
    if ((index < 0) || (index >= mv->mailbox->vcount))
      return -1;
 
    const int n = (count > 1) ? count : 1;
    for (int i = index; (i < mv->mailbox->vcount) && (ARRAY_SIZE(ea) < n); i++)
    {
      struct Email *sel = mutt_get_virt_email(mv->mailbox, i);
      if (!sel || ea_contains_thread_target(ea, sel, subthread))
        continue;
 
      ARRAY_ADD(ea, sel);
    }
    return ARRAY_SIZE(ea);
  }
 
  if (!mv || !mv->mailbox || !mv->mailbox->emails)
    return -1;
 
  struct Mailbox *m = mv->mailbox;
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *et = m->emails[i];
    if (!et)
      break;
    if (!message_is_tagged(et))
      continue;
 
    if (!ea_contains_thread_target(ea, et, subthread))
      ARRAY_ADD(ea, et);
  }
 
  return ARRAY_SIZE(ea);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_thread_email()

static void update_thread_email	(	struct IndexPrivateData *	priv,
		struct Email *	email )

static

Focus a visible email in the current thread.

Parameters

priv	Index private data
email	Current email

Definition at line 757 of file functions.c.

{
  if (!priv || !priv->menu || !email)
    return;
 
  int index = email->vnum;
  if (index < 0)
  {
    struct MuttThread *thread = thread_target(email, false);
    struct Email *e = find_virtual(thread, false);
    if (e)
      index = e->vnum;
  }
 
  if (index >= 0)
    menu_set_index(priv->menu, index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ op_main_change_thread()

static int op_main_change_thread	(	struct IndexFunctionData *	fdata,
		struct EmailArray *	ea,
		enum CollapseMode	mode )

static

Open/close/collapse a working set of threads.

Parameters

fdata	Index function data
ea	Working set of thread roots
mode	Collapse mode to apply

Return values

enum	FunctionRetval

Definition at line 782 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_ERROR;
  }
 
  if (!ea || ARRAY_EMPTY(ea))
    return FR_NO_ACTION;
 
  bool changed = false;
  bool blocked = false;
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, ea)
  {
    struct Email *e = *ep;
    if (!e)
      continue;
 
    switch (mode)
    {
      case COLLAPSE_MODE_OPEN:
        if (!e->collapsed)
          continue;
        mutt_uncollapse_thread(e);
        changed = true;
        break;
      case COLLAPSE_MODE_CLOSE:
        if (e->collapsed)
          continue;
        if (!mutt_thread_can_collapse(e))
        {
          blocked = true;
          continue;
        }
        mutt_collapse_thread(e);
        changed = true;
        break;
      case COLLAPSE_MODE_TOGGLE:
        if (e->collapsed)
        {
          mutt_uncollapse_thread(e);
          changed = true;
        }
        else if (mutt_thread_can_collapse(e))
        {
          mutt_collapse_thread(e);
          changed = true;
        }
        else
        {
          blocked = true;
        }
        break;
    }
  }
 
  if (!changed)
  {
    if (blocked)
    {
      mutt_warning(_("Thread contains unread or flagged messages"));
      return FR_ERROR;
    }
    return FR_NO_ACTION;
  }
 
  mutt_set_vnum(shared->mailbox);
  update_thread_email(priv, shared->email);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ op_main_next_new()

static int op_main_next_new	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Definition at line 2035 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
 
  const int saved_current = menu_get_index(priv->menu);
  const int op = event->op;
  const bool forwards = (op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_NEXT_UNREAD) ||
                        (op == OP_MAIN_NEXT_NEW_THEN_UNREAD);
  const int count = event->count;
 
  if (count > 0)
  {
    int cur = saved_current;
    int last_good = saved_current;
    for (int i = 0; i < count; i++)
    {
      int next = find_next_new_email(shared->mailbox, cur, forwards, op);
      if (next == -1)
        break;
      last_good = next;
      cur = next;
    }
    if (last_good != saved_current)
      menu_set_index(priv->menu, last_good);
    return FR_SUCCESS;
  }
 
  int index = find_next_new_email(shared->mailbox, saved_current, forwards, op);
 
  if (index == -1)
  {
    menu_set_index(priv->menu, saved_current);
    if ((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_PREV_NEW))
    {
      if (mview_has_limit(shared->mailbox_view))
        mutt_error(_("No new messages in this limited view"));
      else
        mutt_error(_("No new messages"));
    }
    else
    {
      if (mview_has_limit(shared->mailbox_view))
        mutt_error(_("No unread messages in this limited view"));
      else
        mutt_error(_("No unread messages"));
    }
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    return FR_ERROR;
  }
 
  menu_set_index(priv->menu, index);
 
  index = menu_get_index(priv->menu);
  if (forwards)
  {
    if (saved_current > index)
    {
      mutt_message(_("Search wrapped to top"));
    }
  }
  else if (saved_current < index)
  {
    mutt_message(_("Search wrapped to bottom"));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ prereq()

static bool prereq	(	struct IndexSharedData *	shared,
		struct Menu *	menu,
		CheckFlags	checks )

static

Check the pre-requisites for a function.

Parameters

shared	Index shared data
menu	Current Menu
checks	Checks to perform, see CheckFlags

Return values

true	The checks pass successfully

Definition at line 3846 of file functions.c.

{
  bool result = true;
  struct MailboxView *mv = shared->mailbox_view;
 
  if (checks & (CHECK_MSGCOUNT | CHECK_VISIBLE | CHECK_READONLY))
    checks |= CHECK_IN_MAILBOX;
 
  if ((checks & CHECK_IN_MAILBOX) && (!mv || !mv->mailbox))
  {
    mutt_error(_("No mailbox is open"));
    result = false;
  }
 
  if (result && (checks & CHECK_MSGCOUNT) && (mv->mailbox->msg_count == 0))
  {
    mutt_error(_("There are no messages"));
    result = false;
  }
 
  int index = menu_get_index(menu);
  if (result && (checks & CHECK_VISIBLE) &&
      ((index < 0) || (index >= mv->mailbox->vcount)))
  {
    mutt_error(_("No visible messages"));
    result = false;
  }
 
  if (result && (checks & CHECK_READONLY) && mv->mailbox->readonly)
  {
    mutt_error(_("Mailbox is read-only"));
    result = false;
  }
 
  if (result && (checks & CHECK_ATTACH) && shared->attach_msg)
  {
    mutt_error(_("Function not permitted in attach-message mode"));
    result = false;
  }
 
  if (!result)
    mutt_flushinp();
 
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ index_get_menu_definition()

struct MenuDefinition * index_get_menu_definition ( void )

Get the Index Menu Definition.

Return values

ptr	Index Menu Definition

Definition at line 4089 of file functions.c.

{
  struct IndexModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_INDEX);
  ASSERT(mod_data);
 
  return mod_data->md_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ OpIndex

const struct MenuFuncOp OpIndex[]

static

Functions for the Index Menu.

Definition at line 88 of file functions.c.

                                           { /* map: index */
  { "alias-dialog",                  OP_ALIAS_DIALOG },
#ifdef USE_AUTOCRYPT
  { "autocrypt-acct-menu",           OP_AUTOCRYPT_ACCT_MENU },
#endif
  { "bounce-message",                OP_BOUNCE_MESSAGE },
  { "break-thread",                  OP_MAIN_BREAK_THREAD },
  { "catchup",                       OP_CATCHUP },
  { "change-folder",                 OP_MAIN_CHANGE_FOLDER },
  { "change-folder-readonly",        OP_MAIN_CHANGE_FOLDER_READONLY },
  { "change-newsgroup",              OP_MAIN_CHANGE_GROUP },
  { "change-newsgroup-readonly",     OP_MAIN_CHANGE_GROUP_READONLY },
#ifdef USE_NOTMUCH
  { "change-vfolder",                OP_MAIN_CHANGE_VFOLDER },
#endif
  { "check-traditional-pgp",         OP_CHECK_TRADITIONAL },
  { "clear-flag",                    OP_MAIN_CLEAR_FLAG },
  { "close-all-threads",             OP_MAIN_CLOSE_ALL_THREADS },
  { "close-thread",                  OP_MAIN_CLOSE_THREAD },
  { "collapse-all",                  OP_MAIN_COLLAPSE_ALL },
  { "collapse-thread",               OP_MAIN_COLLAPSE_THREAD },
  { "compose-to-sender",             OP_COMPOSE_TO_SENDER },
  { "copy-message",                  OP_COPY_MESSAGE },
  { "create-alias",                  OP_CREATE_ALIAS },
  { "decode-copy",                   OP_DECODE_COPY },
  { "decode-save",                   OP_DECODE_SAVE },
  { "decrypt-copy",                  OP_DECRYPT_COPY },
  { "decrypt-save",                  OP_DECRYPT_SAVE },
  { "delete-message",                OP_DELETE },
  { "delete-pattern",                OP_MAIN_DELETE_PATTERN },
  { "delete-subthread",              OP_DELETE_SUBTHREAD },
  { "delete-thread",                 OP_DELETE_THREAD },
  { "display-address",               OP_DISPLAY_ADDRESS },
  { "display-message",               OP_DISPLAY_MESSAGE },
  { "display-toggle-weed",           OP_DISPLAY_HEADERS },
  { "edit",                          OP_EDIT_RAW_MESSAGE },
  { "edit-label",                    OP_EDIT_LABEL },
  { "edit-or-view-raw-message",      OP_EDIT_OR_VIEW_RAW_MESSAGE },
  { "edit-raw-message",              OP_EDIT_RAW_MESSAGE },
  { "edit-type",                     OP_ATTACH_EDIT_TYPE },
#ifdef USE_NOTMUCH
  { "entire-thread",                 OP_MAIN_ENTIRE_THREAD },
#endif
  { "extract-keys",                  OP_EXTRACT_KEYS },
  { "fetch-mail",                    OP_MAIN_FETCH_MAIL },
  { "flag-message",                  OP_FLAG_MESSAGE },
  { "followup-message",              OP_FOLLOWUP },
  { "forward-message",               OP_FORWARD_MESSAGE },
  { "forward-to-group",              OP_FORWARD_TO_GROUP },
  { "get-children",                  OP_GET_CHILDREN },
  { "get-message",                   OP_GET_MESSAGE },
  { "get-parent",                    OP_GET_PARENT },
  { "group-chat-reply",              OP_GROUP_CHAT_REPLY },
  { "group-reply",                   OP_GROUP_REPLY },
  { "imap-fetch-mail",               OP_MAIN_IMAP_FETCH },
  { "imap-logout-all",               OP_MAIN_IMAP_LOGOUT_ALL },
  { "limit",                         OP_MAIN_LIMIT },
  { "limit-current-thread",          OP_LIMIT_CURRENT_THREAD },
  { "link-threads",                  OP_MAIN_LINK_THREADS },
  { "list-action",                   OP_LIST_ACTION },
  { "list-reply",                    OP_LIST_REPLY },
  { "list-subscribe",                OP_LIST_SUBSCRIBE },
  { "list-unsubscribe",              OP_LIST_UNSUBSCRIBE },
  { "mail",                          OP_MAIL },
  { "mail-key",                      OP_MAIL_KEY },
  { "mailbox-list",                  OP_MAILBOX_LIST },
  { "mark-message",                  OP_MARK_MSG },
  { "modify-labels",                 OP_MAIN_MODIFY_TAGS },
  { "modify-labels-then-hide",       OP_MAIN_MODIFY_TAGS_THEN_HIDE },
  { "modify-tags",                   OP_MAIN_MODIFY_TAGS },
  { "modify-tags-then-hide",         OP_MAIN_MODIFY_TAGS_THEN_HIDE },
  { "next-new",                      OP_MAIN_NEXT_NEW },
  { "next-new-then-unread",          OP_MAIN_NEXT_NEW_THEN_UNREAD },
  { "next-subthread",                OP_MAIN_NEXT_SUBTHREAD },
  { "next-thread",                   OP_MAIN_NEXT_THREAD },
  { "next-undeleted",                OP_MAIN_NEXT_UNDELETED },
  { "next-unread",                   OP_MAIN_NEXT_UNREAD },
  { "next-unread-mailbox",           OP_MAIN_NEXT_UNREAD_MAILBOX },
  { "open-all-threads",              OP_MAIN_OPEN_ALL_THREADS },
  { "open-thread",                   OP_MAIN_OPEN_THREAD },
  { "parent-message",                OP_MAIN_PARENT_MESSAGE },
  { "pipe-entry",                    OP_PIPE },
  { "pipe-message",                  OP_PIPE },
  { "post-message",                  OP_POST },
  { "previous-new",                  OP_MAIN_PREV_NEW },
  { "previous-new-then-unread",      OP_MAIN_PREV_NEW_THEN_UNREAD },
  { "previous-subthread",            OP_MAIN_PREV_SUBTHREAD },
  { "previous-thread",               OP_MAIN_PREV_THREAD },
  { "previous-undeleted",            OP_MAIN_PREV_UNDELETED },
  { "previous-unread",               OP_MAIN_PREV_UNREAD },
  { "previous-unread-mailbox",       OP_MAIN_PREV_UNREAD_MAILBOX },
  { "print-message",                 OP_PRINT },
  { "purge-message",                 OP_PURGE_MESSAGE },
  { "purge-thread",                  OP_PURGE_THREAD },
  { "quasi-delete",                  OP_MAIN_QUASI_DELETE },
  { "query",                         OP_QUERY },
  { "read-subthread",                OP_MAIN_READ_SUBTHREAD },
  { "read-thread",                   OP_MAIN_READ_THREAD },
  { "recall-message",                OP_RECALL_MESSAGE },
  { "reconstruct-thread",            OP_RECONSTRUCT_THREAD },
  { "reply",                         OP_REPLY },
  { "resend-message",                OP_RESEND },
  { "root-message",                  OP_MAIN_ROOT_MESSAGE },
  { "save-message",                  OP_SAVE },
  { "set-flag",                      OP_MAIN_SET_FLAG },
  { "show-limit",                    OP_MAIN_SHOW_LIMIT },
  { "sort-mailbox",                  OP_SORT },
  { "sort-reverse",                  OP_SORT_REVERSE },
  { "sync-mailbox",                  OP_MAIN_SYNC_FOLDER },
  { "tag-pattern",                   OP_MAIN_TAG_PATTERN },
  { "tag-subthread",                 OP_TAG_SUBTHREAD },
  { "tag-thread",                    OP_TAG_THREAD },
  { "toggle-new",                    OP_TOGGLE_NEW },
  { "toggle-read",                   OP_TOGGLE_READ },
  { "toggle-write",                  OP_TOGGLE_WRITE },
  { "undelete-message",              OP_UNDELETE },
  { "undelete-pattern",              OP_MAIN_UNDELETE_PATTERN },
  { "undelete-subthread",            OP_UNDELETE_SUBTHREAD },
  { "undelete-thread",               OP_UNDELETE_THREAD },
  { "untag-pattern",                 OP_MAIN_UNTAG_PATTERN },
#ifdef USE_NOTMUCH
  { "vfolder-from-query",            OP_MAIN_VFOLDER_FROM_QUERY },
  { "vfolder-from-query-readonly",   OP_MAIN_VFOLDER_FROM_QUERY_READONLY },
  { "vfolder-window-backward",       OP_MAIN_WINDOWED_VFOLDER_BACKWARD },
  { "vfolder-window-forward",        OP_MAIN_WINDOWED_VFOLDER_FORWARD },
  { "vfolder-window-reset",          OP_MAIN_WINDOWED_VFOLDER_RESET },
#endif
  { "view-attachments",              OP_VIEW_ATTACHMENTS },
  { "view-raw-message",              OP_VIEW_RAW_MESSAGE },
  // Deprecated
  { "buffy-list",                    OP_MAILBOX_LIST, MFF_DEPRECATED },
  { NULL, 0 },
};

◆ IndexDefaultBindings

const struct MenuOpSeq IndexDefaultBindings[]

static

Key bindings for the Index Menu.

Definition at line 225 of file functions.c.

                                                       { /* map: index */
  { OP_ATTACH_EDIT_TYPE,                   "\005" },           // <Ctrl-E>
#ifdef USE_AUTOCRYPT
  { OP_AUTOCRYPT_ACCT_MENU,                "A" },
#endif
  { OP_BOUNCE_MESSAGE,                     "b" },
  { OP_CHECK_TRADITIONAL,                  "\033P" },          // <Alt-P>
  { OP_COPY_MESSAGE,                       "C" },
  { OP_CREATE_ALIAS,                       "a" },
  { OP_DECODE_COPY,                        "\033C" },          // <Alt-C>
  { OP_DECODE_SAVE,                        "\033s" },          // <Alt-s>
  { OP_DELETE,                             "d" },
  { OP_DELETE_SUBTHREAD,                   "\033d" },          // <Alt-d>
  { OP_DELETE_THREAD,                      "\004" },           // <Ctrl-D>
  { OP_DISPLAY_ADDRESS,                    "@" },
  { OP_DISPLAY_HEADERS,                    "h" },
  { OP_DISPLAY_MESSAGE,                    " " },              // <Space>
  { OP_DISPLAY_MESSAGE,                    "<keypadenter>" },
  { OP_DISPLAY_MESSAGE,                    "\n" },             // <Enter>
  { OP_DISPLAY_MESSAGE,                    "\r" },             // <Return>
  { OP_EDIT_LABEL,                         "Y" },
  { OP_EDIT_OR_VIEW_RAW_MESSAGE,           "e" },
  { OP_EXIT,                               "x" },
  { OP_EXTRACT_KEYS,                       "\013" },           // <Ctrl-K>
  { OP_FLAG_MESSAGE,                       "F" },
  { OP_FORGET_PASSPHRASE,                  "\006" },           // <Ctrl-F>
  { OP_FORWARD_MESSAGE,                    "f" },
  { OP_GROUP_REPLY,                        "g" },
  { OP_LIST_ACTION,                        "\033L" },          // <Alt-L>
  { OP_LIST_REPLY,                         "L" },
  { OP_MAIL,                               "m" },
  { OP_MAILBOX_LIST,                       "." },
  { OP_MAIL_KEY,                           "\033k" },          // <Alt-k>
  { OP_MAIN_BREAK_THREAD,                  "#" },
  { OP_MAIN_CHANGE_FOLDER,                 "c" },
  { OP_MAIN_CHANGE_FOLDER_READONLY,        "\033c" },          // <Alt-c>
  { OP_MAIN_CHANGE_GROUP,                  "i" },
  { OP_MAIN_CHANGE_GROUP_READONLY,         "\033i" },          // <Alt-i>
  { OP_MAIN_CLEAR_FLAG,                    "W" },
  { OP_MAIN_COLLAPSE_ALL,                  "\033V" },          // <Alt-V>
  { OP_MAIN_COLLAPSE_THREAD,               "\033v" },          // <Alt-v>
  { OP_MAIN_DELETE_PATTERN,                "D" },
  { OP_MAIN_FETCH_MAIL,                    "G" },
  { OP_MAIN_LIMIT,                         "l" },
  { OP_MAIN_LINK_THREADS,                  "&" },
  { OP_MAIN_NEXT_NEW_THEN_UNREAD,          "\t" },             // <Tab>
  { OP_MAIN_NEXT_SUBTHREAD,                "\033n" },          // <Alt-n>
  { OP_MAIN_NEXT_THREAD,                   "\016" },           // <Ctrl-N>
  { OP_MAIN_NEXT_UNDELETED,                "<down>" },
  { OP_MAIN_NEXT_UNDELETED,                "j" },
  { OP_MAIN_PARENT_MESSAGE,                "P" },
  { OP_MAIN_PREV_NEW_THEN_UNREAD,          "\033\t" },         // <Alt-Tab>
  { OP_MAIN_PREV_SUBTHREAD,                "\033p" },          // <Alt-p>
  { OP_MAIN_PREV_THREAD,                   "\020" },           // <Ctrl-P>
  { OP_MAIN_PREV_UNDELETED,                "<up>" },
  { OP_MAIN_PREV_UNDELETED,                "k" },
  { OP_MAIN_READ_SUBTHREAD,                "\033r" },          // <Alt-r>
  { OP_MAIN_READ_THREAD,                   "\022" },           // <Ctrl-R>
  { OP_MAIN_SET_FLAG,                      "w" },
  { OP_MAIN_SHOW_LIMIT,                    "\033l" },          // <Alt-l>
  { OP_MAIN_SYNC_FOLDER,                   "$" },
  { OP_MAIN_TAG_PATTERN,                   "T" },
  { OP_MAIN_UNDELETE_PATTERN,              "U" },
  { OP_MAIN_UNTAG_PATTERN,                 "\024" },           // <Ctrl-T>
  { OP_MARK_MSG,                           "~" },
  { OP_NEXT_ENTRY,                         "J" },
  { OP_PIPE,                               "|" },
  { OP_PREV_ENTRY,                         "K" },
  { OP_PRINT,                              "p" },
  { OP_QUERY,                              "Q" },
  { OP_QUIT,                               "q" },
  { OP_RECALL_MESSAGE,                     "R" },
  { OP_REPLY,                              "r" },
  { OP_RESEND,                             "\033e" },          // <Alt-e>
  { OP_SAVE,                               "s" },
  { OP_SHOW_LOG_MESSAGES,                  "M" },
  { OP_SORT,                               "o" },
  { OP_SORT_REVERSE,                       "O" },
  { OP_TAG_THREAD,                         "\033t" },          // <Alt-t>
  { OP_TOGGLE_NEW,                         "N" },
  { OP_TOGGLE_WRITE,                       "%" },
  { OP_UNDELETE,                           "u" },
  { OP_UNDELETE_SUBTHREAD,                 "\033u" },          // <Alt-u>
  { OP_UNDELETE_THREAD,                    "\025" },           // <Ctrl-U>
  { OP_VIEW_ATTACHMENTS,                   "v" },
  { 0, NULL },
};

◆ IndexFunctions

const struct IndexFunction IndexFunctions[]

static

All the NeoMutt functions that the Index supports.

Definition at line 3895 of file functions.c.

                                                     {
  // clang-format off
  { OP_ALIAS_DIALOG,                     op_alias_dialog,             CHECK_NONE },
  { OP_ATTACH_EDIT_TYPE,                 op_attach_edit_type,         CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_BOUNCE_MESSAGE,                   op_bounce_message,           CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_CATCHUP,                          op_catchup,                  CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY },
  { OP_CHECK_TRADITIONAL,                op_check_traditional,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_COMPOSE_TO_SENDER,                op_compose_to_sender,        CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_COPY_MESSAGE,                     op_save,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_CREATE_ALIAS,                     op_create_alias,             CHECK_NONE },
  { OP_DECODE_COPY,                      op_save,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_DECODE_SAVE,                      op_save,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_DECRYPT_COPY,                     op_save,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_DECRYPT_SAVE,                     op_save,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_DELETE,                           op_delete,                   CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_DELETE_SUBTHREAD,                 op_delete_thread,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_DELETE_THREAD,                    op_delete_thread,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_DISPLAY_ADDRESS,                  op_display_address,          CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_DISPLAY_HEADERS,                  op_display_message,          CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_DISPLAY_MESSAGE,                  op_display_message,          CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_EDIT_LABEL,                       op_edit_label,               CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_EDIT_OR_VIEW_RAW_MESSAGE,         op_edit_raw_message,         CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_EDIT_RAW_MESSAGE,                 op_edit_raw_message,         CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_END_COND,                         op_end_cond,                 CHECK_NONE },
  { OP_EXIT,                             op_exit,                     CHECK_NONE },
  { OP_EXTRACT_KEYS,                     op_extract_keys,             CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_FLAG_MESSAGE,                     op_flag_message,             CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_FOLLOWUP,                         op_post,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_FORWARD_MESSAGE,                  op_forward_message,          CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_FORWARD_TO_GROUP,                 op_post,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_GET_CHILDREN,                     op_get_children,             CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_GET_MESSAGE,                      op_get_message,              CHECK_ATTACH | CHECK_IN_MAILBOX },
  { OP_GET_PARENT,                       op_get_message,              CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_GENERIC_SELECT_ENTRY,             op_display_message,          CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_GROUP_CHAT_REPLY,                 op_group_reply,              CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_GROUP_REPLY,                      op_group_reply,              CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_JUMP,                             op_jump,                     CHECK_IN_MAILBOX },
  { OP_LIMIT_CURRENT_THREAD,             op_main_limit,               CHECK_IN_MAILBOX },
  { OP_LIST_ACTION,                      op_list_action,              CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_LIST_REPLY,                       op_list_reply,               CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_LIST_SUBSCRIBE,                   op_list_subscribe,           CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_LIST_UNSUBSCRIBE,                 op_list_unsubscribe,         CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIL,                             op_mail,                     CHECK_ATTACH },
  { OP_MAILBOX_LIST,                     op_mailbox_list,             CHECK_NONE },
  { OP_MAIL_KEY,                         op_mail_key,                 CHECK_ATTACH },
  { OP_MAIN_BREAK_THREAD,                op_main_break_thread,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_CHANGE_FOLDER,               op_main_change_folder,       CHECK_NONE },
  { OP_MAIN_CHANGE_FOLDER_READONLY,      op_main_change_folder,       CHECK_NONE },
  { OP_MAIN_CHANGE_GROUP,                op_main_change_group,        CHECK_NONE },
  { OP_MAIN_CHANGE_GROUP_READONLY,       op_main_change_group,        CHECK_NONE },
  { OP_MAIN_CLEAR_FLAG,                  op_main_set_flag,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_CLOSE_ALL_THREADS,           op_main_close_all_threads,   CHECK_IN_MAILBOX },
  { OP_MAIN_CLOSE_THREAD,                op_main_close_thread,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_COLLAPSE_ALL,                op_main_collapse_all,        CHECK_IN_MAILBOX },
  { OP_MAIN_COLLAPSE_THREAD,             op_main_collapse_thread,     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_DELETE_PATTERN,              op_main_delete_pattern,      CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_READONLY },
  { OP_MAIN_FETCH_MAIL,                  op_main_fetch_mail,          CHECK_ATTACH },
  { OP_MAIN_IMAP_FETCH,                  op_main_imap_fetch,          CHECK_NONE },
  { OP_MAIN_IMAP_LOGOUT_ALL,             op_main_imap_logout_all,     CHECK_NONE },
  { OP_MAIN_LIMIT,                       op_main_limit,               CHECK_IN_MAILBOX },
  { OP_MAIN_LINK_THREADS,                op_main_link_threads,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_MODIFY_TAGS,                 op_main_modify_tags,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_MODIFY_TAGS_THEN_HIDE,       op_main_modify_tags,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_NEXT_NEW,                    op_main_next_new,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_NEXT_NEW_THEN_UNREAD,        op_main_next_new,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_NEXT_SUBTHREAD,              op_main_next_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_NEXT_THREAD,                 op_main_next_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_NEXT_UNDELETED,              op_main_next_undeleted,      CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_NEXT_UNREAD,                 op_main_next_new,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_NEXT_UNREAD_MAILBOX,         op_main_next_unread_mailbox, CHECK_IN_MAILBOX },
  { OP_MAIN_PREV_UNREAD_MAILBOX,         op_main_prev_unread_mailbox, CHECK_IN_MAILBOX },
  { OP_MAIN_OPEN_ALL_THREADS,            op_main_open_all_threads,    CHECK_IN_MAILBOX },
  { OP_MAIN_OPEN_THREAD,                 op_main_open_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PARENT_MESSAGE,              op_main_root_message,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PREV_NEW,                    op_main_next_new,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PREV_NEW_THEN_UNREAD,        op_main_next_new,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PREV_SUBTHREAD,              op_main_next_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PREV_THREAD,                 op_main_next_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PREV_UNDELETED,              op_main_prev_undeleted,      CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_PREV_UNREAD,                 op_main_next_new,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_QUASI_DELETE,                op_main_quasi_delete,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_READ_SUBTHREAD,              op_main_read_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_READ_THREAD,                 op_main_read_thread,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_ROOT_MESSAGE,                op_main_root_message,        CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_SET_FLAG,                    op_main_set_flag,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_MAIN_SHOW_LIMIT,                  op_main_show_limit,          CHECK_IN_MAILBOX },
  { OP_MAIN_SYNC_FOLDER,                 op_main_sync_folder,         CHECK_NONE },
  { OP_MAIN_TAG_PATTERN,                 op_main_tag_pattern,         CHECK_IN_MAILBOX },
  { OP_MAIN_UNDELETE_PATTERN,            op_main_undelete_pattern,    CHECK_IN_MAILBOX | CHECK_READONLY },
  { OP_MAIN_UNTAG_PATTERN,               op_main_untag_pattern,       CHECK_IN_MAILBOX },
  { OP_MARK_MSG,                         op_mark_msg,                 CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_NEXT_ENTRY,                       op_next_entry,               CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_PIPE,                             op_pipe,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_POST,                             op_post,                     CHECK_ATTACH | CHECK_IN_MAILBOX },
  { OP_PREV_ENTRY,                       op_prev_entry,               CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_PRINT,                            op_print,                    CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_PURGE_MESSAGE,                    op_delete,                   CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_PURGE_THREAD,                     op_delete_thread,            CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_QUERY,                            op_query,                    CHECK_ATTACH },
  { OP_QUIT,                             op_quit,                     CHECK_NONE },
  { OP_RECALL_MESSAGE,                   op_recall_message,           CHECK_ATTACH },
  { OP_RECONSTRUCT_THREAD,               op_get_children,             CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_REPLY,                            op_reply,                    CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_RESEND,                           op_resend,                   CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_SAVE,                             op_save,                     CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_SEARCH,                           op_search,                   CHECK_IN_MAILBOX },
  { OP_SEARCH_NEXT,                      op_search,                   CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_SEARCH_OPPOSITE,                  op_search,                   CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_SEARCH_REVERSE,                   op_search,                   CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_SORT,                             op_sort,                     CHECK_NONE },
  { OP_SORT_REVERSE,                     op_sort,                     CHECK_NONE },
  { OP_TAG,                              op_tag,                      CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_TAG_SUBTHREAD,                    op_tag_thread,               CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_TAG_THREAD,                       op_tag_thread,               CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_TOGGLE_NEW,                       op_toggle_new,               CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_TOGGLE_READ,                      op_main_limit,               CHECK_IN_MAILBOX },
  { OP_TOGGLE_WRITE,                     op_toggle_write,             CHECK_IN_MAILBOX },
  { OP_UNDELETE,                         op_undelete,                 CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_UNDELETE_SUBTHREAD,               op_undelete_thread,          CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_UNDELETE_THREAD,                  op_undelete_thread,          CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_READONLY | CHECK_VISIBLE },
  { OP_VIEW_ATTACHMENTS,                 op_view_attachments,         CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_VIEW_RAW_MESSAGE,                 op_edit_raw_message,         CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
#ifdef USE_AUTOCRYPT
  { OP_AUTOCRYPT_ACCT_MENU,              op_autocrypt_acct_menu,      CHECK_NONE },
#endif
#ifdef USE_NOTMUCH
  { OP_MAIN_CHANGE_VFOLDER,              op_main_change_folder,       CHECK_NONE },
  { OP_MAIN_ENTIRE_THREAD,               op_main_entire_thread,       CHECK_IN_MAILBOX | CHECK_MSGCOUNT | CHECK_VISIBLE },
  { OP_MAIN_VFOLDER_FROM_QUERY,          op_main_vfolder_from_query,  CHECK_NONE },
  { OP_MAIN_VFOLDER_FROM_QUERY_READONLY, op_main_vfolder_from_query,  CHECK_NONE },
  { OP_MAIN_WINDOWED_VFOLDER_BACKWARD,   op_main_windowed_vfolder,    CHECK_IN_MAILBOX },
  { OP_MAIN_WINDOWED_VFOLDER_FORWARD,    op_main_windowed_vfolder,    CHECK_IN_MAILBOX },
  { OP_MAIN_WINDOWED_VFOLDER_RESET,      op_main_windowed_vfolder,    CHECK_IN_MAILBOX },
#endif
  { 0, NULL, CHECK_NONE },
  // clang-format on
};

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

◆ ResolveMethod

Function Documentation

◆ index_init_keys()

◆ index_get_submenu()

◆ resolve_email()

◆ index_next_undeleted()

◆ ea_add_selection()

◆ thread_target()

◆ ea_contains_thread_target()

◆ ea_add_selection_threads()

◆ update_thread_email()

◆ op_main_change_thread()

◆ op_main_next_new()

◆ prereq()

◆ index_get_menu_definition()

Variable Documentation

◆ OpIndex

◆ IndexDefaultBindings

◆ IndexFunctions