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_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 615 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 625 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 640 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 655 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 679 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 696 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 716 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 868 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 925 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 943 of file functions.c.

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

Here is the call graph for this function:

op_edit_label()

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 1026 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 1070 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 1117 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 1125 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 1147 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 1165 of file functions.c.

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

Here is the call graph for this function:

op_forward_message()

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 1206 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 1236 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 1267 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 1322 of file functions.c.

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

Here is the call graph for this function:

op_list_reply()

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 1335 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 1361 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 1370 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 1379 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 1392 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 1401 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 1416 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 1486 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 1552 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 1570 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 1593 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 1608 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 1623 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 1646 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 1661 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 1686 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 1760 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 1830 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 1968 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 2113 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 2156 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 2214 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 2239 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 2264 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 2322 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 2358 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 2412 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 2431 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 2466 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 2488 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 2572 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 2585 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 2609 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 2622 of file functions.c.

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

Here is the call graph for this function:

op_next_entry()

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 2678 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 2702 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 2725 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 2749 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 2783 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 2793 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 2831 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 2844 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 2870 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 2907 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 2957 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 2998 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 3017 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 3063 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 3087 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 3133 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 3143 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 3186 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 3236 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 3266 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 3276 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 3289 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 3322 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 3344 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 3448 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 3530 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 3610 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 3654 of file functions.c.

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

Here is the call graph for this function:

op_main_vfolder_from_query()

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

Definition at line 3736 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 3785 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 3829 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: