Index Function API

Prototype for an Index Function. More...

Collaboration diagram for Index Function API:

Functions
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 -.

Detailed Description

Prototype for an Index Function.

Parameters

shared	Shared Index data
priv	Private Index data
event	Event to process

Return values

num	FunctionRetval or opcode, e.g. OP_JUMP

Precondition

shared is not NULL

priv is not NULL

event is not NULL

Function Documentation

op_alias_dialog()

static int op_alias_dialog ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Open the aliases dialog - Implements index_function_t -.

Definition at line 429 of file functions.c.

{
  alias_dialog(shared->mailbox, shared->sub);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_edit_type()

static int op_attach_edit_type ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Edit attachment content type - Implements index_function_t -.

Definition at line 439 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
  mutt_edit_content_type(shared->email, shared->email->body, NULL);
 
  menu_queue_redraw(priv->menu, MENU_REDRAW_CURRENT);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_bounce_message()

static int op_bounce_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Remail a message to another user - Implements index_function_t -.

Definition at line 453 of file functions.c.

{
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  index_bounce_message(shared->mailbox, &ea);
  ARRAY_FREE(&ea);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_check_traditional()

static int op_check_traditional ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Check for classic PGP - Implements index_function_t -.

Definition at line 467 of file functions.c.

{
  if (!(WithCrypto & APPLICATION_PGP))
    return FR_NOT_IMPL;
  if (!shared->email)
    return FR_NO_ACTION;
 
  if (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED))
  {
    struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
    ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    ARRAY_FREE(&ea);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_to_sender()

static int op_compose_to_sender ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Compose new message to the current message sender - Implements index_function_t -.

Definition at line 490 of file functions.c.

{
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  int rc = mutt_send_message(SEND_TO_SENDER, NULL, NULL, shared->mailbox, &ea,
                             shared->sub);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_create_alias()

static int op_create_alias ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Create an alias from a message sender - Implements index_function_t -.

Definition at line 506 of file functions.c.

{
  struct AddressList *al = NULL;
  if (shared->email && shared->email->env)
    al = mutt_get_address(shared->email->env, NULL);
  alias_create(al, shared->sub);
  menu_queue_redraw(priv->menu, MENU_REDRAW_CURRENT);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_delete()

static int op_delete ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Delete the current entry - Implements index_function_t -.

This function handles:

• OP_DELETE
• OP_PURGE_MESSAGE

Definition at line 525 of file functions.c.

{
  /* L10N: CHECK_ACL */
  if (!check_acl(shared->mailbox, MUTT_ACL_DELETE, _("Can't delete message")))
    return FR_ERROR;
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
 
  mutt_emails_set_flag(shared->mailbox, &ea, MUTT_DELETE, true);
  mutt_emails_set_flag(shared->mailbox, &ea, MUTT_PURGE, (event->op == OP_PURGE_MESSAGE));
  const bool c_delete_untag = cs_subset_bool(shared->sub, "delete_untag");
  if (c_delete_untag)
    mutt_emails_set_flag(shared->mailbox, &ea, MUTT_TAG, false);
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_delete_thread()

static int op_delete_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Delete all messages in thread - Implements index_function_t -.

This function handles:

• OP_DELETE_SUBTHREAD
• OP_DELETE_THREAD
• OP_PURGE_THREAD

Definition at line 562 of file functions.c.

{
  /* L10N: CHECK_ACL */
  /* L10N: Due to the implementation details we do not know whether we
     delete zero, 1, 12, ... messages. So in English we use
     "messages". Your language might have other means to express this. */
  if (!check_acl(shared->mailbox, MUTT_ACL_DELETE, _("Can't delete messages")))
    return FR_ERROR;
  if (!shared->email)
    return FR_NO_ACTION;
 
  const int op = event->op;
  int subthread = (op == OP_DELETE_SUBTHREAD);
  int rc = mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_DELETE, true, subthread);
  if (rc == -1)
    return FR_ERROR;
  if (op == OP_PURGE_THREAD)
  {
    rc = mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_PURGE, true, subthread);
    if (rc == -1)
      return FR_ERROR;
  }
 
  const bool c_delete_untag = cs_subset_bool(shared->sub, "delete_untag");
  if (c_delete_untag)
    mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_TAG, false, subthread);
 
  resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_display_address()

static int op_display_address ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Display full address of sender - Implements index_function_t -.

Definition at line 598 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
  mutt_display_address(shared->email->env);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_display_message()

static int op_display_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Display a message - Implements index_function_t -.

This function handles:

• OP_DISPLAY_HEADERS
• OP_DISPLAY_MESSAGE

Definition at line 615 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
 
  exec_message_hook(shared->mailbox, shared->email, CMD_MESSAGE_HOOK);
 
  int op = event->op;
  /* toggle the weeding of headers so that a user can press the key
   * again while reading the message.  */
  if (op == OP_DISPLAY_HEADERS)
  {
    bool_str_toggle(shared->sub, "weed", NULL);
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, shared);
    if (!window_is_focused(priv->win_index))
      return FR_SUCCESS;
  }
 
  OptNeedResort = false;
 
  if (mutt_using_threads() && shared->email->collapsed)
  {
    mutt_uncollapse_thread(shared->email);
    mutt_set_vnum(shared->mailbox);
    const bool c_uncollapse_jump = cs_subset_bool(shared->sub, "uncollapse_jump");
    if (c_uncollapse_jump)
      menu_set_index(priv->menu, mutt_thread_next_unread(shared->email));
  }
 
  const bool c_pgp_auto_decode = cs_subset_bool(shared->sub, "pgp_auto_decode");
  if (c_pgp_auto_decode &&
      (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED)))
  {
    struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
    ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    ARRAY_FREE(&ea);
  }
  const int index = menu_get_index(priv->menu);
  index_shared_data_set_email(shared, mutt_get_virt_email(shared->mailbox, index));
 
  const char *const c_pager = pager_get_pager(NeoMutt->sub);
  if (c_pager)
  {
    op = external_pager(shared->mailbox_view, shared->email, c_pager);
  }
  else
  {
    op = mutt_display_message(priv->win_index, shared);
  }
 
  window_set_focus(priv->win_index);
  if (op < OP_NULL)
  {
    OptNeedResort = false;
    return FR_ERROR;
  }
 
  if (shared->mailbox)
  {
    update_index(priv->menu, shared->mailbox_view, MX_STATUS_NEW_MAIL,
                 shared->mailbox->msg_count, shared);
  }
 
  return op;
}

Here is the call graph for this function:

op_edit_label()

static int op_edit_label ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Add, change, or delete a message's label - Implements index_function_t -.

Definition at line 687 of file functions.c.

{
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  int num_changed = mutt_label_message(shared->mailbox_view, &ea);
  ARRAY_FREE(&ea);
 
  if (num_changed > 0)
  {
    shared->mailbox->changed = true;
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    /* L10N: This is displayed when the x-label on one or more
       messages is edited. */
    mutt_message(ngettext("%d label changed", "%d labels changed", num_changed), num_changed);
 
    if (!priv->tag_prefix)
      resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
    return FR_SUCCESS;
  }
 
  /* L10N: This is displayed when editing an x-label, but no messages
     were updated.  Possibly due to canceling at the prompt or if the new
     label is the same as the old label. */
  mutt_message(_("No labels changed"));
  return FR_NO_ACTION;
}

Here is the call graph for this function:

op_edit_raw_message()

static int op_edit_raw_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Edit the raw message (edit and edit-raw-message are synonyms) - Implements index_function_t -.

This function handles:

• OP_EDIT_OR_VIEW_RAW_MESSAGE
• OP_EDIT_RAW_MESSAGE
• OP_VIEW_RAW_MESSAGE

Definition at line 723 of file functions.c.

{
  /* TODO split this into 3 cases? */
  bool edit;
  const int op = event->op;
  if (op == OP_EDIT_RAW_MESSAGE)
  {
    /* L10N: CHECK_ACL */
    if (!check_acl(shared->mailbox, MUTT_ACL_INSERT, _("Can't edit message")))
      return FR_ERROR;
    edit = true;
  }
  else if (op == OP_EDIT_OR_VIEW_RAW_MESSAGE)
  {
    edit = !shared->mailbox->readonly && (shared->mailbox->rights & MUTT_ACL_INSERT);
  }
  else
  {
    edit = false;
  }
 
  if (!shared->email)
    return FR_NO_ACTION;
  const bool c_pgp_auto_decode = cs_subset_bool(shared->sub, "pgp_auto_decode");
  if (c_pgp_auto_decode &&
      (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED)))
  {
    struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
    ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    ARRAY_FREE(&ea);
  }
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  mutt_ev_message(shared->mailbox, &ea, edit ? EVM_EDIT : EVM_VIEW);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_end_cond()

static int op_end_cond ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

End of conditional execution (noop) - Implements index_function_t -.

Definition at line 769 of file functions.c.

{
  return FR_SUCCESS;
}

op_exit()

static int op_exit ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Exit this menu - Implements index_function_t -.

Definition at line 778 of file functions.c.

{
  if (shared->attach_msg)
    return FR_DONE;
 
  if (query_quadoption(_("Exit NeoMutt without saving?"), shared->sub, "quit") == MUTT_YES)
  {
    if (shared->mailbox_view)
    {
      mx_fastclose_mailbox(shared->mailbox, false);
      mview_free(&shared->mailbox_view);
    }
    return FR_DONE;
  }
 
  return FR_NO_ACTION;
}

Here is the call graph for this function:

op_extract_keys()

static int op_extract_keys ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Extract supported public keys - Implements index_function_t -.

Definition at line 800 of file functions.c.

{
  if (!WithCrypto)
    return FR_NOT_IMPL;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  crypt_extract_keys_from_messages(shared->mailbox, &ea);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_flag_message()

static int op_flag_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Toggle a message's 'important' flag - Implements index_function_t -.

Definition at line 817 of file functions.c.

{
  /* L10N: CHECK_ACL */
  if (!check_acl(shared->mailbox, MUTT_ACL_WRITE, _("Can't flag message")))
    return FR_ERROR;
 
  struct Mailbox *m = shared->mailbox;
  if (priv->tag_prefix)
  {
    for (size_t i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (message_is_tagged(e))
        mutt_set_flag(m, e, MUTT_FLAG, !e->flagged, true);
    }
 
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    if (!shared->email)
      return FR_NO_ACTION;
    mutt_set_flag(m, shared->email, MUTT_FLAG, !shared->email->flagged, true);
 
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_forget_passphrase()

static int op_forget_passphrase ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Wipe passphrases from memory - Implements index_function_t -.

Definition at line 853 of file functions.c.

{
  crypt_forget_passphrase();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_forward_message()

static int op_forward_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Forward a message with comments - Implements index_function_t -.

Definition at line 863 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  const bool c_pgp_auto_decode = cs_subset_bool(shared->sub, "pgp_auto_decode");
  if (c_pgp_auto_decode &&
      (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED)))
  {
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  int rc = mutt_send_message(SEND_FORWARD, NULL, NULL, shared->mailbox, &ea,
                             shared->sub);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_group_reply()

static int op_group_reply ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Reply to all recipients - Implements index_function_t -.

This function handles:

• OP_GROUP_CHAT_REPLY
• OP_GROUP_REPLY

Definition at line 892 of file functions.c.

{
  SendFlags replyflags = SEND_REPLY;
  if (event->op == OP_GROUP_REPLY)
    replyflags |= SEND_GROUP_REPLY;
  else
    replyflags |= SEND_GROUP_CHAT_REPLY;
  if (!shared->email)
    return FR_NO_ACTION;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  const bool c_pgp_auto_decode = cs_subset_bool(shared->sub, "pgp_auto_decode");
  if (c_pgp_auto_decode &&
      (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED)))
  {
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  int rc = mutt_send_message(replyflags, NULL, NULL, shared->mailbox, &ea,
                             shared->sub);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_jump()

static int op_jump ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Jump to an index number - Implements index_function_t -.

Definition at line 922 of file functions.c.

{
  int rc = FR_ERROR;
  struct Buffer *buf = buf_pool_get();
 
  const int digit = event->op - OP_JUMP;
  if ((digit > 0) && (digit < 10))
  {
    mutt_unget_ch('0' + digit);
  }
 
  int msg_num = 0;
  if ((mw_get_field(_("Jump to message: "), buf, MUTT_COMP_NO_FLAGS, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(buf))
  {
    mutt_message(_("Nothing to do"));
    rc = FR_NO_ACTION;
  }
  else if (!mutt_str_atoi_full(buf_string(buf), &msg_num))
  {
    mutt_warning(_("Argument must be a message number"));
  }
  else if ((msg_num < 1) || (msg_num > shared->mailbox->msg_count))
  {
    mutt_warning(_("Invalid message number"));
  }
  else if (!shared->mailbox->emails[msg_num - 1] ||
           !shared->mailbox->emails[msg_num - 1]->visible)
  {
    mutt_warning(_("That message is not visible"));
  }
  else
  {
    struct Email *e = shared->mailbox->emails[msg_num - 1];
 
    if (mutt_messages_in_thread(shared->mailbox, e, MIT_POSITION) > 1)
    {
      mutt_uncollapse_thread(e);
      mutt_set_vnum(shared->mailbox);
    }
    menu_set_index(priv->menu, e->vnum);
    rc = FR_SUCCESS;
  }
 
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_list_reply()

static int op_list_reply ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Reply to specified mailing list - Implements index_function_t -.

Definition at line 974 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  const bool c_pgp_auto_decode = cs_subset_bool(shared->sub, "pgp_auto_decode");
  if (c_pgp_auto_decode &&
      (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED)))
  {
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  int rc = mutt_send_message(SEND_REPLY | SEND_LIST_REPLY, NULL, NULL,
                             shared->mailbox, &ea, shared->sub);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_list_subscribe()

static int op_list_subscribe ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Subscribe to a mailing list - Implements index_function_t -.

Definition at line 999 of file functions.c.

{
  return mutt_send_list_subscribe(shared->mailbox, shared->email) ? FR_SUCCESS : FR_NO_ACTION;
}

Here is the call graph for this function:

op_list_unsubscribe()

static int op_list_unsubscribe ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Unsubscribe from mailing list - Implements index_function_t -.

Definition at line 1008 of file functions.c.

{
  return mutt_send_list_unsubscribe(shared->mailbox, shared->email) ? FR_SUCCESS : FR_NO_ACTION;
}

Here is the call graph for this function:

op_mail()

static int op_mail ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Compose a new mail message - Implements index_function_t -.

Definition at line 1017 of file functions.c.

{
  int rc = mutt_send_message(SEND_NO_FLAGS, NULL, NULL, shared->mailbox, NULL,
                             shared->sub);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_mailbox_list()

static int op_mailbox_list ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

List mailboxes with new mail - Implements index_function_t -.

Definition at line 1029 of file functions.c.

{
  mutt_mailbox_list();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_mail_key()

static int op_mail_key ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Mail a PGP public key - Implements index_function_t -.

Definition at line 1039 of file functions.c.

{
  if (!(WithCrypto & APPLICATION_PGP))
    return FR_NOT_IMPL;
  int rc = mutt_send_message(SEND_KEY, NULL, NULL, NULL, NULL, shared->sub);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_main_break_thread()

static int op_main_break_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Break the thread in two - Implements index_function_t -.

Definition at line 1053 of file functions.c.

{
  struct Mailbox *m = shared->mailbox;
  /* L10N: CHECK_ACL */
  if (!check_acl(m, MUTT_ACL_WRITE, _("Can't break thread")))
    return FR_ERROR;
 
  struct Email *e = shared->email;
  if (!e)
    return FR_NO_ACTION;
 
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
 
  struct MailboxView *mv = shared->mailbox_view;
  if (!STAILQ_EMPTY(&e->env->in_reply_to) || !STAILQ_EMPTY(&e->env->references))
  {
    {
      mutt_break_thread(e);
      mutt_sort_headers(mv, true);
      menu_set_index(priv->menu, e->vnum);
    }
 
    m->changed = true;
    mutt_message(_("Thread broken"));
 
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    mutt_error(_("Thread can't be broken, message is not part of a thread"));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_change_folder()

static int op_main_change_folder ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Open a different folder - Implements index_function_t -.

This function handles:

• OP_MAIN_CHANGE_FOLDER
• OP_MAIN_CHANGE_FOLDER_READONLY
• OP_MAIN_CHANGE_VFOLDER

Definition at line 1101 of file functions.c.

{
  struct Buffer *folderbuf = buf_pool_get();
  buf_alloc(folderbuf, PATH_MAX);
 
  char *cp = NULL;
  bool read_only;
  const bool c_read_only = cs_subset_bool(shared->sub, "read_only");
  const int op = event->op;
  if (shared->attach_msg || c_read_only || (op == OP_MAIN_CHANGE_FOLDER_READONLY))
  {
    cp = _("Open mailbox in read-only mode");
    read_only = true;
  }
  else
  {
    cp = _("Open mailbox");
    read_only = false;
  }
 
  const bool c_change_folder_next = cs_subset_bool(shared->sub, "change_folder_next");
  if (c_change_folder_next && shared->mailbox && !buf_is_empty(&shared->mailbox->pathbuf))
  {
    buf_strcpy(folderbuf, mailbox_path(shared->mailbox));
    pretty_mailbox(folderbuf);
  }
  /* By default, fill buf with the next mailbox that contains unread mail */
  mutt_mailbox_next(shared->mailbox_view ? shared->mailbox : NULL, folderbuf);
 
  if (mw_enter_fname(cp, folderbuf, true, shared->mailbox, false, NULL, NULL,
                     MUTT_SEL_NO_FLAGS) == -1)
  {
    goto changefoldercleanup;
  }
 
  /* Selected directory is okay, let's save it. */
  mutt_browser_select_dir(buf_string(folderbuf));
 
  if (buf_is_empty(folderbuf))
  {
    msgwin_clear_text(NULL);
    goto changefoldercleanup;
  }
 
  struct Mailbox *m = mx_mbox_find2(buf_string(folderbuf));
  if (m)
  {
    change_folder_mailbox(priv->menu, m, &priv->oldcount, shared, read_only);
  }
  else
  {
    change_folder_string(priv->menu, folderbuf, &priv->oldcount, shared, read_only);
  }
 
changefoldercleanup:
  buf_pool_release(&folderbuf);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_collapse_all()

static int op_main_collapse_all ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Collapse/uncollapse all threads - Implements index_function_t -.

Definition at line 1166 of file functions.c.

{
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
  collapse_all(shared->mailbox_view, priv->menu, COLLAPSE_MODE_TOGGLE);
  notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_close_all_threads()

static int op_main_close_all_threads ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Collapse all threads - Implements index_function_t -.

Definition at line 1183 of file functions.c.

{
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
 
  if (!shared->mailbox_view || shared->mailbox_view->collapsed)
    return FR_NO_ACTION;
 
  collapse_all(shared->mailbox_view, priv->menu, COLLAPSE_MODE_CLOSE);
  notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_close_thread()

static int op_main_close_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Collapse current thread - Implements index_function_t -.

Definition at line 1205 of file functions.c.

{
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
 
  if (!shared->email || shared->email->collapsed)
    return FR_NO_ACTION;
 
  if (!mutt_thread_can_collapse(shared->email))
  {
    mutt_warning(_("Thread contains unread or flagged messages"));
    return FR_ERROR;
  }
 
  menu_set_index(priv->menu, mutt_collapse_thread(shared->email));
  mutt_set_vnum(shared->mailbox);
  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:

op_main_collapse_thread()

static int op_main_collapse_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Collapse/uncollapse current thread - Implements index_function_t -.

Definition at line 1233 of file functions.c.

{
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
 
  if (!shared->email)
    return FR_NO_ACTION;
 
  if (shared->email->collapsed)
  {
    int index = mutt_uncollapse_thread(shared->email);
    mutt_set_vnum(shared->mailbox);
    const bool c_uncollapse_jump = cs_subset_bool(shared->sub, "uncollapse_jump");
    if (c_uncollapse_jump)
      index = mutt_thread_next_unread(shared->email);
    menu_set_index(priv->menu, index);
  }
  else if (mutt_thread_can_collapse(shared->email))
  {
    menu_set_index(priv->menu, mutt_collapse_thread(shared->email));
    mutt_set_vnum(shared->mailbox);
  }
  else
  {
    mutt_error(_("Thread contains unread or flagged messages"));
    return FR_ERROR;
  }
 
  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:

op_main_open_all_threads()

static int op_main_open_all_threads ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Open all threads - Implements index_function_t -.

Definition at line 1275 of file functions.c.

{
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
 
  if (!shared->mailbox_view || !shared->mailbox_view->collapsed)
    return FR_NO_ACTION;
 
  collapse_all(shared->mailbox_view, priv->menu, COLLAPSE_MODE_OPEN);
  notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_open_thread()

static int op_main_open_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Open current thread - Implements index_function_t -.

Definition at line 1297 of file functions.c.

{
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_NO_ACTION;
  }
 
  if (!shared->email || !shared->email->collapsed)
    return FR_NO_ACTION;
 
  int index = mutt_uncollapse_thread(shared->email);
  mutt_set_vnum(shared->mailbox);
  const bool c_uncollapse_jump = cs_subset_bool(shared->sub, "uncollapse_jump");
  if (c_uncollapse_jump)
    index = mutt_thread_next_unread(shared->email);
  menu_set_index(priv->menu, index);
  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:

op_main_delete_pattern()

static int op_main_delete_pattern ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Delete messages matching a pattern - Implements index_function_t -.

Definition at line 1324 of file functions.c.

{
  /* L10N: CHECK_ACL */
  /* L10N: Due to the implementation details we do not know whether we
     delete zero, 1, 12, ... messages. So in English we use
     "messages". Your language might have other means to express this.  */
  if (!check_acl(shared->mailbox, MUTT_ACL_DELETE, _("Can't delete messages")))
    return FR_ERROR;
 
  mutt_pattern_func(shared->mailbox_view, MUTT_DELETE, _("Delete messages matching: "));
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_limit()

static int op_main_limit ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Limit view to a pattern/thread - Implements index_function_t -.

This function handles:

• OP_LIMIT_CURRENT_THREAD
• OP_MAIN_LIMIT
• OP_TOGGLE_READ

Definition at line 1348 of file functions.c.

{
  const bool lmt = mview_has_limit(shared->mailbox_view);
  int old_index = shared->email ? shared->email->index : -1;
  const int op = event->op;
  if (op == OP_TOGGLE_READ)
  {
    struct Buffer *buf2 = buf_pool_get();
 
    if (!lmt || !mutt_strn_equal(shared->mailbox_view->pattern, "!~R!~D~s", 8))
    {
      buf_printf(buf2, "!~R!~D~s%s", lmt ? shared->mailbox_view->pattern : ".*");
    }
    else
    {
      const char *pat = shared->mailbox_view->pattern + 8;
      if ((*pat == '\0') || mutt_strn_equal(pat, ".*", 2))
        buf_strcpy(buf2, "~A");
      else
        buf_strcpy(buf2, pat);
    }
    mutt_str_replace(&shared->mailbox_view->pattern, buf_string(buf2));
    buf_pool_release(&buf2);
    mutt_pattern_func(shared->mailbox_view, MUTT_LIMIT, NULL);
  }
 
  if (((op == OP_LIMIT_CURRENT_THREAD) &&
       mutt_limit_current_thread(shared->mailbox_view, shared->email)) ||
      (op == OP_TOGGLE_READ) ||
      ((op == OP_MAIN_LIMIT) && (mutt_pattern_func(shared->mailbox_view, MUTT_LIMIT,
                                                   _("Limit to messages matching: ")) == 0)))
  {
    priv->menu->max = shared->mailbox->vcount;
    menu_set_index(priv->menu, 0);
    if (old_index >= 0)
    {
      /* try to find what used to be the current message */
      for (size_t i = 0; i < shared->mailbox->vcount; i++)
      {
        struct Email *e = mutt_get_virt_email(shared->mailbox, i);
        if (!e)
          continue;
        if (e->index == old_index)
        {
          menu_set_index(priv->menu, i);
          break;
        }
      }
    }
 
    if ((shared->mailbox->msg_count != 0) && mutt_using_threads())
    {
      const bool c_collapse_all = cs_subset_bool(shared->sub, "collapse_all");
      if (c_collapse_all)
        collapse_all(shared->mailbox_view, priv->menu, COLLAPSE_MODE_CLOSE);
      mutt_draw_tree(shared->mailbox_view->threads);
    }
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  if (lmt)
    mutt_message(_("To view all messages, limit to \"all\""));
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_link_threads()

static int op_main_link_threads ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Link tagged message to the current one - Implements index_function_t -.

Definition at line 1418 of file functions.c.

{
  struct Mailbox *m = shared->mailbox;
  /* L10N: CHECK_ACL */
  if (!check_acl(m, MUTT_ACL_WRITE, _("Can't link threads")))
    return FR_ERROR;
 
  struct Email *e = shared->email;
  if (!e)
    return FR_NO_ACTION;
 
  enum FunctionRetval rc = FR_ERROR;
 
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    rc = FR_NO_ACTION;
  }
  else if (!e->env->message_id)
  {
    mutt_error(_("No Message-ID: header available to link thread"));
  }
  else
  {
    struct MailboxView *mv = shared->mailbox_view;
    struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
    ea_add_tagged(&ea, mv, NULL, true);
 
    if (mutt_link_threads(e, &ea, m))
    {
      mutt_sort_headers(mv, true);
      menu_set_index(priv->menu, e->vnum);
 
      m->changed = true;
      mutt_message(_("Threads linked"));
      rc = FR_SUCCESS;
    }
    else
    {
      mutt_error(_("No thread linked"));
      rc = FR_NO_ACTION;
    }
 
    ARRAY_FREE(&ea);
  }
 
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return rc;
}

Here is the call graph for this function:

op_main_modify_tags()

static int op_main_modify_tags ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Modify (notmuch/imap) tags - Implements index_function_t -.

This function handles:

• OP_MAIN_MODIFY_TAGS
• OP_MAIN_MODIFY_TAGS_THEN_HIDE

Definition at line 1476 of file functions.c.

{
  int rc = FR_ERROR;
  struct Buffer *buf = NULL;
 
  if (!shared->mailbox)
    goto done;
  struct Mailbox *m = shared->mailbox;
  if (!mx_tags_is_supported(m))
  {
    mutt_message(_("Folder doesn't support tagging, aborting"));
    goto done;
  }
  if (!shared->email)
  {
    rc = FR_NO_ACTION;
    goto done;
  }
 
  const int op = event->op;
  struct Buffer *tags = buf_pool_get();
  if (!priv->tag_prefix)
    driver_tags_get_with_hidden(&shared->email->tags, tags);
  /* Prompt the user to edit the tag string */
  buf = buf_pool_get();
  int rc2 = mx_tags_edit(m, buf_string(tags), buf);
  buf_pool_release(&tags);
  if (rc2 < 0)
  {
    goto done;
  }
  else if (rc2 == 0)
  {
    mutt_message(_("No tag specified, aborting"));
    goto done;
  }
 
  if (priv->tag_prefix)
  {
    /* Batch mode: apply the tag change to all tagged messages */
    struct Progress *progress = NULL;
 
    if (m->verbose)
    {
      progress = progress_new(MUTT_PROGRESS_WRITE, m->msg_tagged);
      progress_set_message(progress, _("Update tags..."));
    }
 
#ifdef USE_NOTMUCH
    if (m->type == MUTT_NOTMUCH)
      nm_db_longrun_init(m, true);
#endif
    for (int px = 0, i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (!message_is_tagged(e))
        continue;
 
      progress_update(progress, ++px, -1);
      mx_tags_commit(m, e, buf_string(buf));
      e->attr_color = NULL;
      if (op == OP_MAIN_MODIFY_TAGS_THEN_HIDE)
      {
        bool still_queried = false;
#ifdef USE_NOTMUCH
        if (m->type == MUTT_NOTMUCH)
          still_queried = nm_message_is_still_queried(m, e);
#endif
        e->quasi_deleted = !still_queried;
        m->changed = true;
      }
    }
    progress_free(&progress);
#ifdef USE_NOTMUCH
    if (m->type == MUTT_NOTMUCH)
      nm_db_longrun_done(m);
#endif
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    /* Single message mode: apply tag change to the current message only */
    if (mx_tags_commit(m, shared->email, buf_string(buf)))
    {
      mutt_message(_("Failed to modify tags, aborting"));
      goto done;
    }
    shared->email->attr_color = NULL;
    if (op == OP_MAIN_MODIFY_TAGS_THEN_HIDE)
    {
      bool still_queried = false;
#ifdef USE_NOTMUCH
      if (m->type == MUTT_NOTMUCH)
        still_queried = nm_message_is_still_queried(m, shared->email);
#endif
      shared->email->quasi_deleted = !still_queried;
      m->changed = true;
    }
 
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
  }
  rc = FR_SUCCESS;
 
done:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_main_next_new()

static int op_main_next_new ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Jump to the next new message - Implements index_function_t -.

This function handles:

• OP_MAIN_NEXT_NEW
• OP_MAIN_NEXT_NEW_THEN_UNREAD
• OP_MAIN_NEXT_UNREAD
• OP_MAIN_PREV_NEW
• OP_MAIN_PREV_NEW_THEN_UNREAD
• OP_MAIN_PREV_UNREAD

Definition at line 1598 of file functions.c.

{
  int first_unread = -1;
  int first_new = -1;
 
  const int saved_current = menu_get_index(priv->menu);
  int mcur = saved_current;
  int index = -1;
  const bool threaded = mutt_using_threads();
  const int op = event->op;
  /* Scan through all virtual messages in the mailbox, wrapping around.
   * Track the first new and first unread message found. */
  for (size_t i = 0; i != shared->mailbox->vcount; i++)
  {
    if ((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_NEXT_UNREAD) ||
        (op == OP_MAIN_NEXT_NEW_THEN_UNREAD))
    {
      mcur++;
      if (mcur > (shared->mailbox->vcount - 1))
      {
        mcur = 0;
      }
    }
    else
    {
      mcur--;
      if (mcur < 0)
      {
        mcur = shared->mailbox->vcount - 1;
      }
    }
 
    struct Email *e = mutt_get_virt_email(shared->mailbox, mcur);
    if (!e)
      break;
    if (e->collapsed && threaded)
    {
      int unread = mutt_thread_contains_unread(e);
      if ((unread != 0) && (first_unread == -1))
        first_unread = mcur;
      if ((unread == 1) && (first_new == -1))
        first_new = mcur;
    }
    else if (!e->deleted && !e->read)
    {
      if (first_unread == -1)
        first_unread = mcur;
      if (!e->old && (first_new == -1))
        first_new = mcur;
    }
 
    if (((op == OP_MAIN_NEXT_UNREAD) || (op == OP_MAIN_PREV_UNREAD)) && (first_unread != -1))
    {
      break;
    }
    if (((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_PREV_NEW) ||
         (op == OP_MAIN_NEXT_NEW_THEN_UNREAD) || (op == OP_MAIN_PREV_NEW_THEN_UNREAD)) &&
        (first_new != -1))
    {
      break;
    }
  }
  /* Select the best match based on the operation: prefer "new" for *_NEW ops,
   * fall back to "unread" for *_THEN_UNREAD ops */
  if (((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_PREV_NEW) ||
       (op == OP_MAIN_NEXT_NEW_THEN_UNREAD) || (op == OP_MAIN_PREV_NEW_THEN_UNREAD)) &&
      (first_new != -1))
  {
    index = first_new;
  }
  else if (((op == OP_MAIN_NEXT_UNREAD) || (op == OP_MAIN_PREV_UNREAD) ||
            (op == OP_MAIN_NEXT_NEW_THEN_UNREAD) || (op == OP_MAIN_PREV_NEW_THEN_UNREAD)) &&
           (first_unread != -1))
  {
    index = first_unread;
  }
 
  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;
  }
  else
  {
    menu_set_index(priv->menu, index);
  }
 
  index = menu_get_index(priv->menu);
  if ((op == OP_MAIN_NEXT_NEW) || (op == OP_MAIN_NEXT_UNREAD) ||
      (op == OP_MAIN_NEXT_NEW_THEN_UNREAD))
  {
    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:

op_main_next_thread()

static int op_main_next_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Jump to the next thread - Implements index_function_t -.

This function handles:

• OP_MAIN_NEXT_SUBTHREAD
• OP_MAIN_NEXT_THREAD
• OP_MAIN_PREV_SUBTHREAD
• OP_MAIN_PREV_THREAD

Definition at line 1727 of file functions.c.

{
  int index = -1;
  const int op = event->op;
  switch (op)
  {
    case OP_MAIN_NEXT_THREAD:
      index = mutt_next_thread(shared->email);
      break;
 
    case OP_MAIN_NEXT_SUBTHREAD:
      index = mutt_next_subthread(shared->email);
      break;
 
    case OP_MAIN_PREV_THREAD:
      index = mutt_previous_thread(shared->email);
      break;
 
    case OP_MAIN_PREV_SUBTHREAD:
      index = mutt_previous_subthread(shared->email);
      break;
  }
 
  if (index != -1)
    menu_set_index(priv->menu, index);
 
  if (index < 0)
  {
    if ((op == OP_MAIN_NEXT_THREAD) || (op == OP_MAIN_NEXT_SUBTHREAD))
      mutt_error(_("No more threads"));
    else
      mutt_error(_("You are on the first thread"));
 
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_next_undeleted()

static int op_main_next_undeleted ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Move to the next undeleted message - Implements index_function_t -.

Definition at line 1770 of file functions.c.

{
  int index = menu_get_index(priv->menu);
  if (index >= (shared->mailbox->vcount - 1))
  {
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    mutt_message(_("You are on the last message"));
    return FR_ERROR;
  }
 
  const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
 
  index = find_next_undeleted(shared->mailbox_view, index, uncollapse);
  if (index != -1)
  {
    menu_set_index(priv->menu, index);
    if (uncollapse)
      menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  if (index == -1)
  {
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    mutt_error(_("No undeleted messages"));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_next_unread_mailbox()

static int op_main_next_unread_mailbox ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Open next mailbox with unread mail - Implements index_function_t -.

Definition at line 1803 of file functions.c.

{
  struct Mailbox *m = shared->mailbox;
 
  struct Buffer *folderbuf = buf_pool_get();
  buf_strcpy(folderbuf, mailbox_path(m));
  m = mutt_mailbox_next_unread(m, folderbuf);
  buf_pool_release(&folderbuf);
 
  if (!m)
  {
    mutt_error(_("No mailboxes have new mail"));
    return FR_ERROR;
  }
 
  change_folder_mailbox(priv->menu, m, &priv->oldcount, shared, false);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_prev_undeleted()

static int op_main_prev_undeleted ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Move to the previous undeleted message - Implements index_function_t -.

Definition at line 1827 of file functions.c.

{
  int index = menu_get_index(priv->menu);
  if (index < 1)
  {
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    mutt_message(_("You are on the first message"));
    return FR_ERROR;
  }
 
  const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
 
  index = find_previous_undeleted(shared->mailbox_view, index, uncollapse);
  if (index != -1)
  {
    menu_set_index(priv->menu, index);
    if (uncollapse)
      menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  if (index == -1)
  {
    mutt_error(_("No undeleted messages"));
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_quasi_delete()

static int op_main_quasi_delete ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Delete from NeoMutt, don't touch on disk - Implements index_function_t -.

Definition at line 1860 of file functions.c.

{
  if (priv->tag_prefix)
  {
    struct Mailbox *m = shared->mailbox;
    for (size_t i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (message_is_tagged(e))
      {
        e->quasi_deleted = true;
        m->changed = true;
      }
    }
  }
  else
  {
    if (!shared->email)
      return FR_NO_ACTION;
    shared->email->quasi_deleted = true;
    shared->mailbox->changed = true;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_read_thread()

static int op_main_read_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Mark the current thread as read - Implements index_function_t -.

This function handles:

• OP_MAIN_READ_SUBTHREAD
• OP_MAIN_READ_THREAD

Definition at line 1896 of file functions.c.

{
  /* L10N: CHECK_ACL */
  /* L10N: Due to the implementation details we do not know whether we
     mark zero, 1, 12, ... messages as read. So in English we use
     "messages". Your language might have other means to express this. */
  if (!check_acl(shared->mailbox, MUTT_ACL_SEEN, _("Can't mark messages as read")))
    return FR_ERROR;
 
  const int op = event->op;
  int rc = mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_READ, true,
                                (op != OP_MAIN_READ_THREAD));
  if (rc != -1)
  {
    const enum ResolveMethod rm = (op == OP_MAIN_READ_THREAD) ? RESOLVE_NEXT_THREAD :
                                                                RESOLVE_NEXT_SUBTHREAD;
    resolve_email(priv, shared, rm);
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_root_message()

static int op_main_root_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Jump to root message in thread - Implements index_function_t -.

This function handles:

• OP_MAIN_PARENT_MESSAGE
• OP_MAIN_ROOT_MESSAGE

Definition at line 1927 of file functions.c.

{
  int index = mutt_parent_message(shared->email, event->op == OP_MAIN_ROOT_MESSAGE);
  if (index != -1)
    menu_set_index(priv->menu, index);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_set_flag()

static int op_main_set_flag ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Set a status flag on a message - Implements index_function_t -.

This function handles:

• OP_MAIN_CLEAR_FLAG
• OP_MAIN_SET_FLAG

Definition at line 1944 of file functions.c.

{
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
 
  if (mw_change_flag(shared->mailbox, &ea, (event->op == OP_MAIN_SET_FLAG)) == 0)
  {
    if (priv->tag_prefix)
    {
      menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    }
    else
    {
      resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
    }
  }
  ARRAY_FREE(&ea);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_show_limit()

static int op_main_show_limit ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Show currently active limit pattern - Implements index_function_t -.

Definition at line 1969 of file functions.c.

{
  if (mview_has_limit(shared->mailbox_view))
  {
    struct Buffer *buf = buf_pool_get();
    /* L10N: ask for a limit to apply */
    buf_printf(buf, _("Limit: %s"), shared->mailbox_view->pattern);
    mutt_message("%s", buf_string(buf));
    buf_pool_release(&buf);
  }
  else
  {
    mutt_message(_("No limit pattern is in effect"));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_sync_folder()

static int op_main_sync_folder ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Save changes to mailbox - Implements index_function_t -.

Definition at line 1991 of file functions.c.

{
  if (!shared->mailbox || (shared->mailbox->msg_count == 0) || shared->mailbox->readonly)
    return FR_NO_ACTION;
 
  int ovc = shared->mailbox->vcount;
  int oc = shared->mailbox->msg_count;
  struct Email *e = NULL;
 
  /* don't attempt to move the cursor if there are no visible messages in the current limit */
  int index = menu_get_index(priv->menu);
  if (index < shared->mailbox->vcount)
  {
    /* threads may be reordered, so figure out what header the cursor
     * should be on. */
    int newidx = index;
    if (!shared->email)
      return FR_NO_ACTION;
    if (shared->email->deleted)
      newidx = find_next_undeleted(shared->mailbox_view, index, false);
    if (newidx < 0)
      newidx = find_previous_undeleted(shared->mailbox_view, index, false);
    if (newidx >= 0)
      e = mutt_get_virt_email(shared->mailbox, newidx);
  }
 
  enum MxStatus check = mx_mbox_sync(shared->mailbox);
  if (check == MX_STATUS_OK)
  {
    if (e && (shared->mailbox->vcount != ovc))
    {
      for (size_t i = 0; i < shared->mailbox->vcount; i++)
      {
        struct Email *e2 = mutt_get_virt_email(shared->mailbox, i);
        if (e2 == e)
        {
          menu_set_index(priv->menu, i);
          break;
        }
      }
    }
    mutt_pattern_free(&shared->search_state->pattern);
  }
  else if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
  {
    update_index(priv->menu, shared->mailbox_view, check, oc, shared);
  }
 
  /* do a sanity check even if mx_mbox_sync failed.  */
 
  index = menu_get_index(priv->menu);
  if ((index < 0) || (shared->mailbox && (index >= shared->mailbox->vcount)))
  {
    menu_set_index(priv->menu, find_first_message(shared->mailbox_view));
  }
 
  /* check for a fatal error, or all messages deleted */
  if (shared->mailbox && buf_is_empty(&shared->mailbox->pathbuf))
  {
    mview_free(&shared->mailbox_view);
  }
 
  if (shared->mailbox)
  {
    priv->menu->max = shared->mailbox->vcount;
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
    struct EventMailbox ev_m = { shared->mailbox };
    notify_send(shared->mailbox->notify, NT_MAILBOX, NT_MAILBOX_CHANGE, &ev_m);
  }
  else
  {
    priv->menu->max = 0;
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_tag_pattern()

static int op_main_tag_pattern ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Tag messages matching a pattern - Implements index_function_t -.

Definition at line 2074 of file functions.c.

{
  mutt_pattern_func(shared->mailbox_view, MUTT_TAG, _("Tag messages matching: "));
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_undelete_pattern()

static int op_main_undelete_pattern ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Undelete messages matching a pattern - Implements index_function_t -.

Definition at line 2086 of file functions.c.

{
  /* L10N: CHECK_ACL */
  /* L10N: Due to the implementation details we do not know whether we
     undelete zero, 1, 12, ... messages. So in English we use
     "messages". Your language might have other means to express this. */
  if (!check_acl(shared->mailbox, MUTT_ACL_DELETE, _("Can't undelete messages")))
    return FR_ERROR;
 
  if (mutt_pattern_func(shared->mailbox_view, MUTT_UNDELETE,
                        _("Undelete messages matching: ")) == 0)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_untag_pattern()

static int op_main_untag_pattern ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Untag messages matching a pattern - Implements index_function_t -.

Definition at line 2109 of file functions.c.

{
  if (mutt_pattern_func(shared->mailbox_view, MUTT_UNTAG, _("Untag messages matching: ")) == 0)
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_mark_msg()

static int op_mark_msg ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Create a hotkey macro for the current message - Implements index_function_t -.

Definition at line 2121 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
 
  int rc = FR_SUCCESS;
 
  if (shared->email->env->message_id)
  {
    struct Buffer *buf = buf_pool_get();
 
    /* L10N: This is the prompt for <mark-message>.  Whatever they
       enter will be prefixed by $mark_macro_prefix and will become
       a macro hotkey to jump to the currently selected message. */
    if ((mw_get_field(_("Enter macro stroke: "), buf, MUTT_COMP_NO_FLAGS,
                      HC_OTHER, NULL, NULL) == 0) &&
        !buf_is_empty(buf))
    {
      const char *const c_mark_macro_prefix = cs_subset_string(shared->sub, "mark_macro_prefix");
      char str[256] = { 0 };
      snprintf(str, sizeof(str), "%s%s", c_mark_macro_prefix, buf_string(buf));
 
      struct Buffer *msg_id = buf_pool_get();
      mutt_file_sanitize_regex(msg_id, shared->email->env->message_id);
      char macro[256] = { 0 };
      snprintf(macro, sizeof(macro), "<search>~i '%s'\n", buf_string(msg_id));
      buf_pool_release(&msg_id);
 
      /* L10N: "message hotkey" is the key bindings menu description of a
         macro created by <mark-message>. */
      km_bind(MdIndex, str, OP_MACRO, macro, _("message hotkey"), NULL);
 
      /* L10N: This is echoed after <mark-message> creates a new hotkey
         macro.  %s is the hotkey string ($mark_macro_prefix followed
         by whatever they typed at the prompt.) */
      buf_printf(buf, _("Message bound to %s"), str);
      mutt_message("%s", buf_string(buf));
      mutt_debug(LL_DEBUG1, "Mark: %s => %s\n", str, macro);
    }
    buf_pool_release(&buf);
  }
  else
  {
    /* L10N: This error is printed if <mark-message> can't find a
       Message-ID for the currently selected message in the index. */
    mutt_error(_("No message ID to macro"));
    rc = FR_ERROR;
  }
 
  return rc;
}

Here is the call graph for this function:

op_next_entry()

static int op_next_entry ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Move to the next entry - Implements index_function_t -.

Definition at line 2177 of file functions.c.

{
  const int index = menu_get_index(priv->menu) + 1;
  if (index >= shared->mailbox->vcount)
  {
    mutt_message(_("You are on the last message"));
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    return FR_ERROR;
  }
  menu_set_index(priv->menu, index);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_pipe()

static int op_pipe ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Pipe message/attachment to a shell command - Implements index_function_t -.

Definition at line 2194 of file functions.c.

{
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  mutt_pipe_message(shared->mailbox, &ea);
  ARRAY_FREE(&ea);
 
  /* in an IMAP folder index with imap_peek=no, piping could change
   * new or old messages status to read. Redraw what's needed.  */
  const bool c_imap_peek = cs_subset_bool(shared->sub, "imap_peek");
  if ((shared->mailbox->type == MUTT_IMAP) && !c_imap_peek)
  {
    menu_queue_redraw(priv->menu, (priv->tag_prefix ? MENU_REDRAW_INDEX : MENU_REDRAW_CURRENT));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_prev_entry()

static int op_prev_entry ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Move to the previous entry - Implements index_function_t -.

Definition at line 2216 of file functions.c.

{
  int index = menu_get_index(priv->menu);
  if (index < 1)
  {
    notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    mutt_message(_("You are on the first message"));
    return FR_ERROR;
  }
  menu_set_index(priv->menu, index - 1);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_print()

static int op_print ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Print the current entry - Implements index_function_t -.

Definition at line 2233 of file functions.c.

{
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  mutt_print_message(shared->mailbox, &ea);
  ARRAY_FREE(&ea);
 
  /* in an IMAP folder index with imap_peek=no, printing could change
   * new or old messages status to read. Redraw what's needed.  */
  const bool c_imap_peek = cs_subset_bool(shared->sub, "imap_peek");
  if ((shared->mailbox->type == MUTT_IMAP) && !c_imap_peek)
  {
    menu_queue_redraw(priv->menu, (priv->tag_prefix ? MENU_REDRAW_INDEX : MENU_REDRAW_CURRENT));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_query()

static int op_query ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Query external program for addresses - Implements index_function_t -.

Definition at line 2255 of file functions.c.

{
  query_index(shared->mailbox, shared->sub);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_quit()

static int op_quit ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Save changes to mailbox and quit - Implements index_function_t -.

Definition at line 2265 of file functions.c.

{
  if (shared->attach_msg)
    return FR_DONE;
 
  if (query_quadoption(_("Quit NeoMutt?"), shared->sub, "quit") == MUTT_YES)
  {
    priv->oldcount = shared->mailbox ? shared->mailbox->msg_count : 0;
 
    exec_startup_shutdown_hook(CMD_SHUTDOWN_HOOK);
    mutt_debug(LL_NOTIFY, "NT_GLOBAL_SHUTDOWN\n");
    notify_send(NeoMutt->notify, NT_GLOBAL, NT_GLOBAL_SHUTDOWN, NULL);
 
    enum MxStatus check = MX_STATUS_OK;
    if (!shared->mailbox_view || ((check = mx_mbox_close(shared->mailbox)) == MX_STATUS_OK))
    {
      mview_free(&shared->mailbox_view);
      mailbox_free(&shared->mailbox);
      return FR_DONE;
    }
 
    if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
    {
      update_index(priv->menu, shared->mailbox_view, check, priv->oldcount, shared);
    }
 
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL); /* new mail arrived? */
    mutt_pattern_free(&shared->search_state->pattern);
  }
 
  return FR_NO_ACTION;
}

Here is the call graph for this function:

op_recall_message()

static int op_recall_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Recall a postponed message - Implements index_function_t -.

Definition at line 2302 of file functions.c.

{
  int rc = mutt_send_message(SEND_POSTPONED, NULL, NULL, shared->mailbox, NULL,
                             shared->sub);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_reply()

static int op_reply ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Reply to a message - Implements index_function_t -.

Definition at line 2314 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
  const bool c_pgp_auto_decode = cs_subset_bool(shared->sub, "pgp_auto_decode");
  if (c_pgp_auto_decode &&
      (priv->tag_prefix || !(shared->email->security & PGP_TRADITIONAL_CHECKED)))
  {
    if (mutt_check_traditional_pgp(shared->mailbox, &ea))
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  int rc = mutt_send_message(SEND_REPLY, NULL, NULL, shared->mailbox, &ea,
                             shared->sub);
  ARRAY_FREE(&ea);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_resend()

static int op_resend ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Use the current message as a template for a new one - Implements index_function_t -.

Definition at line 2339 of file functions.c.

{
  int rc = -1;
  if (priv->tag_prefix)
  {
    struct Mailbox *m = shared->mailbox;
    for (size_t i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (message_is_tagged(e))
        rc = mutt_resend_message(NULL, shared->mailbox, e, shared->sub);
    }
  }
  else
  {
    rc = mutt_resend_message(NULL, shared->mailbox, shared->email, shared->sub);
  }
 
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_save()

static int op_save ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Make decrypted copy - Implements index_function_t -.

This function handles:

• OP_COPY_MESSAGE
• OP_DECODE_COPY
• OP_DECODE_SAVE
• OP_DECRYPT_COPY
• OP_DECRYPT_SAVE
• OP_SAVE

Definition at line 2375 of file functions.c.

{
  const int op = event->op;
  if (((op == OP_DECRYPT_COPY) || (op == OP_DECRYPT_SAVE)) && !WithCrypto)
    return FR_NOT_IMPL;
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
 
  const enum MessageSaveOpt save_opt = ((op == OP_SAVE) || (op == OP_DECODE_SAVE) ||
                                        (op == OP_DECRYPT_SAVE)) ?
                                           SAVE_MOVE :
                                           SAVE_COPY;
 
  enum MessageTransformOpt transform_opt =
      ((op == OP_DECODE_SAVE) || (op == OP_DECODE_COPY))   ? TRANSFORM_DECODE :
      ((op == OP_DECRYPT_SAVE) || (op == OP_DECRYPT_COPY)) ? TRANSFORM_DECRYPT :
                                                             TRANSFORM_NONE;
 
  const int rc = mutt_save_message(shared->mailbox, &ea, save_opt, transform_opt);
  if ((rc == 0) && (save_opt == SAVE_MOVE) && !priv->tag_prefix)
  {
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
  }
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix)
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return (rc == -1) ? FR_ERROR : FR_SUCCESS;
}

Here is the call graph for this function:

op_search()

static int op_search ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Search for a regular expression - Implements index_function_t -.

This function handles:

• OP_SEARCH
• OP_SEARCH_NEXT
• OP_SEARCH_OPPOSITE
• OP_SEARCH_REVERSE

Definition at line 2417 of file functions.c.

{
  SearchFlags flags = SEARCH_NO_FLAGS;
  switch (event->op)
  {
    case OP_SEARCH:
      flags |= SEARCH_PROMPT;
      shared->search_state->reverse = false;
      break;
    case OP_SEARCH_REVERSE:
      flags |= SEARCH_PROMPT;
      shared->search_state->reverse = true;
      break;
    case OP_SEARCH_NEXT:
      break;
    case OP_SEARCH_OPPOSITE:
      flags |= SEARCH_OPPOSITE;
      break;
  }
 
  // Initiating a search can happen on an empty mailbox, but
  // searching for next/previous/... needs to be on a message and
  // thus a non-empty mailbox
  int index = menu_get_index(priv->menu);
  index = mutt_search_command(shared->mailbox_view, priv->menu, index,
                              shared->search_state, flags);
  if (index != -1)
    menu_set_index(priv->menu, index);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_sort()

static int op_sort ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Sort messages - Implements index_function_t -.

This function handles:

• OP_SORT
• OP_SORT_REVERSE

Definition at line 2457 of file functions.c.

{
  if (!mutt_select_sort(event->op == OP_SORT_REVERSE))
    return FR_ERROR;
 
  if (shared->mailbox && (shared->mailbox->msg_count != 0))
  {
    resort_index(shared->mailbox_view, priv->menu);
    mutt_pattern_free(&shared->search_state->pattern);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_tag()

static int op_tag ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Tag the current entry - Implements index_function_t -.

Definition at line 2475 of file functions.c.

{
  const bool c_auto_tag = cs_subset_bool(shared->sub, "auto_tag");
  if (priv->tag_prefix && !c_auto_tag)
  {
    struct Mailbox *m = shared->mailbox;
    for (size_t i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (e->visible)
        mutt_set_flag(m, e, MUTT_TAG, false, true);
    }
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    return FR_SUCCESS;
  }
 
  if (!shared->email)
    return FR_NO_ACTION;
 
  mutt_set_flag(shared->mailbox, shared->email, MUTT_TAG, !shared->email->tagged, true);
 
  resolve_email(priv, shared, RESOLVE_NEXT_EMAIL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_tag_thread()

static int op_tag_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Tag the current thread - Implements index_function_t -.

This function handles:

• OP_TAG_SUBTHREAD
• OP_TAG_THREAD

Definition at line 2510 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
 
  const int op = event->op;
  int rc = mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_TAG,
                                !shared->email->tagged, (op != OP_TAG_THREAD));
  if (rc != -1)
  {
    const enum ResolveMethod rm = (op == OP_TAG_THREAD) ? RESOLVE_NEXT_THREAD :
                                                          RESOLVE_NEXT_SUBTHREAD;
    resolve_email(priv, shared, rm);
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_toggle_new()

static int op_toggle_new ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Toggle a message's 'new' flag - Implements index_function_t -.

Definition at line 2533 of file functions.c.

{
  /* L10N: CHECK_ACL */
  if (!check_acl(shared->mailbox, MUTT_ACL_SEEN, _("Can't toggle new")))
    return FR_ERROR;
 
  struct Mailbox *m = shared->mailbox;
  if (priv->tag_prefix)
  {
    for (size_t i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      if (!message_is_tagged(e))
        continue;
 
      if (e->read || e->old)
        mutt_set_flag(m, e, MUTT_NEW, true, true);
      else
        mutt_set_flag(m, e, MUTT_READ, true, true);
    }
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    if (!shared->email)
      return FR_NO_ACTION;
    if (shared->email->read || shared->email->old)
      mutt_set_flag(m, shared->email, MUTT_NEW, true, true);
    else
      mutt_set_flag(m, shared->email, MUTT_READ, true, true);
 
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_toggle_write()

static int op_toggle_write ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Toggle whether the mailbox will be rewritten - Implements index_function_t -.

Definition at line 2576 of file functions.c.

{
  mx_toggle_write(shared->mailbox);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_undelete()

static int op_undelete ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Undelete the current entry - Implements index_function_t -.

Definition at line 2586 of file functions.c.

{
  /* L10N: CHECK_ACL */
  if (!check_acl(shared->mailbox, MUTT_ACL_DELETE, _("Can't undelete message")))
    return FR_ERROR;
 
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
 
  mutt_emails_set_flag(shared->mailbox, &ea, MUTT_DELETE, false);
  mutt_emails_set_flag(shared->mailbox, &ea, MUTT_PURGE, false);
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    resolve_email(priv, shared, RESOLVE_NEXT_EMAIL);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_undelete_thread()

static int op_undelete_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Undelete all messages in thread - Implements index_function_t -.

This function handles:

• OP_UNDELETE_SUBTHREAD
• OP_UNDELETE_THREAD

Definition at line 2619 of file functions.c.

{
  /* L10N: CHECK_ACL */
  /* L10N: Due to the implementation details we do not know whether we
     undelete zero, 1, 12, ... messages. So in English we use
     "messages". Your language might have other means to express this. */
  if (!check_acl(shared->mailbox, MUTT_ACL_DELETE, _("Can't undelete messages")))
    return FR_ERROR;
 
  const int op = event->op;
  int rc = mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_DELETE,
                                false, (op != OP_UNDELETE_THREAD));
  if (rc != -1)
  {
    rc = mutt_thread_set_flag(shared->mailbox, shared->email, MUTT_PURGE, false,
                              (op != OP_UNDELETE_THREAD));
  }
  if (rc != -1)
  {
    const enum ResolveMethod rm = (op == OP_UNDELETE_THREAD) ? RESOLVE_NEXT_THREAD :
                                                               RESOLVE_NEXT_SUBTHREAD;
    resolve_email(priv, shared, rm);
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_view_attachments()

static int op_view_attachments ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Show MIME attachments - Implements index_function_t -.

Definition at line 2651 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
 
  enum FunctionRetval rc = FR_ERROR;
  struct Message *msg = mx_msg_open(shared->mailbox, shared->email);
  if (msg)
  {
    dlg_attach(NeoMutt->sub, shared->mailbox_view, shared->email, msg->fp,
               shared->attach_msg);
    if (shared->email->attach_del)
    {
      shared->mailbox->changed = true;
    }
    mx_msg_close(shared->mailbox, &msg);
    rc = FR_SUCCESS;
  }
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return rc;
}

Here is the call graph for this function:

op_autocrypt_acct_menu()

static int op_autocrypt_acct_menu ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Manage autocrypt accounts - Implements index_function_t -.

Definition at line 2680 of file functions.c.

{
  dlg_autocrypt();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_imap_fetch()

static int op_main_imap_fetch ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Force retrieval of mail from IMAP server - Implements index_function_t -.

Definition at line 2691 of file functions.c.

{
  if (!shared->mailbox || (shared->mailbox->type != MUTT_IMAP))
    return FR_NO_ACTION;
 
  imap_check_mailbox(shared->mailbox, true);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_imap_logout_all()

static int op_main_imap_logout_all ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Logout from all IMAP servers - Implements index_function_t -.

Definition at line 2704 of file functions.c.

{
  if (shared->mailbox && (shared->mailbox->type == MUTT_IMAP))
  {
    const enum MxStatus check = mx_mbox_close(shared->mailbox);
    if (check == MX_STATUS_OK)
    {
      mview_free(&shared->mailbox_view);
    }
    else
    {
      if ((check == MX_STATUS_NEW_MAIL) || (check == MX_STATUS_REOPENED))
      {
        update_index(priv->menu, shared->mailbox_view, check, priv->oldcount, shared);
      }
      mutt_pattern_free(&shared->search_state->pattern);
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
      return FR_ERROR;
    }
  }
  imap_logout_all();
  mutt_message(_("Logged out of IMAP servers"));
  mutt_pattern_free(&shared->search_state->pattern);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_catchup()

static int op_catchup ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Mark all articles in newsgroup as read - Implements index_function_t -.

Definition at line 2737 of file functions.c.

{
  struct Mailbox *m = shared->mailbox;
  if (!m || (m->type != MUTT_NNTP))
    return FR_NO_ACTION;
 
  struct NntpMboxData *mdata = m->mdata;
  if (mutt_newsgroup_catchup(m, mdata->adata, mdata->group))
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_get_children()

static int op_get_children ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Get all children of the current message - Implements index_function_t -.

This function handles:

• OP_GET_CHILDREN
• OP_RECONSTRUCT_THREAD

Definition at line 2758 of file functions.c.

{
  struct Mailbox *m = shared->mailbox;
  if (m->type != MUTT_NNTP)
    return FR_ERROR;
 
  struct Email *e = shared->email;
  if (!e)
    return FR_NO_ACTION;
 
  char buf[PATH_MAX] = { 0 };
  int oldmsgcount = m->msg_count;
  int oldindex = e->index;
  int rc = 0;
 
  if (!e->env->message_id)
  {
    mutt_error(_("No Message-ID. Unable to perform operation."));
    return FR_ERROR;
  }
 
  mutt_message(_("Fetching message headers..."));
  if (!m->id_hash)
    m->id_hash = mutt_make_id_hash(m);
  mutt_str_copy(buf, e->env->message_id, sizeof(buf));
 
  const int op = event->op;
  /* trying to find msgid of the root message */
  if (op == OP_RECONSTRUCT_THREAD)
  {
    struct ListNode *ref = NULL;
    STAILQ_FOREACH(ref, &e->env->references, entries)
    {
      if (!mutt_hash_find(m->id_hash, ref->data))
      {
        rc = nntp_check_msgid(m, ref->data);
        if (rc < 0)
          return FR_ERROR;
      }
 
      /* the last msgid in References is the root message */
      if (!STAILQ_NEXT(ref, entries))
        mutt_str_copy(buf, ref->data, sizeof(buf));
    }
  }
 
  /* fetching all child messages */
  rc = nntp_check_children(m, buf);
 
  /* at least one message has been loaded */
  if (m->msg_count > oldmsgcount)
  {
    bool verbose = m->verbose;
 
    if (rc < 0)
      m->verbose = false;
 
    struct MailboxView *mv = shared->mailbox_view;
    mutt_sort_headers(mv, (op == OP_RECONSTRUCT_THREAD));
    m->verbose = verbose;
 
    /* if the root message was retrieved, move to it */
    struct Email *e2 = mutt_hash_find(m->id_hash, buf);
    if (e2)
    {
      menu_set_index(priv->menu, e2->vnum);
    }
    else
    {
      /* try to restore old position */
      for (int i = 0; i < m->msg_count; i++)
      {
        e2 = m->emails[i];
        if (!e2)
          break;
        if (e2->index == oldindex)
        {
          menu_set_index(priv->menu, e2->vnum);
          /* as an added courtesy, recenter the menu
           * with the current entry at the middle of the screen */
          menu_current_middle(priv->menu);
        }
      }
    }
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  }
  else if (rc >= 0)
  {
    mutt_error(_("No deleted messages found in the thread"));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_get_message()

static int op_get_message ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Get parent of the current message - Implements index_function_t -.

This function handles:

• OP_GET_MESSAGE
• OP_GET_PARENT

Definition at line 2860 of file functions.c.

{
  struct Mailbox *m = shared->mailbox;
  if (m->type != MUTT_NNTP)
    return FR_SUCCESS;
 
  int rc = FR_ERROR;
  struct Buffer *buf = buf_pool_get();
 
  const int op = event->op;
  if (op == OP_GET_MESSAGE)
  {
    if ((mw_get_field(_("Enter Message-ID: "), buf, MUTT_COMP_NO_FLAGS,
                      HC_OTHER, NULL, NULL) != 0) ||
        buf_is_empty(buf))
    {
      goto done;
    }
  }
  else
  {
    struct Email *e = shared->email;
    if (!e || STAILQ_EMPTY(&e->env->references))
    {
      mutt_error(_("Article has no parent reference"));
      goto done;
    }
    buf_strcpy(buf, STAILQ_FIRST(&e->env->references)->data);
  }
 
  if (!m->id_hash)
    m->id_hash = mutt_make_id_hash(m);
  struct Email *e = mutt_hash_find(m->id_hash, buf_string(buf));
  if (e)
  {
    if (e->vnum != -1)
    {
      menu_set_index(priv->menu, e->vnum);
    }
    else if (e->collapsed)
    {
      mutt_uncollapse_thread(e);
      mutt_set_vnum(m);
      menu_set_index(priv->menu, e->vnum);
    }
    else
    {
      mutt_error(_("Message is not visible in limited view"));
    }
  }
  else
  {
    mutt_message(_("Fetching %s from server..."), buf_string(buf));
    int rc2 = nntp_check_msgid(m, buf_string(buf));
    if (rc2 == 0)
    {
      e = m->emails[m->msg_count - 1];
      struct MailboxView *mv = shared->mailbox_view;
      mutt_sort_headers(mv, false);
      menu_set_index(priv->menu, e->vnum);
      menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
      rc = FR_SUCCESS;
    }
    else if (rc2 > 0)
    {
      mutt_error(_("Article %s not found on the server"), buf_string(buf));
    }
  }
 
done:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_main_change_group()

static int op_main_change_group ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Open a different newsgroup - Implements index_function_t -.

This function handles:

• OP_MAIN_CHANGE_GROUP
• OP_MAIN_CHANGE_GROUP_READONLY

Definition at line 2942 of file functions.c.

{
  struct Buffer *folderbuf = buf_pool_get();
  buf_alloc(folderbuf, PATH_MAX);
 
  OptNews = false;
  bool read_only;
  char *cp = NULL;
  const bool c_read_only = cs_subset_bool(shared->sub, "read_only");
  const int op = event->op;
  if (shared->attach_msg || c_read_only || (op == OP_MAIN_CHANGE_GROUP_READONLY))
  {
    cp = _("Open newsgroup in read-only mode");
    read_only = true;
  }
  else
  {
    cp = _("Open newsgroup");
    read_only = false;
  }
 
  const bool c_change_folder_next = cs_subset_bool(shared->sub, "change_folder_next");
  if (c_change_folder_next && shared->mailbox && !buf_is_empty(&shared->mailbox->pathbuf))
  {
    buf_strcpy(folderbuf, mailbox_path(shared->mailbox));
    pretty_mailbox(folderbuf);
  }
 
  OptNews = true;
  const char *const c_news_server = cs_subset_string(shared->sub, "news_server");
  if (!CurrentNewsSrv)
    CurrentNewsSrv = nntp_select_server(shared->mailbox, c_news_server, false);
  if (!CurrentNewsSrv)
    goto changefoldercleanup2;
 
  nntp_mailbox(shared->mailbox, folderbuf->data, folderbuf->dsize);
 
  if (mw_enter_fname(cp, folderbuf, true, shared->mailbox, false, NULL, NULL,
                     MUTT_SEL_NO_FLAGS) == -1)
  {
    goto changefoldercleanup2;
  }
 
  /* Selected directory is okay, let's save it. */
  mutt_browser_select_dir(buf_string(folderbuf));
 
  if (buf_is_empty(folderbuf))
  {
    msgwin_clear_text(NULL);
    goto changefoldercleanup2;
  }
 
  struct Mailbox *m = mx_mbox_find2(buf_string(folderbuf));
  if (m)
  {
    change_folder_mailbox(priv->menu, m, &priv->oldcount, shared, read_only);
  }
  else
  {
    change_folder_string(priv->menu, folderbuf, &priv->oldcount, shared, read_only);
  }
  struct MuttWindow *dlg = dialog_find(priv->win_index);
  dlg->help_data = IndexNewsHelp;
 
changefoldercleanup2:
  buf_pool_release(&folderbuf);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_post()

static int op_post ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Followup to newsgroup - Implements index_function_t -.

This function handles:

• OP_FOLLOWUP
• OP_POST

Definition at line 3019 of file functions.c.

{
  if (!shared->email)
    return FR_NO_ACTION;
 
  const int op = event->op;
  if ((op != OP_FOLLOWUP) || !shared->email->env->followup_to ||
      !mutt_istr_equal(shared->email->env->followup_to, "poster") ||
      (query_quadoption(_("Reply by mail as poster prefers?"), shared->sub,
                        "followup_to_poster") != MUTT_YES))
  {
    if (shared->mailbox && (shared->mailbox->type == MUTT_NNTP) &&
        !((struct NntpMboxData *) shared->mailbox->mdata)->allowed &&
        (query_quadoption(_("Posting to this group not allowed, may be moderated. Continue?"),
                          shared->sub, "post_moderated") != MUTT_YES))
    {
      return FR_ERROR;
    }
    if (op == OP_POST)
    {
      mutt_send_message(SEND_NEWS, NULL, NULL, shared->mailbox, NULL, shared->sub);
    }
    else
    {
      struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
      ea_add_tagged(&ea, shared->mailbox_view, shared->email, priv->tag_prefix);
      mutt_send_message(((op == OP_FOLLOWUP) ? SEND_REPLY : SEND_FORWARD) | SEND_NEWS,
                        NULL, NULL, shared->mailbox, &ea, shared->sub);
      ARRAY_FREE(&ea);
    }
    menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
    return FR_SUCCESS;
  }
 
  struct KeyEvent event_r = { 0, OP_REPLY };
  return op_reply(shared, priv, &event_r);
}

Here is the call graph for this function:

op_main_entire_thread()

static int op_main_entire_thread ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Read entire thread of the current message - Implements index_function_t -.

Definition at line 3062 of file functions.c.

{
  if (shared->mailbox->type != MUTT_NOTMUCH)
  {
    if (((shared->mailbox->type != MUTT_MH) && (shared->mailbox->type != MUTT_MAILDIR)) ||
        (!shared->email || !shared->email->env || !shared->email->env->message_id))
    {
      mutt_message(_("No virtual folder and no Message-ID, aborting"));
      return FR_ERROR;
    } // no virtual folder, but we have Message-ID, reconstruct thread on-the-fly
 
    struct Buffer *buf = buf_pool_get();
    buf_alloc(buf, PATH_MAX);
    buf_addstr(buf, "id:");
 
    int msg_id_offset = 0;
    if ((shared->email->env->message_id)[0] == '<')
      msg_id_offset = 1;
 
    buf_addstr(buf, shared->email->env->message_id + msg_id_offset);
 
    size_t len = buf_len(buf);
    ASSERT(len > 0);
    if (buf->data[len - 1] == '>')
      buf->data[len - 1] = '\0';
 
    change_folder_notmuch(priv->menu, buf->data, buf->dsize, &priv->oldcount, shared, false);
    buf_pool_release(&buf);
 
    // If notmuch doesn't contain the message, we're left in an empty
    // vfolder. No messages are found, but nm_read_entire_thread assumes
    // a valid Message-ID and will throw a segfault.
    //
    // To prevent that, stay in the empty vfolder and print an error.
    if (shared->mailbox->msg_count == 0)
    {
      mutt_error(_("failed to find message in notmuch database. try running 'notmuch new'."));
      return FR_ERROR;
    }
  }
  priv->oldcount = shared->mailbox->msg_count;
  int index = menu_get_index(priv->menu);
  struct Email *e_oldcur = mutt_get_virt_email(shared->mailbox, index);
  if (!e_oldcur)
    return FR_ERROR;
 
  if (nm_read_entire_thread(shared->mailbox, e_oldcur) < 0)
  {
    mutt_message(_("Failed to read thread, aborting"));
    return FR_ERROR;
  }
 
  // nm_read_entire_thread() may modify msg_count and menu won't be updated.
  priv->menu->max = shared->mailbox->msg_count;
 
  if (priv->oldcount < shared->mailbox->msg_count)
  {
    /* nm_read_entire_thread() triggers mutt_sort_headers() if necessary */
    index = e_oldcur->vnum;
    if (e_oldcur->collapsed || shared->mailbox_view->collapsed)
    {
      index = mutt_uncollapse_thread(e_oldcur);
      mutt_set_vnum(shared->mailbox);
    }
    menu_set_index(priv->menu, index);
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_vfolder_from_query()

static int op_main_vfolder_from_query ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Generate virtual folder from query - Implements index_function_t -.

This function handles:

• OP_MAIN_VFOLDER_FROM_QUERY
• OP_MAIN_VFOLDER_FROM_QUERY_READONLY op_main_vfolder_from_query

Definition at line 3141 of file functions.c.

{
  int rc = FR_SUCCESS;
  struct Buffer *buf = buf_pool_get();
 
  if ((mw_get_field("Query: ", buf, MUTT_COMP_NO_FLAGS, HC_OTHER,
                    &CompleteNmQueryOps, NULL) != 0) ||
      buf_is_empty(buf))
  {
    mutt_message(_("No query, aborting"));
    rc = FR_NO_ACTION;
    goto done;
  }
 
  // Keep copy of user's query to name the mailbox
  char *query_unencoded = buf_strdup(buf);
 
  buf_alloc(buf, PATH_MAX);
  const int op = event->op;
  struct Mailbox *m_query = change_folder_notmuch(priv->menu, buf->data, buf->dsize,
                                                  &priv->oldcount, shared,
                                                  (op == OP_MAIN_VFOLDER_FROM_QUERY_READONLY));
  if (m_query)
  {
    FREE(&m_query->name);
    m_query->name = query_unencoded;
    query_unencoded = NULL;
    rc = FR_SUCCESS;
  }
  else
  {
    FREE(&query_unencoded);
  }
 
done:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_main_windowed_vfolder()

static int op_main_windowed_vfolder ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Shifts virtual folder time window - Implements index_function_t -.

This function handles:

• OP_MAIN_WINDOWED_VFOLDER_BACKWARD
• OP_MAIN_WINDOWED_VFOLDER_FORWARD
• OP_MAIN_WINDOWED_VFOLDER_RESET

Definition at line 3190 of file functions.c.

{
  // Common guard clauses.
  if (!nm_query_window_available())
  {
    mutt_message(_("Windowed queries disabled"));
    return FR_ERROR;
  }
  const char *const c_nm_query_window_current_search = cs_subset_string(shared->sub, "nm_query_window_current_search");
  if (!c_nm_query_window_current_search)
  {
    mutt_message(_("No notmuch vfolder currently loaded"));
    return FR_ERROR;
  }
 
  // Call the specific operation.
  switch (event->op)
  {
    case OP_MAIN_WINDOWED_VFOLDER_BACKWARD:
      nm_query_window_backward();
      break;
    case OP_MAIN_WINDOWED_VFOLDER_FORWARD:
      nm_query_window_forward();
      break;
    case OP_MAIN_WINDOWED_VFOLDER_RESET:
      nm_query_window_reset();
      break;
  }
 
  // Common query window folder change.
  char buf[PATH_MAX] = { 0 };
  mutt_str_copy(buf, c_nm_query_window_current_search, sizeof(buf));
  change_folder_notmuch(priv->menu, buf, sizeof(buf), &priv->oldcount, shared, false);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_fetch_mail()

static int op_main_fetch_mail ( struct IndexSharedData * shared, struct IndexPrivateData * priv, const struct KeyEvent * event )

static

Retrieve mail from POP server - Implements index_function_t -.

Definition at line 3233 of file functions.c.

{
  pop_fetch_mail();
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function: