Prototype for an Index Function. More...

Collaboration diagram for Index Function API:

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

Detailed Description

Prototype for an Index Function.

Parameters

fdata	Index Function context data
event	Event to process

Return values

num	FunctionRetval or opcode, e.g. OP_NEXT_ENTRY

Precondition: fdata is not NULL; event is not NULL

Function Documentation

◆ op_alias_dialog()

int op_alias_dialog	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Open the aliases dialog - Implements index_function_t -.

Definition at line 620 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  alias_dialog(shared->mailbox, shared->sub);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_attach_edit_type()

int op_attach_edit_type	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Edit attachment content type - Implements index_function_t -.

Definition at line 630 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_bounce_message	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Remail a message to another user - Implements index_function_t -.

Definition at line 645 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_check_traditional	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Check for classic PGP - Implements index_function_t -.

Definition at line 660 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_compose_to_sender	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 684 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

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

static

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

Definition at line 701 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

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

static

Delete the current entry - Implements index_function_t -.

This function handles:

OP_DELETE
OP_PURGE_MESSAGE

Definition at line 721 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
 
  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, 1);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_delete_thread()

int op_delete_thread	(	struct IndexFunctionData *	fdata,
		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_SUBTHREAD
OP_PURGE_THREAD

Definition at line 874 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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;
  const bool subthread = ((op == OP_DELETE_SUBTHREAD) || (op == OP_PURGE_SUBTHREAD));
  int rc = 0;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection_threads(&ea, shared->mailbox_view, shared->email,
                           priv->tag_prefix, subthread, event->count);
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  {
    rc = mutt_thread_set_flag(shared->mailbox, *ep, MUTT_DELETE, true, subthread);
    if (rc == -1)
      break;
 
    if ((op == OP_PURGE_THREAD) || (op == OP_PURGE_SUBTHREAD))
    {
      rc = mutt_thread_set_flag(shared->mailbox, *ep, MUTT_PURGE, true, subthread);
      if (rc == -1)
        break;
    }
 
    const bool c_delete_untag = cs_subset_bool(shared->sub, "delete_untag");
    if (c_delete_untag)
      mutt_thread_set_flag(shared->mailbox, *ep, MUTT_TAG, false, subthread);
  }
  ARRAY_FREE(&ea);
 
  if (rc == -1)
    return FR_ERROR;
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    return FR_SUCCESS;
  }
 
  resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED, 1);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_display_address()

int op_display_address	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Display full address of sender - Implements index_function_t -.

Definition at line 931 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  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()

int op_display_message	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Display a message - Implements index_function_t -.

This function handles:

OP_DISPLAY_HEADERS
OP_DISPLAY_MESSAGE
OP_GENERIC_SELECT_ENTRY

Definition at line 949 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (!shared->email)
    return FR_NO_ACTION;
 
  if (event->count > 0)
    return op_jump(fdata, event);
 
  int op = event->op;
 
  if (op == OP_DISPLAY_MESSAGE)
  {
    if (!window_is_focused(priv->win_index))
      return FR_SUCCESS;
  }
 
  exec_message_hook(shared->mailbox, shared->email, CMD_MESSAGE_HOOK);
 
  /* 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(fdata->n->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()

int op_edit_label	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 1032 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
  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, num);
    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()

int op_edit_raw_message	(	struct IndexFunctionData *	fdata,
		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 1076 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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()

int op_end_cond	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 1123 of file functions.c.

{
  return FR_SUCCESS;
}

◆ op_exit()

int op_exit	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Exit this menu - Implements index_function_t -.

Definition at line 1131 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  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()

int op_extract_keys	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Extract supported public keys - Implements index_function_t -.

Definition at line 1153 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_flag_message	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 1171 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* L10N: CHECK_ACL */
  if (!check_acl(shared->mailbox, MUTT_ACL_WRITE, _("Can't flag message")))
    return FR_ERROR;
 
  struct Mailbox *m = shared->mailbox;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  mutt_set_flag(m, *ep, MUTT_FLAG, !(*ep)->flagged, true);
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED, num);
    if (num > 1)
      menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_forward_message()

int op_forward_message	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Forward a message with comments - Implements index_function_t -.

Definition at line 1212 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_group_reply	(	struct IndexFunctionData *	fdata,
		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 1242 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

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

static

Jump to an index number - Implements index_function_t -.

Definition at line 1273 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int rc = FR_ERROR;
  struct Buffer *buf = buf_pool_get();
 
  int num = event->count;
  if (num == 0)
  {
    if ((mw_get_field(_("Jump to message: "), buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0) ||
        buf_is_empty(buf))
    {
      mutt_message(_("Nothing to do"));
      rc = FR_NO_ACTION;
      goto done;
    }
 
    if (!mutt_str_atoi_full(buf_string(buf), &num))
    {
      mutt_warning(_("Argument must be a message number"));
      goto done;
    }
  }
 
  if ((num < 1) || (num > shared->mailbox->msg_count))
  {
    mutt_warning(_("Invalid message number"));
  }
  else if (!shared->mailbox->emails[num - 1] ||
           !shared->mailbox->emails[num - 1]->visible)
  {
    mutt_warning(_("That message is not visible"));
  }
  else
  {
    struct Email *e = shared->mailbox->emails[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;
  }
 
done:
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

◆ op_list_action()

int op_list_action	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Show mailing-list actions - Implements index_function_t -.

Definition at line 1328 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
 
  dlg_mlist(shared->mailbox, shared->email);
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_list_reply()

int op_list_reply	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Reply to specified mailing list - Implements index_function_t -.

Definition at line 1341 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_list_subscribe	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Subscribe to a mailing list - Implements index_function_t -.

Definition at line 1367 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  return mutt_send_list_subscribe(shared->mailbox, shared->email) ? FR_SUCCESS : FR_ERROR;
}

Here is the call graph for this function:

◆ op_list_unsubscribe()

int op_list_unsubscribe	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Unsubscribe from mailing list - Implements index_function_t -.

Definition at line 1376 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  return mutt_send_list_unsubscribe(shared->mailbox, shared->email) ? FR_SUCCESS : FR_ERROR;
}

Here is the call graph for this function:

◆ op_mail()

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

static

Compose a new mail message - Implements index_function_t -.

Definition at line 1385 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int rc = mutt_send_message(SEND_NONE, 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()

int op_mailbox_list	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

List mailboxes with new mail - Implements index_function_t -.

Definition at line 1398 of file functions.c.

{
  mutt_mailbox_list();
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_mail_key()

int op_mail_key	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Mail a PGP public key - Implements index_function_t -.

Definition at line 1407 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_main_break_thread	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Break the thread in two - Implements index_function_t -.

Definition at line 1422 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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;
 
  const bool has_repeat_count = (event->count > 0);
 
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_ERROR;
  }
 
  struct MailboxView *mv = shared->mailbox_view;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  if (ea_add_selection(&ea, mv, e, false, event->count) <= 0)
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
 
  bool changed = false;
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  {
    e = *ep;
    if (!e || (STAILQ_EMPTY(&e->env->in_reply_to) && STAILQ_EMPTY(&e->env->references)))
      continue;
 
    {
      mutt_break_thread(e);
      changed = true;
    }
  }
  ARRAY_FREE(&ea);
 
  if (changed)
  {
    mutt_sort_headers(mv, true);
    menu_set_index(priv->menu, shared->email->vnum);
    m->changed = true;
    mutt_message(_("Thread broken"));
 
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else if (!has_repeat_count)
  {
    mutt_error(_("Thread can't be broken, message is not part of a thread"));
    return FR_ERROR;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_change_folder()

int op_main_change_folder	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Open a different folder - Implements index_function_t -.

This function handles:

OP_MAIN_BROWSE_MAILBOXES
OP_MAIN_BROWSE_MAILBOXES_READONLY
OP_MAIN_CHANGE_FOLDER
OP_MAIN_CHANGE_FOLDER_READONLY
OP_MAIN_CHANGE_VFOLDER

Definition at line 1494 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct Buffer *folderbuf = buf_pool_get();
  buf_alloc(folderbuf, PATH_MAX);
 
  const int op = event->op;
  const bool browse = (op == OP_MAIN_BROWSE_MAILBOXES) ||
                      (op == OP_MAIN_BROWSE_MAILBOXES_READONLY);
  const bool c_read_only = cs_subset_bool(shared->sub, "read_only");
  const bool read_only = shared->attach_msg || c_read_only ||
                         (op == OP_MAIN_BROWSE_MAILBOXES_READONLY) ||
                         (op == OP_MAIN_CHANGE_FOLDER_READONLY);
 
  if (browse)
  {
    dlg_browser(folderbuf, MUTT_SEL_FOLDER | MUTT_SEL_MAILBOX,
                shared->mailbox, NULL, NULL);
  }
  else
  {
    const char *cp = read_only ? _("Open mailbox in read-only mode") :
                                 _("Open mailbox");
 
    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_NONE) == -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()

int op_main_collapse_all	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Collapse/uncollapse all threads - Implements index_function_t -.

Definition at line 1564 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_ERROR;
  }
  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()

int op_main_close_all_threads	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Collapse all threads - Implements index_function_t -.

Definition at line 1582 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_ERROR;
  }
 
  if (!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()

int op_main_close_thread	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Collapse current thread - Implements index_function_t -.

Definition at line 1605 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection_threads(&ea, shared->mailbox_view, shared->email,
                           priv->tag_prefix, false, event->count);
  const int rc = op_main_change_thread(fdata, &ea, COLLAPSE_MODE_CLOSE);
  ARRAY_FREE(&ea);
  return rc;
}

Here is the call graph for this function:

◆ op_main_collapse_thread()

int op_main_collapse_thread	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Collapse/uncollapse current thread - Implements index_function_t -.

Definition at line 1620 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection_threads(&ea, shared->mailbox_view, shared->email,
                           priv->tag_prefix, false, event->count);
  const int rc = op_main_change_thread(fdata, &ea, COLLAPSE_MODE_TOGGLE);
  ARRAY_FREE(&ea);
  return rc;
}

Here is the call graph for this function:

◆ op_main_open_all_threads()

int op_main_open_all_threads	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Open all threads - Implements index_function_t -.

Definition at line 1635 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (!mutt_using_threads())
  {
    mutt_warning(_("Threading is not enabled"));
    return FR_ERROR;
  }
 
  if (!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()

int op_main_open_thread	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Open current thread - Implements index_function_t -.

Definition at line 1658 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection_threads(&ea, shared->mailbox_view, shared->email,
                           priv->tag_prefix, false, event->count);
  const int rc = op_main_change_thread(fdata, &ea, COLLAPSE_MODE_OPEN);
  ARRAY_FREE(&ea);
  return rc;
}

Here is the call graph for this function:

◆ op_main_delete_pattern()

int op_main_delete_pattern	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Delete messages matching a pattern - Implements index_function_t -.

This function handles:

OP_MAIN_DELETE_PATTERN
OP_PURGE_PATTERN

Definition at line 1677 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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;
 
  const bool purge = (event->op == OP_PURGE_PATTERN);
  mutt_pattern_func(shared->mailbox_view, MUTT_DELETE, _("Delete messages matching: "));
  if (purge)
    mutt_pattern_func(shared->mailbox_view, MUTT_PURGE, NULL);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_limit()

int op_main_limit	(	struct IndexFunctionData *	fdata,
		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 1705 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_main_link_threads	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 1779 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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_ERROR;
  }
  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;
 
    // If there's a repeat-count, use it.
    // If not, behave as if <tag-prefix> has been pressed.
    const bool tag_prefix = (event->count < 1);
    ea_add_selection(&ea, mv, e, tag_prefix, event->count);
 
    if (!tag_prefix)
    {
      struct Email **ep = ARRAY_GET(&ea, 0);
      if (ep && (*ep == e))
        ARRAY_REMOVE(&ea, ep);
    }
 
    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_ERROR;
    }
 
    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()

int op_main_modify_tags	(	struct IndexFunctionData *	fdata,
		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 1849 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int rc = FR_ERROR;
  struct Buffer *buf = NULL;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
 
  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;
  }
 
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  const int num = ARRAY_SIZE(&ea);
 
  if (priv->tag_prefix || (num > 1))
  {
    struct Progress *progress = NULL;
 
    if (m->verbose)
    {
      progress = progress_new(MUTT_PROGRESS_WRITE, num);
      progress_set_message(progress, _("Update tags..."));
    }
 
#ifdef USE_NOTMUCH
    if (m->type == MUTT_NOTMUCH)
      nm_db_longrun_init(m, true);
#endif
    struct Email **ep = NULL;
    int px = 0;
    ARRAY_FOREACH(ep, &ea)
    {
      struct Email *e = *ep;
 
      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);
    if (!priv->tag_prefix)
      resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED,
                    (op == OP_MAIN_MODIFY_TAGS_THEN_HIDE) ? 1 : num);
  }
  else
  {
    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,
                  (op == OP_MAIN_MODIFY_TAGS_THEN_HIDE) ? 1 : num);
  }
  rc = FR_SUCCESS;
 
done:
  ARRAY_FREE(&ea);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

◆ find_next_new_email()

int find_next_new_email	(	struct Mailbox *	m,
		int	start,
		bool	forwards,
		int	op )

static

Jump to 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 Find the next new/unread message with wrapping
Parameters

m Mailbox

start Index to start searching from

forwards Direction: true for next, false for previous

op Operation to determine match type

Return values

>=0 Index of matching message

-1 No match found

Definition at line 1987 of file functions.c.

{
  int first_unread = -1;
  int first_new = -1;
  int mcur = start;
  const bool threaded = mutt_using_threads();
 
  for (int i = 0; i < m->vcount; i++)
  {
    if (forwards)
    {
      mcur++;
      if (mcur > (m->vcount - 1))
        mcur = 0;
    }
    else
    {
      mcur--;
      if (mcur < 0)
        mcur = m->vcount - 1;
    }
 
    struct Email *e = mutt_get_virt_email(m, 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;
    }
  }
 
  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))
  {
    return first_new;
  }
  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))
  {
    return first_unread;
  }
 
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ op_main_next_thread()

int op_main_next_thread	(	struct IndexFunctionData *	fdata,
		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 2132 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  const int op = event->op;
  const int count = event->count;
  const bool forwards = (op == OP_MAIN_NEXT_THREAD) || (op == OP_MAIN_NEXT_SUBTHREAD);
  const bool subthreads = (op == OP_MAIN_NEXT_SUBTHREAD) || (op == OP_MAIN_PREV_SUBTHREAD);
 
  if (count > 0)
  {
    for (int i = 0; i < count; i++)
    {
      int index = mutt_aside_thread(shared->email, forwards, subthreads);
      if (index == -1)
        break;
      menu_set_index(priv->menu, index);
    }
    return FR_SUCCESS;
  }
 
  int index = mutt_aside_thread(shared->email, forwards, subthreads);
 
  if (index != -1)
    menu_set_index(priv->menu, index);
 
  if (index < 0)
  {
    if (forwards)
      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_ERROR;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_next_undeleted()

int op_main_next_undeleted	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Move to the next undeleted message - Implements index_function_t -.

Definition at line 2175 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  const int count = event->count;
  int index = menu_get_index(priv->menu);
 
  if (count > 0)
  {
    const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
    int last_good = index;
    for (int i = 0; i < count; i++)
    {
      int next = find_next_undeleted(shared->mailbox_view, index, uncollapse);
      if (next == -1)
        break;
      last_good = next;
      index = next;
    }
    if (last_good != menu_get_index(priv->menu))
    {
      menu_set_index(priv->menu, last_good);
      if (uncollapse)
        menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    }
    return FR_SUCCESS;
  }
 
  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_ERROR;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_next_unread_mailbox()

int op_main_next_unread_mailbox	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Open next mailbox with unread mail - Implements index_function_t -.

Definition at line 2233 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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_unread_mailbox()

int op_main_prev_unread_mailbox	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Open previous mailbox with unread mail - Implements index_function_t -.

Definition at line 2258 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct Mailbox *m = shared->mailbox;
 
  struct Buffer *folderbuf = buf_pool_get();
  buf_strcpy(folderbuf, mailbox_path(m));
  m = mutt_mailbox_prev_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()

int op_main_prev_undeleted	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Move to the previous undeleted message - Implements index_function_t -.

Definition at line 2283 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  const int count = event->count;
  int index = menu_get_index(priv->menu);
 
  if (count > 0)
  {
    const bool uncollapse = mutt_using_threads() && !window_is_focused(priv->win_index);
    int last_good = index;
    for (int i = 0; i < count; i++)
    {
      int prev = find_previous_undeleted(shared->mailbox_view, index, uncollapse);
      if (prev == -1)
        break;
      last_good = prev;
      index = prev;
    }
    if (last_good != menu_get_index(priv->menu))
    {
      menu_set_index(priv->menu, last_good);
      if (uncollapse)
        menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    }
    return FR_SUCCESS;
  }
 
  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_ERROR;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_quasi_delete()

int op_main_quasi_delete	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 2341 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct Mailbox *m = shared->mailbox;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  {
    (*ep)->quasi_deleted = true;
    m->changed = true;
  }
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix || (num > 1))
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_read_thread()

int op_main_read_thread	(	struct IndexFunctionData *	fdata,
		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 2377 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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;
  const bool subthread = (op != OP_MAIN_READ_THREAD);
  int rc = 0;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection_threads(&ea, shared->mailbox_view, shared->email,
                           priv->tag_prefix, subthread, event->count);
  const int num = ARRAY_SIZE(&ea);
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  {
    rc = mutt_thread_set_flag(shared->mailbox, *ep, MUTT_READ, true, subthread);
    if (rc == -1)
      break;
  }
  ARRAY_FREE(&ea);
 
  if (rc == -1)
    return FR_ERROR;
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    return FR_SUCCESS;
  }
 
  const enum ResolveMethod rm = (op == OP_MAIN_READ_THREAD) ? RESOLVE_NEXT_THREAD :
                                                              RESOLVE_NEXT_SUBTHREAD;
  resolve_email(priv, shared, rm, num);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_root_message()

int op_main_root_message	(	struct IndexFunctionData *	fdata,
		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

When called with a count prefix, will jump N ancestors up the thread (for parent-message, not for root-message which always goes to root).

Definition at line 2431 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int count = event->op == OP_MAIN_ROOT_MESSAGE ? 0 : MAX(event->count, 1);
  int index = mutt_parent_message(shared->email, event->op == OP_MAIN_ROOT_MESSAGE, count);
  if (index != -1)
    menu_set_index(priv->menu, index);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_set_flag()

int op_main_set_flag	(	struct IndexFunctionData *	fdata,
		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 2450 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
 
  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, num);
      if (num > 1)
        menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    }
  }
  ARRAY_FREE(&ea);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_show_limit()

int op_main_show_limit	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Show currently active limit pattern - Implements index_function_t -.

Definition at line 2485 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  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()

int op_main_sync_folder	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Save changes to mailbox - Implements index_function_t -.

Definition at line 2507 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

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

static

Tag messages matching a pattern - Implements index_function_t -.

Definition at line 2591 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_main_undelete_pattern	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Undelete messages matching a pattern - Implements index_function_t -.

Definition at line 2604 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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()

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

static

Untag messages matching a pattern - Implements index_function_t -.

Definition at line 2628 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_mark_msg	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 2641 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  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_NONE, 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(fdata->mod_data->md_index, 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()

int op_next_entry	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Move to the next entry - Implements index_function_t -.

Definition at line 2697 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int count = MAX(event->count, 1);
  int index = menu_get_index(priv->menu) + count;
 
  if (index >= shared->mailbox->vcount)
  {
    index = shared->mailbox->vcount - 1;
    if (event->count == 0)
    {
      mutt_message(_("You are on the last message"));
      notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
    }
  }
 
  menu_set_index(priv->menu, index);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_pipe()

int op_pipe	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 2721 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_prev_entry	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Move to the previous entry - Implements index_function_t -.

Definition at line 2744 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int count = MAX(event->count, 1);
  int index = menu_get_index(priv->menu) - count;
 
  if (index < 0)
  {
    index = 0;
    if (event->count == 0)
    {
      notify_send(shared->notify, NT_INDEX, NT_INDEX_EMAIL, NULL);
      mutt_message(_("You are on the first message"));
    }
  }
 
  menu_set_index(priv->menu, index);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_print()

int op_print	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Print the current entry - Implements index_function_t -.

Definition at line 2768 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
  const bool printed = mutt_print_message(shared->mailbox, &ea);
  ARRAY_FREE(&ea);
 
  if (printed && !priv->tag_prefix)
    resolve_email(priv, shared, RESOLVE_NEXT_EMAIL, num);
 
  /* 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 (printed && (shared->mailbox->type == MUTT_IMAP) && !c_imap_peek)
  {
    menu_queue_redraw(priv->menu,
                      ((priv->tag_prefix || (num > 1)) ? MENU_REDRAW_INDEX : MENU_REDRAW_CURRENT));
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_query()

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

static

Query external program for addresses - Implements index_function_t -.

Definition at line 2802 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  query_index(shared->mailbox, shared->sub);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_quit()

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

static

Save changes to mailbox and quit - Implements index_function_t -.

Definition at line 2812 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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(fdata->n->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()

int op_recall_message	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Recall a postponed message - Implements index_function_t -.

Definition at line 2850 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_reply	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Reply to a message - Implements index_function_t -.

Definition at line 2863 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_resend	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 2889 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_save	(	struct IndexFunctionData *	fdata,
		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 2926 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
 
  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, 1);
  }
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix || (num > 1))
    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()

int op_search	(	struct IndexFunctionData *	fdata,
		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 2976 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  SearchFlags flags = SEARCH_NONE;
  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;
 
    default:
      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()

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

static

Sort messages - Implements index_function_t -.

This function handles:

OP_SORT
OP_SORT_REVERSE

Definition at line 3020 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_tag	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Tag the current entry - Implements index_function_t -.

Definition at line 3039 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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)
        continue;
      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;
 
  int count = MAX(event->count, 1);
  int current_index = menu_get_index(priv->menu);
 
  for (int i = 0; i < count && current_index + i < shared->mailbox->vcount; i++)
  {
    struct Email *e = mutt_get_virt_email(shared->mailbox, current_index + i);
    if (e)
      mutt_set_flag(shared->mailbox, e, MUTT_TAG, !e->tagged, true);
  }
 
  if (count > 0)
    resolve_email(priv, shared, RESOLVE_NEXT_EMAIL, count);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_tag_thread()

int op_tag_thread	(	struct IndexFunctionData *	fdata,
		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 3085 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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, 1);
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_toggle_new()

int op_toggle_new	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 3109 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* L10N: CHECK_ACL */
  if (!check_acl(shared->mailbox, MUTT_ACL_SEEN, _("Can't toggle new")))
    return FR_ERROR;
 
  struct Mailbox *m = shared->mailbox;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  {
    if ((*ep)->read || (*ep)->old)
      mutt_set_flag(m, *ep, MUTT_NEW, true, true);
    else
      mutt_set_flag(m, *ep, MUTT_READ, true, true);
  }
  ARRAY_FREE(&ea);
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
  else
  {
    resolve_email(priv, shared, RESOLVE_NEXT_UNDELETED, num);
    if (num > 1)
      menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_toggle_write()

int op_toggle_write	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 3155 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  mx_toggle_write(shared->mailbox);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_undelete()

int op_undelete	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Undelete the current entry - Implements index_function_t -.

Definition at line 3165 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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_selection(&ea, shared->mailbox_view, shared->email, priv->tag_prefix,
                   event->count);
  if (ARRAY_EMPTY(&ea))
  {
    ARRAY_FREE(&ea);
    return FR_NO_ACTION;
  }
  const int num = ARRAY_SIZE(&ea);
 
  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, num);
    if (num > 1)
      menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_undelete_thread()

int op_undelete_thread	(	struct IndexFunctionData *	fdata,
		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 3208 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  /* 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;
  const bool subthread = (op != OP_UNDELETE_THREAD);
  int rc = 0;
  struct EmailArray ea = ARRAY_HEAD_INITIALIZER;
  ea_add_selection_threads(&ea, shared->mailbox_view, shared->email,
                           priv->tag_prefix, subthread, event->count);
  const int num = ARRAY_SIZE(&ea);
 
  struct Email **ep = NULL;
  ARRAY_FOREACH(ep, &ea)
  {
    rc = mutt_thread_set_flag(shared->mailbox, *ep, MUTT_DELETE, false, subthread);
    if (rc == -1)
      break;
    rc = mutt_thread_set_flag(shared->mailbox, *ep, MUTT_PURGE, false, subthread);
    if (rc == -1)
      break;
  }
  ARRAY_FREE(&ea);
 
  if (rc == -1)
    return FR_ERROR;
 
  if (priv->tag_prefix)
  {
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    return FR_SUCCESS;
  }
 
  const enum ResolveMethod rm = (op == OP_UNDELETE_THREAD) ? RESOLVE_NEXT_THREAD :
                                                             RESOLVE_NEXT_SUBTHREAD;
  resolve_email(priv, shared, rm, num);
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_view_attachments()

int op_view_attachments	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Show MIME attachments - Implements index_function_t -.

Definition at line 3258 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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(fdata->n->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()

int op_autocrypt_acct_menu	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Manage autocrypt accounts - Implements index_function_t -.

Definition at line 3288 of file functions.c.

{
  dlg_autocrypt();
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_main_imap_fetch()

int op_main_imap_fetch	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 3298 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  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()

int op_main_imap_logout_all	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Logout from all IMAP servers - Implements index_function_t -.

Definition at line 3311 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_catchup	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 3344 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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()

int op_get_children	(	struct IndexFunctionData *	fdata,
		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 3366 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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_ERROR;
  }
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

◆ op_get_message()

int op_get_message	(	struct IndexFunctionData *	fdata,
		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 3470 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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_NONE, 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()

int op_main_change_group	(	struct IndexFunctionData *	fdata,
		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 3552 of file functions.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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 (!mod_data->current_news_srv)
    mod_data->current_news_srv = nntp_select_server(shared->mailbox, c_news_server, false);
  if (!mod_data->current_news_srv)
    goto changefoldercleanup2;
 
  nntp_mailbox(shared->mailbox, folderbuf->data, folderbuf->dsize);
 
  if (mw_enter_fname(cp, folderbuf, true, shared->mailbox, false, NULL, NULL,
                     MUTT_SEL_NONE) == -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()

int op_post	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Followup to newsgroup - Implements index_function_t -.

This function handles:

OP_FOLLOWUP
OP_FORWARD_TO_GROUP
OP_POST

Definition at line 3632 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  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(fdata, &event_r);
}

Here is the call graph for this function:

◆ op_main_entire_thread()

int op_main_entire_thread	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

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

Definition at line 3676 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (shared->mailbox->type != MUTT_NOTMUCH)
  {
    if (!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)
      return FR_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()

int op_main_vfolder_from_query	(	struct IndexFunctionData *	fdata,
		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

Definition at line 3758 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  int rc = FR_SUCCESS;
  struct Buffer *buf = buf_pool_get();
 
  if ((mw_get_field("Query: ", buf, MUTT_COMP_NONE, 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()

int op_main_windowed_vfolder	(	struct IndexFunctionData *	fdata,
		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 3807 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  // 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;
 
    default:
      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()

int op_main_fetch_mail	(	struct IndexFunctionData *	fdata,
		const struct KeyEvent *	event )

static

Retrieve mail from POP server - Implements index_function_t -.

Definition at line 3854 of file functions.c.

{
  struct IndexPrivateData *priv = fdata->priv;
  pop_fetch_mail();
  menu_queue_redraw(priv->menu, MENU_REDRAW_FULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

m	Mailbox
start	Index to start searching from
forwards	Direction: true for next, false for previous
op	Operation to determine match type

Functions

Detailed Description

Function Documentation

◆ op_alias_dialog()

◆ op_attach_edit_type()

◆ op_bounce_message()

◆ op_check_traditional()

◆ op_compose_to_sender()

◆ op_create_alias()

◆ op_delete()

◆ op_delete_thread()

◆ op_display_address()

◆ op_display_message()

◆ op_edit_label()

◆ op_edit_raw_message()

◆ op_end_cond()

◆ op_exit()

◆ op_extract_keys()

◆ op_flag_message()

◆ op_forward_message()

◆ op_group_reply()

◆ op_jump()

◆ op_list_action()

◆ op_list_reply()

◆ op_list_subscribe()

◆ op_list_unsubscribe()

◆ op_mail()

◆ op_mailbox_list()

◆ op_mail_key()

◆ op_main_break_thread()

◆ op_main_change_folder()

◆ op_main_collapse_all()

◆ op_main_close_all_threads()

◆ op_main_close_thread()

◆ op_main_collapse_thread()

◆ op_main_open_all_threads()

◆ op_main_open_thread()

◆ op_main_delete_pattern()

◆ op_main_limit()

◆ op_main_link_threads()

◆ op_main_modify_tags()

◆ find_next_new_email()

◆ op_main_next_thread()

◆ op_main_next_undeleted()

◆ op_main_next_unread_mailbox()

◆ op_main_prev_unread_mailbox()

◆ op_main_prev_undeleted()

◆ op_main_quasi_delete()

◆ op_main_read_thread()

◆ op_main_root_message()

◆ op_main_set_flag()

◆ op_main_show_limit()

◆ op_main_sync_folder()

◆ op_main_tag_pattern()

◆ op_main_undelete_pattern()

◆ op_main_untag_pattern()

◆ op_mark_msg()

◆ op_next_entry()

◆ op_pipe()

◆ op_prev_entry()

◆ op_print()

◆ op_query()

◆ op_quit()

◆ op_recall_message()

◆ op_reply()

◆ op_resend()

◆ op_save()

◆ op_search()

◆ op_sort()

◆ op_tag()

◆ op_tag_thread()

◆ op_toggle_new()

◆ op_toggle_write()

◆ op_undelete()

◆ op_undelete_thread()

◆ op_view_attachments()

◆ op_autocrypt_acct_menu()

◆ op_main_imap_fetch()

◆ op_main_imap_logout_all()

◆ op_catchup()