functions.c File Reference

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 "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 "mutt_mailbox.h"
#include "muttlib.h"
#include "mx.h"
#include "nntp/mdata.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
void	index_init_keys (struct SubMenu *sm_generic)
	Initialise the Index Keybindings - Implements ::init_keys_api.
static bool	resolve_email (struct IndexPrivateData *priv, struct IndexSharedData *shared, enum ResolveMethod rm)
	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	op_alias_dialog (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Open the aliases dialog - Implements index_function_t -.
static int	op_attach_edit_type (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Edit attachment content type - Implements index_function_t -.
static int	op_bounce_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Remail a message to another user - Implements index_function_t -.
static int	op_check_traditional (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Check for classic PGP - Implements index_function_t -.
static int	op_compose_to_sender (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Compose new message to the current message sender - Implements index_function_t -.
static int	op_create_alias (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Create an alias from a message sender - Implements index_function_t -.
static int	op_delete (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Delete the current entry - Implements index_function_t -.
static int	op_delete_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Delete all messages in thread - Implements index_function_t -.
static int	op_display_address (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Display full address of sender - Implements index_function_t -.
static int	op_display_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Display a message - Implements index_function_t -.
static int	op_edit_label (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Add, change, or delete a message's label - Implements index_function_t -.
static int	op_edit_raw_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, 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 IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	End of conditional execution (noop) - Implements index_function_t -.
static int	op_exit (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Exit this menu - Implements index_function_t -.
static int	op_extract_keys (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Extract supported public keys - Implements index_function_t -.
static int	op_flag_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Toggle a message's 'important' flag - Implements index_function_t -.
static int	op_forget_passphrase (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Wipe passphrases from memory - Implements index_function_t -.
static int	op_forward_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Forward a message with comments - Implements index_function_t -.
static int	op_group_reply (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Reply to all recipients - Implements index_function_t -.
static int	op_jump (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Jump to an index number - Implements index_function_t -.
static int	op_list_reply (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Reply to specified mailing list - Implements index_function_t -.
static int	op_list_subscribe (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Subscribe to a mailing list - Implements index_function_t -.
static int	op_list_unsubscribe (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Unsubscribe from mailing list - Implements index_function_t -.
static int	op_mail (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Compose a new mail message - Implements index_function_t -.
static int	op_mailbox_list (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	List mailboxes with new mail - Implements index_function_t -.
static int	op_mail_key (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Mail a PGP public key - Implements index_function_t -.
static int	op_main_break_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Break the thread in two - Implements index_function_t -.
static int	op_main_change_folder (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Open a different folder - Implements index_function_t -.
static int	op_main_collapse_all (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Collapse/uncollapse all threads - Implements index_function_t -.
static int	op_main_close_all_threads (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Collapse all threads - Implements index_function_t -.
static int	op_main_close_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Collapse current thread - Implements index_function_t -.
static int	op_main_collapse_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Collapse/uncollapse current thread - Implements index_function_t -.
static int	op_main_open_all_threads (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Open all threads - Implements index_function_t -.
static int	op_main_open_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Open current thread - Implements index_function_t -.
static int	op_main_delete_pattern (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Delete messages matching a pattern - Implements index_function_t -.
static int	op_main_limit (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Limit view to a pattern/thread - Implements index_function_t -.
static int	op_main_link_threads (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Link tagged message to the current one - Implements index_function_t -.
static int	op_main_modify_tags (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Modify (notmuch/imap) tags - Implements index_function_t -.
static int	op_main_next_new (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Jump to the next new message - Implements index_function_t -.
static int	op_main_next_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Jump to the next thread - Implements index_function_t -.
static int	op_main_next_undeleted (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Move to the next undeleted message - Implements index_function_t -.
static int	op_main_next_unread_mailbox (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Open next mailbox with unread mail - Implements index_function_t -.
static int	op_main_prev_undeleted (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Move to the previous undeleted message - Implements index_function_t -.
static int	op_main_quasi_delete (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Delete from NeoMutt, don't touch on disk - Implements index_function_t -.
static int	op_main_read_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Mark the current thread as read - Implements index_function_t -.
static int	op_main_root_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Jump to root message in thread - Implements index_function_t -.
static int	op_main_set_flag (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Set a status flag on a message - Implements index_function_t -.
static int	op_main_show_limit (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Show currently active limit pattern - Implements index_function_t -.
static int	op_main_sync_folder (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Save changes to mailbox - Implements index_function_t -.
static int	op_main_tag_pattern (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Tag messages matching a pattern - Implements index_function_t -.
static int	op_main_undelete_pattern (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Undelete messages matching a pattern - Implements index_function_t -.
static int	op_main_untag_pattern (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Untag messages matching a pattern - Implements index_function_t -.
static int	op_mark_msg (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Create a hotkey macro for the current message - Implements index_function_t -.
static int	op_next_entry (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Move to the next entry - Implements index_function_t -.
static int	op_pipe (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Pipe message/attachment to a shell command - Implements index_function_t -.
static int	op_prev_entry (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Move to the previous entry - Implements index_function_t -.
static int	op_print (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Print the current entry - Implements index_function_t -.
static int	op_query (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Query external program for addresses - Implements index_function_t -.
static int	op_quit (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Save changes to mailbox and quit - Implements index_function_t -.
static int	op_recall_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Recall a postponed message - Implements index_function_t -.
static int	op_reply (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Reply to a message - Implements index_function_t -.
static int	op_resend (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Use the current message as a template for a new one - Implements index_function_t -.
static int	op_save (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Make decrypted copy - Implements index_function_t -.
static int	op_search (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Search for a regular expression - Implements index_function_t -.
static int	op_sort (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Sort messages - Implements index_function_t -.
static int	op_tag (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Tag the current entry - Implements index_function_t -.
static int	op_tag_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Tag the current thread - Implements index_function_t -.
static int	op_toggle_new (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Toggle a message's 'new' flag - Implements index_function_t -.
static int	op_toggle_write (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Toggle whether the mailbox will be rewritten - Implements index_function_t -.
static int	op_undelete (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Undelete the current entry - Implements index_function_t -.
static int	op_undelete_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Undelete all messages in thread - Implements index_function_t -.
static int	op_view_attachments (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Show MIME attachments - Implements index_function_t -.
static int	op_autocrypt_acct_menu (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Manage autocrypt accounts - Implements index_function_t -.
static int	op_main_imap_fetch (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Force retrieval of mail from IMAP server - Implements index_function_t -.
static int	op_main_imap_logout_all (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Logout from all IMAP servers - Implements index_function_t -.
static int	op_catchup (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Mark all articles in newsgroup as read - Implements index_function_t -.
static int	op_get_children (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Get all children of the current message - Implements index_function_t -.
static int	op_get_message (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Get parent of the current message - Implements index_function_t -.
static int	op_main_change_group (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Open a different newsgroup - Implements index_function_t -.
static int	op_post (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Followup to newsgroup - Implements index_function_t -.
static int	op_main_entire_thread (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Read entire thread of the current message - Implements index_function_t -.
static int	op_main_vfolder_from_query (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Generate virtual folder from query - Implements index_function_t -.
static int	op_main_windowed_vfolder (struct IndexSharedData *shared, struct IndexPrivateData *priv, const struct KeyEvent *event)
	Shifts virtual folder time window - Implements index_function_t -.
static int	op_main_fetch_mail (struct IndexSharedData *shared, struct IndexPrivateData *priv, 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 -.

Variables
struct MenuDefinition *	MdIndex = NULL
	Index Menu Definition.
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 315 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 SubMenu *

sm_generic

)

Initialise the Index Keybindings - Implements ::init_keys_api.

Definition at line 326 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);
 
  MdIndex = md;
}

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 )

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

Return values

true	Resolve succeeded

Definition at line 349 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;
 
  int index = -1;
  switch (rm)
  {
    case RESOLVE_NEXT_EMAIL:
      index = menu_get_index(priv->menu) + 1;
      break;
 
    case RESOLVE_NEXT_UNDELETED:
    {
      const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
      index = find_next_undeleted(shared->mailbox_view, menu_get_index(priv->menu), uncollapse);
      break;
    }
 
    case RESOLVE_NEXT_THREAD:
      index = mutt_next_thread(shared->email);
      break;
 
    case RESOLVE_NEXT_SUBTHREAD:
      index = mutt_next_subthread(shared->email);
      break;
  }
 
  if ((index < 0) || (index >= shared->mailbox->vcount))
  {
    // Resolve failed
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    return false;
  }
 
  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 398 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:

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 3250 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:

Variable Documentation

MdIndex

struct MenuDefinition* MdIndex = NULL

Index Menu Definition.

Definition at line 80 of file functions.c.

OpIndex

const struct MenuFuncOp OpIndex[]

static

Functions for the Index Menu.

Definition at line 86 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
  { "exit",                          OP_EXIT },
  { "extract-keys",                  OP_EXTRACT_KEYS },
  { "fetch-mail",                    OP_MAIN_FETCH_MAIL },
  { "flag-message",                  OP_FLAG_MESSAGE },
  { "followup-message",              OP_FOLLOWUP },
  { "forget-passphrase",             OP_FORGET_PASSPHRASE },
  { "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-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 },
  { "print-message",                 OP_PRINT },
  { "purge-message",                 OP_PURGE_MESSAGE },
  { "purge-thread",                  OP_PURGE_THREAD },
  { "quasi-delete",                  OP_MAIN_QUASI_DELETE },
  { "query",                         OP_QUERY },
  { "quit",                          OP_QUIT },
  { "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 224 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_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 3299 of file functions.c.

                                                     {
  // clang-format off
  { OP_ALIAS_DIALOG,                     op_alias_dialog,             CHECK_NO_FLAGS },
  { 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_NO_FLAGS },
  { 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_NO_FLAGS },
  { OP_EXIT,                             op_exit,                     CHECK_NO_FLAGS },
  { 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_FORGET_PASSPHRASE,                op_forget_passphrase,        CHECK_NO_FLAGS },
  { 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_READONLY | CHECK_VISIBLE },
  { OP_GET_MESSAGE,                      op_get_message,              CHECK_ATTACH | CHECK_IN_MAILBOX | CHECK_READONLY },
  { 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_JUMP_1,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_2,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_3,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_4,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_5,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_6,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_7,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_8,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_JUMP_9,                           op_jump,                     CHECK_IN_MAILBOX },
  { OP_LIMIT_CURRENT_THREAD,             op_main_limit,               CHECK_IN_MAILBOX },
  { 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_NO_FLAGS },
  { 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_NO_FLAGS },
  { OP_MAIN_CHANGE_FOLDER_READONLY,      op_main_change_folder,       CHECK_NO_FLAGS },
  { OP_MAIN_CHANGE_GROUP,                op_main_change_group,        CHECK_NO_FLAGS },
  { OP_MAIN_CHANGE_GROUP_READONLY,       op_main_change_group,        CHECK_NO_FLAGS },
  { 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_NO_FLAGS },
  { OP_MAIN_IMAP_LOGOUT_ALL,             op_main_imap_logout_all,     CHECK_NO_FLAGS },
  { 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_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_NO_FLAGS },
  { 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_NO_FLAGS },
  { 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_NO_FLAGS },
  { OP_SORT_REVERSE,                     op_sort,                     CHECK_NO_FLAGS },
  { 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_NO_FLAGS },
#endif
#ifdef USE_NOTMUCH
  { OP_MAIN_CHANGE_VFOLDER,              op_main_change_folder,       CHECK_NO_FLAGS },
  { 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_NO_FLAGS },
  { OP_MAIN_VFOLDER_FROM_QUERY_READONLY, op_main_vfolder_from_query,  CHECK_NO_FLAGS },
  { 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_NO_FLAGS },
  // clang-format on
};