functions.c File Reference

Compose functions. More...

#include "config.h"
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.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 "lib.h"
#include "attach/lib.h"
#include "browser/lib.h"
#include "editor/lib.h"
#include "history/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 "functions.h"
#include "globals.h"
#include "hook.h"
#include "mutt_header.h"
#include "mutt_logging.h"
#include "muttlib.h"
#include "mview.h"
#include "mx.h"
#include "nntp/adata.h"
#include "protos.h"
#include "rfc3676.h"
#include "shared_data.h"
#include <libintl.h>

Include dependency graph for functions.c:

Go to the source code of this file.

Functions
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_attachment_attach_file (struct ComposeSharedData *shared, int op)
	Attach files to this message - Implements compose_function_t -.
static int	op_attachment_attach_key (struct ComposeSharedData *shared, int op)
	Attach a PGP public key - Implements compose_function_t -.
static int	op_attachment_attach_message (struct ComposeSharedData *shared, int op)
	Attach messages to this message - Implements compose_function_t -.
static int	op_attachment_detach (struct ComposeSharedData *shared, int op)
	Delete the current entry - Implements compose_function_t -.
static int	op_attachment_edit_content_id (struct ComposeSharedData *shared, int op)
	Edit the 'Content-ID' of the attachment - Implements compose_function_t -.
static int	op_attachment_edit_description (struct ComposeSharedData *shared, int op)
	Edit attachment description - Implements compose_function_t -.
static int	op_attachment_edit_encoding (struct ComposeSharedData *shared, int op)
	Edit attachment transfer-encoding - Implements compose_function_t -.
static int	op_attachment_edit_language (struct ComposeSharedData *shared, int op)
	Edit the 'Content-Language' of the attachment - Implements compose_function_t -.
static int	op_attachment_edit_mime (struct ComposeSharedData *shared, int op)
	Edit attachment using mailcap entry - Implements compose_function_t -.
static int	op_attachment_edit_type (struct ComposeSharedData *shared, int op)
	Edit attachment content type - Implements compose_function_t -.
static int	op_attachment_filter (struct ComposeSharedData *shared, int op)
	Filter attachment through a shell command - Implements compose_function_t -.
static int	op_attachment_get_attachment (struct ComposeSharedData *shared, int op)
	Get a temporary copy of an attachment - Implements compose_function_t -.
static int	op_attachment_group_alts (struct ComposeSharedData *shared, int op)
	Group tagged attachments as 'multipart/alternative' - Implements compose_function_t -.
static int	op_attachment_group_lingual (struct ComposeSharedData *shared, int op)
	Group tagged attachments as 'multipart/multilingual' - Implements compose_function_t -.
static int	op_attachment_group_related (struct ComposeSharedData *shared, int op)
	Group tagged attachments as 'multipart/related' - Implements compose_function_t -.
static int	op_attachment_move_down (struct ComposeSharedData *shared, int op)
	Move an attachment down in the attachment list - Implements compose_function_t -.
static int	op_attachment_move_up (struct ComposeSharedData *shared, int op)
	Move an attachment up in the attachment list - Implements compose_function_t -.
static int	op_attachment_new_mime (struct ComposeSharedData *shared, int op)
	Compose new attachment using mailcap entry - Implements compose_function_t -.
static int	op_attachment_print (struct ComposeSharedData *shared, int op)
	Print the current entry - Implements compose_function_t -.
static int	op_attachment_rename_attachment (struct ComposeSharedData *shared, int op)
	Send attachment with a different name - Implements compose_function_t -.
static int	op_attachment_save (struct ComposeSharedData *shared, int op)
	Save message/attachment to a mailbox/file - Implements compose_function_t -.
static int	op_attachment_toggle_disposition (struct ComposeSharedData *shared, int op)
	Toggle disposition between inline/attachment - Implements compose_function_t -.
static int	op_attachment_toggle_recode (struct ComposeSharedData *shared, int op)
	Toggle recoding of this attachment - Implements compose_function_t -.
static int	op_attachment_toggle_unlink (struct ComposeSharedData *shared, int op)
	Toggle whether to delete file after sending it - Implements compose_function_t -.
static int	op_attachment_ungroup (struct ComposeSharedData *shared, int op)
	Ungroup a 'multipart' attachment - Implements compose_function_t -.
static int	op_attachment_update_encoding (struct ComposeSharedData *shared, int op)
	Update an attachment's encoding info - Implements compose_function_t -.
static int	op_envelope_edit_headers (struct ComposeSharedData *shared, int op)
	Edit the message with headers - Implements compose_function_t -.
static int	op_compose_edit_file (struct ComposeSharedData *shared, int op)
	Edit the file to be attached - Implements compose_function_t -.
static int	op_compose_edit_message (struct ComposeSharedData *shared, int op)
	Edit the message - Implements compose_function_t -.
static int	op_compose_ispell (struct ComposeSharedData *shared, int op)
	Run ispell on the message - Implements compose_function_t -.
static int	op_compose_postpone_message (struct ComposeSharedData *shared, int op)
	Save this message to send later - Implements compose_function_t -.
static int	op_compose_rename_file (struct ComposeSharedData *shared, int op)
	Rename/move an attached file - Implements compose_function_t -.
static int	op_compose_send_message (struct ComposeSharedData *shared, int op)
	Send the message - Implements compose_function_t -.
static int	op_compose_write_message (struct ComposeSharedData *shared, int op)
	Write the message to a folder - Implements compose_function_t -.
static int	op_display_headers (struct ComposeSharedData *shared, int op)
	Display message and toggle header weeding - Implements compose_function_t -.
static int	op_exit (struct ComposeSharedData *shared, int op)
	Exit this menu - Implements compose_function_t -.
static int	op_forget_passphrase (struct ComposeSharedData *shared, int op)
	Wipe passphrases from memory - Implements compose_function_t -.
int	compose_function_dispatcher (struct MuttWindow *win, int op)
	Perform a Compose function - Implements function_dispatcher_t -.

Variables
const struct MenuFuncOp	OpCompose []
	Functions for the Compose Menu.
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

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 216 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 233 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 249 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 269 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);
      buf_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);
      buf_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 332 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 422 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 447 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 513 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);
 
  mutt_message_hook(NULL, shared->email, MUTT_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[]

Functions for the Compose Menu.

Definition at line 87 of file functions.c.

ComposeDefaultBindings

const struct MenuOpSeq ComposeDefaultBindings[]

Key bindings for the Compose Menu.

Definition at line 153 of file functions.c.

ComposeFunctions

const struct ComposeFunction ComposeFunctions[]

static

All the NeoMutt functions that the Compose supports.

Definition at line 2084 of file functions.c.