NeoMutt  2024-10-02-7-gd3e66a
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
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

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
actxAttachment context
Return values
trueThere are attachments

Definition at line 216 of file functions.c.

217{
218 if (actx->idxlen == 0)
219 {
220 mutt_error(_("There are no attachments"));
221 return false;
222 }
223
224 return true;
225}
#define mutt_error(...)
Definition: logging2.h:92
#define _(a)
Definition: message.h:28
short idxlen
Number of attachmentes.
Definition: attach.h:70
+ Here is the caller graph for this function:

◆ gen_cid()

static char * gen_cid ( void  )
static

Generate a random Content ID.

Return values
ptrContent ID
Note
The caller should free the string

Definition at line 233 of file functions.c.

234{
235 char rndid[MUTT_RANDTAG_LEN + 1];
236
237 mutt_rand_base32(rndid, sizeof(rndid) - 1);
238 rndid[MUTT_RANDTAG_LEN] = 0;
239
240 return mutt_str_dup(rndid);
241}
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
void mutt_rand_base32(char *buf, size_t buflen)
Fill a buffer with a base32-encoded random string.
Definition: random.c:106
#define MUTT_RANDTAG_LEN
Definition: sendlib.h:35
+ 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
cidContent-ID to check
Return values
trueContent-ID is valid
falseContent-ID is not valid

Definition at line 249 of file functions.c.

250{
251 static const char *check = "^[-\\.0-9@A-Z_a-z]+$";
252
253 struct Regex *check_cid_regex = mutt_regex_new(check, 0, NULL);
254
255 const bool valid = mutt_regex_match(check_cid_regex, cid);
256
257 mutt_regex_free(&check_cid_regex);
258
259 return valid;
260}
struct Regex * mutt_regex_new(const char *str, uint32_t flags, struct Buffer *err)
Create an Regex from a string.
Definition: regex.c:80
void mutt_regex_free(struct Regex **ptr)
Free a Regex object.
Definition: regex.c:118
bool mutt_regex_match(const struct Regex *regex, const char *str)
Shorthand to mutt_regex_capture()
Definition: regex.c:614
Cached regular expression.
Definition: regex3.h:85
+ 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
actxAttachment context
subConfigSubset
Return values
0Success
-1Error

Definition at line 269 of file functions.c.

270{
271 int rc = -1;
272 struct stat st = { 0 };
273 struct Buffer *pretty = NULL, *msg = NULL;
274
275 for (int i = 0; i < actx->idxlen; i++)
276 {
277 if (actx->idx[i]->body->type == TYPE_MULTIPART)
278 continue;
279 if (stat(actx->idx[i]->body->filename, &st) != 0)
280 {
281 if (!pretty)
282 pretty = buf_pool_get();
283 buf_strcpy(pretty, actx->idx[i]->body->filename);
284 buf_pretty_mailbox(pretty);
285 /* L10N: This message is displayed in the compose menu when an attachment
286 doesn't stat. %d is the attachment number and %s is the attachment
287 filename. The filename is located last to avoid a long path hiding
288 the error message. */
289 mutt_error(_("Attachment #%d no longer exists: %s"), i + 1, buf_string(pretty));
290 goto cleanup;
291 }
292
293 if (actx->idx[i]->body->stamp < st.st_mtime)
294 {
295 if (!pretty)
296 pretty = buf_pool_get();
297 buf_strcpy(pretty, actx->idx[i]->body->filename);
298 buf_pretty_mailbox(pretty);
299
300 if (!msg)
301 msg = buf_pool_get();
302 /* L10N: This message is displayed in the compose menu when an attachment
303 is modified behind the scenes. %d is the attachment number and %s is
304 the attachment filename. The filename is located last to avoid a long
305 path hiding the prompt question. */
306 buf_printf(msg, _("Attachment #%d modified. Update encoding for %s?"),
307 i + 1, buf_string(pretty));
308
310 if (ans == MUTT_YES)
311 mutt_update_encoding(actx->idx[i]->body, sub);
312 else if (ans == MUTT_ABORT)
313 goto cleanup;
314 }
315 }
316
317 rc = 0;
318
319cleanup:
320 buf_pool_release(&pretty);
321 buf_pool_release(&msg);
322 return rc;
323}
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
size_t buf_strcpy(struct Buffer *buf, const char *s)
Copy a string into a Buffer.
Definition: buffer.c:395
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37
void buf_pretty_mailbox(struct Buffer *buf)
Shorten a mailbox path using '~' or '='.
Definition: muttlib.c:519
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_yesorno(const char *prompt, enum QuadOption def)
Ask the user a Yes/No question.
Definition: question.c:327
void mutt_update_encoding(struct Body *b, struct ConfigSubset *sub)
Update the encoding type.
Definition: sendlib.c:422
struct AttachPtr ** idx
Array of attachments.
Definition: attach.h:69
struct Body * body
Attachment.
Definition: attach.h:38
time_t stamp
Time stamp of last encoding update.
Definition: body.h:77
unsigned int type
content-type primary type, ContentType
Definition: body.h:40
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:59
String manipulation buffer.
Definition: buffer.h:36
+ 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
actxAttachment context
aidxIndex number of attachment to delete
Return values
0Success
-1Error

Definition at line 332 of file functions.c.

333{
334 if (!actx || (aidx < 0) || (aidx >= actx->idxlen))
335 return -1;
336
337 struct AttachPtr **idx = actx->idx;
338 struct Body *b_previous = NULL;
339 struct Body *b_parent = NULL;
340
341 if (aidx == 0)
342 {
343 struct Body *b = actx->idx[0]->body;
344 if (!b->next) // There's only one attachment left
345 {
346 mutt_error(_("You may not delete the only attachment"));
347 return -1;
348 }
349
350 if (cs_subset_bool(NeoMutt->sub, "compose_confirm_detach_first"))
351 {
352 /* L10N: Prompt when trying to hit <detach-file> on the first entry in
353 the compose menu. This entry is most likely the message they just
354 typed. Hitting yes will remove the entry and unlink the file, so
355 it's worth confirming they really meant to do it. */
356 enum QuadOption ans = query_yesorno_help(_("Really delete the main message?"),
358 "compose_confirm_detach_first");
359 if (ans == MUTT_NO)
360 {
361 idx[aidx]->body->tagged = false;
362 return -1;
363 }
364 }
365 }
366
367 if (idx[aidx]->level > 0)
368 {
369 if (attach_body_parent(idx[0]->body, NULL, idx[aidx]->body, &b_parent))
370 {
371 if (attach_body_count(b_parent->parts, false) < 3)
372 {
373 mutt_error(_("Can't leave group with only one attachment"));
374 return -1;
375 }
376 }
377 }
378
379 // reorder body pointers
380 if (aidx > 0)
381 {
382 if (attach_body_previous(idx[0]->body, idx[aidx]->body, &b_previous))
383 b_previous->next = idx[aidx]->body->next;
384 else if (attach_body_parent(idx[0]->body, NULL, idx[aidx]->body, &b_parent))
385 b_parent->parts = idx[aidx]->body->next;
386 }
387
388 // free memory
389 int part_count = 1;
390 if (aidx < (actx->idxlen - 1))
391 {
392 if ((idx[aidx]->body->type == TYPE_MULTIPART) &&
393 (idx[aidx + 1]->level > idx[aidx]->level))
394 {
395 part_count += attach_body_count(idx[aidx]->body->parts, true);
396 }
397 }
398 idx[aidx]->body->next = NULL;
399 mutt_body_free(&(idx[aidx]->body));
400 for (int i = 0; i < part_count; i++)
401 {
402 FREE(&idx[aidx + i]->tree);
403 FREE(&idx[aidx + i]);
404 }
405
406 // reorder attachment list
407 for (int i = aidx; i < (actx->idxlen - part_count); i++)
408 idx[i] = idx[i + part_count];
409 for (int i = 0; i < part_count; i++)
410 idx[actx->idxlen - i - 1] = NULL;
411 actx->idxlen -= part_count;
412
413 return 0;
414}
bool attach_body_parent(struct Body *start, struct Body *start_parent, struct Body *body, struct Body **body_parent)
Find the parent of a body.
Definition: lib.c:71
int attach_body_count(struct Body *body, bool recurse)
Count bodies.
Definition: lib.c:42
bool attach_body_previous(struct Body *start, struct Body *body, struct Body **previous)
Find the previous body of a body.
Definition: lib.c:142
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
void mutt_body_free(struct Body **ptr)
Free a Body.
Definition: body.c:58
#define FREE(x)
Definition: memory.h:45
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
enum QuadOption query_yesorno_help(const char *prompt, enum QuadOption def, struct ConfigSubset *sub, const char *name)
Ask the user a Yes/No question offering help.
Definition: question.c:355
An email to which things will be attached.
Definition: attach.h:37
The body of an email.
Definition: body.h:36
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:73
bool tagged
This attachment is tagged.
Definition: body.h:90
struct Body * next
next attachment in the list
Definition: body.h:72
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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
menuCurrent menu
actxAttachment context
apAttachment to add

Definition at line 422 of file functions.c.

423{
424 ap->level = 0;
425 for (int i = actx->idxlen; i > 0; i--)
426 {
427 if (ap->level == actx->idx[i - 1]->level)
428 {
429 actx->idx[i - 1]->body->next = ap->body;
430 break;
431 }
432 }
433
434 ap->body->aptr = ap;
435 mutt_actx_add_attach(actx, ap);
436 update_menu(actx, menu, false);
437 menu_set_index(menu, actx->vcount - 1);
438}
void mutt_actx_add_attach(struct AttachCtx *actx, struct AttachPtr *attach)
Add an Attachment to an Attachment Context.
Definition: attach.c:65
void update_menu(struct AttachCtx *actx, struct Menu *menu, bool init)
Redraw the compose window.
Definition: dlg_compose.c:217
MenuRedrawFlags menu_set_index(struct Menu *menu, int index)
Set the current selection in the Menu.
Definition: menu.c:174
short vcount
The number of virtual attachments.
Definition: attach.h:74
int level
Nesting depth of attachment.
Definition: attach.h:42
struct AttachPtr * aptr
Menu information, used in recvattach.c.
Definition: body.h:75
+ 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
eEmail
actxAttachment information
firstIndex of first attachment to swap
secondIndex of second attachment to swap

Definition at line 447 of file functions.c.

448{
449 struct AttachPtr **idx = actx->idx;
450
451 // check that attachments really are adjacent
452 if (idx[first]->body->next != idx[second]->body)
453 return;
454
455 // reorder Body pointers
456 if (first == 0)
457 {
458 // first attachment is the fundamental part
459 idx[first]->body->next = idx[second]->body->next;
460 idx[second]->body->next = idx[first]->body;
461 e->body = idx[second]->body;
462 }
463 else
464 {
465 // find previous attachment
466 struct Body *b_previous = NULL;
467 struct Body *b_parent = NULL;
468 if (attach_body_previous(e->body, idx[first]->body, &b_previous))
469 {
470 idx[first]->body->next = idx[second]->body->next;
471 idx[second]->body->next = idx[first]->body;
472 b_previous->next = idx[second]->body;
473 }
474 else if (attach_body_parent(e->body, NULL, idx[first]->body, &b_parent))
475 {
476 idx[first]->body->next = idx[second]->body->next;
477 idx[second]->body->next = idx[first]->body;
478 b_parent->parts = idx[second]->body;
479 }
480 }
481
482 // reorder attachment list
483 struct AttachPtr *saved = idx[second];
484 for (int i = second; i > first; i--)
485 idx[i] = idx[i - 1];
486 idx[first] = saved;
487
488 // if moved attachment is a group then move subparts too
489 if ((idx[first]->body->type == TYPE_MULTIPART) && (second < actx->idxlen - 1))
490 {
491 int i = second + 1;
492 while (idx[i]->level > idx[first]->level)
493 {
494 saved = idx[i];
495 int destidx = i - second + first;
496 for (int j = i; j > destidx; j--)
497 idx[j] = idx[j - 1];
498 idx[destidx] = saved;
499 i++;
500 if (i >= actx->idxlen)
501 break;
502 }
503 }
504}
struct Body * body
List of MIME parts.
Definition: email.h:69
+ 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
sharedShared compose data
subtypeMIME subtype
Return values
FR_SUCCESSSuccess
FR_ERRORFailure

Definition at line 513 of file functions.c.

514{
515 struct AttachCtx *actx = shared->adata->actx;
516 int group_level = -1;
517 struct Body *bptr_parent = NULL;
518
519 // Attachments to be grouped must have the same parent
520 for (int i = 0; i < actx->idxlen; i++)
521 {
522 // check if all tagged attachments are at same level
523 if (actx->idx[i]->body->tagged)
524 {
525 if (group_level == -1)
526 {
527 group_level = actx->idx[i]->level;
528 }
529 else
530 {
531 if (group_level != actx->idx[i]->level)
532 {
533 mutt_error(_("Attachments to be grouped must have the same parent"));
534 return FR_ERROR;
535 }
536 }
537 // if not at top level check if all tagged attachments have same parent
538 if (group_level > 0)
539 {
540 if (bptr_parent)
541 {
542 struct Body *bptr_test = NULL;
543 if (!attach_body_parent(actx->idx[0]->body, NULL, actx->idx[i]->body, &bptr_test))
544 mutt_debug(LL_DEBUG5, "can't find parent\n");
545 if (bptr_test != bptr_parent)
546 {
547 mutt_error(_("Attachments to be grouped must have the same parent"));
548 return FR_ERROR;
549 }
550 }
551 else
552 {
553 if (!attach_body_parent(actx->idx[0]->body, NULL, actx->idx[i]->body, &bptr_parent))
554 mutt_debug(LL_DEBUG5, "can't find parent\n");
555 }
556 }
557 }
558 }
559
560 // Can't group all attachments unless at top level
561 if (bptr_parent)
562 {
563 if (shared->adata->menu->num_tagged == attach_body_count(bptr_parent->parts, false))
564 {
565 mutt_error(_("Can't leave group with only one attachment"));
566 return FR_ERROR;
567 }
568 }
569
570 struct Body *group = mutt_body_new();
571 group->type = TYPE_MULTIPART;
572 group->subtype = mutt_str_dup(subtype);
573 group->encoding = ENC_7BIT;
574
575 struct Body *bptr_first = NULL; // first tagged attachment
576 struct Body *bptr = NULL; // current tagged attachment
577 struct Body *group_parent = NULL; // parent of group
578 struct Body *group_previous = NULL; // previous body to group
579 struct Body *group_part = NULL; // current attachment in group
580 int group_idx = 0; // index in attachment list where group will be inserted
581 int group_last_idx = 0; // index of last part of previous found group
582 int group_parent_type = TYPE_OTHER;
583
584 for (int i = 0; i < actx->idxlen; i++)
585 {
586 bptr = actx->idx[i]->body;
587 if (bptr->tagged)
588 {
589 // set group properties based on first tagged attachment
590 if (!bptr_first)
591 {
592 group->disposition = bptr->disposition;
593 if (bptr->language && !mutt_str_equal(subtype, "multilingual"))
594 group->language = mutt_str_dup(bptr->language);
595 group_parent_type = bptr->aptr->parent_type;
596 bptr_first = bptr;
597 if (i > 0)
598 {
599 if (!attach_body_previous(shared->email->body, bptr, &group_previous))
600 {
601 mutt_debug(LL_DEBUG5, "couldn't find previous\n");
602 }
603 if (!attach_body_parent(shared->email->body, NULL, bptr, &group_parent))
604 {
605 mutt_debug(LL_DEBUG5, "couldn't find parent\n");
606 }
607 }
608 }
609
610 shared->adata->menu->num_tagged--;
611 bptr->tagged = false;
612 bptr->aptr->level++;
614
615 // append bptr to the group parts list and remove from email body list
616 struct Body *bptr_previous = NULL;
617 if (attach_body_previous(shared->email->body, bptr, &bptr_previous))
618 bptr_previous->next = bptr->next;
619 else if (attach_body_parent(shared->email->body, NULL, bptr, &bptr_parent))
620 bptr_parent->parts = bptr->next;
621 else
622 shared->email->body = bptr->next;
623
624 if (group_part)
625 {
626 // add bptr to group parts list
627 group_part->next = bptr;
628 group_part = group_part->next;
629 group_part->next = NULL;
630
631 // reorder attachments and set levels
632 int bptr_attachments = attach_body_count(bptr, true);
633 for (int j = i + 1; j < (i + bptr_attachments); j++)
634 actx->idx[j]->level++;
635 if (i > (group_last_idx + 1))
636 {
637 for (int j = 0; j < bptr_attachments; j++)
638 {
639 struct AttachPtr *saved = actx->idx[i + bptr_attachments - 1];
640 for (int k = i + bptr_attachments - 1; k > (group_last_idx + 1); k--)
641 actx->idx[k] = actx->idx[k - 1];
642 actx->idx[group_last_idx + 1] = saved;
643 }
644 }
645 i += bptr_attachments - 1;
646 group_last_idx += bptr_attachments;
647 }
648 else
649 {
650 group_idx = i;
651 group->parts = bptr;
652 group_part = bptr;
653 group_part->next = NULL;
654 int bptr_attachments = attach_body_count(bptr, true);
655 for (int j = i + 1; j < (i + bptr_attachments); j++)
656 actx->idx[j]->level++;
657 i += bptr_attachments - 1;
658 group_last_idx = i;
659 }
660 }
661 }
662
663 if (!bptr_first)
664 {
665 mutt_body_free(&group);
666 return FR_ERROR;
667 }
668
669 // set group->next
670 int next_aidx = group_idx + attach_body_count(group->parts, true);
671 if (group_parent)
672 {
673 // find next attachment with the same parent as the group
674 struct Body *b = NULL;
675 struct Body *b_parent = NULL;
676 while (next_aidx < actx->idxlen)
677 {
678 b = actx->idx[next_aidx]->body;
679 b_parent = NULL;
680 if (attach_body_parent(shared->email->body, NULL, b, &b_parent))
681 {
682 if (group_parent == b_parent)
683 {
684 group->next = b;
685 break;
686 }
687 }
688 next_aidx++;
689 }
690 }
691 else if (next_aidx < actx->idxlen)
692 {
693 // group is at top level
694 group->next = actx->idx[next_aidx]->body;
695 }
696
697 // set previous or parent for group
698 if (group_previous)
699 group_previous->next = group;
700 else if (group_parent)
701 group_parent->parts = group;
702
704
705 struct AttachPtr *group_ap = mutt_aptr_new();
706 group_ap->body = group;
707 group_ap->body->aptr = group_ap;
708 group_ap->level = group_level;
709 group_ap->parent_type = group_parent_type;
710
711 // insert group into attachment list
712 mutt_actx_ins_attach(actx, group_ap, group_idx);
713
714 // update email body and last attachment pointers
715 shared->email->body = actx->idx[0]->body;
716 actx->idx[actx->idxlen - 1]->body->next = NULL;
717
718 update_menu(actx, shared->adata->menu, false);
719 shared->adata->menu->current = group_idx;
721
723 return FR_SUCCESS;
724}
void mutt_actx_ins_attach(struct AttachCtx *actx, struct AttachPtr *attach, int aidx)
Insert an Attachment into an Attachment Context at Specified Index.
Definition: attach.c:91
struct AttachPtr * mutt_aptr_new(void)
Create a new Attachment Pointer.
Definition: attach.c:40
@ FR_SUCCESS
Valid function - successfully performed.
Definition: dispatcher.h:39
@ FR_ERROR
Valid function - error occurred.
Definition: dispatcher.h:38
struct Body * mutt_body_new(void)
Create a new Body.
Definition: body.c:44
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
void mutt_message_hook(struct Mailbox *m, struct Email *e, HookFlags type)
Perform a message hook.
Definition: hook.c:692
#define MUTT_SEND2_HOOK
send2-hook: when changing fields in the compose menu
Definition: hook.h:48
@ LL_DEBUG5
Log at debug level 5.
Definition: logging2.h:47
#define MENU_REDRAW_INDEX
Redraw the index.
Definition: lib.h:56
void menu_queue_redraw(struct Menu *menu, MenuRedrawFlags redraw)
Queue a request for a redraw.
Definition: menu.c:184
@ ENC_7BIT
7-bit text
Definition: mime.h:49
@ TYPE_OTHER
Unknown Content-Type.
Definition: mime.h:31
void mutt_generate_boundary(struct ParameterList *pl)
Create a unique boundary id for a MIME part.
Definition: multipart.c:86
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:660
A set of attachments.
Definition: attach.h:65
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
Definition: attach.h:40
char * language
content-language (RFC8255)
Definition: body.h:78
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:63
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42
char * subtype
content-type subtype
Definition: body.h:61
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41
struct Menu * menu
Menu displaying the attachments.
Definition: attach_data.h:35
struct AttachCtx * actx
Set of attachments.
Definition: attach_data.h:34
struct ComposeAttachData * adata
Attachments.
Definition: shared_data.h:39
struct Email * email
Email being composed.
Definition: shared_data.h:38
int current
Current entry.
Definition: lib.h:80
int num_tagged
Number of tagged entries.
Definition: lib.h:93
+ 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.