Compose functions. More...

#include "config.h"
#include <errno.h>
#include <stdbool.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "private.h"
#include "mutt/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "conn/lib.h"
#include "gui/lib.h"
#include "mutt.h"
#include "functions.h"
#include "lib.h"
#include "attach/lib.h"
#include "browser/lib.h"
#include "editor/lib.h"
#include "history/lib.h"
#include "hooks/lib.h"
#include "imap/lib.h"
#include "index/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "ncrypt/lib.h"
#include "nntp/lib.h"
#include "pop/lib.h"
#include "question/lib.h"
#include "send/lib.h"
#include "attach_data.h"
#include "external.h"
#include "globals.h"
#include "module_data.h"
#include "mutt_logging.h"
#include "muttlib.h"
#include "mx.h"
#include "nntp/adata.h"
#include "shared_data.h"
#include <libintl.h>

Include dependency graph for functions.c:

Go to the source code of this file.

Functions
void	compose_init_keys (struct NeoMutt n, struct SubMenu sm_generic)
	Initialise the Compose Keybindings - Implements ::init_keys_api.

static bool	check_count (struct AttachCtx *actx)
	Check if there are any attachments.

static char *	gen_cid (void)
	Generate a random Content ID.

static bool	check_cid (const char *cid)
	Check if a Content-ID is valid.

static bool	content_id_exists (struct AttachCtx actx, const struct Body skip, const char *cid)
	Check whether a Content-ID is already in use.

static int	check_attachments (struct AttachCtx actx, struct ConfigSubset sub)
	Check if any attachments have changed or been deleted.

static int	delete_attachment (struct AttachCtx actx, int aidx, struct ConfigSubset sub)
	Delete an attachment.

static void	update_idx (struct Menu menu, struct AttachCtx actx, struct AttachPtr *ap)
	Add a new attachment to the message.

static void	compose_attach_swap (struct Email e, struct AttachCtx actx, int first, int second)
	Swap two adjacent entries in the attachment list.

static int	body_index (struct AttachCtx actx, const struct Body b)
	Find the index of an attachment body.

static int	prev_sibling (struct AttachCtx *actx, int index)
	Find the previous sibling of an attachment.

static int	next_sibling (struct AttachCtx *actx, int index)
	Find the next sibling of an attachment.

static bool	body_array_contains (struct BodyArray ba, const struct Body b)
	Does a selection contain a body?

static bool	selected_attachments_are_siblings (struct Email e, struct BodyArray ba)
	Check whether selected attachments are siblings.

static MenuRedrawFlags	selection_redraw_flags (size_t count)
	Choose redraw flags for a selection.

static int	move_attachment (struct ComposeSharedData *shared, bool up, int count)
	Move attachments in the attachment list.

static int	group_attachments (struct ComposeSharedData shared, char subtype, struct BodyArray *ba)
	Group selected attachments into a multipart group.

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_exit (struct ComposeFunctionData fdata, const struct KeyEvent event)
	Exit this menu - Implements compose_function_t -.

static int	op_forget_passphrase (struct ComposeFunctionData fdata, const struct KeyEvent event)
	Wipe passphrases from memory - Implements compose_function_t -.

int	compose_function_dispatcher (struct MuttWindow win, const struct KeyEvent event)
	Perform a Compose function - Implements function_dispatcher_t -.

Variables
static const struct MenuFuncOp	OpCompose []
	Functions for the Compose Menu.

static const struct MenuOpSeq	ComposeDefaultBindings []
	Key bindings for the Compose Menu.

static const struct ComposeFunction	ComposeFunctions []
	All the NeoMutt functions that the Compose supports.

Detailed Description

Compose functions.

Authors

Pietro Cerutti
Richard Russon
David Purton

Copyright: This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file functions.c.

Function Documentation

◆ compose_init_keys()

void compose_init_keys	(	struct NeoMutt *	n,
		struct SubMenu *	sm_generic )

Initialise the Compose Keybindings - Implements ::init_keys_api.

Definition at line 209 of file functions.c.

{
  struct ComposeModuleData *mod_data = neomutt_get_module_data(n, MODULE_ID_COMPOSE);
  ASSERT(mod_data);
 
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm = NULL;
 
  sm = km_register_submenu(OpCompose);
  md = km_register_menu(MENU_COMPOSE, "compose");
  km_menu_add_submenu(md, sm);
  km_menu_add_submenu(md, sm_generic);
  km_menu_add_bindings(md, ComposeDefaultBindings);
 
  mod_data->md_compose = md;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_count()

static bool check_count ( struct AttachCtx * actx )

static

Check if there are any attachments.

Parameters

actx	Attachment context

Return values

true	There are attachments

Definition at line 231 of file functions.c.

{
  if (actx->idxlen == 0)
  {
    mutt_error(_("There are no attachments"));
    return false;
  }
 
  return true;
}

Here is the caller graph for this function:

◆ gen_cid()

static char * gen_cid ( void )

static

Generate a random Content ID.

Return values

ptr	Content ID

Note: The caller should free the string

Definition at line 248 of file functions.c.

{
  char rndid[MUTT_RANDTAG_LEN + 1];
 
  mutt_rand_base32(rndid, sizeof(rndid) - 1);
  rndid[MUTT_RANDTAG_LEN] = 0;
 
  return mutt_str_dup(rndid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_cid()

static bool check_cid ( const char * cid )

static

Check if a Content-ID is valid.

Parameters

cid	Content-ID to check

Return values

true	Content-ID is valid
false	Content-ID is not valid

Definition at line 264 of file functions.c.

{
  static const char *check = "^[-\\.0-9@A-Z_a-z]+$";
 
  struct Regex *check_cid_regex = mutt_regex_new(check, 0, NULL);
 
  const bool valid = mutt_regex_match(check_cid_regex, cid);
 
  mutt_regex_free(&check_cid_regex);
 
  return valid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ content_id_exists()

static bool content_id_exists	(	struct AttachCtx *	actx,
		const struct Body *	skip,
		const char *	cid )

static

Check whether a Content-ID is already in use.

Parameters

actx	Attachment context
skip	Body to ignore
cid	Content-ID to check

Return values

true	Content-ID already exists

Definition at line 284 of file functions.c.

{
  if (!actx || !cid)
    return false;
 
  for (int i = 0; i < actx->idxlen; i++)
  {
    struct Body *b = actx->idx[i]->body;
    if ((b == skip) || !b->content_id)
      continue;
 
    if (mutt_str_equal(b->content_id, cid))
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_attachments()

static int check_attachments	(	struct AttachCtx *	actx,
		struct ConfigSubset *	sub )

static

Check if any attachments have changed or been deleted.

Parameters

actx	Attachment context
sub	ConfigSubset

Return values

0	Success
-1	Error

Definition at line 309 of file functions.c.

{
  int rc = -1;
  struct stat st = { 0 };
  struct Buffer *pretty = NULL, *msg = NULL;
 
  for (int i = 0; i < actx->idxlen; i++)
  {
    if (actx->idx[i]->body->type == TYPE_MULTIPART)
      continue;
    if (stat(actx->idx[i]->body->filename, &st) != 0)
    {
      if (!pretty)
        pretty = buf_pool_get();
      buf_strcpy(pretty, actx->idx[i]->body->filename);
      pretty_mailbox(pretty);
      /* L10N: This message is displayed in the compose menu when an attachment
         doesn't stat.  %d is the attachment number and %s is the attachment
         filename.  The filename is located last to avoid a long path hiding
         the error message.  */
      mutt_error(_("Attachment #%d no longer exists: %s"), i + 1, buf_string(pretty));
      goto cleanup;
    }
 
    if (actx->idx[i]->body->stamp < st.st_mtime)
    {
      if (!pretty)
        pretty = buf_pool_get();
      buf_strcpy(pretty, actx->idx[i]->body->filename);
      pretty_mailbox(pretty);
 
      if (!msg)
        msg = buf_pool_get();
      /* L10N: This message is displayed in the compose menu when an attachment
         is modified behind the scenes.  %d is the attachment number and %s is
         the attachment filename.  The filename is located last to avoid a long
         path hiding the prompt question.  */
      buf_printf(msg, _("Attachment #%d modified. Update encoding for %s?"),
                 i + 1, buf_string(pretty));
 
      enum QuadOption ans = query_yesorno(buf_string(msg), MUTT_YES);
      if (ans == MUTT_YES)
        mutt_update_encoding(actx->idx[i]->body, sub);
      else if (ans == MUTT_ABORT)
        goto cleanup;
    }
  }
 
  rc = 0;
 
cleanup:
  buf_pool_release(&pretty);
  buf_pool_release(&msg);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_attachment()

static int delete_attachment	(	struct AttachCtx *	actx,
		int	aidx,
		struct ConfigSubset *	sub )

static

Delete an attachment.

Parameters

actx	Attachment context
aidx	Index number of attachment to delete
sub	Config subset

Return values

0	Success
-1	Error

Definition at line 373 of file functions.c.

{
  if (!actx || (aidx < 0) || (aidx >= actx->idxlen))
    return -1;
 
  struct AttachPtr **idx = actx->idx;
  struct Body *b_previous = NULL;
  struct Body *b_parent = NULL;
 
  if (aidx == 0)
  {
    struct Body *b = actx->idx[0]->body;
    if (!b->next) // There's only one attachment left
    {
      mutt_error(_("You may not delete the only attachment"));
      return -1;
    }
 
    if (cs_subset_bool(sub, "compose_confirm_detach_first"))
    {
      /* L10N: Prompt when trying to hit <detach-file> on the first entry in
         the compose menu.  This entry is most likely the message they just
         typed.  Hitting yes will remove the entry and unlink the file, so
         it's worth confirming they really meant to do it. */
      enum QuadOption ans = query_yesorno_help(_("Really delete the main message?"), MUTT_NO,
                                               sub, "compose_confirm_detach_first");
      if (ans == MUTT_NO)
      {
        idx[aidx]->body->tagged = false;
        return -1;
      }
    }
  }
 
  if (idx[aidx]->level > 0)
  {
    if (attach_body_parent(idx[0]->body, NULL, idx[aidx]->body, &b_parent))
    {
      if (attach_body_count(b_parent->parts, false) < 3)
      {
        mutt_error(_("Can't leave group with only one attachment"));
        return -1;
      }
    }
  }
 
  // reorder body pointers
  if (aidx > 0)
  {
    if (attach_body_previous(idx[0]->body, idx[aidx]->body, &b_previous))
      b_previous->next = idx[aidx]->body->next;
    else if (attach_body_parent(idx[0]->body, NULL, idx[aidx]->body, &b_parent))
      b_parent->parts = idx[aidx]->body->next;
  }
 
  // free memory
  int part_count = 1;
  if (aidx < (actx->idxlen - 1))
  {
    if ((idx[aidx]->body->type == TYPE_MULTIPART) &&
        (idx[aidx + 1]->level > idx[aidx]->level))
    {
      part_count += attach_body_count(idx[aidx]->body->parts, true);
    }
  }
  idx[aidx]->body->next = NULL;
  mutt_body_free(&(idx[aidx]->body));
  for (int i = 0; i < part_count; i++)
  {
    FREE(&idx[aidx + i]->tree);
    FREE(&idx[aidx + i]);
  }
 
  // reorder attachment list
  for (int i = aidx; i < (actx->idxlen - part_count); i++)
    idx[i] = idx[i + part_count];
  for (int i = 0; i < part_count; i++)
    idx[actx->idxlen - i - 1] = NULL;
  actx->idxlen -= part_count;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_idx()

static void update_idx	(	struct Menu *	menu,
		struct AttachCtx *	actx,
		struct AttachPtr *	ap )

static

Add a new attachment to the message.

Parameters

menu	Current menu
actx	Attachment context
ap	Attachment to add

Definition at line 462 of file functions.c.

{
  ap->level = 0;
  for (int i = actx->idxlen; i > 0; i--)
  {
    if (ap->level == actx->idx[i - 1]->level)
    {
      actx->idx[i - 1]->body->next = ap->body;
      break;
    }
  }
 
  ap->body->aptr = ap;
  mutt_actx_add_attach(actx, ap);
  update_menu(actx, menu, false);
  menu_set_index(menu, actx->vcount - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compose_attach_swap()

static void compose_attach_swap	(	struct Email *	e,
		struct AttachCtx *	actx,
		int	first,
		int	second )

static

Swap two adjacent entries in the attachment list.

Parameters

e	Email
actx	Attachment information
first	Index of first attachment to swap
second	Index of second attachment to swap

Definition at line 487 of file functions.c.

{
  struct AttachPtr **idx = actx->idx;
 
  // check that attachments really are adjacent
  if (idx[first]->body->next != idx[second]->body)
    return;
 
  // reorder Body pointers
  if (first == 0)
  {
    // first attachment is the fundamental part
    idx[first]->body->next = idx[second]->body->next;
    idx[second]->body->next = idx[first]->body;
    e->body = idx[second]->body;
  }
  else
  {
    // find previous attachment
    struct Body *b_previous = NULL;
    struct Body *b_parent = NULL;
    if (attach_body_previous(e->body, idx[first]->body, &b_previous))
    {
      idx[first]->body->next = idx[second]->body->next;
      idx[second]->body->next = idx[first]->body;
      b_previous->next = idx[second]->body;
    }
    else if (attach_body_parent(e->body, NULL, idx[first]->body, &b_parent))
    {
      idx[first]->body->next = idx[second]->body->next;
      idx[second]->body->next = idx[first]->body;
      b_parent->parts = idx[second]->body;
    }
  }
 
  // reorder attachment list
  struct AttachPtr *saved = idx[second];
  for (int i = second; i > first; i--)
    idx[i] = idx[i - 1];
  idx[first] = saved;
 
  // if moved attachment is a group then move subparts too
  if ((idx[first]->body->type == TYPE_MULTIPART) && (second < actx->idxlen - 1))
  {
    int i = second + 1;
    while (idx[i]->level > idx[first]->level)
    {
      saved = idx[i];
      int destidx = i - second + first;
      for (int j = i; j > destidx; j--)
        idx[j] = idx[j - 1];
      idx[destidx] = saved;
      i++;
      if (i >= actx->idxlen)
        break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ body_index()

static int body_index	(	struct AttachCtx *	actx,
		const struct Body *	b )

static

Find the index of an attachment body.

Parameters

actx	Attachment context
b	Body to find

Return values

num	Index of body
-1	Body wasn't found

Definition at line 553 of file functions.c.

{
  if (!actx || !b)
    return -1;
 
  for (int i = 0; i < actx->idxlen; i++)
  {
    if (actx->idx[i]->body == b)
      return i;
  }
 
  return -1;
}

Here is the caller graph for this function:

◆ prev_sibling()

static int prev_sibling	(	struct AttachCtx *	actx,
		int	index )

static

Find the previous sibling of an attachment.

Parameters

actx	Attachment context
index	Index of attachment

Return values

num	Index of previous sibling
-1	No previous sibling

Definition at line 574 of file functions.c.

{
  if (!actx || (index <= 0) || (index >= actx->idxlen))
    return -1;
 
  const int level = actx->idx[index]->level;
  int previdx = index - 1;
  while ((previdx > 0) && (actx->idx[previdx]->level > level))
    previdx--;
 
  return (actx->idx[previdx]->level == level) ? previdx : -1;
}

Here is the caller graph for this function:

◆ next_sibling()

static int next_sibling	(	struct AttachCtx *	actx,
		int	index )

static

Find the next sibling of an attachment.

Parameters

actx	Attachment context
index	Index of attachment

Return values

num	Index of next sibling
-1	No next sibling

Definition at line 594 of file functions.c.

{
  if (!actx || (index < 0) || (index >= actx->idxlen))
    return -1;
 
  const int level = actx->idx[index]->level;
  int nextidx = index + 1;
  while ((nextidx < actx->idxlen) && (actx->idx[nextidx]->level > level))
    nextidx++;
 
  if ((nextidx >= actx->idxlen) || (actx->idx[nextidx]->level != level))
    return -1;
 
  return nextidx;
}

Here is the caller graph for this function:

◆ body_array_contains()

static bool body_array_contains	(	struct BodyArray *	ba,
		const struct Body *	b )

static

Does a selection contain a body?

Parameters

ba	Selected attachments
b	Body to find

Return values

true	Body is selected

Definition at line 616 of file functions.c.

{
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, ba)
  {
    if (*bp == b)
      return true;
  }
 
  return false;
}

Here is the caller graph for this function:

◆ selected_attachments_are_siblings()

static bool selected_attachments_are_siblings	(	struct Email *	e,
		struct BodyArray *	ba )

static

Check whether selected attachments are siblings.

Parameters

e	Email
ba	Selected attachments

Return values

true	Selected attachments are siblings

Definition at line 634 of file functions.c.

{
  if (!e || !ba)
    return false;
 
  int level = -1;
  struct Body *parent = NULL;
  struct Body **bp = NULL;
  ARRAY_FOREACH(bp, ba)
  {
    struct Body *this_parent = NULL;
    struct Body *body = *bp;
    if (body->aptr && (body->aptr->level > 0))
    {
      if (!attach_body_parent(e->body, NULL, body, &this_parent))
        return false;
    }
 
    if (level == -1)
    {
      level = body->aptr ? body->aptr->level : 0;
      parent = this_parent;
      continue;
    }
 
    if ((level != (body->aptr ? body->aptr->level : 0)) || (parent != this_parent))
      return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selection_redraw_flags()

static MenuRedrawFlags selection_redraw_flags ( size_t count )

static

Choose redraw flags for a selection.

Parameters

count Number of selected attachments

Return values

redraw flags for the selection

Definition at line 671 of file functions.c.

{
  return (count > 1) ? MENU_REDRAW_FULL : MENU_REDRAW_CURRENT;
}

Here is the caller graph for this function:

◆ move_attachment()

static int move_attachment	(	struct ComposeSharedData *	shared,
		bool	up,
		int	count )

static

Move attachments in the attachment list.

Parameters

shared	Shared compose data
up	If true, move up, otherwise move down
count	Repeat-count

Return values

enum	FunctionRetval

Definition at line 683 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  if (!check_count(actx))
    return FR_ERROR;
 
  struct Menu *menu = shared->adata->menu;
  struct AttachPtr *cur_att = current_attachment(actx, menu);
  if (!cur_att)
    return FR_ERROR;
 
  struct Body *cur_body = cur_att->body;
  struct BodyArray ba = ARRAY_HEAD_INITIALIZER;
  ba_add_selection(&ba, actx, menu, menu->tag_prefix, count);
  if (ARRAY_EMPTY(&ba))
    goto done;
 
  if ((ARRAY_SIZE(&ba) > 1) && !selected_attachments_are_siblings(shared->email, &ba))
  {
    mutt_error(_("Selected attachments must be siblings"));
    ARRAY_FREE(&ba);
    return FR_ERROR;
  }
 
  bool moved = false;
  if (up)
  {
    struct Body **bp = NULL;
    ARRAY_FOREACH(bp, &ba)
    {
      const int index = body_index(actx, *bp);
      const int previdx = prev_sibling(actx, index);
      if (previdx < 0)
        continue;
      if (body_array_contains(&ba, actx->idx[previdx]->body))
        continue;
 
      compose_attach_swap(shared->email, actx, previdx, index);
      moved = true;
    }
  }
  else
  {
    for (int i = ARRAY_SIZE(&ba) - 1; i >= 0; i--)
    {
      struct Body **bp = ARRAY_GET(&ba, i);
      const int index = body_index(actx, *bp);
      const int nextidx = next_sibling(actx, index);
      if (nextidx < 0)
        continue;
      if (body_array_contains(&ba, actx->idx[nextidx]->body))
        continue;
 
      compose_attach_swap(shared->email, actx, index, nextidx);
      moved = true;
    }
  }
 
  if (!moved)
  {
    mutt_error(up ? _("Attachment is already at top") : _("Attachment is already at bottom"));
    goto done;
  }
 
  mutt_update_tree(actx);
  menu_queue_redraw(menu, MENU_REDRAW_INDEX);
  notify_send(shared->email->notify, NT_EMAIL, NT_EMAIL_CHANGE_ATTACH, NULL);
 
  const int index = body_index(actx, cur_body);
  if (index >= 0)
    menu_set_index(menu, index);
 
  ARRAY_FREE(&ba);
  return FR_SUCCESS;
 
done:
  ARRAY_FREE(&ba);
  return FR_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ group_attachments()

static int group_attachments	(	struct ComposeSharedData *	shared,
		char *	subtype,
		struct BodyArray *	ba )

static

Group selected attachments into a multipart group.

Parameters

shared	Shared compose data
subtype	MIME subtype
ba	Selected attachments

Return values

FR_SUCCESS	Success
FR_ERROR	Failure

Definition at line 771 of file functions.c.

{
  struct AttachCtx *actx = shared->adata->actx;
  int group_level = -1;
  struct Body *bptr_parent = NULL;
 
  // Attachments to be grouped must have the same parent
  for (int i = 0; i < actx->idxlen; i++)
  {
    if (body_array_contains(ba, actx->idx[i]->body))
    {
      if (group_level == -1)
      {
        group_level = actx->idx[i]->level;
      }
      else
      {
        if (group_level != actx->idx[i]->level)
        {
          mutt_error(_("Attachments to be grouped must have the same parent"));
          return FR_ERROR;
        }
      }
      // if not at top level check if all tagged attachments have same parent
      if (group_level > 0)
      {
        if (bptr_parent)
        {
          struct Body *bptr_test = NULL;
          if (!attach_body_parent(actx->idx[0]->body, NULL, actx->idx[i]->body, &bptr_test))
            mutt_debug(LL_DEBUG5, "can't find parent\n");
          if (bptr_test != bptr_parent)
          {
            mutt_error(_("Attachments to be grouped must have the same parent"));
            return FR_ERROR;
          }
        }
        else
        {
          if (!attach_body_parent(actx->idx[0]->body, NULL, actx->idx[i]->body, &bptr_parent))
            mutt_debug(LL_DEBUG5, "can't find parent\n");
        }
      }
    }
  }
 
  // Can't group all attachments unless at top level
  if (bptr_parent)
  {
    if (ARRAY_SIZE(ba) == attach_body_count(bptr_parent->parts, false))
    {
      mutt_error(_("Can't leave group with only one attachment"));
      return FR_ERROR;
    }
  }
 
  struct Body *group = mutt_body_new();
  group->type = TYPE_MULTIPART;
  group->subtype = mutt_str_dup(subtype);
  group->encoding = ENC_7BIT;
 
  struct Body *bptr_first = NULL;     // first selected attachment
  struct Body *bptr = NULL;           // current selected attachment
  struct Body *group_parent = NULL;   // parent of group
  struct Body *group_previous = NULL; // previous body to group
  struct Body *group_part = NULL;     // current attachment in group
  int group_idx = 0; // index in attachment list where group will be inserted
  int group_last_idx = 0; // index of last part of previous found group
  int group_parent_type = TYPE_OTHER;
 
  for (int i = 0; i < actx->idxlen; i++)
  {
    bptr = actx->idx[i]->body;
    if (body_array_contains(ba, bptr))
    {
      // set group properties based on first selected attachment
      if (!bptr_first)
      {
        group->disposition = bptr->disposition;
        if (bptr->language && !mutt_str_equal(subtype, "multilingual"))
          group->language = mutt_str_dup(bptr->language);
        group_parent_type = bptr->aptr->parent_type;
        bptr_first = bptr;
        if (i > 0)
        {
          if (!attach_body_previous(shared->email->body, bptr, &group_previous))
          {
            mutt_debug(LL_DEBUG5, "couldn't find previous\n");
          }
          if (!attach_body_parent(shared->email->body, NULL, bptr, &group_parent))
          {
            mutt_debug(LL_DEBUG5, "couldn't find parent\n");
          }
        }
      }
 
      if (bptr->tagged)
      {
        shared->adata->menu->num_tagged--;
        bptr->tagged = false;
      }
      bptr->aptr->level++;
      bptr->aptr->parent_type = TYPE_MULTIPART;
 
      // append bptr to the group parts list and remove from email body list
      struct Body *bptr_previous = NULL;
      if (attach_body_previous(shared->email->body, bptr, &bptr_previous))
        bptr_previous->next = bptr->next;
      else if (attach_body_parent(shared->email->body, NULL, bptr, &bptr_parent))
        bptr_parent->parts = bptr->next;
      else
        shared->email->body = bptr->next;
 
      if (group_part)
      {
        // add bptr to group parts list
        group_part->next = bptr;
        group_part = group_part->next;
        group_part->next = NULL;
 
        // reorder attachments and set levels
        int bptr_attachments = attach_body_count(bptr, true);
        for (int j = i + 1; j < (i + bptr_attachments); j++)
          actx->idx[j]->level++;
        if (i > (group_last_idx + 1))
        {
          for (int j = 0; j < bptr_attachments; j++)
          {
            struct AttachPtr *saved = actx->idx[i + bptr_attachments - 1];
            for (int k = i + bptr_attachments - 1; k > (group_last_idx + 1); k--)
              actx->idx[k] = actx->idx[k - 1];
            actx->idx[group_last_idx + 1] = saved;
          }
        }
        i += bptr_attachments - 1;
        group_last_idx += bptr_attachments;
      }
      else
      {
        group_idx = i;
        group->parts = bptr;
        group_part = bptr;
        group_part->next = NULL;
        int bptr_attachments = attach_body_count(bptr, true);
        for (int j = i + 1; j < (i + bptr_attachments); j++)
          actx->idx[j]->level++;
        i += bptr_attachments - 1;
        group_last_idx = i;
      }
    }
  }
 
  if (!bptr_first)
  {
    mutt_body_free(&group);
    return FR_ERROR;
  }
 
  // set group->next
  int next_aidx = group_idx + attach_body_count(group->parts, true);
  if (group_parent)
  {
    // find next attachment with the same parent as the group
    struct Body *b = NULL;
    struct Body *b_parent = NULL;
    while (next_aidx < actx->idxlen)
    {
      b = actx->idx[next_aidx]->body;
      b_parent = NULL;
      if (attach_body_parent(shared->email->body, NULL, b, &b_parent))
      {
        if (group_parent == b_parent)
        {
          group->next = b;
          break;
        }
      }
      next_aidx++;
    }
  }
  else if (next_aidx < actx->idxlen)
  {
    // group is at top level
    group->next = actx->idx[next_aidx]->body;
  }
 
  // set previous or parent for group
  if (group_previous)
    group_previous->next = group;
  else if (group_parent)
    group_parent->parts = group;
 
  mutt_generate_boundary(&group->parameter);
 
  struct AttachPtr *group_ap = mutt_aptr_new();
  group_ap->body = group;
  group_ap->body->aptr = group_ap;
  group_ap->level = group_level;
  group_ap->parent_type = group_parent_type;
 
  // insert group into attachment list
  mutt_actx_ins_attach(actx, group_ap, group_idx);
 
  // update email body and last attachment pointers
  shared->email->body = actx->idx[0]->body;
  actx->idx[actx->idxlen - 1]->body->next = NULL;
 
  update_menu(actx, shared->adata->menu, false);
  shared->adata->menu->current = group_idx;
  menu_queue_redraw(shared->adata->menu, MENU_REDRAW_INDEX);
 
  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:

Variable Documentation

◆ OpCompose

const struct MenuFuncOp OpCompose[]

static

Functions for the Compose Menu.

Definition at line 78 of file functions.c.

                                             { /* map: compose */
  { "attach-file",                   OP_ATTACH_ATTACH_FILE },
  { "attach-key",                    OP_ATTACH_ATTACH_KEY },
  { "attach-message",                OP_ATTACH_ATTACH_MESSAGE },
  { "attach-news-message",           OP_ATTACH_ATTACH_NEWS_MESSAGE },
#ifdef USE_AUTOCRYPT
  { "autocrypt-menu",                OP_COMPOSE_AUTOCRYPT_MENU },
#endif
  { "copy-file",                     OP_ATTACH_SAVE },
  { "detach-file",                   OP_ATTACH_DETACH },
  { "display-toggle-weed",           OP_DISPLAY_HEADERS },
  { "edit-bcc",                      OP_ENVELOPE_EDIT_BCC },
  { "edit-cc",                       OP_ENVELOPE_EDIT_CC },
  { "edit-content-id",               OP_ATTACH_EDIT_CONTENT_ID },
  { "edit-description",              OP_ATTACH_EDIT_DESCRIPTION },
  { "edit-encoding",                 OP_ATTACH_EDIT_ENCODING },
  { "edit-fcc",                      OP_ENVELOPE_EDIT_FCC },
  { "edit-file",                     OP_COMPOSE_EDIT_FILE },
  { "edit-followup-to",              OP_ENVELOPE_EDIT_FOLLOWUP_TO },
  { "edit-from",                     OP_ENVELOPE_EDIT_FROM },
  { "edit-headers",                  OP_ENVELOPE_EDIT_HEADERS },
  { "edit-language",                 OP_ATTACH_EDIT_LANGUAGE },
  { "edit-message",                  OP_COMPOSE_EDIT_MESSAGE },
  { "edit-mime",                     OP_ATTACH_EDIT_MIME },
  { "edit-newsgroups",               OP_ENVELOPE_EDIT_NEWSGROUPS },
  { "edit-reply-to",                 OP_ENVELOPE_EDIT_REPLY_TO },
  { "edit-subject",                  OP_ENVELOPE_EDIT_SUBJECT },
  { "edit-to",                       OP_ENVELOPE_EDIT_TO },
  { "edit-type",                     OP_ATTACH_EDIT_TYPE },
  { "edit-x-comment-to",             OP_ENVELOPE_EDIT_X_COMMENT_TO },
  { "exit",                          OP_EXIT },
  { "filter-entry",                  OP_ATTACH_FILTER },
  { "forget-passphrase",             OP_FORGET_PASSPHRASE },
  { "get-attachment",                OP_ATTACH_GET_ATTACHMENT },
  { "group-alternatives",            OP_ATTACH_GROUP_ALTS },
  { "group-multilingual",            OP_ATTACH_GROUP_LINGUAL },
  { "group-related",                 OP_ATTACH_GROUP_RELATED },
  { "ispell",                        OP_COMPOSE_ISPELL },
  { "move-down",                     OP_ATTACH_MOVE_DOWN },
  { "move-up",                       OP_ATTACH_MOVE_UP },
  { "new-mime",                      OP_ATTACH_NEW_MIME },
  { "pgp-menu",                      OP_COMPOSE_PGP_MENU },
  { "pipe-entry",                    OP_PIPE },
  { "pipe-message",                  OP_PIPE },
  { "postpone-message",              OP_COMPOSE_POSTPONE_MESSAGE },
  { "preview-page-down",             OP_PREVIEW_PAGE_DOWN },
  { "preview-page-up",               OP_PREVIEW_PAGE_UP },
  { "print-entry",                   OP_ATTACH_PRINT },
  { "rename-attachment",             OP_ATTACH_RENAME_ATTACHMENT },
  { "rename-file",                   OP_COMPOSE_RENAME_FILE },
  { "send-message",                  OP_COMPOSE_SEND_MESSAGE },
  { "smime-menu",                    OP_COMPOSE_SMIME_MENU },
  { "toggle-disposition",            OP_ATTACH_TOGGLE_DISPOSITION },
  { "toggle-recode",                 OP_ATTACH_TOGGLE_RECODE },
  { "toggle-unlink",                 OP_ATTACH_TOGGLE_UNLINK },
  { "ungroup-attachment",            OP_ATTACH_UNGROUP },
  { "update-encoding",               OP_ATTACH_UPDATE_ENCODING },
  { "view-attach",                   OP_ATTACH_VIEW },
  { "view-mailcap",                  OP_ATTACH_VIEW_MAILCAP },
  { "view-pager",                    OP_ATTACH_VIEW_PAGER },
  { "view-text",                     OP_ATTACH_VIEW_TEXT },
  { "write-fcc",                     OP_COMPOSE_WRITE_MESSAGE },
  { NULL, 0 },
};

◆ ComposeDefaultBindings

const struct MenuOpSeq ComposeDefaultBindings[]

static

Key bindings for the Compose Menu.

Definition at line 146 of file functions.c.

                                                         { /* map: compose */
  { OP_ATTACH_ATTACH_FILE,             "a" },
  { OP_ATTACH_ATTACH_KEY,              "\033k" },          // <Alt-k>
  { OP_ATTACH_ATTACH_MESSAGE,          "A" },
  { OP_ATTACH_DETACH,                  "D" },
  { OP_ATTACH_EDIT_CONTENT_ID,         "\033i" },          // <Alt-i>
  { OP_ATTACH_EDIT_DESCRIPTION,        "d" },
  { OP_ATTACH_EDIT_ENCODING,           "\005" },           // <Ctrl-E>
  { OP_ATTACH_EDIT_LANGUAGE,           "\014" },           // <Ctrl-L>
  { OP_ATTACH_EDIT_MIME,               "m" },
  { OP_ATTACH_EDIT_TYPE,               "\024" },           // <Ctrl-T>
  { OP_ATTACH_FILTER,                  "F" },
  { OP_ATTACH_GET_ATTACHMENT,          "G" },
  { OP_ATTACH_GROUP_ALTS,              "&" },
  { OP_ATTACH_GROUP_LINGUAL,           "^" },
  { OP_ATTACH_GROUP_RELATED,           "%" },
  { OP_ATTACH_MOVE_DOWN,               "+" },
  { OP_ATTACH_MOVE_UP,                 "-" },
  { OP_ATTACH_NEW_MIME,                "n" },
  { OP_EXIT,                               "q" },
  { OP_PIPE,                               "|" },
  { OP_ATTACH_PRINT,                   "l" },
  { OP_ATTACH_RENAME_ATTACHMENT,       "\017" },           // <Ctrl-O>
  { OP_ATTACH_SAVE,                    "C" },
  { OP_ATTACH_TOGGLE_DISPOSITION,      "\004" },           // <Ctrl-D>
  { OP_ATTACH_TOGGLE_UNLINK,           "u" },
  { OP_ATTACH_UNGROUP,                 "#" },
  { OP_ATTACH_UPDATE_ENCODING,         "U" },
  { OP_ATTACH_VIEW,                    "<keypadenter>" },
  { OP_ATTACH_VIEW,                    "\n" },             // <Enter>
  { OP_ATTACH_VIEW,                    "\r" },             // <Return>
#ifdef USE_AUTOCRYPT
  { OP_COMPOSE_AUTOCRYPT_MENU,             "o" },
#endif
  { OP_COMPOSE_EDIT_FILE,                  "\033e" },          // <Alt-e>
  { OP_COMPOSE_EDIT_MESSAGE,               "e" },
  { OP_COMPOSE_ISPELL,                     "i" },
  { OP_COMPOSE_PGP_MENU,                   "p" },
  { OP_COMPOSE_POSTPONE_MESSAGE,           "P" },
  { OP_COMPOSE_RENAME_FILE,                "R" },
  { OP_COMPOSE_SEND_MESSAGE,               "y" },
  { OP_COMPOSE_SMIME_MENU,                 "S" },
  { OP_COMPOSE_WRITE_MESSAGE,              "w" },
  { OP_DISPLAY_HEADERS,                    "h" },
  { OP_ENVELOPE_EDIT_BCC,                  "b" },
  { OP_ENVELOPE_EDIT_CC,                   "c" },
  { OP_ENVELOPE_EDIT_FCC,                  "f" },
  { OP_ENVELOPE_EDIT_FROM,                 "\033f" },          // <Alt-f>
  { OP_ENVELOPE_EDIT_HEADERS,              "E" },
  { OP_ENVELOPE_EDIT_REPLY_TO,             "r" },
  { OP_ENVELOPE_EDIT_SUBJECT,              "s" },
  { OP_ENVELOPE_EDIT_TO,                   "t" },
  { OP_PREVIEW_PAGE_DOWN,                  "<pagedown>" },
  { OP_PREVIEW_PAGE_UP,                    "<pageup>" },
  { OP_FORGET_PASSPHRASE,                  "\006" },           // <Ctrl-F>
  { OP_TAG,                                "T" },
  { 0, NULL },
};

◆ ComposeFunctions

const struct ComposeFunction ComposeFunctions[]

static

All the NeoMutt functions that the Compose supports.

Definition at line 2661 of file functions.c.

                                                         {
  // clang-format off
  { OP_ATTACH_ATTACH_FILE,         op_attach_attach_file        },
  { OP_ATTACH_ATTACH_KEY,          op_attach_attach_key         },
  { OP_ATTACH_ATTACH_MESSAGE,      op_attach_attach_message     },
  { OP_ATTACH_ATTACH_NEWS_MESSAGE, op_attach_attach_message     },
  { OP_ATTACH_DETACH,              op_attach_detach             },
  { OP_ATTACH_EDIT_CONTENT_ID,     op_attach_edit_content_id    },
  { OP_ATTACH_EDIT_DESCRIPTION,    op_attach_edit_description   },
  { OP_ATTACH_EDIT_ENCODING,       op_attach_edit_encoding      },
  { OP_ATTACH_EDIT_LANGUAGE,       op_attach_edit_language      },
  { OP_ATTACH_EDIT_MIME,           op_attach_edit_mime          },
  { OP_ATTACH_EDIT_TYPE,           op_attach_edit_type          },
  { OP_ATTACH_FILTER,              op_attach_filter             },
  { OP_ATTACH_GET_ATTACHMENT,      op_attach_get_attachment     },
  { OP_ATTACH_GROUP_ALTS,          op_attach_group_alts         },
  { OP_ATTACH_GROUP_LINGUAL,       op_attach_group_lingual      },
  { OP_ATTACH_GROUP_RELATED,       op_attach_group_related      },
  { OP_ATTACH_MOVE_DOWN,           op_attach_move_down          },
  { OP_ATTACH_MOVE_UP,             op_attach_move_up            },
  { OP_ATTACH_NEW_MIME,            op_attach_new_mime           },
  { OP_ATTACH_PRINT,               op_attach_print              },
  { OP_ATTACH_RENAME_ATTACHMENT,   op_attach_rename_attachment  },
  { OP_ATTACH_SAVE,                op_attach_save               },
  { OP_ATTACH_TOGGLE_DISPOSITION,  op_attach_toggle_disposition },
  { OP_ATTACH_TOGGLE_RECODE,       op_attach_toggle_recode      },
  { OP_ATTACH_TOGGLE_UNLINK,       op_attach_toggle_unlink      },
  { OP_ATTACH_UNGROUP,             op_attach_ungroup            },
  { OP_ATTACH_UPDATE_ENCODING,     op_attach_update_encoding    },
  { OP_ATTACH_VIEW,                op_display_headers           },
  { OP_ATTACH_VIEW_MAILCAP,        op_display_headers           },
  { OP_ATTACH_VIEW_PAGER,          op_display_headers           },
  { OP_ATTACH_VIEW_TEXT,           op_display_headers           },
  { OP_COMPOSE_EDIT_FILE,          op_compose_edit_file         },
  { OP_COMPOSE_EDIT_MESSAGE,       op_compose_edit_message      },
  { OP_COMPOSE_ISPELL,             op_compose_ispell            },
  { OP_COMPOSE_POSTPONE_MESSAGE,   op_compose_postpone_message  },
  { OP_COMPOSE_RENAME_FILE,        op_compose_rename_file       },
  { OP_COMPOSE_SEND_MESSAGE,       op_compose_send_message      },
  { OP_COMPOSE_WRITE_MESSAGE,      op_compose_write_message     },
  { OP_DISPLAY_HEADERS,            op_display_headers           },
  { OP_ENVELOPE_EDIT_HEADERS,      op_envelope_edit_headers     },
  { OP_EXIT,                       op_exit                      },
  { OP_FORGET_PASSPHRASE,          op_forget_passphrase         },
  { OP_PIPE,                       op_attach_filter             },
  { 0, NULL },
  // clang-format on
};

Functions

Variables

Detailed Description

Function Documentation

◆ compose_init_keys()

◆ check_count()

◆ gen_cid()

◆ check_cid()

◆ content_id_exists()

◆ check_attachments()

◆ delete_attachment()

◆ update_idx()

◆ compose_attach_swap()

◆ body_index()

◆ prev_sibling()

◆ next_sibling()

◆ body_array_contains()

◆ selected_attachments_are_siblings()

◆ selection_redraw_flags()

◆ move_attachment()

◆ group_attachments()

Variable Documentation

◆ OpCompose

◆ ComposeDefaultBindings

◆ ComposeFunctions