Compose Function API

Prototype for a Compose Function. More...

Collaboration diagram for Compose Function API:

Functions
static int	op_attach_attach_file (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Attach files to this message - Implements compose_function_t -.
static int	op_attach_attach_key (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Attach a PGP public key - Implements compose_function_t -.
static int	op_attach_attach_message (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Attach messages to this message - Implements compose_function_t -.
static int	op_attach_detach (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Delete the current entry - Implements compose_function_t -.
static int	op_attach_edit_content_id (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit the 'Content-ID' of the attachment - Implements compose_function_t -.
static int	op_attach_edit_description (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit attachment description - Implements compose_function_t -.
static int	op_attach_edit_encoding (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit attachment transfer-encoding - Implements compose_function_t -.
static int	op_attach_edit_language (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit the 'Content-Language' of the attachment - Implements compose_function_t -.
static int	op_attach_edit_mime (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit attachment using mailcap entry - Implements compose_function_t -.
static int	op_attach_edit_type (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit attachment content type - Implements compose_function_t -.
static int	op_attach_filter (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Filter attachment through a shell command - Implements compose_function_t -.
static int	op_attach_get_attachment (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Get a temporary copy of an attachment - Implements compose_function_t -.
static int	op_attach_group_alts (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Group selected attachments as 'multipart/alternative' - Implements compose_function_t -.
static int	op_attach_group_lingual (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Group selected attachments as 'multipart/multilingual' - Implements compose_function_t -.
static int	op_attach_group_related (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Group selected attachments as 'multipart/related' - Implements compose_function_t -.
static int	op_attach_move_down (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Move an attachment down in the attachment list - Implements compose_function_t -.
static int	op_attach_move_up (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Move an attachment up in the attachment list - Implements compose_function_t -.
static int	op_attach_new_mime (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Compose new attachment using mailcap entry - Implements compose_function_t -.
static int	op_attach_print (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Print the current entry - Implements compose_function_t -.
static int	op_attach_rename_attachment (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Send attachment with a different name - Implements compose_function_t -.
static int	op_attach_save (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Save message/attachment to a mailbox/file - Implements compose_function_t -.
static int	op_attach_toggle_disposition (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Toggle disposition between inline/attachment - Implements compose_function_t -.
static int	op_attach_toggle_recode (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Toggle recoding of this attachment - Implements compose_function_t -.
static int	op_attach_toggle_unlink (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Toggle whether to delete file after sending it - Implements compose_function_t -.
static int	op_attach_ungroup (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Ungroup a 'multipart' attachment - Implements compose_function_t -.
static int	op_attach_update_encoding (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Update an attachment's encoding info - Implements compose_function_t -.
static int	op_envelope_edit_headers (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit the message with headers - Implements compose_function_t -.
static int	op_compose_edit_file (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit the file to be attached - Implements compose_function_t -.
static int	op_compose_edit_message (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Edit the message - Implements compose_function_t -.
static int	op_compose_ispell (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Run ispell on the message - Implements compose_function_t -.
static int	op_compose_postpone_message (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Save this message to send later - Implements compose_function_t -.
static int	op_compose_rename_file (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Rename/move an attached file - Implements compose_function_t -.
static int	op_compose_send_message (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Send the message - Implements compose_function_t -.
static int	op_compose_write_message (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Write the message to a folder - Implements compose_function_t -.
static int	op_display_headers (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Display message and toggle header weeding - Implements compose_function_t -.
static int	op_quit (struct ComposeFunctionData *fdata, const struct KeyEvent *event)
	Save changes and exit this dialog - Implements compose_function_t -.

Detailed Description

Prototype for a Compose Function.

Parameters

fdata	Compose Function context data
event	Event to process

Return values

enum	FunctionRetval

Precondition

fdata is not NULL

event is not NULL

Function Documentation

op_attach_attach_file()

static int op_attach_attach_file ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Attach files to this message - Implements compose_function_t -.

Definition at line 1023 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  char *prompt = _("Attach file");
  int numfiles = 0;
  char **files = NULL;
 
  struct Buffer *fname = buf_pool_get();
  if ((mw_enter_fname(prompt, fname, false, NULL, true, &files, &numfiles,
                      MUTT_SEL_MULTI) == -1) ||
      buf_is_empty(fname))
  {
    for (int i = 0; i < numfiles; i++)
      FREE(&files[i]);
 
    FREE(&files);
    buf_pool_release(&fname);
    return FR_NO_ACTION;
  }
 
  bool error = false;
  bool added_attachment = false;
  if (numfiles > 1)
  {
    mutt_message(ngettext("Attaching selected file...",
                          "Attaching selected files...", numfiles));
  }
  for (int i = 0; i < numfiles; i++)
  {
    char *att = files[i];
    if (!att)
      continue;
 
    struct AttachPtr *ap = mutt_aptr_new();
    ap->unowned = true;
    ap->body = mutt_make_file_attach(att, shared->sub);
    if (ap->body)
    {
      added_attachment = true;
      update_idx(shared->adata->menu, shared->adata->actx, ap);
    }
    else
    {
      error = true;
      mutt_error(_("Unable to attach %s"), att);
      mutt_aptr_free(&ap);
    }
    FREE(&files[i]);
  }
 
  FREE(&files);
  buf_pool_release(&fname);
 
  if (!error)
    mutt_clear_error();
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  if (added_attachment)
    exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return added_attachment ? FR_SUCCESS : (error ? FR_ERROR : FR_NO_ACTION);
}

Here is the call graph for this function:

op_attach_attach_key()

static int op_attach_attach_key ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Attach a PGP public key - Implements compose_function_t -.

Definition at line 1089 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (!(WithCrypto & APPLICATION_PGP))
    return FR_NOT_IMPL;
  struct AttachPtr *ap = mutt_aptr_new();
  ap->body = crypt_pgp_make_key_attachment();
  if (ap->body)
  {
    update_idx(shared->adata->menu, shared->adata->actx, ap);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
    exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  }
  else
  {
    mutt_aptr_free(&ap);
  }
 
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_attach_message()

static int op_attach_attach_message ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Attach messages to this message - Implements compose_function_t -.

This function handles:

• OP_ATTACH_ATTACH_MESSAGE
• OP_ATTACH_ATTACH_NEWS_MESSAGE

Definition at line 1118 of file functions.c.

{
  struct NntpModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_NNTP);
  struct ComposeSharedData *shared = fdata->shared;
  char *prompt = _("Open mailbox to attach message from");
 
  OptNews = false;
  const int op = event->op;
  if (shared->mailbox && (op == OP_ATTACH_ATTACH_NEWS_MESSAGE))
  {
    const char *const c_news_server = cs_subset_string(shared->sub, "news_server");
    mod_data->current_news_srv = nntp_select_server(shared->mailbox, c_news_server, false);
    if (!mod_data->current_news_srv)
      return FR_NO_ACTION;
 
    prompt = _("Open newsgroup to attach message from");
    OptNews = true;
  }
 
  struct Buffer *fname = buf_pool_get();
  if (shared->mailbox)
  {
    if ((op == OP_ATTACH_ATTACH_MESSAGE) ^ (shared->mailbox->type == MUTT_NNTP))
    {
      buf_strcpy(fname, mailbox_path(shared->mailbox));
      pretty_mailbox(fname);
    }
  }
 
  if ((mw_enter_fname(prompt, fname, true, shared->mailbox, false, NULL, NULL,
                      MUTT_SEL_NONE) == -1) ||
      buf_is_empty(fname))
  {
    buf_pool_release(&fname);
    return FR_NO_ACTION;
  }
 
  if (OptNews)
    nntp_expand_path(fname->data, fname->dsize,
                     &mod_data->current_news_srv->conn->account);
  else
    expand_path(fname, false);
 
  if (imap_path_probe(buf_string(fname), NULL) != MUTT_IMAP)
  {
    if (pop_path_probe(buf_string(fname), NULL) != MUTT_POP)
    {
      if (!OptNews && (nntp_path_probe(buf_string(fname), NULL) != MUTT_NNTP))
      {
        if (mx_path_probe(buf_string(fname)) != MUTT_NOTMUCH)
        {
          /* check to make sure the file exists and is readable */
          if (access(buf_string(fname), R_OK) == -1)
          {
            mutt_perror("%s", buf_string(fname));
            buf_pool_release(&fname);
            return FR_ERROR;
          }
        }
      }
    }
  }
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
 
  struct Mailbox *m_attach = mx_path_resolve(buf_string(fname));
  const bool old_readonly = m_attach->readonly;
  if (!mx_mbox_open(m_attach, MUTT_READONLY))
  {
    mutt_error(_("Unable to open mailbox %s"), buf_string(fname));
    mx_fastclose_mailbox(m_attach, false);
    m_attach = NULL;
    buf_pool_release(&fname);
    return FR_ERROR;
  }
  buf_pool_release(&fname);
 
  if (m_attach->msg_count == 0)
  {
    mx_mbox_close(m_attach);
    mutt_error(_("No messages in that folder"));
    return FR_ERROR;
  }
 
  /* `$sort`, `$sort_aux`, `$use_threads` could be changed in dlg_index() */
  const enum EmailSortType old_sort = cs_subset_sort(shared->sub, "sort");
  const enum EmailSortType old_sort_aux = cs_subset_sort(shared->sub, "sort_aux");
  const unsigned char old_use_threads = cs_subset_enum(shared->sub, "use_threads");
 
  mutt_message(_("Tag the messages you want to attach"));
  struct MuttWindow *dlg = index_pager_init();
  struct IndexSharedData *index_shared = dlg->wdata;
  index_shared->attach_msg = true;
  dialog_push(dlg);
  struct Mailbox *m_attach_new = dlg_index(dlg, m_attach);
  dialog_pop();
  mutt_window_free(&dlg);
 
  if (!shared->mailbox)
  {
    /* Restore old $sort variables */
    cs_subset_str_native_set(shared->sub, "sort", old_sort, NULL);
    cs_subset_str_native_set(shared->sub, "sort_aux", old_sort_aux, NULL);
    cs_subset_str_native_set(shared->sub, "use_threads", old_use_threads, NULL);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
    notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
    return FR_SUCCESS;
  }
 
  bool added_attachment = false;
  for (int i = 0; i < m_attach_new->msg_count; i++)
  {
    if (!m_attach_new->emails[i])
      break;
    if (!message_is_tagged(m_attach_new->emails[i]))
      continue;
 
    struct AttachPtr *ap = mutt_aptr_new();
    ap->body = mutt_make_message_attach(m_attach_new, m_attach_new->emails[i],
                                        true, shared->sub);
    if (ap->body)
    {
      added_attachment = true;
      update_idx(shared->adata->menu, shared->adata->actx, ap);
    }
    else
    {
      mutt_error(_("Unable to attach"));
      mutt_aptr_free(&ap);
    }
  }
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
 
  if (m_attach_new == m_attach)
  {
    m_attach->readonly = old_readonly;
  }
  mx_fastclose_mailbox(m_attach_new, false);
 
  /* Restore old $sort variables */
  cs_subset_str_native_set(shared->sub, "sort", old_sort, NULL);
  cs_subset_str_native_set(shared->sub, "sort_aux", old_sort_aux, NULL);
  cs_subset_str_native_set(shared->sub, "use_threads", old_use_threads, NULL);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  if (added_attachment)
    exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return added_attachment ? FR_SUCCESS : FR_ERROR;
}

Here is the call graph for this function:

op_attach_detach()

static int op_attach_detach ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Delete the current entry - Implements compose_function_t -.

Definition at line 1271 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  struct Menu *menu = shared->adata->menu;
  int rc = FR_NO_ACTION;
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, actx, menu, menu->tag_prefix, event->count);
 
  if (ARRAY_SIZE(&aa) > 1)
  {
    for (int i = ARRAY_SIZE(&aa) - 1; i >= 0; i--)
    {
      struct AttachPtr **app = ARRAY_GET(&aa, i);
      if (!app || !*app)
        continue;
      struct AttachPtr *ap = *app;
 
      if (ap->unowned)
        ap->body->unlink = false;
 
      const int index = body_index(actx, ap->body);
      if ((index >= 0) && (delete_attachment(actx, index, fdata->n->sub) == 0))
        rc = FR_SUCCESS;
    }
 
    if (rc != FR_SUCCESS)
    {
      menu->num_tagged = 0;
      for (int i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged)
          menu->num_tagged++;
      }
      update_menu(actx, menu, false);
      ARRAY_FREE(&aa);
      return FR_ERROR;
    }
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(actx, menu);
    if (cur_att->unowned)
      cur_att->body->unlink = false;
 
    const int index = menu_get_index(menu);
    if (delete_attachment(actx, index, fdata->n->sub) == -1)
    {
      menu->num_tagged = 0;
      for (int i = 0; i < actx->idxlen; i++)
      {
        if (actx->idx[i]->body->tagged)
          menu->num_tagged++;
      }
      update_menu(actx, menu, false);
      ARRAY_FREE(&aa);
      return FR_ERROR;
    }
 
    rc = FR_SUCCESS;
  }
 
  if (rc == FR_SUCCESS)
    menu_queue_redraw(menu, selection_redraw_flags(event->count));
 
  menu->num_tagged = 0;
  for (int i = 0; i < actx->idxlen; i++)
  {
    if (actx->idx[i]->body->tagged)
      menu->num_tagged++;
  }
 
  update_menu(actx, menu, false);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
 
  const int index = menu_get_index(menu);
  if (index == 0)
    shared->email->body = actx->idx[0]->body;
 
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  ARRAY_FREE(&aa);
  return rc;
}

Here is the call graph for this function:

op_attach_edit_content_id()

static int op_attach_edit_content_id ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit the 'Content-ID' of the attachment - Implements compose_function_t -.

Definition at line 1361 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct Buffer *buf = buf_pool_get();
  struct Buffer *cid = buf_pool_get();
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
 
  struct AttachPtr *cur_att = current_attachment(actx, menu);
 
  char *id = cur_att->body->content_id;
  if (id)
  {
    buf_strcpy(buf, id);
  }
  else
  {
    id = gen_cid();
    buf_strcpy(buf, id);
    FREE(&id);
  }
 
  if (mw_get_field("Content-ID: ", buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) == 0)
  {
    if (check_cid(buf_string(buf)))
    {
      bool changed = false;
      struct Body **bp = NULL;
      ARRAY_FOREACH(bp, &ba)
      {
        const bool multi = (ARRAY_SIZE(&ba) > 1);
        int suffix = multi ? (ARRAY_FOREACH_IDX_bp + 1) : 0;
 
        do
        {
          if (suffix == 0)
            buf_strcpy(cid, buf_string(buf));
          else
            buf_printf(cid, "%s-%d", buf_string(buf), suffix);
 
          suffix++;
        } while (content_id_exists(actx, *bp, buf_string(cid)));
 
        if (!mutt_str_equal((*bp)->content_id, buf_string(cid)))
        {
          mutt_str_replace(&(*bp)->content_id, buf_string(cid));
          changed = true;
        }
      }
 
      if (changed)
      {
        menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&ba)));
        resolve_attachment(menu, shared->sub, index, num);
        notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
        exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
        rc = FR_SUCCESS;
      }
    }
    else
    {
      mutt_error(_("Content-ID can only contain the characters: -.0-9@A-Z_a-z"));
      rc = FR_ERROR;
    }
  }
 
  ARRAY_FREE(&ba);
  buf_pool_release(&cid);
  buf_pool_release(&buf);
 
  if (rc != FR_ERROR)
    mutt_clear_error();
 
  return rc;
}

Here is the call graph for this function:

op_attach_edit_description()

static int op_attach_edit_description ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit attachment description - Implements compose_function_t -.

Definition at line 1449 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct Buffer *buf = buf_pool_get();
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
 
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  buf_strcpy(buf, cur_att->body->description);
 
  /* header names should not be translated */
  if (mw_get_field("Description: ", buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) == 0)
  {
    ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
    const int num = ARRAY_SIZE(&ba);
 
    bool changed = false;
    struct Body **bp = NULL;
    ARRAY_FOREACH(bp, &ba)
    {
      if (!mutt_str_equal((*bp)->description, buf_string(buf)))
      {
        mutt_str_replace(&(*bp)->description, buf_string(buf));
        changed = true;
      }
    }
 
    if (changed)
    {
      menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&ba)));
      resolve_attachment(menu, shared->sub, index, num);
      exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
      rc = FR_SUCCESS;
    }
  }
 
  ARRAY_FREE(&ba);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_attach_edit_encoding()

static int op_attach_edit_encoding ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit attachment transfer-encoding - Implements compose_function_t -.

Definition at line 1500 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct Buffer *buf = buf_pool_get();
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
 
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  buf_strcpy(buf, ENCODING(cur_att->body->encoding));
 
  if ((mw_get_field("Content-Transfer-Encoding: ", buf, MUTT_COMP_NONE,
                    HC_OTHER, NULL, NULL) == 0) &&
      !buf_is_empty(buf))
  {
    int enc = mutt_check_encoding(buf_string(buf));
    if ((enc != ENC_OTHER) && (enc != ENC_UUENCODED))
    {
      ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
      const int num = ARRAY_SIZE(&ba);
 
      bool changed = false;
      struct Body **bp = NULL;
      ARRAY_FOREACH(bp, &ba)
      {
        if ((*bp)->encoding != enc)
        {
          (*bp)->encoding = enc;
          changed = true;
        }
      }
 
      if (changed)
      {
        menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&ba)));
        resolve_attachment(menu, shared->sub, index, num);
        notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
        mutt_clear_error();
        exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
        rc = FR_SUCCESS;
      }
    }
    else
    {
      mutt_error(_("Invalid encoding"));
      rc = FR_ERROR;
    }
  }
 
  ARRAY_FREE(&ba);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_attach_edit_language()

static int op_attach_edit_language ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit the 'Content-Language' of the attachment - Implements compose_function_t -.

Definition at line 1563 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct Buffer *buf = buf_pool_get();
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  struct AttachPtr *cur_att = current_attachment(actx, menu);
 
  buf_strcpy(buf, cur_att->body->language);
  if (mw_get_field("Content-Language: ", buf, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) == 0)
  {
    ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
    const int num = ARRAY_SIZE(&ba);
 
    bool changed = false;
    struct Body **bp = NULL;
    ARRAY_FOREACH(bp, &ba)
    {
      if (!mutt_str_equal((*bp)->language, buf_string(buf)))
      {
        mutt_str_replace(&(*bp)->language, buf_string(buf));
        changed = true;
      }
    }
 
    if (changed)
    {
      menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&ba)));
      resolve_attachment(menu, shared->sub, index, num);
      notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
      exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
      rc = FR_SUCCESS;
    }
    mutt_clear_error();
  }
  else
  {
    mutt_warning(_("Empty 'Content-Language'"));
    rc = FR_ERROR;
  }
 
  ARRAY_FREE(&ba);
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

op_attach_edit_mime()

static int op_attach_edit_mime ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit attachment using mailcap entry - Implements compose_function_t -.

Definition at line 1619 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
  if (ARRAY_EMPTY(&ba))
    goto done;
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    if (!mutt_edit_attachment(*bp))
      continue;
 
    mutt_update_encoding(*bp, shared->sub);
    rc = FR_SUCCESS;
  }
 
  if (rc != FR_SUCCESS)
    goto done;
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  resolve_attachment(menu, shared->sub, index, num);
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
 
done:
  ARRAY_FREE(&ba);
  return rc;
}

Here is the call graph for this function:

op_attach_edit_type()

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

static

Edit attachment content type - Implements compose_function_t -.

Definition at line 1660 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (!check_count(shared->adata->actx))
    return FR_ERROR;
 
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (!mutt_edit_content_type(NULL, cur_att->body, NULL))
    return FR_NO_ACTION;
 
  /* this may have been a change to text/something */
  mutt_update_encoding(cur_att->body, shared->sub);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_filter()

static int op_attach_filter ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Filter attachment through a shell command - Implements compose_function_t -.

This function handles:

• OP_ATTACH_FILTER
• OP_PIPE

Definition at line 1685 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&aa);
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, &aa)
  {
    if ((*app)->body->type == TYPE_MULTIPART)
    {
      ARRAY_FREE(&aa);
      mutt_error(_("Can't filter multipart attachments"));
      return FR_ERROR;
    }
  }
 
  const int op = event->op;
  mutt_pipe_attachment_list(&aa, (op == OP_ATTACH_FILTER));
  if (op == OP_ATTACH_FILTER) /* cte might have changed */
  {
    menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&aa)));
  }
  resolve_attachment(menu, shared->sub, index, num);
  ARRAY_FREE(&aa);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_get_attachment()

static int op_attach_get_attachment ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Get a temporary copy of an attachment - Implements compose_function_t -.

Definition at line 1724 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_ERROR;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
  if (ARRAY_EMPTY(&ba))
    goto done;
 
  struct Body **bp = NULL;
  bool got_attachment = false;
  ARRAY_FOREACH(bp, &ba)
  {
    if ((*bp)->type == TYPE_MULTIPART)
    {
      mutt_warning(_("Can't get multipart attachments"));
      continue;
    }
    mutt_get_tmp_attachment(*bp);
    got_attachment = true;
  }
 
  if (got_attachment)
  {
    menu_queue_redraw(menu, MENU_REDRAW_FULL);
    resolve_attachment(menu, shared->sub, index, num);
    rc = FR_SUCCESS;
  }
 
done:
  ARRAY_FREE(&ba);
  /* No send2hook since this doesn't change the message. */
  return rc;
}

Here is the call graph for this function:

op_attach_group_alts()

static int op_attach_group_alts ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Group selected attachments as 'multipart/alternative' - Implements compose_function_t -.

Definition at line 1770 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, shared->adata->actx, shared->adata->menu,
                   shared->adata->menu->tag_prefix, event->count);
  if (ARRAY_SIZE(&ba) < 2)
  {
    ARRAY_FREE(&ba);
    mutt_error(_("Grouping 'alternatives' requires at least 2 selected attachments"));
    return FR_ERROR;
  }
 
  const int rc = group_attachments(shared, "alternative", &ba);
  ARRAY_FREE(&ba);
  return rc;
}

Here is the call graph for this function:

op_attach_group_lingual()

static int op_attach_group_lingual ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Group selected attachments as 'multipart/multilingual' - Implements compose_function_t -.

Definition at line 1791 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, shared->adata->actx, shared->adata->menu,
                   shared->adata->menu->tag_prefix, event->count);
  if (ARRAY_SIZE(&ba) < 2)
  {
    ARRAY_FREE(&ba);
    mutt_error(_("Grouping 'multilingual' requires at least 2 selected attachments"));
    return FR_ERROR;
  }
 
  int tagged_with_lang_num = 0;
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    if ((*bp)->language && *(*bp)->language)
      tagged_with_lang_num++;
  }
 
  if (ARRAY_SIZE(&ba) != tagged_with_lang_num)
  {
    if (query_yesorno(_("Not all parts have 'Content-Language' set, continue?"),
                      MUTT_YES) != MUTT_YES)
    {
      ARRAY_FREE(&ba);
      mutt_message(_("Not sending this message"));
      return FR_ERROR;
    }
  }
 
  const int rc = group_attachments(shared, "multilingual", &ba);
  ARRAY_FREE(&ba);
  return rc;
}

Here is the call graph for this function:

op_attach_group_related()

static int op_attach_group_related ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Group selected attachments as 'multipart/related' - Implements compose_function_t -.

Definition at line 1832 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, shared->adata->actx, shared->adata->menu,
                   shared->adata->menu->tag_prefix, event->count);
  if (ARRAY_SIZE(&ba) < 2)
  {
    ARRAY_FREE(&ba);
    mutt_error(_("Grouping 'related' requires at least 2 selected attachments"));
    return FR_ERROR;
  }
 
  // ensure Content-ID is set for selected attachments
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    if ((*bp)->type == TYPE_MULTIPART)
      continue;
 
    if (!(*bp)->content_id)
    {
      (*bp)->content_id = gen_cid();
    }
  }
 
  const int rc = group_attachments(shared, "related", &ba);
  ARRAY_FREE(&ba);
  return rc;
}

Here is the call graph for this function:

op_attach_move_down()

static int op_attach_move_down ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Move an attachment down in the attachment list - Implements compose_function_t -.

Definition at line 1867 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (shared->adata->menu->tag_prefix || (event->count > 1))
    return move_attachment(shared, false, event->count);
 
  int index = menu_get_index(shared->adata->menu);
 
  struct AttachCtx *actx = shared->adata->actx;
 
  if (index < 0)
    return FR_ERROR;
 
  if (index == (actx->idxlen - 1))
  {
    mutt_error(_("Attachment is already at bottom"));
    return FR_ERROR;
  }
  if ((actx->idx[index]->parent_type == TYPE_MULTIPART) &&
      !actx->idx[index]->body->next)
  {
    mutt_error(_("Attachment can't be moved out of group"));
    return FR_ERROR;
  }
 
  // find next attachment at current level
  int nextidx = index + 1;
  while ((nextidx < actx->idxlen) &&
         (actx->idx[nextidx]->level > actx->idx[index]->level))
  {
    nextidx++;
  }
  if (nextidx == actx->idxlen)
  {
    mutt_error(_("Attachment is already at bottom"));
    return FR_ERROR;
  }
 
  // find final position
  int finalidx = index + 1;
  if (nextidx < actx->idxlen - 1)
  {
    if ((actx->idx[nextidx]->body->type == TYPE_MULTIPART) &&
        (actx->idx[nextidx + 1]->level > actx->idx[nextidx]->level))
    {
      finalidx += attach_body_count(actx->idx[nextidx]->body->parts, true);
    }
  }
 
  compose_attach_swap(shared->email, shared->adata->actx, index, nextidx);
  mutt_update_tree(shared->adata->actx);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  menu_set_index(shared->adata->menu, finalidx);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_move_up()

static int op_attach_move_up ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Move an attachment up in the attachment list - Implements compose_function_t -.

Definition at line 1927 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (shared->adata->menu->tag_prefix || (event->count > 1))
    return move_attachment(shared, true, event->count);
 
  int index = menu_get_index(shared->adata->menu);
  if (index < 0)
    return FR_ERROR;
 
  struct AttachCtx *actx = shared->adata->actx;
 
  if (index == 0)
  {
    mutt_error(_("Attachment is already at top"));
    return FR_ERROR;
  }
  if (actx->idx[index - 1]->level < actx->idx[index]->level)
  {
    mutt_error(_("Attachment can't be moved out of group"));
    return FR_ERROR;
  }
 
  // find previous attachment at current level
  int previdx = index - 1;
  while ((previdx > 0) && (actx->idx[previdx]->level > actx->idx[index]->level))
    previdx--;
 
  compose_attach_swap(shared->email, actx, previdx, index);
  mutt_update_tree(actx);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  menu_set_index(shared->adata->menu, previdx);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_new_mime()

static int op_attach_new_mime ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Compose new attachment using mailcap entry - Implements compose_function_t -.

Definition at line 1966 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  int rc = FR_NO_ACTION;
  struct Buffer *fname = buf_pool_get();
  struct Buffer *type = NULL;
  struct AttachPtr *ap = NULL;
 
  struct FileCompletionData cdata = { false, shared->mailbox, NULL, NULL, NULL };
  if ((mw_get_field(_("New file: "), fname, MUTT_COMP_NONE, HC_FILE,
                    &CompleteFileOps, &cdata) != 0) ||
      buf_is_empty(fname))
  {
    goto done;
  }
  expand_path(fname, false);
 
  /* Call to lookup_mime_type () ?  maybe later */
  type = buf_pool_get();
  if ((mw_get_field("Content-Type: ", type, MUTT_COMP_NONE, HC_OTHER, NULL, NULL) != 0) ||
      buf_is_empty(type))
  {
    goto done;
  }
 
  rc = FR_ERROR;
  char *p = strchr(buf_string(type), '/');
  if (!p)
  {
    mutt_error(_("Content-Type is of the form base/sub"));
    goto done;
  }
  *p++ = 0;
  enum ContentType itype = mutt_check_mime_type(buf_string(type));
  if (itype == TYPE_OTHER)
  {
    mutt_error(_("Unknown Content-Type %s"), buf_string(type));
    goto done;
  }
 
  ap = mutt_aptr_new();
  /* Touch the file */
  if (!mutt_file_touch(buf_string(fname)))
  {
    mutt_error(_("Can't create file %s"), buf_string(fname));
    goto done;
  }
 
  ap->body = mutt_make_file_attach(buf_string(fname), shared->sub);
  if (!ap->body)
  {
    mutt_error(_("Error attaching file"));
    goto done;
  }
  update_idx(shared->adata->menu, shared->adata->actx, ap);
  ap = NULL; // shared->adata->actx has taken ownership
 
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  cur_att->body->type = itype;
  mutt_str_replace(&cur_att->body->subtype, p);
  cur_att->body->unlink = true;
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
 
  if (mutt_compose_attachment(cur_att->body))
  {
    mutt_update_encoding(cur_att->body, shared->sub);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  }
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  rc = FR_SUCCESS;
 
done:
  mutt_aptr_free(&ap);
  buf_pool_release(&type);
  buf_pool_release(&fname);
  return rc;
}

Here is the call graph for this function:

op_attach_print()

static int op_attach_print ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Print the current entry - Implements compose_function_t -.

Definition at line 2049 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&aa);
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, &aa)
  {
    if ((*app)->body->type == TYPE_MULTIPART)
    {
      ARRAY_FREE(&aa);
      mutt_error(_("Can't print multipart attachments"));
      return FR_ERROR;
    }
  }
 
  mutt_print_attachment_list(&aa);
  ARRAY_FREE(&aa);
  resolve_attachment(menu, shared->sub, index, num);
  /* no send2hook, since this doesn't modify the message */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_rename_attachment()

static int op_attach_rename_attachment ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Send attachment with a different name - Implements compose_function_t -.

Definition at line 2082 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (!check_count(shared->adata->actx))
    return FR_ERROR;
  char *src = NULL;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (cur_att->body->d_filename)
    src = cur_att->body->d_filename;
  else
    src = cur_att->body->filename;
  struct Buffer *fname = buf_pool_get();
  buf_strcpy(fname, mutt_path_basename(NONULL(src)));
  struct FileCompletionData cdata = { false, shared->mailbox, NULL, NULL, NULL };
  int rc = mw_get_field(_("Send attachment with name: "), fname, MUTT_COMP_NONE,
                        HC_FILE, &CompleteFileOps, &cdata);
  if (rc == 0)
  {
    // It's valid to set an empty string here, to erase what was set
    mutt_str_replace(&cur_att->body->d_filename, buf_string(fname));
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  }
  buf_pool_release(&fname);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_save()

static int op_attach_save ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Save message/attachment to a mailbox/file - Implements compose_function_t -.

Definition at line 2113 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct AttachPtrArray aa = ARRAY_HEAD_INITIALIZER;
  aa_add_selection(&aa, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&aa);
  struct AttachPtr **app = NULL;
  ARRAY_FOREACH(app, &aa)
  {
    if ((*app)->body->type == TYPE_MULTIPART)
    {
      ARRAY_FREE(&aa);
      mutt_error(_("Can't save multipart attachments"));
      return FR_ERROR;
    }
  }
 
  mutt_save_attachment_list(&aa, NULL, menu);
  ARRAY_FREE(&aa);
  resolve_attachment(menu, shared->sub, index, num);
  /* no send2hook, since this doesn't modify the message */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_toggle_disposition()

static int op_attach_toggle_disposition ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Toggle disposition between inline/attachment - Implements compose_function_t -.

Definition at line 2146 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  /* toggle the content-disposition between inline/attachment */
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    (*bp)->disposition = ((*bp)->disposition == DISP_INLINE) ? DISP_ATTACH : DISP_INLINE;
    rc = FR_SUCCESS;
  }
 
  if (rc == FR_SUCCESS)
  {
    menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&ba)));
    resolve_attachment(menu, shared->sub, index, num);
  }
 
  ARRAY_FREE(&ba);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  return rc;
}

Here is the call graph for this function:

op_attach_toggle_recode()

static int op_attach_toggle_recode ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Toggle recoding of this attachment - Implements compose_function_t -.

Definition at line 2183 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    if (!mutt_is_text_part(*bp))
      continue;
 
    (*bp)->noconv = !(*bp)->noconv;
    rc = FR_SUCCESS;
  }
 
  if (rc == FR_NO_ACTION)
  {
    mutt_error(_("Recoding only affects text attachments"));
    ARRAY_FREE(&ba);
    return FR_ERROR;
  }
 
  if (ARRAY_SIZE(&ba) == 1)
  {
    struct AttachPtr *cur_att = current_attachment(actx, menu);
    if (cur_att->body->noconv)
      mutt_message(_("The current attachment won't be converted"));
    else
      mutt_message(_("The current attachment will be converted"));
  }
  else
  {
    mutt_clear_error();
  }
 
  menu_queue_redraw(menu, selection_redraw_flags(ARRAY_SIZE(&ba)));
  resolve_attachment(menu, shared->sub, index, num);
  ARRAY_FREE(&ba);
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_toggle_unlink()

static int op_attach_toggle_unlink ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Toggle whether to delete file after sending it - Implements compose_function_t -.

Definition at line 2238 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    (*bp)->unlink = !(*bp)->unlink;
    rc = FR_SUCCESS;
  }
 
  if (rc == FR_SUCCESS)
  {
    menu_queue_redraw(menu, MENU_REDRAW_INDEX);
    resolve_attachment(menu, shared->sub, index, num);
  }
 
  ARRAY_FREE(&ba);
  /* No send2hook since this doesn't change the message. */
  return rc;
}

Here is the call graph for this function:

op_attach_ungroup()

static int op_attach_ungroup ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Ungroup a 'multipart' attachment - Implements compose_function_t -.

Definition at line 2274 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (shared->adata->actx->idx[shared->adata->menu->current]->body->type != TYPE_MULTIPART)
  {
    mutt_error(_("Attachment is not 'multipart'"));
    return FR_ERROR;
  }
 
  int aidx = shared->adata->menu->current;
  struct AttachCtx *actx = shared->adata->actx;
  struct Body *b = actx->idx[aidx]->body;
  struct Body *b_next = b->next;
  struct Body *b_previous = NULL;
  struct Body *b_parent = NULL;
  int parent_type = actx->idx[aidx]->parent_type;
  int level = actx->idx[aidx]->level;
 
  // reorder body pointers
  if (attach_body_previous(shared->email->body, b, &b_previous))
    b_previous->next = b->parts;
  else if (attach_body_parent(shared->email->body, NULL, b, &b_parent))
    b_parent->parts = b->parts;
  else
    shared->email->body = b->parts;
 
  // update attachment list
  int i = aidx + 1;
  while ((i < actx->idxlen) && (actx->idx[i]->level > level))
  {
    actx->idx[i]->level--;
    if (actx->idx[i]->level == level)
    {
      actx->idx[i]->parent_type = parent_type;
      // set body->next for final attachment in group
      if (!actx->idx[i]->body->next)
        actx->idx[i]->body->next = b_next;
    }
    i++;
  }
 
  // free memory
  actx->idx[aidx]->body->parts = NULL;
  actx->idx[aidx]->body->next = NULL;
  actx->idx[aidx]->body->email = NULL;
  mutt_body_free(&actx->idx[aidx]->body);
  FREE(&actx->idx[aidx]->tree);
  FREE(&actx->idx[aidx]);
 
  // reorder attachment list
  for (int j = aidx; j < (actx->idxlen - 1); j++)
    actx->idx[j] = actx->idx[j + 1];
  actx->idx[actx->idxlen - 1] = NULL;
  actx->idxlen--;
  update_menu(actx, shared->adata->menu, false);
 
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_attach_update_encoding()

static int op_attach_update_encoding ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Update an attachment's encoding info - Implements compose_function_t -.

Definition at line 2337 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  int rc = FR_NO_ACTION;
  struct Menu *menu = shared->adata->menu;
  const int index = menu_get_index(menu);
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, event->count);
  const int num = ARRAY_SIZE(&ba);
  if (ARRAY_EMPTY(&ba))
    goto done;
 
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, &ba)
  {
    mutt_update_encoding(*bp, shared->sub);
  }
 
  menu_queue_redraw(menu, MENU_REDRAW_FULL);
  resolve_attachment(menu, shared->sub, index, num);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  rc = FR_SUCCESS;
 
done:
  ARRAY_FREE(&ba);
  return rc;
}

Here is the call graph for this function:

op_envelope_edit_headers()

static int op_envelope_edit_headers ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit the message with headers - Implements compose_function_t -.

Definition at line 2376 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  mutt_rfc3676_space_unstuff(shared->email);
  const char *tag = NULL;
  char *err = NULL;
  mutt_env_to_local(shared->email->env);
  const char *const c_editor = cs_subset_string(shared->sub, "editor");
  if (shared->email->body->type == TYPE_MULTIPART)
  {
    struct Body *b = shared->email->body->parts;
    while (b && b->parts)
      b = b->parts;
    if (b)
      mutt_edit_headers(NONULL(c_editor), b->filename, shared->email, shared->fcc);
  }
  else
  {
    mutt_edit_headers(NONULL(c_editor), shared->email->body->filename,
                      shared->email, shared->fcc);
  }
 
  if (mutt_env_to_intl(shared->email->env, &tag, &err))
  {
    mutt_error(_("Bad IDN in '%s': '%s'"), tag, err);
    FREE(&err);
  }
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ENVELOPE, NULL);
 
  mutt_rfc3676_space_stuff(shared->email);
  mutt_update_encoding(shared->email->body, shared->sub);
 
  /* attachments may have been added */
  if (shared->adata->actx->idxlen &&
      shared->adata->actx->idx[shared->adata->actx->idxlen - 1]->body->next)
  {
    mutt_actx_entries_free(shared->adata->actx);
    update_menu(shared->adata->actx, shared->adata->menu, true);
  }
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  /* Unconditional hook since editor was invoked */
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_compose_edit_file()

static int op_compose_edit_file ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit the file to be attached - Implements compose_function_t -.

Definition at line 2426 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (!check_count(shared->adata->actx))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't edit multipart attachments"));
    return FR_ERROR;
  }
  const char *const c_editor = cs_subset_string(shared->sub, "editor");
  mutt_edit_file(NONULL(c_editor), cur_att->body->filename);
  mutt_update_encoding(cur_att->body, shared->sub);
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  /* Unconditional hook since editor was invoked */
  exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_edit_message()

static int op_compose_edit_message ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Edit the message - Implements compose_function_t -.

Definition at line 2451 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  const bool c_edit_headers = cs_subset_bool(shared->sub, "edit_headers");
  if (!c_edit_headers)
  {
    mutt_rfc3676_space_unstuff(shared->email);
    const char *const c_editor = cs_subset_string(shared->sub, "editor");
    mutt_edit_file(c_editor, shared->email->body->filename);
    mutt_rfc3676_space_stuff(shared->email);
    mutt_update_encoding(shared->email->body, shared->sub);
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
    /* Unconditional hook since editor was invoked */
    exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
    return FR_SUCCESS;
  }
 
  return op_envelope_edit_headers(fdata, event);
}

Here is the call graph for this function:

op_compose_ispell()

static int op_compose_ispell ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Run ispell on the message - Implements compose_function_t -.

Definition at line 2475 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  endwin();
  const char *const c_ispell = cs_subset_string(shared->sub, "ispell");
  struct Buffer *cmd = buf_pool_get();
  struct Buffer *quoted = buf_pool_get();
  buf_quote_filename(quoted, shared->email->body->filename, true);
  buf_printf(cmd, "%s -x %s", NONULL(c_ispell), buf_string(quoted));
  buf_pool_release(&quoted);
  if (mutt_system(buf_string(cmd)) == -1)
  {
    mutt_error(_("Error running \"%s\""), buf_string(cmd));
    buf_pool_release(&cmd);
    return FR_ERROR;
  }
  buf_pool_release(&cmd);
 
  mutt_update_encoding(shared->email->body, shared->sub);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_postpone_message()

static int op_compose_postpone_message ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Save this message to send later - Implements compose_function_t -.

Definition at line 2501 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (check_attachments(shared->adata->actx, shared->sub) != 0)
  {
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
    return FR_ERROR;
  }
 
  shared->rc = 1;
  return FR_DONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

op_compose_rename_file()

static int op_compose_rename_file ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Rename/move an attached file - Implements compose_function_t -.

Definition at line 2518 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (!check_count(shared->adata->actx))
    return FR_ERROR;
  struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                 shared->adata->menu);
  if (cur_att->body->type == TYPE_MULTIPART)
  {
    mutt_error(_("Can't rename multipart attachments"));
    return FR_ERROR;
  }
  struct Buffer *fname = buf_pool_get();
  buf_strcpy(fname, cur_att->body->filename);
  pretty_mailbox(fname);
  struct FileCompletionData cdata = { false, shared->mailbox, NULL, NULL, NULL };
  if ((mw_get_field(_("Rename to: "), fname, MUTT_COMP_NONE, HC_FILE,
                    &CompleteFileOps, &cdata) == 0) &&
      !buf_is_empty(fname))
  {
    struct stat st = { 0 };
    if (stat(cur_att->body->filename, &st) == -1)
    {
      /* L10N: "stat" is a system call. Do "man 2 stat" for more information. */
      mutt_error(_("Can't stat %s: %s"), buf_string(fname), strerror(errno));
      buf_pool_release(&fname);
      return FR_ERROR;
    }
 
    expand_path(fname, false);
    if (mutt_file_rename(cur_att->body->filename, buf_string(fname)))
    {
      buf_pool_release(&fname);
      return FR_ERROR;
    }
 
    mutt_str_replace(&cur_att->body->filename, buf_string(fname));
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_CURRENT);
 
    if (cur_att->body->stamp >= st.st_mtime)
      mutt_stamp_attachment(cur_att->body);
    exec_message_hook(NULL, shared->email, CMD_SEND2_HOOK);
  }
  buf_pool_release(&fname);
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_compose_send_message()

static int op_compose_send_message ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Send the message - Implements compose_function_t -.

Definition at line 2569 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  /* Note: We don't invoke send2-hook here, since we want to leave
   * users an opportunity to change settings from the ":" prompt.  */
  if (check_attachments(shared->adata->actx, shared->sub) != 0)
  {
    menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
    return FR_NO_ACTION;
  }
 
  if (!shared->fcc_set && !buf_is_empty(shared->fcc))
  {
    enum QuadOption ans = query_quadoption(_("Save a copy of this message?"),
                                           shared->sub, "copy");
    if (ans == MUTT_ABORT)
      return FR_NO_ACTION;
    else if (ans == MUTT_NO)
      buf_reset(shared->fcc);
  }
 
  shared->rc = 0;
  return FR_DONE;
}

Here is the call graph for this function:

op_compose_write_message()

static int op_compose_write_message ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Write the message to a folder - Implements compose_function_t -.

Definition at line 2598 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  int rc = FR_NO_ACTION;
  struct Buffer *fname = buf_pool_get();
  if (shared->mailbox)
  {
    buf_strcpy(fname, mailbox_path(shared->mailbox));
    pretty_mailbox(fname);
  }
  if (shared->adata->actx->idxlen)
    shared->email->body = shared->adata->actx->idx[0]->body;
  if ((mw_enter_fname(_("Write message to mailbox"), fname, true,
                      shared->mailbox, false, NULL, NULL, MUTT_SEL_NONE) != -1) &&
      !buf_is_empty(fname))
  {
    mutt_message(_("Writing message to %s ..."), buf_string(fname));
    expand_path(fname, false);
 
    if (shared->email->body->next)
      shared->email->body = mutt_make_multipart(shared->email->body);
 
    if (mutt_write_fcc(buf_string(fname), shared->email, NULL, false, NULL,
                       NULL, shared->sub) == 0)
      mutt_message(_("Message written"));
 
    shared->email->body = mutt_remove_multipart(shared->email->body);
    rc = FR_SUCCESS;
  }
  buf_pool_release(&fname);
  return rc;
}

Here is the call graph for this function:

op_display_headers()

static int op_display_headers ( struct ComposeFunctionData * fdata, const struct KeyEvent * event )

static

Display message and toggle header weeding - Implements compose_function_t -.

This function handles:

• OP_ATTACH_VIEW
• OP_ATTACH_VIEW_MAILCAP
• OP_ATTACH_VIEW_PAGER
• OP_ATTACH_VIEW_TEXT
• OP_DISPLAY_HEADERS

Definition at line 2642 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  if (!check_count(shared->adata->actx))
    return FR_ERROR;
 
  enum ViewAttachMode mode = MUTT_VA_REGULAR;
 
  const int op = event->op;
  switch (op)
  {
    case OP_ATTACH_VIEW:
    case OP_DISPLAY_HEADERS:
      break;
 
    case OP_ATTACH_VIEW_MAILCAP:
      mode = MUTT_VA_MAILCAP;
      break;
 
    case OP_ATTACH_VIEW_PAGER:
      mode = MUTT_VA_PAGER;
      break;
 
    case OP_ATTACH_VIEW_TEXT:
      mode = MUTT_VA_AS_TEXT;
      break;
  }
 
  if (mode == MUTT_VA_REGULAR)
  {
    mutt_attach_display_loop(shared->sub, shared->adata->menu, op,
                             shared->email, shared->adata->actx, false);
  }
  else
  {
    struct AttachPtr *cur_att = current_attachment(shared->adata->actx,
                                                   shared->adata->menu);
    mutt_view_attachment(NULL, cur_att->body, mode, shared->email,
                         shared->adata->actx, shared->adata->menu->win);
  }
 
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_FULL);
  /* no send2hook, since this doesn't modify the message */
  return FR_SUCCESS;
}

Here is the call graph for this function:

op_quit()

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

static

Save changes and exit this dialog - Implements compose_function_t -.

Definition at line 2691 of file functions.c.

{
  struct ComposeSharedData *shared = fdata->shared;
  enum QuadOption ans = query_quadoption(_("Save (postpone) draft message?"),
                                         shared->sub, "postpone");
  if (ans == MUTT_NO)
  {
    for (int i = 0; i < shared->adata->actx->idxlen; i++)
      if (shared->adata->actx->idx[i]->unowned)
        shared->adata->actx->idx[i]->body->unlink = false;
 
    if (!(shared->flags & MUTT_COMPOSE_NOFREEHEADER))
    {
      for (int i = 0; i < shared->adata->actx->idxlen; i++)
      {
        /* avoid freeing other attachments */
        shared->adata->actx->idx[i]->body->next = NULL;
        if (!shared->adata->actx->idx[i]->body->email)
          shared->adata->actx->idx[i]->body->parts = NULL;
        mutt_body_free(&shared->adata->actx->idx[i]->body);
      }
    }
    shared->rc = -1;
    return FR_DONE;
  }
  else if (ans == MUTT_ABORT)
  {
    return FR_NO_ACTION;
  }
 
  return op_compose_postpone_message(fdata, event);
}

Here is the call graph for this function: