Index Function API

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_forget_passphrase (struct IndexFunctionData *fdata, const struct KeyEvent *event)
	Wipe passphrases from memory - 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()

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

static

Open the aliases dialog - Implements index_function_t -.

Definition at line 642 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()

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

static

Edit attachment content type - Implements index_function_t -.

Definition at line 652 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()

static 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 667 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()

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

static

Check for classic PGP - Implements index_function_t -.

Definition at line 682 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()

static 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 706 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()

static 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 723 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()

static 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 743 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()

static 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_THREAD

Definition at line 895 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);
  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)
    {
      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()

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

static

Display full address of sender - Implements index_function_t -.

Definition at line 952 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()

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

static 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 1046 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()

static 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 1090 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()

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

static

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

Definition at line 1137 of file functions.c.

{
  return FR_SUCCESS;
}

op_exit()

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

static

Exit this menu - Implements index_function_t -.

Definition at line 1145 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()

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

static

Extract supported public keys - Implements index_function_t -.

Definition at line 1167 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()

static 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 1185 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_forget_passphrase()

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

static

Wipe passphrases from memory - Implements index_function_t -.

Definition at line 1226 of file functions.c.

{
  crypt_forget_passphrase();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_forward_message()

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

static

Forward a message with comments - Implements index_function_t -.

Definition at line 1235 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()

static 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 1265 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()

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

static

Jump to an index number - Implements index_function_t -.

Definition at line 1296 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()

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

static

Show mailing-list actions - Implements index_function_t -.

Definition at line 1351 of file functions.c.

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

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

static

Reply to specified mailing list - Implements index_function_t -.

Definition at line 1364 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()

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

static

Subscribe to a mailing list - Implements index_function_t -.

Definition at line 1390 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()

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

static

Unsubscribe from mailing list - Implements index_function_t -.

Definition at line 1399 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()

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

static

Compose a new mail message - Implements index_function_t -.

Definition at line 1408 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()

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

static

List mailboxes with new mail - Implements index_function_t -.

Definition at line 1421 of file functions.c.

{
  mutt_mailbox_list();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_mail_key()

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

static

Mail a PGP public key - Implements index_function_t -.

Definition at line 1430 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()

static 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 1445 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()

static 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_CHANGE_FOLDER
• OP_MAIN_CHANGE_FOLDER_READONLY
• OP_MAIN_CHANGE_VFOLDER

Definition at line 1515 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);
 
  char *cp = NULL;
  bool read_only;
  const bool c_read_only = cs_subset_bool(shared->sub, "read_only");
  const int op = event->op;
  if (shared->attach_msg || c_read_only || (op == OP_MAIN_CHANGE_FOLDER_READONLY))
  {
    cp = _("Open mailbox in read-only mode");
    read_only = true;
  }
  else
  {
    cp = _("Open mailbox");
    read_only = false;
  }
 
  const bool c_change_folder_next = cs_subset_bool(shared->sub, "change_folder_next");
  if (c_change_folder_next && shared->mailbox && !buf_is_empty(&shared->mailbox->pathbuf))
  {
    buf_strcpy(folderbuf, mailbox_path(shared->mailbox));
    pretty_mailbox(folderbuf);
  }
  /* By default, fill buf with the next mailbox that contains unread mail */
  mutt_mailbox_next(shared->mailbox_view ? shared->mailbox : NULL, folderbuf);
 
  if (mw_enter_fname(cp, folderbuf, true, shared->mailbox, false, NULL, NULL,
                     MUTT_SEL_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()

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

static

Collapse/uncollapse all threads - Implements index_function_t -.

Definition at line 1581 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()

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

static

Collapse all threads - Implements index_function_t -.

Definition at line 1599 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()

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

static

Collapse current thread - Implements index_function_t -.

Definition at line 1622 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()

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

static

Collapse/uncollapse current thread - Implements index_function_t -.

Definition at line 1637 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()

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

static

Open all threads - Implements index_function_t -.

Definition at line 1652 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()

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

static

Open current thread - Implements index_function_t -.

Definition at line 1675 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()

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

static

Delete messages matching a pattern - Implements index_function_t -.

Definition at line 1690 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;
 
  mutt_pattern_func(shared->mailbox_view, MUTT_DELETE, _("Delete messages matching: "));
  menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_limit()

static int op_main_limit ( struct 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 1715 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()

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

static

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

<link-threads> is only meaningful with tagged emails. Let the user run the function with or without <tag-prefix>.

Definition at line 1789 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()

static 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 1859 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()

static 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 1997 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()

static 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 2142 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()

static 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 2185 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()

static 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 2243 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()

static 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 2268 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()

static 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 2293 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()

static 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 2351 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()

static 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 2387 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()

static 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 2441 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()

static 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 2460 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()

static 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 2495 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()

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

static

Save changes to mailbox - Implements index_function_t -.

Definition at line 2517 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()

static 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 2601 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()

static 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 2614 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()

static 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 2638 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()

static 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 2651 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->menu_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()

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

static

Move to the next entry - Implements index_function_t -.

Definition at line 2707 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()

static 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 2731 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()

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

static

Move to the previous entry - Implements index_function_t -.

Definition at line 2754 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()

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

static

Print the current entry - Implements index_function_t -.

Definition at line 2778 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()

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

static

Query external program for addresses - Implements index_function_t -.

Definition at line 2812 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()

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

static

Save changes to mailbox and quit - Implements index_function_t -.

Definition at line 2822 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()

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

static

Recall a postponed message - Implements index_function_t -.

Definition at line 2860 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()

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

static

Reply to a message - Implements index_function_t -.

Definition at line 2873 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()

static 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 2899 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()

static 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 2936 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()

static 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 2986 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;
  }
 
  // Initiating a search can happen on an empty mailbox, but
  // searching for next/previous/... needs to be on a message and
  // thus a non-empty mailbox
  int index = menu_get_index(priv->menu);
  index = mutt_search_command(shared->mailbox_view, priv->menu, index,
                              shared->search_state, flags);
  if (index != -1)
    menu_set_index(priv->menu, index);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_sort()

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

static

Sort messages - Implements index_function_t -.

This function handles:

• OP_SORT
• OP_SORT_REVERSE

Definition at line 3027 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()

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

static

Tag the current entry - Implements index_function_t -.

Definition at line 3046 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)
        break;
      if (e->visible)
        mutt_set_flag(m, e, MUTT_TAG, false, true);
    }
    menu_queue_redraw(priv->menu, MENU_REDRAW_INDEX);
    return FR_SUCCESS;
  }
 
  if (!shared->email)
    return FR_NO_ACTION;
 
  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()

static 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 3092 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()

static 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 3116 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()

static 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 3162 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()

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

static

Undelete the current entry - Implements index_function_t -.

Definition at line 3172 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()

static 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 3215 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()

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

static

Show MIME attachments - Implements index_function_t -.

Definition at line 3265 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()

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

static

Manage autocrypt accounts - Implements index_function_t -.

Definition at line 3295 of file functions.c.

{
  dlg_autocrypt();
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_imap_fetch()

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

static

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

Definition at line 3305 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()

static 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 3318 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()

static 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 3351 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()

static 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 3373 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()

static 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 3477 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()

static 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 3559 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()

static 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 3639 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()

static 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 3683 of file functions.c.

{
  struct IndexSharedData *shared = fdata->shared;
  struct IndexPrivateData *priv = fdata->priv;
  if (shared->mailbox->type != MUTT_NOTMUCH)
  {
    if (((shared->mailbox->type != MUTT_MH) && (shared->mailbox->type != MUTT_MAILDIR)) ||
        (!shared->email || !shared->email->env || !shared->email->env->message_id))
    {
      mutt_message(_("No virtual folder and no Message-ID, aborting"));
      return FR_ERROR;
    } // no virtual folder, but we have Message-ID, reconstruct thread on-the-fly
 
    struct Buffer *buf = buf_pool_get();
    buf_alloc(buf, PATH_MAX);
    buf_addstr(buf, "id:");
 
    int msg_id_offset = 0;
    if ((shared->email->env->message_id)[0] == '<')
      msg_id_offset = 1;
 
    buf_addstr(buf, shared->email->env->message_id + msg_id_offset);
 
    size_t len = buf_len(buf);
    ASSERT(len > 0);
    if (buf->data[len - 1] == '>')
      buf->data[len - 1] = '\0';
 
    change_folder_notmuch(priv->menu, buf->data, buf->dsize, &priv->oldcount, shared, false);
    buf_pool_release(&buf);
 
    // If notmuch doesn't contain the message, we're left in an empty
    // vfolder. No messages are found, but nm_read_entire_thread assumes
    // a valid Message-ID and will throw a segfault.
    //
    // To prevent that, stay in the empty vfolder and print an error.
    if (!shared->mailbox)
      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()

static 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 op_main_vfolder_from_query

Definition at line 3766 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()

static 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 3815 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;
  }
 
  // Common query window folder change.
  char buf[PATH_MAX] = { 0 };
  mutt_str_copy(buf, c_nm_query_window_current_search, sizeof(buf));
  change_folder_notmuch(priv->menu, buf, sizeof(buf), &priv->oldcount, shared, false);
 
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_main_fetch_mail()

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

static

Retrieve mail from POP server - Implements index_function_t -.

Definition at line 3859 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: