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 "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 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 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)
	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	group_attachments (struct ComposeSharedData shared, char subtype)
	Group tagged attachments into a multipart group.

static int	op_attach_attach_file (struct ComposeSharedData shared, const struct KeyEvent event)
	Attach files to this message - Implements compose_function_t -.

static int	op_attach_attach_key (struct ComposeSharedData shared, const struct KeyEvent event)
	Attach a PGP public key - Implements compose_function_t -.

static int	op_attach_attach_message (struct ComposeSharedData shared, const struct KeyEvent event)
	Attach messages to this message - Implements compose_function_t -.

static int	op_attach_detach (struct ComposeSharedData shared, const struct KeyEvent event)
	Delete the current entry - Implements compose_function_t -.

static int	op_attach_edit_content_id (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit the 'Content-ID' of the attachment - Implements compose_function_t -.

static int	op_attach_edit_description (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit attachment description - Implements compose_function_t -.

static int	op_attach_edit_encoding (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit attachment transfer-encoding - Implements compose_function_t -.

static int	op_attach_edit_language (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit the 'Content-Language' of the attachment - Implements compose_function_t -.

static int	op_attach_edit_mime (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit attachment using mailcap entry - Implements compose_function_t -.

static int	op_attach_edit_type (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit attachment content type - Implements compose_function_t -.

static int	op_attach_filter (struct ComposeSharedData shared, const struct KeyEvent event)
	Filter attachment through a shell command - Implements compose_function_t -.

static int	op_attach_get_attachment (struct ComposeSharedData shared, const struct KeyEvent event)
	Get a temporary copy of an attachment - Implements compose_function_t -.

static int	op_attach_group_alts (struct ComposeSharedData shared, const struct KeyEvent event)
	Group tagged attachments as 'multipart/alternative' - Implements compose_function_t -.

static int	op_attach_group_lingual (struct ComposeSharedData shared, const struct KeyEvent event)
	Group tagged attachments as 'multipart/multilingual' - Implements compose_function_t -.

static int	op_attach_group_related (struct ComposeSharedData shared, const struct KeyEvent event)
	Group tagged attachments as 'multipart/related' - Implements compose_function_t -.

static int	op_attach_move_down (struct ComposeSharedData shared, const struct KeyEvent event)
	Move an attachment down in the attachment list - Implements compose_function_t -.

static int	op_attach_move_up (struct ComposeSharedData shared, const struct KeyEvent event)
	Move an attachment up in the attachment list - Implements compose_function_t -.

static int	op_attach_new_mime (struct ComposeSharedData shared, const struct KeyEvent event)
	Compose new attachment using mailcap entry - Implements compose_function_t -.

static int	op_attach_print (struct ComposeSharedData shared, const struct KeyEvent event)
	Print the current entry - Implements compose_function_t -.

static int	op_attach_rename_attachment (struct ComposeSharedData shared, const struct KeyEvent event)
	Send attachment with a different name - Implements compose_function_t -.

static int	op_attach_save (struct ComposeSharedData shared, const struct KeyEvent event)
	Save message/attachment to a mailbox/file - Implements compose_function_t -.

static int	op_attach_toggle_disposition (struct ComposeSharedData shared, const struct KeyEvent event)
	Toggle disposition between inline/attachment - Implements compose_function_t -.

static int	op_attach_toggle_recode (struct ComposeSharedData shared, const struct KeyEvent event)
	Toggle recoding of this attachment - Implements compose_function_t -.

static int	op_attach_toggle_unlink (struct ComposeSharedData shared, const struct KeyEvent event)
	Toggle whether to delete file after sending it - Implements compose_function_t -.

static int	op_attach_ungroup (struct ComposeSharedData shared, const struct KeyEvent event)
	Ungroup a 'multipart' attachment - Implements compose_function_t -.

static int	op_attach_update_encoding (struct ComposeSharedData shared, const struct KeyEvent event)
	Update an attachment's encoding info - Implements compose_function_t -.

static int	op_envelope_edit_headers (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit the message with headers - Implements compose_function_t -.

static int	op_compose_edit_file (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit the file to be attached - Implements compose_function_t -.

static int	op_compose_edit_message (struct ComposeSharedData shared, const struct KeyEvent event)
	Edit the message - Implements compose_function_t -.

static int	op_compose_ispell (struct ComposeSharedData shared, const struct KeyEvent event)
	Run ispell on the message - Implements compose_function_t -.

static int	op_compose_postpone_message (struct ComposeSharedData shared, const struct KeyEvent event)
	Save this message to send later - Implements compose_function_t -.

static int	op_compose_rename_file (struct ComposeSharedData shared, const struct KeyEvent event)
	Rename/move an attached file - Implements compose_function_t -.

static int	op_compose_send_message (struct ComposeSharedData shared, const struct KeyEvent event)
	Send the message - Implements compose_function_t -.

static int	op_compose_write_message (struct ComposeSharedData shared, const struct KeyEvent event)
	Write the message to a folder - Implements compose_function_t -.

static int	op_display_headers (struct ComposeSharedData shared, const struct KeyEvent event)
	Display message and toggle header weeding - Implements compose_function_t -.

static int	op_exit (struct ComposeSharedData shared, const struct KeyEvent event)
	Exit this menu - Implements compose_function_t -.

static int	op_forget_passphrase (struct ComposeSharedData shared, 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
struct MenuDefinition *	MdCompose = NULL
	Compose Menu Definition.

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 SubMenu * sm_generic )

Initialise the Compose Keybindings - Implements ::init_keys_api.

Definition at line 211 of file functions.c.

{
  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);
 
  MdCompose = 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 230 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 247 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 263 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:

◆ 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 283 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 )

static

Delete an attachment.

Parameters

actx	Attachment context
aidx	Index number of attachment to delete

Return values

0	Success
-1	Error

Definition at line 346 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(NeoMutt->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, NeoMutt->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 436 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 461 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:

◆ group_attachments()

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

static

Group tagged attachments into a multipart group.

Parameters

shared	Shared compose data
subtype	MIME subtype

Return values

FR_SUCCESS	Success
FR_ERROR	Failure

Definition at line 527 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++)
  {
    // check if all tagged attachments are at same level
    if (actx->idx[i]->body->tagged)
    {
      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 (shared->adata->menu->num_tagged == 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 tagged attachment
  struct Body *bptr = NULL;           // current tagged 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 (bptr->tagged)
    {
      // set group properties based on first tagged 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");
          }
        }
      }
 
      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

◆ MdCompose

struct MenuDefinition* MdCompose = NULL

Compose Menu Definition.

Definition at line 74 of file functions.c.

◆ OpCompose

const struct MenuFuncOp OpCompose[]

static

Functions for the Compose Menu.

Definition at line 80 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 148 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 2127 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()

◆ check_attachments()

◆ delete_attachment()

◆ update_idx()

◆ compose_attach_swap()

◆ group_attachments()

Variable Documentation

◆ MdCompose

◆ OpCompose

◆ ComposeDefaultBindings

◆ ComposeFunctions