From 85bfe763362b95935a3967f6585e14b3f9890a70 Mon Sep 17 00:00:00 2001
From: "Dirk-Jan C. Binnema" <djcb@djcbsoftware.nl>
Date: Thu, 5 Oct 2023 08:57:22 +0300
Subject: [PATCH] mu4e-compose: overhaul message composer

This is a new composer sub-system, which more closely follows
Gnus/message; in particular, we let gnus take care of creating draft
messages.

This reduces code size and allows us to re-use some of the more advanced
features.

There are a number of user-visible changes:

- `mu4e-compose-resend' directly uses `message-resend', so there is no
  more editing phase (which used to be a bit broken with re-encoding
  MIME messages.
---
 mu4e/meson.build       |    1 -
 mu4e/mu4e-compose.el   | 1496 ++++++++++++++++++++--------------------
 mu4e/mu4e-draft.el     |  738 --------------------
 mu4e/mu4e-icalendar.el |    5 +-
 mu4e/mu4e-obsolete.el  |   45 +-
 mu4e/mu4e.el           |    2 +-
 6 files changed, 778 insertions(+), 1509 deletions(-)
 delete mode 100644 mu4e/mu4e-draft.el

diff --git a/mu4e/meson.build b/mu4e/meson.build
index a2a22bbd..079e7486 100644
--- a/mu4e/meson.build
+++ b/mu4e/meson.build
@@ -43,7 +43,6 @@ mu4e_srcs=[
   'mu4e-contacts.el',
   'mu4e-context.el',
   'mu4e-contrib.el',
-  'mu4e-draft.el',
   'mu4e-folders.el',
   'mu4e.el',
   'mu4e-headers.el',
diff --git a/mu4e/mu4e-compose.el b/mu4e/mu4e-compose.el
index 958bca61..75843ab4 100644
--- a/mu4e/mu4e-compose.el
+++ b/mu4e/mu4e-compose.el
@@ -1,6 +1,6 @@
 ;;; mu4e-compose.el --- Compose and send messages -*- lexical-binding: t -*-
 
-;; Copyright (C) 2011-2022 Dirk-Jan C. Binnema
+;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -22,197 +22,255 @@
 
 ;;; Commentary:
 
-;; In this file, various functions to compose/send messages, piggybacking on
-;; gnus' message mode
+;; Implements mu4e-compose-mode, which is a `message-mode' derivative. This is a
+;; *fairly* thin wrapper around the gnus functions for message composition,
+;; integrated with mu4e. Still, quite a bit of code to make it work nicely
+;; in the mu4e context.
 
-;; Magic / Rupe Goldberg
-
-;; 1) When we reply/forward a message, we get it from the backend, ie:
-;; we send to the backend (mu4e-compose):
-;;     compose type:reply docid:30935
-;; backend responds with:
-;;      (:compose reply :original ( .... <original message> ))
-
-;; 2) When we compose a message, message and headers are separated by
-;; `mail-header-separator', ie. '--text follows this line--. We use
-;; before-save-hook and after-save-hook to remove/re-add this special line, so
-;; it stays in the buffer, but never hits the disk.
-;; see:
-;;     mu4e~compose-insert-mail-header-separator
-;;     mu4e~compose-remove-mail-header-separator
-;;
-;; (maybe we can get away with remove it only just before sending? what does
-;; gnus do?)
-
-;; 3) When sending a message, we want to do a few things:
-;;   a) move the message from drafts to the sent folder (maybe; depends on
-;;      `mu4e-sent-messages-behavior')
-;;   b) if it's a reply, mark the replied-to message as "R", i.e. replied
-;;      if it's a forward, mark the forwarded message as "P", i.e.
-;;      passed (forwarded)
-;;   c) kill all buffers looking at the sent message
-
-;;  a) is dealt with by message-mode, but we need to tell it where to move the
-;;     sent message. We do this by adding an Fcc: header with the target folder,
-;;     see `mu4e~compose-setup-fcc-maybe'. Since message-mode does not natively
-;;     understand maildirs, we also need to tell it what to do, so we also set
-;;     `message-fcc-handler-function' there. Finally, we add the the message in
-;;     the sent-folder to the database.
-;;
-;;   b) this is handled in `mu4e~compose-set-parent-flag'
-;;
-;;   c) this is handled in our handler for the `sent'-message from the backend
-;;   (`mu4e-sent-handler')
-
-;;; Code:
-
-(require 'cl-lib)
+
 (require 'message)
-(require 'mail-parse)
-(require 'smtpmail)
-
+(require 'mu4e-obsolete)
 (require 'mu4e-server)
 (require 'mu4e-actions)
 (require 'mu4e-message)
-(require 'mu4e-draft)
 (require 'mu4e-context)
 (require 'mu4e-window)
+
 
-;;; Configuration
-;; see mu4e-drafts.el
+;;; User configuration for compose-mode
+(defgroup mu4e-compose nil
+  "Customization for composing/sending messages."
+  :group 'mu4e)
+
+(defcustom mu4e-sent-messages-behavior 'sent
+  "Determines what mu4e does with sent messages.
+
+This is one of the symbols:
+* `sent'    move the sent message to the Sent-folder (`mu4e-sent-folder')
+* `trash'   move the sent message to the Trash-folder (`mu4e-trash-folder')
+* `delete'  delete the sent message.
+
+Note, when using GMail/IMAP, you should set this to either
+`trash' or `delete', since GMail already takes care of keeping
+copies in the sent folder.
+
+Alternatively, `mu4e-sent-messages-behavior' can be a function
+which takes no arguments, and which should return one of the mentioned
+symbols, for example:
+
+  (setq mu4e-sent-messages-behavior (lambda ()
+  (if (string= (message-sendmail-envelope-from) \"foo@example.com\")
+       \\='delete \\='sent)))
+
+The various `message-' functions from `message-mode' are available
+for querying the message information."
+  :type '(choice (const :tag "move message to mu4e-sent-folder" sent)
+                 (const :tag "move message to mu4e-trash-folder" trash)
+                 (const :tag "delete message" delete))
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-switch nil
+  "Where to display the new message?
+A symbol:
+- nil       : default (new buffer)
+- window    : compose in new window
+- frame or t: compose in new frame
+
+For backward compatibility with `mu4e-compose-in-new-frame', t is
+treated as =\\'frame."
+  :type 'symbol
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-context-policy 'ask
+  "Policy for determining the context when composing a new message.
+
+If the value is `always-ask', ask the user unconditionally.
+
+In all other cases, if any context matches (using its match
+function), this context is used. Otherwise, if none of the
+contexts match, we have the following choices:
+
+- `pick-first': pick the first of the contexts available (ie. the default)
+- `ask': ask the user
+- `ask-if-none': ask if there is no context yet, otherwise leave it as it is
+-  nil: return nil; leaves the current context as is.
+
+Also see `mu4e-context-policy'."
+  :type '(choice
+          (const :tag "Always ask what context to use" always-ask)
+          (const :tag "Ask if none of the contexts match" ask)
+          (const :tag "Ask when there's no context yet" ask-if-none)
+          (const :tag "Pick the first context if none match" pick-first)
+          (const :tag "Don't change the context when none match" nil))
+  :safe 'symbolp
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-crypto-policy
+  '(encrypt-encrypted-replies sign-encrypted-replies)
+  "Policy to control when messages will be signed/encrypted.
+
+The value is a list which influence the way draft messages are
+created. Specifically, it might contain:
+
+- `sign-all-messages': Always add a signature.
+- `sign-new-messages': Add a signature to new message, ie.
+  messages that aren't responses to another message.
+- `sign-forwarded-messages': Add a signature when forwarding
+  a message
+- `sign-edited-messages': Add a signature to drafts
+- `sign-all-replies': Add a signature when responding to
+  another message.
+- `sign-plain-replies': Add a signature when responding to
+  non-encrypted messages.
+- `sign-encrypted-replies': Add a signature when responding
+  to encrypted messages.
+
+It should be noted that certain symbols have priorities over one
+another. So `sign-all-messages' implies `sign-all-replies', which
+in turn implies `sign-plain-replies'. Adding both to the set, is
+not a contradiction, but a redundant configuration.
+
+All `sign-*' options have a `encrypt-*' analogue."
+  :type '(set :greedy t
+              (const :tag "Sign all messages" sign-all-messages)
+              (const :tag "Encrypt all messages" encrypt-all-messages)
+              (const :tag "Sign new messages" sign-new-messages)
+              (const :tag "Encrypt new messages" encrypt-new-messages)
+              (const :tag "Sign forwarded messages" sign-forwarded-messages)
+              (const :tag "Encrypt forwarded messages"
+                     encrypt-forwarded-messages)
+              (const :tag "Sign edited messages" sign-edited-messages)
+              (const :tag "Encrypt edited messages" edited-forwarded-messages)
+              (const :tag "Sign all replies" sign-all-replies)
+              (const :tag "Encrypt all replies" encrypt-all-replies)
+              (const :tag "Sign replies to plain messages" sign-plain-replies)
+              (const :tag "Encrypt replies to plain messages"
+                     encrypt-plain-replies)
+              (const :tag "Sign replies to encrypted messages"
+                     sign-encrypted-replies)
+              (const :tag "Encrypt replies to encrypted messages"
+                     encrypt-encrypted-replies))
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-format-flowed nil
+  "Whether to compose messages to be sent as format=flowed.
+\(Or with long lines if variable `use-hard-newlines' is set to
+nil). The variable `fill-flowed-encode-column' lets you customize
+the width beyond which format=flowed lines are wrapped."
+  :type 'boolean
+  :safe 'booleanp
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-pre-hook nil
+  "Hook run just *before* message composition starts.
+
+If the compose-type is a symbol, either `reply' or `forward', the
+variable `mu4e-compose-parent-message' is the message replied to
+/ being forwarded / edited, and `mu4e-compose-type' contains the
+type of message to be composed.
+
+Note that there is no draft message yet when this hook runs, it
+is meant for influencing the how mu4e constructs the draft
+message. If you want to do something with the draft messages
+after it has been constructed, `mu4e-compose-mode-hook' would be
+the place to do that."
+  :type 'hook
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-reply-ignore-address
+  '("no-?reply")
+  "Addresses to prune when doing wide replies.
+
+This can be a regexp matching the address, a list of regexps or a
+predicate function. A value of nil keeps all the addresses."
+  :type '(choice
+          (const nil)
+          function
+          string
+          (repeat string))
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-dont-reply-to-self nil
+  "If non-nil, do not include self.
+Selfness is decided by `mu4e-personal-address-p'"
+  :type 'boolean
+  :group 'mu4e-compose)
+
+(defcustom mu4e-compose-reply-recipients 'ask
+  "Which recipients to use when replying to a message.
+May be a symbol `ask', `all', `sender'.  Note that this option
+only applies to non-mailing-list message; for mailing-list
+messages, mu4e always asks."
+  :type '(choice (const ask)
+                 (const all)
+                 (const sender))
+  :group 'mu4e-compose)
+
 
-;;; Attachments
-(defun mu4e-compose-attach-message (msg)
-  "Insert message MSG as an attachment."
-  (let ((path (plist-get msg :path)))
-    (unless (file-exists-p path)
-      (mu4e-warn "Message file not found"))
-    (mml-attach-file
-     path
-     "message/rfc822"
-     (or (plist-get msg :subject) "No subject")
-     "attachment")))
+;;; Runtime variables; useful for user-hooks etc.
+(defvar-local mu4e-compose-parent-message nil
+  "The parent message plist.
+This is the message being replied to, forwarded or edited; used
+in `mu4e-compose-pre-hook'. For new (non-reply, forward etc.)
+messages, it is nil.")
 
-(defun mu4e-compose-attach-captured-message ()
-  "Insert the last captured message file as an attachment.
-Messages are captured with `mu4e-action-capture-message'."
-  (interactive)
-  (unless mu4e-captured-message
-    (mu4e-warn "No message has been captured"))
-  (mu4e-compose-attach-message mu4e-captured-message))
+(defvar-local mu4e-compose-type nil
+  "The compose-type for the current message.")
 
-;;; Misc
+
+;;; Filenames
+(defun mu4e--message-basename()
+  "Construct a randomized filename for a message with flags FLAGSTR.
+It looks something like
+    <time>-<random>.<hostname>
 
-;; 'fcc' refers to saving a copy of a sent message to a certain folder. that's
+This filename is used for the draft message and the sent message,
+depending on `mu4e-sent-messages-behavior'."
+  (let* ((sysname (if (fboundp 'system-name)
+                      (system-name) (with-no-warnings system-name)))
+         (sysname (if (string= sysname "") "localhost" sysname))
+         (hostname (downcase
+                    (save-match-data
+                      (substring sysname
+                                 (string-match "^[^.]+" sysname)
+                                 (match-end 0))))))
+    (format "%s.%04x%04x%04x%04x.%s"
+            (format-time-string "%s" (current-time))
+            (random 65535) (random 65535) (random 65535) (random 65535)
+            hostname)))
 
-;; what these 'Sent mail' folders are for!
-;;
-;; We let message mode take care of this by adding a field
+(defun mu4e--draft-message-path (base-name &optional parent)
+  "Construct a draft message path, based on PARENT if provided.
 
-;;   Fcc: <full-path-to-message-in-target-folder>
+PARENT is either nil or the original message (being replied
+ to/forwarded etc.), and is used to determine the draft folder.
+BASE-NAME is the base filename without any Maildir decoration."
+  (let ((draft-dir (mu4e-get-drafts-folder parent)))
+    (mu4e-join-paths
+     (mu4e-root-maildir) draft-dir "cur"
+     (format "%s%s2,DS" base-name mu4e-maildir-info-delimiter))))
 
-;; in the "message-send-hook" (ie., just before sending).  message mode will
-;; then take care of the saving when the message is actually sent.
-;;
-;; note, where and if you make this copy depends on the value of
-;; `mu4e-sent-messages-behavior'.
+(defun mu4e--fcc-path (base-name &optional parent)
+  "Construct a Fcc: path, based on PARENT and `mu4e-sent-messages-behavior'.
 
-(defun mu4e~compose-setup-fcc-maybe ()
-  "Maybe setup Fcc, based on `mu4e-sent-messages-behavior'.
-If needed, set the Fcc header, and register the handler function."
-  (let* ((sent-behavior
-          ;; Note; we cannot simply use functionp here, since at least
-          ;; delete is a function, too...
-          (if (member mu4e-sent-messages-behavior '(delete trash sent))
-              mu4e-sent-messages-behavior
-            (if (functionp mu4e-sent-messages-behavior)
-                (funcall mu4e-sent-messages-behavior)
-              mu4e-sent-messages-behavior)))
-         (mdir
-          (pcase sent-behavior
+PARENT is either nil or the original message (being replied
+to/forwarded etc.), and is used to determine the sent folder,
+together with `mu4e-sent-messages-behavior'. BASE-NAME is the
+base filename without any Maildir decoration.
+
+Returns the path for the sent message, either in the sent or
+trash folder, or nil if the message should be removed after
+sending."
+  (when-let ((sent-dir
+          (pcase mu4e-sent-messages-behavior
             ('delete nil)
-            ('trash (mu4e-get-trash-folder mu4e-compose-parent-message))
-            ('sent (mu4e-get-sent-folder mu4e-compose-parent-message))
-            (_ (mu4e-error
-                "Unsupported value %S for `mu4e-sent-messages-behavior'"
-                mu4e-sent-messages-behavior))))
-         (fccfile (and mdir
-                       (concat (mu4e-root-maildir) mdir "/cur/"
-                               (mu4e~draft-message-filename-construct "S")))))
-    ;; if there's an fcc header, add it to the file
-    (when fccfile
-      (message-add-header (concat "Fcc: " fccfile "\n"))
-      ;; sadly, we cannot define as 'buffer-local'...  this will screw up gnus
-      ;; etc. if you run it after mu4e so, (hack hack) we reset it to the old
-      ;; handler after we've done our thing.
-      (setq message-fcc-handler-function
-            (let ((maildir mdir)
-                  (old-handler message-fcc-handler-function))
-              (lambda (file)
-                (setq message-fcc-handler-function old-handler)
-                ;; reset the fcc handler
-                (let ((mdir-path (concat (mu4e-root-maildir) maildir)))
-                  ;; Create the full maildir structure for the sent folder if it
-                  ;; doesn't exist. `mu4e--server-mkdir` runs asynchronously but
-                  ;; no matter whether it runs before or after `write-file`, the
-                  ;; sent maildir ends up in the correct state.
-                  (unless (file-exists-p mdir-path)
-                    (mu4e--server-mkdir mdir-path)))
-                (write-file file) ;; writing maildirs files is easy
-                (mu4e--server-add file))))))) ;; update the database
-
-(defvar mu4e-compose-hidden-headers
-  `("^References:" "^Face:" "^X-Face:"
-    "^X-Draft-From:" "^User-agent:")
-  "Hidden headers when composing.")
-
-(defun mu4e~compose-hide-headers ()
-  "Hide the headers as per `mu4e-compose-hidden-headers'."
-  (let ((message-hidden-headers mu4e-compose-hidden-headers))
-    (message-hide-headers)))
-
-(defconst mu4e~compose-address-fields-regexp
-  "^\\(To\\|B?Cc\\|Reply-To\\|From\\):")
-
-(defun mu4e~compose-register-message-save-hooks ()
-  "Just before saving, we remove the `mail-header-separator'.
-Just after saving we restore it; thus, the separator should never
-appear on disk. Also update the Date and ensure we have a
-Message-ID."
-  (add-hook 'before-save-hook
-            #'mu4e~compose-before-save-hook-fn
-            nil t)
-  (add-hook 'after-save-hook
-            #'mu4e~compose-after-save-hook-fn
-            nil t))
-
-(defvar-local mu4e~compose-undo nil
-  "Remember the undo-state.")
-
-(defun mu4e~compose-before-save-hook-fn ()
-  "Add the message-id if necessary and update the date."
-  (setq mu4e~compose-undo buffer-undo-list)
-  (save-excursion
-    (save-restriction
-      (message-narrow-to-headers)
-      (unless (message-fetch-field "Message-ID")
-        (message-generate-headers '(Message-ID)))
-      (message-generate-headers '(Date)))
-    (save-match-data
-      (mu4e~draft-remove-mail-header-separator))))
-
-(defun mu4e~compose-after-save-hook-fn ()
-  (save-match-data
-    (mu4e~compose-set-friendly-buffer-name)
-    (mu4e~draft-insert-mail-header-separator)
-    ;; hide some headers again
-    (widen)
-    (mu4e~compose-hide-headers)
-    (set-buffer-modified-p nil)
-    (mu4e-message "Saved (%d lines)" (count-lines (point-min) (point-max)))
-    ;; update the file on disk -- ie., without the separator
-    (mu4e--server-add (buffer-file-name)))
-  (setq buffer-undo-list mu4e~compose-undo))
+            ('trash (mu4e-get-trash-folder parent))
+            ('sent (mu4e-get-sent-folder parent))
+            ((pred functionp) (funcall mu4e-sent-messages-behavior))
+            (_ (mu4e-error "Error in `mu4e-sent-messages-behavior'")))))
+    (mu4e-join-paths
+     (mu4e-root-maildir) sent-dir "cur"
+     (format "%s%s2,S" base-name mu4e-maildir-info-delimiter))))
 
 
 ;;; address completion
@@ -220,7 +278,7 @@ Message-ID."
 ;; inspired by org-contacts.el and
 ;; https://github.com/nordlow/elisp/blob/master/mine/completion-styles-cycle.el
 
-(defun mu4e~compose-complete-handler (str pred action)
+(defun mu4e--compose-complete-handler (str pred action)
   "Complete address STR with predication PRED for ACTION."
   (cond
    ((eq action nil)
@@ -228,23 +286,29 @@ Message-ID."
    ((eq action t)
     (all-completions str mu4e--contacts-set pred))
    ((eq action 'metadata)
-    ;; our contacts are already sorted - just need to tell the
-    ;; completion machinery not to try to undo that...
+    ;; our contacts are already sorted - just need to tell the completion
+    ;; machinery not to try to undo that...
     '(metadata
       (display-sort-function . identity)
       (cycle-sort-function   . identity)))))
 
-(defun mu4e~compose-complete-contact (&optional start)
+(defconst mu4e--header-separator ;; XX properties down work... why not?
+  (propertize "--text follows this line--" 'read-only t 'intangible t)
+  "Line used to separate headers from text in messages being composed.")
+
+(defun mu4e--compose-complete-contact (&optional start)
   "Complete the text at START with a contact.
 Ie. either \"name <email>\" or \"email\")."
   (interactive)
-  (let ((mail-abbrev-mode-regexp mu4e~compose-address-fields-regexp)
+  (let ((mail-abbrev-mode-regexp
+         "^\\(To\\|B?Cc\\|Reply-To\\|From\\|Sender\\):")
+        (mail-header-separator mu4e--header-separator)
         (eoh ;; end-of-headers
          (save-excursion
            (goto-char (point-min))
            (search-forward-regexp mail-header-separator nil t))))
-    ;; try to complete only when we're in the headers area,
-    ;; looking  at an address field.
+    ;; try to complete only when we're in the headers area, looking at an
+    ;; address field.
     (when (and eoh (> eoh (point)) (mail-abbrev-in-expansion-header-p))
       (let* ((end (point))
              (start
@@ -253,435 +317,80 @@ Ie. either \"name <email>\" or \"email\")."
                     (re-search-backward "\\(\\`\\|[\n:,]\\)[ \t]*")
                     (goto-char (match-end 0))
                     (point)))))
-        (list start end 'mu4e~compose-complete-handler)))))
+        (list start end 'mu4e--compose-complete-handler)))))
 
-(defun mu4e~compose-setup-completion ()
+(defun mu4e--compose-setup-completion ()
   "Set up auto-completion of addresses."
   (set (make-local-variable 'completion-ignore-case) t)
   (set (make-local-variable 'completion-cycle-threshold) 7)
   (add-to-list (make-local-variable 'completion-styles) 'substring)
   (add-hook 'completion-at-point-functions
-            'mu4e~compose-complete-contact nil t))
+            'mu4e--compose-complete-contact nil t))
 
-(defun mu4e~remove-refs-maybe ()
-  "Remove References: if In-Reply-To: is missing.
-This allows the user to effectively start a new message-thread by
-removing the In-Reply-To header."
-  (unless (message-fetch-field "in-reply-to")
-    (message-remove-header "References")))
+
+(defun mu4e--fcc-handler (msgpath)
+  "Handle Fcc: for MSGPATH.
 
-;;; Compose Mode
+This ensures that a copy of a sent messages ends up in the
+appropriate sent-messages folder.
 
-(defvar mu4e-compose-mode-map nil
-  "Keymap for \"*mu4e-compose*\" buffers.")
-(unless mu4e-compose-mode-map
-  (setq mu4e-compose-mode-map
-        (let ((map (make-sparse-keymap)))
-          (define-key map (kbd "C-S-u")   'mu4e-update-mail-and-index)
-          (define-key map (kbd "C-c C-u") 'mu4e-update-mail-and-index)
-          (define-key map (kbd "C-c C-k") 'mu4e-message-kill-buffer)
-          (define-key map (kbd "C-c ;")   'mu4e-compose-context-switch)
-          (define-key map (kbd "M-q")     'mu4e-fill-paragraph)
-          map)))
+If MSGPATH is nil, do nothing."
+  (when msgpath
+    (let* ((target-dir (file-name-directory msgpath))
+           (target-mdir (file-name-directory target-dir)))
+      ;; create maildir if needed
+      (unless (file-exists-p target-mdir)
+        (make-directory
+         (mu4e-join-paths target-mdir "cur" 'parents))
+        (make-directory
+         (mu4e-join-paths target-mdir "new" 'parents)))
+      (write-file msgpath)
+      (mu4e--server-add msgpath))))
+
+;; save / send hooks
 
-(defun mu4e-fill-paragraph (&optional region)
-  "Re-layout either the whole message or REGION.
-If variable `use-hard-newlines', takes a multi-line paragraph and
-makes it into a single line of text. Assume paragraphs are
-separated by blank lines. If variable `use-hard-newlines' is not
-set, this simply executes `fill-paragraph'."
-  ;; Inspired by https://www.emacswiki.org/emacs/UnfillParagraph
-  (interactive (progn (barf-if-buffer-read-only) '(t)))
-  (ignore-errors
-    (if mu4e-compose-format-flowed
-        (let ((fill-column (point-max))
-              (use-hard-newlines nil)); rfill "across" hard newlines
-          (when (use-region-p)
-            (delete-trailing-whitespace (region-beginning) (region-end)))
-          (fill-paragraph nil region))
-      (when (use-region-p)
-        (delete-trailing-whitespace (region-beginning) (region-end)))
-      (fill-paragraph nil region))))
+(defvar-local mu4e--compose-undo nil
+  "Remember the undo-state.")
 
-(defun mu4e-toggle-use-hard-newlines ()
-  (interactive)
-  (setq use-hard-newlines (not use-hard-newlines))
-  (if use-hard-newlines
-      (turn-off-auto-fill)
-    (turn-on-auto-fill)))
+(defun mu4e--delimit-headers ()
+  "Delimit headers."
+  (let ((mail-header-separator mu4e--header-separator))
+    (save-excursion (mail-sendmail-delimit-header))))
 
-(defun mu4e~compose-remap-faces ()
-  "Remap `message-mode' faces to mu4e ones.
-Our parent `message-mode' uses font-locking for the compose
-buffers; lets remap its faces so it uses the ones for mu4e."
-  ;; normal headers
-  (face-remap-add-relative 'message-header-name 'mu4e-header-field-face)
-  (face-remap-add-relative 'message-header-other 'mu4e-header-value-face)
-  ;; special headers
-  (face-remap-add-relative 'message-header-from 'mu4e-contact-face)
-  (face-remap-add-relative 'message-header-to 'mu4e-contact-face)
-  (face-remap-add-relative 'message-header-cc 'mu4e-contact-face)
-  (face-remap-add-relative 'message-header-bcc 'mu4e-contact-face)
-  (face-remap-add-relative 'message-header-subject 'mu4e-special-header-value-face))
+(defun mu4e--undelimit-headers ()
+  "Undelimit headers."
+  (let ((mail-header-separator mu4e--header-separator))
+    (save-excursion (mail-sendmail-undelimit-header))))
 
-(define-derived-mode mu4e-compose-mode message-mode "mu4e:compose"
-  "Major mode for the mu4e message composition, derived from `message-mode'.
-\\{message-mode-map}."
-  (progn
-    (use-local-map mu4e-compose-mode-map)
-    (mu4e-context-minor-mode)
-
-    (set (make-local-variable 'message-signature) mu4e-compose-signature)
-    ;; set this to allow mu4e to work when gnus-agent is unplugged in gnus
-    (set (make-local-variable 'message-send-mail-real-function) nil)
-    ;; Set to nil to enable `electric-quote-local-mode' to work:
-    (make-local-variable 'comment-use-syntax)
-    (setq comment-use-syntax nil)
-    ;; message-mode has font-locking, but uses its own faces. Let's
-    ;; use the mu4e-specific ones instead
-    (mu4e~compose-remap-faces)
-    (mu4e~compose-register-message-save-hooks)
-    ;; offer completion for e-mail addresses
-    (when mu4e-compose-complete-addresses
-      (unless mu4e--contacts-set
-        ;; work-around for https://github.com/djcb/mu/issues/1016
-        (mu4e--request-contacts-maybe))
-      (mu4e~compose-setup-completion))
-    (if mu4e-compose-format-flowed
-        (progn
-          (turn-off-auto-fill)
-          (setq truncate-lines nil
-                word-wrap t
-                mml-enable-flowed t
-                use-hard-newlines t)
-          (visual-line-mode t))
-      (setq mml-enable-flowed nil))
-
-    ;; set the attachment dir to something more reasonable than the draft
-    ;; directory.
-    (setq default-directory (mu4e-determine-attachment-dir))
-
-    (let ((keymap (lookup-key message-mode-map [menu-bar text])))
-      (when keymap
-        (define-key-after
-          keymap
-          [mu4e-hard-newlines]
-          '(menu-item "Format=flowed" mu4e-toggle-use-hard-newlines
-                      :button (:toggle . use-hard-newlines)
-                      :help "Toggle format=flowed"
-                      :visible (eq major-mode 'mu4e-compose-mode)
-                      :enable mu4e-compose-format-flowed)
-          'sep)
-
-        (define-key-after
-          keymap
-          [mu4e-electric-quote-mode]
-          '(menu-item "Electric quote" electric-quote-local-mode
-                      :button (:toggle . electric-quote-mode)
-                      :help "Toggle Electric quote mode"
-                      :visible (and (eq major-mode 'mu4e-compose-mode)
-                                    (functionp 'electric-quote-local-mode)))
-          'mu4e-hard-newlines)))
-
-    (when (lookup-key mml-mode-map [menu-bar Attachments])
-      (define-key-after
-        (lookup-key mml-mode-map [menu-bar Attachments])
-        [mu4e-compose-attach-captured-message]
-        '(menu-item "Attach captured message"
-                    mu4e-compose-attach-captured-message
-                    :help "Attach message captured in Headers View (with 'a c')"
-                    :visible (eq major-mode 'mu4e-compose-mode))
-        (quote Attach\ External...)))
-
-    ;; setup the fcc-stuff, if needed
-    (add-hook 'message-send-hook
-              #'mu4e~setup-fcc-message-sent-hook-fn
-               nil t)
-    ;; when the message has been sent.
-    (add-hook 'message-sent-hook
-              #'mu4e~set-sent-handler-message-sent-hook-fn
-              nil t))
-  ;; mark these two hooks as permanent-local, so they'll survive mode-changes
-  ;;  (put 'mu4e~compose-save-before-sending 'permanent-local-hook t)
-  (put 'mu4e~compose-mark-after-sending 'permanent-local-hook t))
-
-(defun mu4e~setup-fcc-message-sent-hook-fn ()
-  ;; mu4e~compose-save-before-sending
-  ;; when in-reply-to was removed, remove references as well.
-  (when (eq mu4e-compose-type 'reply)
-    (mu4e~remove-refs-maybe))
-  (when use-hard-newlines
-    (mu4e-send-harden-newlines))
-  ;; for safety, always save the draft before sending
-  (set-buffer-modified-p t)
-  (save-buffer)
-  (mu4e~compose-setup-fcc-maybe)
-  (widen))
-
-(defun mu4e~set-sent-handler-message-sent-hook-fn ()
-  ;;  mu4e~compose-mark-after-sending
-  (setq mu4e-sent-func 'mu4e-sent-handler)
-  (mu4e--server-sent (buffer-file-name)))
-
-(defun mu4e-send-harden-newlines ()
-  "Set the hard property to all newlines."
+(defun mu4e--compose-before-save ()
+  "Function called just before the draft buffer is saved."
+  ;; This does 3 things:
+  ;;  - set the message id (if not already)
+  ;;  - set the Date (if not already)
+  ;;  - (temporarily) remove the mail-header separator
+  (setq mu4e--compose-undo buffer-undo-list)
   (save-excursion
-    (goto-char (point-min))
-    (while (search-forward "\n" nil t)
-      (put-text-property (1- (point)) (point) 'hard t))))
+    (save-restriction
+      (message-narrow-to-headers)
+      (unless (message-fetch-field "Message-ID")
+        (message-generate-headers '(Message-ID)))
+      (message-generate-headers '(Date)))
+    (mu4e--undelimit-headers))) ;; remove separator
 
-(defconst mu4e~compose-buffer-max-name-length 30
-  "Maximum length of the mu4e-send-buffer-name.")
-
-(defun mu4e~compose-set-friendly-buffer-name (&optional compose-type)
-  "Set some user-friendly buffer name based on the COMPOSE-TYPE."
+(defvar mu4e--compose-buffer-max-name-length 48)
+(defun mu4e--compose-set-friendly-buffer-name ()
+  "Use some friendly name for this composition buffer."
   (let* ((subj (message-field-value "subject"))
-         (subj (unless (and subj (string-match "^[:blank:]*$" subj)) subj))
-         (str (or subj
-                  (pcase compose-type
-                    ('reply       "*mu4e-reply*")
-                    ('forward     "*mu4e-forward*")
-                    (_             "*mu4e-draft*")))))
+         (subj (if (or (not subj) (string-match "^[:blank:]*$" subj))
+                   "No subject"  subj)))
     (rename-buffer (generate-new-buffer-name
-                    (truncate-string-to-width
-                     str mu4e~compose-buffer-max-name-length)
-                    (buffer-name)))))
+                    (format "\"%s\""
+                            (truncate-string-to-width subj
+                             mu4e--compose-buffer-max-name-length
+                             0 nil t)))
+                   (buffer-name))))
 
-(defun mu4e-compose-crypto-message (parent compose-type)
-  "Possibly encrypt or sign a message based on PARENT and COMPOSE-TYPE.
-See `mu4e-compose-crypto-policy' for more details."
-  (let* ((encrypted-p
-          (and parent (memq 'encrypted (mu4e-message-field parent :flags))))
-         (encrypt
-          (or (memq 'encrypt-all-messages mu4e-compose-crypto-policy)
-              ;; new messages
-              (and (memq 'encrypt-new-messages mu4e-compose-crypto-policy)
-                   (eq compose-type 'new))
-              ;; forwarded messages
-              (and (eq compose-type 'forward)
-                   (memq 'encrypt-forwarded-messages mu4e-compose-crypto-policy))
-              ;; edited messages
-              (and (eq compose-type 'edit)
-                   (memq 'encrypt-edited-messages mu4e-compose-crypto-policy))
-              ;; all replies
-              (and (eq compose-type 'reply)
-                   (memq 'encrypt-all-replies mu4e-compose-crypto-policy))
-              ;; plain replies
-              (and (eq compose-type 'reply) (not encrypted-p)
-                   (memq 'encrypt-plain-replies mu4e-compose-crypto-policy))
-              ;; encrypted replies
-              (and (eq compose-type 'reply) encrypted-p
-                   (memq 'encrypt-encrypted-replies
-                         mu4e-compose-crypto-policy))))
-         (sign
-          (or (memq 'sign-all-messages mu4e-compose-crypto-policy)
-              ;; new messages
-              (and (eq compose-type 'new)
-                   (memq 'sign-new-messages mu4e-compose-crypto-policy))
-              ;; forwarded messages
-              (and (eq compose-type 'forward)
-                   (memq 'sign-forwarded-messages mu4e-compose-crypto-policy))
-              ;; edited messages
-              (and (eq compose-type 'edit)
-                   (memq 'sign-edited-messages mu4e-compose-crypto-policy))
-              ;; all replies
-              (and (eq compose-type 'reply)
-                   (memq 'sign-all-replies mu4e-compose-crypto-policy))
-              ;; plain replies
-              (and (eq compose-type 'reply) (not encrypted-p)
-                   (memq 'sign-plain-replies mu4e-compose-crypto-policy))
-              ;; encrypted replies
-              (and (eq compose-type 'reply) encrypted-p
-                   (memq 'sign-encrypted-replies mu4e-compose-crypto-policy)))))
-    (cond ((and sign encrypt)
-           (mml-secure-message-sign-encrypt))
-          (sign (mml-secure-message-sign))
-          (encrypt (mml-secure-message-encrypt)))))
-
-(cl-defun mu4e~compose-handler (compose-type &optional original-msg includes)
-  "Create a new draft message, or open an existing one.
-
-COMPOSE-TYPE determines the kind of message to compose and is a
-symbol, either `reply', `forward', `edit', `resend' `new'. `edit'
-is for editing existing (draft) messages. When COMPOSE-TYPE is
-`reply' or `forward', MSG should be a message plist.  If
-COMPOSE-TYPE is `new', ORIGINAL-MSG should be nil.
-
-Optionally (when forwarding, replying) ORIGINAL-MSG is the original
-message we will forward / reply to.
-
-Optionally (when inline forwarding) INCLUDES contains a list of
-   (:file-name <filename> :mime-type <mime-type>
-    :description <description> :disposition <disposition>)
-or
-   (:buffer-name <filename> :mime-type <mime-type>
-    :description <description> :disposition <disposition>)
-for the attachments to include; file-name refers to
-a file which our backend has conveniently saved for us (as a
-tempfile).  The properties :mime-type, :description and :disposition
-are optional."
-
-  ;; Run the hooks defined for `mu4e-compose-pre-hook'. If compose-type is
-  ;; `reply', `forward' or `edit', `mu4e-compose-parent-message' points to the
-  ;; message being forwarded or replied to, otherwise it is nil.
-  (set (make-local-variable 'mu4e-compose-parent-message) original-msg)
-  (put 'mu4e-compose-parent-message 'permanent-local t)
-  ;; remember the compose-type
-  (set (make-local-variable 'mu4e-compose-type) compose-type)
-  (put 'mu4e-compose-type 'permanent-local t)
-  ;; maybe switch the context
-  (mu4e--context-autoswitch mu4e-compose-parent-message
-                            mu4e-compose-context-policy)
-  (run-hooks 'mu4e-compose-pre-hook)
-  ;; this opens (or re-opens) a message with all the basic headers set.
-  (let ((draft-buffer))
-    (let ((winconf (current-window-configuration)))
-      (condition-case nil
-          (setq draft-buffer (mu4e-draft-open compose-type original-msg))
-        (quit (set-window-configuration winconf)
-              (mu4e-message "Operation aborted")
-              (cl-return-from mu4e~compose-handler))))
-    (set-buffer draft-buffer)
-    ;; insert mail-header-separator, which is needed by message mode to separate
-    ;; headers and body. will be removed before saving to disk
-    (mu4e~draft-insert-mail-header-separator)
-
-    ;; maybe encrypt/sign replies
-    (mu4e-compose-crypto-message original-msg compose-type)
-
-    ;; include files -- e.g. when inline forwarding a message with
-    ;; attachments, we take those from the original.
-    (save-excursion
-      (goto-char (point-max)) ;; put attachments at the end
-
-      (if (and (eq compose-type 'forward) mu4e-compose-forward-as-attachment)
-          (mu4e-compose-attach-message original-msg)
-        (dolist (att includes)
-          (let ((file-name (plist-get att :file-name))
-                (mime (plist-get att :mime-type))
-                (description (plist-get att :description))
-                (disposition (plist-get att :disposition)))
-            (if file-name
-                (mml-attach-file file-name mime description disposition)
-              (mml-attach-buffer (plist-get att :buffer-name)
-                                 mime description disposition))))))
-
-    (mu4e~compose-set-friendly-buffer-name compose-type)
-
-    ;; bind to `mu4e-compose-parent-message' of compose buffer
-    (set (make-local-variable 'mu4e-compose-parent-message) original-msg)
-    (put 'mu4e-compose-parent-message 'permanent-local t)
-    ;; set mu4e-compose-type once more for this buffer,
-    (set (make-local-variable 'mu4e-compose-type) compose-type)
-    (put 'mu4e-compose-type 'permanent-local t)
-
-    ;; hide some headers
-    (mu4e~compose-hide-headers)
-    ;; switch on the mode
-    (mu4e-compose-mode)
-
-    ;; now jump to some useful positions, and start writing that mail!
-    (if (member compose-type '(new forward))
-        (message-goto-to)
-      ;; otherwise, it depends...
-      (pcase message-cite-reply-position
-        ((or 'above 'traditional) (message-goto-body))
-        (_ (when (message-goto-signature) (forward-line -2)))))
-
-    ;; don't allow undoing anything before this.
-    (setq buffer-undo-list nil)
-
-    (when mu4e-compose-in-new-frame
-      ;; make sure to close the frame when we're done with the message these are
-      ;; all buffer-local;
-      (push 'delete-frame message-exit-actions)
-      (push 'delete-frame message-postpone-actions))
-
-    ;; buffer is not user-modified yet
-    (set-buffer-modified-p nil)
-    (mu4e-display-buffer draft-buffer t)))
-
-(defun mu4e~switch-back-to-mu4e-buffer ()
-  "Try to go back to some previous buffer, in the order view->headers->main."
-  (if (buffer-live-p (mu4e-get-view-buffer))
-      (mu4e-display-buffer (mu4e-get-view-buffer) t)
-    (if (buffer-live-p (mu4e-get-headers-buffer))
-        (mu4e-display-buffer (mu4e-get-headers-buffer) t)
-      ;; if all else fails, back to the main view
-      (when (fboundp 'mu4e) (mu4e)))))
-
-(defun mu4e-compose-context-switch (&optional force name)
-  "Change the context for the current draft message.
-
-With NAME, switch to the context with NAME, and with FORCE non-nil,
-switch even if the switch is to the same context.
-
-Like `mu4e-context-switch' but with some changes after switching:
-1. Update the From and Organization headers as per the new context
-2. Update the message-signature as per the new context.
-
-Unlike some earlier version of this function, does _not_ update
-the draft folder for the messages, as that would require changing
-the file under our feet, which is a bit fragile."
-  (interactive "P")
-
-  (unless (derived-mode-p 'mu4e-compose-mode)
-    (mu4e-error "Only available in mu4e compose buffers"))
-
-  (let ((old-context (mu4e-context-current)))
-    (unless (and name (not force) (eq old-context name))
-      (unless (and (not force)
-                   (eq old-context (mu4e-context-switch nil name)))
-        (save-excursion
-          ;; Change From / Organization if needed.
-          (message-replace-header "Organization"
-                                  (or (message-make-organization) "")
-                                  '("Subject")) ;; keep in same place
-          (message-replace-header "From"
-                                  (or (mu4e~draft-from-construct) ""))
-          ;; Update signature.
-          (when (message-goto-signature) ;; delete old signature.
-            (if message-signature-insert-empty-line
-                (forward-line -2) (forward-line -1))
-            (delete-region (point) (point-max)))
-          (if (and mu4e-compose-signature-auto-include mu4e-compose-signature)
-              (let ((message-signature mu4e-compose-signature))
-                (save-excursion (message-insert-signature)))))))))
-
-(defun mu4e-sent-handler (docid path)
-  "Handler called with DOCID and PATH for the just-sent message.
-For Forwarded ('Passed') and Replied messages, try to set the
-appropriate flag at the message forwarded or replied-to."
-  (mu4e~compose-set-parent-flag path)
-  (when (file-exists-p path) ;; maybe the draft was not saved at all
-    (mu4e--server-remove docid))
-  ;; kill any remaining buffers for the draft file, or they will hang around...
-  ;; this seems a bit hamfisted...
-  (when message-kill-buffer-on-exit
-    (dolist (buf (buffer-list))
-      (and (buffer-file-name buf)
-           (string= (buffer-file-name buf) path)
-           (kill-buffer buf))))
-  (mu4e~switch-back-to-mu4e-buffer)
-  (mu4e-message "Message sent"))
-
-(defun mu4e-message-kill-buffer ()
-  "Wrapper around `message-kill-buffer'.
-It restores mu4e window layout after killing the compose-buffer."
-  (interactive)
-  (let ((current-buffer (current-buffer))
-        (win (selected-window)))
-    (message-kill-buffer)
-    (when (window-live-p win)
-      (delete-window win))
-    ;; Compose buffer killed
-    (when (not (equal current-buffer (current-buffer)))
-      ;; Restore mu4e
-      (if mu4e-compose-in-new-frame
-          (delete-frame)
-        (mu4e~switch-back-to-mu4e-buffer)))))
-
-(defun mu4e~compose-set-parent-flag (path)
+(defun mu4e--set-parent-flags (path)
   "Set flags for replied-to and forwarded for the message at PATH.
 That is, set the `replied' \"R\" flag on messages we replied to,
 and the `passed' \"F\" flag on message we have forwarded.
@@ -718,160 +427,449 @@ message buffer."
                     (push (match-string 0) refs))
                   ;; the last will be the first
                   (setq forwarded-from (car refs))))))
-          ;; remove the <>
+          ;; remove the <> and update the flags on the server-side.
           (when (and in-reply-to (string-match "<\\(.*\\)>" in-reply-to))
             (mu4e--server-move (match-string 1 in-reply-to) nil "+R-N"))
           (when (and forwarded-from (string-match "<\\(.*\\)>" forwarded-from))
             (mu4e--server-move (match-string 1 forwarded-from) nil "+P-N")))))))
 
-(defun mu4e-compose (compose-type)
-  "Start composing a message of COMPOSE-TYPE.
-COMPOSE-TYPE is a symbol, one of `reply', `forward', `edit',
-`resend' `new'. All but `new' take the message at point as input.
-Symbol `edit' is only allowed for draft messages."
-  (let ((msg (mu4e-message-at-point 'noerror)))
-    ;; some sanity checks
-    (unless (or msg (eq compose-type 'new))
-      (mu4e-warn "No message at point"))
-    (unless (member compose-type '(reply forward edit resend new))
-      (mu4e-error "Invalid compose type '%S'" compose-type))
-    (when (and (eq compose-type 'edit)
-               (not (member 'draft (mu4e-message-field msg :flags))))
-      (mu4e-warn "Editing is only allowed for draft messages"))
+(defun mu4e--compose-after-save()
+  "Function called immediately after the draft buffer is saved."
+  ;; This does 3 things:
+  ;; - restore the mail-header-separator (see mu4e--compose-before-save)
+  ;; - update the buffer name (based on the message subject
+  ;; - tell the mu server about the updated draft message
+  (mu4e--delimit-headers)
+  (mu4e--compose-set-friendly-buffer-name)
+  ;; tell the server
+  (mu4e--server-add (buffer-file-name))
+  ;; restore history.
+  (set-buffer-modified-p nil)
+  (setq buffer-undo-list mu4e--compose-undo))
 
-    (unless (mu4e-running-p) ;; start mu4e if it's not yet running.
-      (mu4e 'background))
+(defun mu4e-sent-handler (docid path)
+  "Handler called with DOCID and PATH for the just-sent message.
+For Forwarded ('Passed') and Replied messages, try to set the
+appropriate flag at the message forwarded or replied-to."
+  (mu4e--set-parent-flags path)
+  ;; if the draft file exists, remove it now.
+  (when (file-exists-p path)
+    (mu4e--server-remove docid)))
 
-    ;; 'new is special, since it takes no existing message as arg; therefore, we
-    ;; don't need to involve the backend, and call the handler *directly*
-    (if (eq compose-type 'new)
-        (mu4e~compose-handler 'new)
-      ;; otherwise, we need the doc-id
-      (let* ((docid (mu4e-message-field msg :docid))
-             ;; decrypt (or not), based on `mu4e-decryption-policy'.
-             (decrypt
-              (and (member 'encrypted (mu4e-message-field msg :flags))
-                   (if (eq mu4e-decryption-policy 'ask)
-                       (yes-or-no-p (mu4e-format "Decrypt message?"))
-                     mu4e-decryption-policy))))
-        ;; if there's a visible view window, select that before starting
-        ;; composing a new message, so that one will be replaced by the compose
-        ;; window. The 10-or-so line headers buffer is not a good place to write
-        ;; it...
-        ;; (mu4e-display-buffer (mu4e-get-view-buffer))
-        ;; talk to the backend
-        (mu4e--server-compose compose-type decrypt docid)))))
+(defun mu4e--send-harden-newlines ()
+  "Set the hard property to all newlines."
+  (save-excursion
+    (goto-char (point-min))
+    (while (search-forward "\n" nil t)
+      (put-text-property (1- (point)) (point) 'hard t))))
 
-(defun mu4e-compose-reply ()
-  "Compose a reply for the message at point in the headers buffer."
+(defun mu4e--compose-before-send ()
+  "Function called just before sending a message."
+  ;; Remove References: if In-Reply-To: is missing.
+  ;; This allows the user to effectively start a new message-thread by
+  ;; removing the In-Reply-To header.
+  (when (eq mu4e-compose-type 'reply)
+    (unless (message-fetch-field "in-reply-to")
+      (message-remove-header "References")))
+  (when use-hard-newlines
+    (mu4e--send-harden-newlines))
+  ;; for safety, always save the draft before sending
+  (set-buffer-modified-p t)
+  (save-buffer))
+
+(defun mu4e--compose-after-send ()
+  "Function called just after sending a message."
+  (setq mu4e-sent-func #'mu4e-sent-handler)
+  (mu4e--server-sent (buffer-file-name)))
+
+(defun mu4e-message-kill-buffer ()
+  "Wrapper around `message-kill-buffer'.
+It attempts to restore some mu4e window layout after killing the
+compose-buffer."
   (interactive)
-  (mu4e-compose 'reply))
+  (let ((win (selected-window))
+        (view (mu4e-get-view-buffer))
+        (hdrs (mu4e-get-headers-buffer)))
+    (message-kill-buffer)
+    (when (window-live-p win) (delete-window win))
+    ;; try to go back to some mu window if its live; otherwise do nothing.
+    (if (and (buffer-live-p view) (window-live-p (get-buffer-window view)))
+        (switch-to-buffer view)
+      (when (and (buffer-live-p hdrs) (window-live-p (get-buffer-window hdrs)))
+        (switch-to-buffer hdrs)))))
+
+;;; Crypto
+(defun mu4e--compose-setup-crypto (parent compose-type)
+  "Possibly encrypt or sign a message based on PARENT and COMPOSE-TYPE.
+See `mu4e-compose-crypto-policy' for more details."
+  (let* ((encrypted-p
+          (and parent (memq 'encrypted (mu4e-message-field parent :flags))))
+         (encrypt
+          (or (memq 'encrypt-all-messages mu4e-compose-crypto-policy)
+              (and (memq 'encrypt-new-messages mu4e-compose-crypto-policy)
+                   (eq compose-type 'new))    ;; new messages
+              (and (eq compose-type 'forward) ;; forwarded
+                   (memq 'encrypt-forwarded-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'edit) ;; edit
+                   (memq 'encrypt-edited-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) ;; all replies
+                   (memq 'encrypt-all-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) (not encrypted-p) ;; plain replies
+                   (memq 'encrypt-plain-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) encrypted-p
+                   (memq 'encrypt-encrypted-replies
+                         mu4e-compose-crypto-policy)))) ;; encrypted replies
+         (sign
+          (or (memq 'sign-all-messages mu4e-compose-crypto-policy)
+              (and (eq compose-type 'new) ;; new messages
+                   (memq 'sign-new-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'forward) ;; forwarded messages
+                   (memq 'sign-forwarded-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'edit) ;; edited messages
+                   (memq 'sign-edited-messages mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) ;; all replies
+                   (memq 'sign-all-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) (not encrypted-p) ;; plain replies
+                   (memq 'sign-plain-replies mu4e-compose-crypto-policy))
+              (and (eq compose-type 'reply) encrypted-p ;; encrypted replies
+                   (memq 'sign-encrypted-replies mu4e-compose-crypto-policy)))))
+    (cond ((and sign encrypt) (mml-secure-message-sign-encrypt))
+          (sign (mml-secure-message-sign))
+          (encrypt (mml-secure-message-encrypt)))))
 
-(defun mu4e-compose-forward ()
-  "Forward the message at point in the headers buffer."
-  (interactive)
-  (mu4e-compose 'forward))
+ ;;; mu4e-compose-mode
+(defun mu4e--compose-remap-faces ()
+  "Remap `message-mode' faces to mu4e ones.
 
-(defun mu4e-compose-edit ()
-  "Edit the draft message at point in the headers buffer.
-This is only possible if the message at point is, in fact, a
-draft message."
-  (interactive)
-  (mu4e-compose 'edit))
+Our parent `message-mode' uses font-locking for the compose
+buffers; lets remap its faces so it uses the ones for mu4e."
+  ;; normal headers
+  (face-remap-add-relative 'message-header-name  'mu4e-header-field-face)
+  (face-remap-add-relative 'message-header-other 'mu4e-header-value-face)
+  ;; special headers
+  (face-remap-add-relative 'message-header-from 'mu4e-contact-face)
+  (face-remap-add-relative 'message-header-to   'mu4e-contact-face)
+  (face-remap-add-relative 'message-header-cc   'mu4e-contact-face)
+  (face-remap-add-relative 'message-header-bcc  'mu4e-contact-face)
+  (face-remap-add-relative 'message-header-subject
+                           'mu4e-special-header-value-face))
 
-(defun mu4e-compose-resend ()
-  "Resend the message at point in the headers buffer."
-  (interactive)
-  (mu4e-compose 'resend))
+(defvar mu4e-compose-mode-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map message-mode-map)
+    (define-key map (kbd "C-S-u")               #'mu4e-update-mail-and-index)
+    (define-key map (kbd "C-c C-u")             #'mu4e-update-mail-and-index)
+    (define-key map [remap message-kill-buffer] #'mu4e-message-kill-buffer)
+    ;; remove some unsupport... [remap ..]  does not work here
+    ;; XXX remove from menu, too.
+    (define-key map (kbd "C-c C-f C-n")   nil) ;; message-goto-newsgroups
+    (define-key map (kbd "C-c C-n")       nil) ;; message-insert-newsgroups
+    (define-key map (kbd "C-c C-j")       nil) ;; gnus-delay-article
+    map)
+  "The keymap for mu4e-compose buffers.")
 
+(defun mu4e--compose-unsupported (&rest _args)
+  "Advise wrapper for Gnus unsupported functions in mu4e."
+  (when (eq major-mode 'mu4e-compose-mode)
+    (mu4e-warn "Not available in mu4e")))
+
+(defun mu4e--neutralize-undesirables ()
+  "Beware Gnus commands that do not work with mu4e."
+  ;; the Field menu contains many items that don't apply.
+  (advice-add 'gnus-delay-article
+              :before #'mu4e--compose-unsupported) ;; # XXX does not work?!
+  (advice-add 'message-goto-newsgroups :before #'mu4e--compose-unsupported)
+  (advice-add 'message-insert-newsgroups :before #'mu4e--compose-unsupported))
+
+(define-derived-mode mu4e-compose-mode message-mode "mu4e:compose"
+  "Major mode for the mu4e message composition, derived from `message-mode'.
+\\{mu4e-compose-mode-map}."
+  (progn
+    (use-local-map mu4e-compose-mode-map)
+    (mu4e-context-minor-mode)
+    (mu4e--neutralize-undesirables)
+    (mu4e--compose-remap-faces)
+    ;; set this to allow mu4e to work when gnus-agent is unplugged in gnus
+    (set (make-local-variable 'message-send-mail-real-function) nil)
+    ;; Set to nil to enable `electric-quote-local-mode' to work:
+    (set (make-local-variable 'comment-use-syntax) nil)
+    ;; offer completion for e-mail addresses
+    (when mu4e-compose-complete-addresses
+      (mu4e--compose-setup-completion))
+    ;; format-flowed
+    (if mu4e-compose-format-flowed
+        (progn
+          (turn-off-auto-fill)
+          (setq truncate-lines nil
+                word-wrap t
+                mml-enable-flowed t
+                use-hard-newlines t)
+          (visual-line-mode t))
+      (setq mml-enable-flowed nil))))
+
+
+(defvar mu4e-compose-hidden-headers
+  (append message-hidden-headers '("^User-agent:" "^Fcc:"))
+  "Message headers to hide when composing.
+This is mu4e's version of `message-hidden-headers'.")
+
+(declare-function mu4e-view-message-text "mu4e-view")
+
+(defun mu4e-message-cite-nothing ()
+  "Function for `message-cite-function' that cites_ nothing_."
+  (save-excursion
+    (message-cite-original-without-signature)
+    (delete-region (point-min) (point-max))))
+
+(defun mu4e--compose-cite (parent)
+  "Return a cited version of the PARENT message.
+This function uses `message-cite-function', and its settings apply."
+  (with-temp-buffer
+    (insert (mu4e-view-message-text parent))
+    (goto-char (point-min))
+    (push-mark (point-max))
+    (let ((message-signature-separator "^-- *$")
+          (message-signature-insert-empty-line t))
+      (funcall message-cite-function))
+    (pop-mark)
+    (goto-char (point-min))
+    (buffer-string)))
+
+(defun mu4e--address-blacklist ()
+  "Get the list of addresses *not* to send mail to in wide-replies."
+  (let ((ignored mu4e-compose-reply-ignore-address)
+        (addrs (mu4e-personal-addresses))
+        (is-rx (lambda (addr) (string-match-p "^/.*/" addr))))
+    (when mu4e-compose-dont-reply-to-self
+      (setq ignored
+            (append ignored
+                    (list
+                     (regexp-opt
+                      (seq-filter (lambda (addr)
+                                    (not (funcall is-rx addr))) addrs))
+                     (seq-filter (lambda (addr)
+                                   (funcall is-rx addr)) addrs)))))
+    (flatten-list ignored)))
+
+(defvar mu4e-user-agent-string
+  (format "mu4e %s; emacs %s" mu4e-mu-version emacs-version)
+  "The User-Agent string for mu4e, or nil.")
+
+(defun mu4e--compose-switch-function ()
+  "Function to switch & display composition buffer.
+Based on the value of `mu4e-compose-switch'."
+  (pcase mu4e-compose-switch
+    ('nil           #'switch-to-buffer)
+    ('window        #'switch-to-buffer-other-window)
+    ((or 'frame 't) #'switch-to-buffer-other-frame)
+    ;; t for backward compatibility with mu4e-compose-in-new-frame
+    (_             (mu4e-error "Invalid mu4e-compose-switch"))))
+
+(defun mu4e--fake-pop-to-buffer (name &optional _switch)
+  "A fake `message-pop-to-buffer' which creates NAME.
+This is a little glue to use `message-reply', `message-forward'
+etc. We cannot use the normal `message-pop-to-buffer' since we're
+not ready yet to show the buffer in mu4e."
+  (set-buffer (get-buffer-create name))
+  (erase-buffer)
+  (current-buffer))
+
+(defun mu4e--compose-setup-buffer (compose-func parent)
+  "Set up a buffer for message composition before mu4e-compose-mode.
+
+COMPOSE-FUNC is a function / lambda to create the specific type
+of message; it should return (but not show) the created buffer.
+
+PARENT is the \"parent\" message; nil
+ for a \\='new message, set for all others (the message replied to /
+ forwarded / ...)."
+  (with-current-buffer
+      (with-temp-buffer
+        ;; call the call message function; turn off the gnus crypto stuff;
+        ;; we handle that ourselves below
+        (let ((message-required-mail-headers
+               '(From Subject Date (optional . In-Reply-To)
+                      Message-ID
+                      (optional . User-Agent)
+                      (optional . Organization)))
+              (message-this-is-mail t))
+          ;; we handle it ourselves.
+          (setq-local gnus-message-replysign nil
+                      gnus-message-replyencrypt nil
+                      gnus-message-replysignencrypted nil)
+          (when parent
+            (insert-file-contents (plist-get parent :path)))
+          (goto-char (point-min))
+          ;; annoyingly, various message- functions call `message-pop-to-buffer`
+          ;; (showing the message. But we're not ready for that yet. So
+          ;; temporarily override that.
+          (advice-add 'message-pop-to-buffer
+                      :override #'mu4e--fake-pop-to-buffer)
+          (funcall compose-func parent)
+          (advice-remove 'message-pop-to-buffer #'mu4e--fake-pop-to-buffer)
+          (current-buffer))) ;; returns new buffer
+
+    (set-visited-file-name ;; make it a draft file
+     (mu4e--draft-message-path (mu4e--message-basename) parent))
+    ;; Extra headers
+    (when-let ((fcc-path (mu4e--fcc-path (mu4e--message-basename) parent)))
+      (message-add-header (concat "Fcc: " fcc-path "\n")))
+    (when mu4e-user-agent-string
+      (message-add-header (format "User-Agent: %s\n" mu4e-user-agent-string)))
+    (when-let ((org (message-make-organization)))
+      (message-add-header (format "Organization: %s\n" org)))
+    (current-buffer)))
+
+(defun mu4e--compose-setup-post (compose-type &optional parent)
+  "Prepare the new message buffer while in mu4e-compose-mode."
+
+  ;; remember some variables, e.g for user hooks.
+  (setq-local
+   mu4e-compose-parent-message parent
+   mu4e-compose-type compose-type
+   message-hidden-headers mu4e-compose-hidden-headers)
+  (message-hide-headers)
+  (mu4e--compose-set-friendly-buffer-name)
+  ;; crypto
+  (mu4e--compose-setup-crypto parent compose-type)
+  ;; set the attachment dir to something more reasonable than the draft
+  ;; directory.
+  (setq default-directory (mu4e-determine-attachment-dir))
+
+  (add-hook 'before-save-hook  #'mu4e--compose-before-save nil t)
+  (add-hook 'after-save-hook   #'mu4e--compose-after-save nil t)
+  (add-hook 'message-send-hook #'mu4e--compose-before-send nil t)
+  (add-hook 'message-sent-hook #'mu4e--compose-after-send nil t)
+
+  (setq-local message-fcc-handler-function #'mu4e--fcc-handler))
+
+(defun mu4e--compose-setup (compose-type compose-func &optional switch)
+  "Set up a new buffer for mu4e message composition.
+
+COMPOSE-TYPE is a symbol for the kind of message; one of
+ \\='(new reply forward edit)
+PARENT is the \"parent\" message; nil for a \\='new message, set for
+all others (the message replied to / forwarded / ...).
+
+COMPOSE-FUNC is a function / lambda to create the specific type
+of message."
+  (cl-assert (member compose-type '(reply forward edit new)))
+
+  (unless (mu4e-running-p) (mu4e 'background)) ;; start if needed
+  (let* ((parent
+         (when (member compose-type '(reply forward edit))
+           (mu4e-message-at-point)))
+         (mu4e-compose-parent-message parent)
+         (mu4e-compose-type compose-type))
+
+    (run-hooks 'mu4e-compose-pre-hook) ;; run the pre-hook. Still useful?
+
+    (mu4e--context-autoswitch parent mu4e-compose-context-policy)
+    (with-current-buffer (mu4e--compose-setup-buffer compose-func parent)
+      (mu4e-compose-mode)
+      (mu4e--compose-setup-post compose-type parent)
+      (set-buffer-modified-p nil) ;; buffer is not user-modified yet
+      ;; show the complete message buffer.
+      (funcall (or switch (mu4e--compose-switch-function)) (current-buffer))
+      ;; jump to some reasonable place.
+      (if (not (message-field-value "To"))
+          (message-goto-to)
+        (if (not (message-field-value "Subject"))
+            (message-goto-subject)
+          (message-goto-body))))))
+
+;;;###autoload
 (defun mu4e-compose-new ()
-  "Start writing a new message."
+  "Compose a new message."
   (interactive)
-  (mu4e-compose 'new))
+  (mu4e--compose-setup
+   'new (lambda (_parent) (message-mail nil))))
+
+;;;###autoload
+(defun mu4e-compose-reply (&optional wide)
+  "Reply to the message at point."
+  (interactive)
+  (mu4e--compose-setup
+   'reply
+   (lambda (parent)
+     (let ((message-dont-reply-to-names (mu4e--address-blacklist)))
+       (message-reply nil wide)
+       (insert (mu4e--compose-cite parent))))))
+
+;;;###autoload
+(defun mu4e-compose-wide-reply ()
+  "Reply to the message at point to all recipients."
+  (interactive)
+  (mu4e-compose-reply 'wide))
+
+;;;###autoload
+(defun mu4e-compose-forward ()
+  "Forward the message at point."
+  (interactive)
+  (mu4e--compose-setup
+   'forward
+   (lambda (_parent)
+     (let ((message-make-forward-subject-function
+            #'message-forward-subject-fwd)
+           (cur (current-buffer)))
+       (message-mail nil (message-make-forward-subject) nil nil nil)
+       (message-forward-make-body cur)))))
+
+;;;###autoload
+(defun mu4e-compose-edit ()
+  "Edit an existing message."
+  (interactive)
+  (let* ((msg (mu4e-message-at-point)))
+    (unless (member 'draft (mu4e-message-field msg :flags))
+      (mu4e-warn "Editing is only allowed for draft messages"))
+    (mu4e--compose-setup
+     'edit (lambda (msg)
+             (with-current-buffer
+                 (insert-file-contents (plist-get msg :path))
+               (mu4e--delimit-headers))))))
+
+;;;###autoload
+(defun mu4e-compose-resend (address)
+  "Re-send the message at point."
+  (interactive
+   (list (completing-read
+          "Resend message to address: " mu4e--contacts-set)))
+  (unless (mu4e-running-p) (mu4e 'background))
+  (let ((path (plist-get (mu4e-message-at-point) :path)))
+    (with-temp-buffer
+      (insert-file-contents path)
+      (message-resend address))))
 
 
 ;;; Compose Mail
-;; mu4e-compose-func and mu4e-send-func are wrappers so we can set ourselves
-;; as default emacs mailer (define-mail-user-agent etc.)
 
 (declare-function mu4e "mu4e")
 
 ;;;###autoload
-(defun mu4e~compose-mail (&optional to subject other-headers _continue
-                                    _switch-action yank-action _send-actions _return-action)
+(defun mu4e-compose-mail (&optional to subject other-headers continue
+                                    switch-function yank-action send-actions
+                                    return-action &rest _)
   "This is mu4e's implementation of `compose-mail'.
-Quoting its docstring:
-
-Start composing a mail message to send. This uses the user's
-chosen mail composition package as selected with the variable
-`mail-user-agent'. The optional arguments TO and SUBJECT specify
-recipients and the initial Subject field, respectively.
-
-OTHER-HEADERS is an alist specifying additional
-header fields.  Elements look like (HEADER . VALUE) where both
-HEADER and VALUE are strings.
-
-CONTINUE, if non-nil, says to continue editing a message already
-being composed.  Interactively, CONTINUE is the prefix argument.
-
-YANK-ACTION, if non-nil, is an action to perform, if and when
-necessary, to insert the raw text of the message being replied
-to. It has the form (FUNCTION . ARGS). The user agent will apply
-FUNCTION to ARGS, to insert the raw text of the original message.
-\(The user agent will also run `mail-citation-hook', *after* the
-original text has been inserted in this way.)
-
-SEND-ACTIONS is a list of actions to call when the message is sent.
-Each action has the form (FUNCTION . ARGS).
-
-RETURN-ACTION, if non-nil, is an action for returning to the
-caller.  It has the form (FUNCTION . ARGS).  The function is
-called after the mail has been sent or put aside, and the mail
-buffer buried."
 
+TO, SUBJECT, OTHER-HEADERS, CONTINUE, SWITCH-FUNCTION, YANK-ACTION SEND-ACTIONS
+RETURN-ACTION are as described in `compose-mail', and to the extend that
+they do not conflict with mu4e inner workings."
   ;; create a new draft message 'resetting' (as below) is not actually needed in
   ;; this case, but let's prepare for the re-edit case as well
-  (mu4e~compose-handler 'new nil nil)
+  (mu4e--compose-setup
+   'new
+   (lambda (_parent)
+     (message-mail to subject other-headers continue nil
+                   yank-action send-actions return-action))
+   switch-function))
 
-  (when (message-goto-to) ;; reset to-address, if needed
-    (message-delete-line))
-  (message-add-header (concat "To: " to "\n"))
-
-  (when (message-goto-subject) ;; reset subject, if needed
-    (message-delete-line))
-  (message-add-header (concat "Subject: " subject "\n"))
-
-  ;; add any other headers specified
-  (seq-each (lambda(hdr)
-              (let ((field (capitalize(car hdr))) (value (cdr hdr)))
-                ;; fix in-reply without <>
-                (when (and (string= field "In-Reply-To")
-                           (string-match-p "\\`[^ @]+@[^ @]+\\'" value)
-                           (not (string-match-p "\\`<.*>\\'" value)))
-                  (setq value (concat "<" value ">")))
-                (message-add-header (concat (capitalize field) ": " value "\n"))))
-            other-headers)
-
-  ;; yank message
-  (if (bufferp yank-action)
-      (list 'insert-buffer yank-action)
-    yank-action)
-
-  ;; try to put the user at some reasonable spot...
-  (if (not to)
-      (message-goto-to)
-    (if (not subject)
-        (message-goto-subject)
-      (message-goto-body))))
-
-;; happily, we can re-use most things from message mode
 ;;;###autoload
 (define-mail-user-agent 'mu4e-user-agent
-  'mu4e~compose-mail
+  'mu4e-compose-mail
   'message-send-and-exit
   'message-kill-buffer
   'message-send-hook)
-;; Without this `mail-user-agent' cannot be set to `mu4e-user-agent'
+;; Without this, `mail-user-agent' cannot be set to `mu4e-user-agent'
 ;; through customize, as the custom type expects a function.  Not
 ;; sure whether this function is actually ever used; if it is then
 ;; returning the symbol is probably the correct thing to do, as other
@@ -880,48 +878,21 @@ buffer buried."
   "Return the `mu4e-user-agent' symbol."
   'mu4e-user-agent)
 
-;;; Go to bottom / top
-
-(defun mu4e-compose-goto-top (&optional arg)
-  "Go to the beginning of the message or buffer.
-Go to the beginning of the message or, if already there, go to the
-beginning of the buffer.
-
-Push mark at previous position, unless either a \\[universal-argument] prefix
-is supplied, or Transient Mark mode is enabled and the mark is active."
-  (interactive "P")
-  (or arg
-      (region-active-p)
-      (push-mark))
-  (let ((old-position (point)))
-    (message-goto-body)
-    (when (equal (point) old-position)
-      (goto-char (point-min)))))
-
-(define-key mu4e-compose-mode-map
-  (vector 'remap 'beginning-of-buffer) 'mu4e-compose-goto-top)
-
-(defun mu4e-compose-goto-bottom (&optional arg)
-  "Go to the end of the message or buffer.
-Go to the end of the message (before signature) or, if already there, go to the
-end of the buffer.
-
-Push mark at previous position, unless either a \\[universal-argument] prefix
-is supplied, or Transient Mark mode is enabled and the mark is active."
-  (interactive "P")
-  (or arg
-      (region-active-p)
-      (push-mark))
-  (let ((old-position (point))
-        (message-position (save-excursion (message-goto-body) (point))))
-    (goto-char (point-max))
-    (when (re-search-backward message-signature-separator message-position t)
-      (forward-line -1))
-    (when (equal (point) old-position)
-      (goto-char (point-max)))))
-
-(define-key mu4e-compose-mode-map
-  (vector 'remap 'end-of-buffer) 'mu4e-compose-goto-bottom)
+ ;;; minor mode for use in other modes.
+(define-minor-mode mu4e-compose-minor-mode
+  "Mode for searching for messages."
+  :global nil
+  :init-value nil ;; disabled by default
+  :group 'mu4e
+  :lighter ""
+  :keymap
+  (let ((map (make-sparse-keymap)))
+    (define-key map "R" #'mu4e-compose-reply)
+    (define-key map "W" #'mu4e-compose-wide-reply)
+    (define-key map "F" #'mu4e-compose-forward)
+    (define-key map "E" #'mu4e-compose-edit)
+    (define-key map "C" #'mu4e-compose-new)
+    map))
 
 (defvar mu4e--compose-menu-items
   '("--"
@@ -929,10 +900,13 @@ is supplied, or Transient Mark mode is enabled and the mark is active."
      :help "Compose new message"]
     ["Reply" mu4e-compose-reply
      :help "Reply to message"]
+    ["Reply to all" mu4e-compose-wide-reply
+     :help "Reply to all-recipients"]
     ["Forward" mu4e-compose-forward
-     :help "Forward message"])
-  "Easy menu items for search.")
-
-;;; _
+     :help "Forward message"]
+    ["Resend" mu4e-compose-resend
+     :help "Re-send message"])
+  "Easy menu items for message composition.")
+ ;;;
 (provide 'mu4e-compose)
 ;;; mu4e-compose.el ends here
diff --git a/mu4e/mu4e-draft.el b/mu4e/mu4e-draft.el
deleted file mode 100644
index 8ce8498c..00000000
--- a/mu4e/mu4e-draft.el
+++ /dev/null
@@ -1,738 +0,0 @@
-;;; mu4e-draft.el --- Creating draft messages -*- lexical-binding: t -*-
-;;
-;; Copyright (C) 2011-2023 Dirk-Jan C. Binnema
-
-;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
-;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
-
-;; This file is not part of GNU Emacs.
-
-;; mu4e 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 3 of the License, or
-;; (at your option) any later version.
-
-;; mu4e 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 mu4e.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; In this file, various functions to create draft messages
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'mu4e-message)
-(require 'mu4e-contacts)
-(require 'mu4e-folders)
-(require 'message) ;; mail-header-separator
-
-
-;;; Configuration
-(defgroup mu4e-compose nil
-  "Customizations for composing/sending messages."
-  :group 'mu4e)
-
-(defcustom mu4e-compose-reply-recipients 'ask
-  "Which recipients to use when replying to a message.
-May be a symbol `ask', `all', `sender'.  Note that this option
-only applies to non-mailing-list message; for mailing-list
-messages, mu4e always asks."
-  :type '(choice (const ask)
-                 (const all)
-                 (const sender))
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-reply-to-address nil
-  "When non-nil, the Reply-To address.
-Useful when this is not equal to the From: address."
-  :type '(choice (const :tag "Same as the \"From:\" address" nil)
-                 string)
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-forward-as-attachment nil
-  "Whether to forward messages as attachments instead of inline."
-  :type 'boolean
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-keep-self-cc nil
-  "When non-nil, keep your e-mail address in Cc: when replying."
-  :type 'boolean
-  :group 'mu4e-compose)
-
-(defvar mu4e-compose-parent-message nil
-  "The parent message plist.
-This is the message being replied to, forwarded or edited; used
-in `mu4e-compose-pre-hook'. For new messages, it is nil.")
-
-(defcustom mu4e-decryption-policy t
-  "Policy for dealing with replying/forwarding encrypted parts.
-The setting is a symbol:
- * t:     try to decrypt automatically
- * `ask': ask before decrypting anything
- * nil:   don't try to decrypt anything."
-  :type '(choice (const :tag "Try to decrypt automatically" t)
-                 (const :tag "Ask before decrypting anything" ask)
-                 (const :tag "Don't try to decrypt anything" nil))
-  :group 'mu4e-compose)
-
-;;; Composing / Sending messages
-
-(defcustom mu4e-sent-messages-behavior 'sent
-  "Determines what mu4e does with sent messages.
-
-This is one of the symbols:
-* `sent'    move the sent message to the Sent-folder (`mu4e-sent-folder')
-* `trash'   move the sent message to the Trash-folder (`mu4e-trash-folder')
-* `delete'  delete the sent message.
-
-Note, when using GMail/IMAP, you should set this to either
-`trash' or `delete', since GMail already takes care of keeping
-copies in the sent folder.
-
-Alternatively, `mu4e-sent-messages-behavior' can be a function
-which takes no arguments, and which should return one of the mentioned
-symbols, for example:
-
-  (setq mu4e-sent-messages-behavior (lambda ()
-  (if (string= (message-sendmail-envelope-from) \"foo@example.com\")
-       \\='delete \\='sent)))
-
-The various `message-' functions from `message-mode' are available
-for querying the message information."
-  :type '(choice (const :tag "move message to mu4e-sent-folder" sent)
-                 (const :tag "move message to mu4e-trash-folder" trash)
-                 (const :tag "delete message" delete))
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-context-policy 'ask
-  "Policy for determining the context when composing a new message.
-
-If the value is `always-ask', ask the user unconditionally.
-
-In all other cases, if any context matches (using its match
-function), this context is used. Otherwise, if none of the
-contexts match, we have the following choices:
-
-- `pick-first': pick the first of the contexts available (ie. the default)
-- `ask': ask the user
-- `ask-if-none': ask if there is no context yet, otherwise leave it as it is
--  nil: return nil; leaves the current context as is.
-
-Also see `mu4e-context-policy'."
-  :type '(choice
-          (const :tag "Always ask what context to use" always-ask)
-          (const :tag "Ask if none of the contexts match" ask)
-          (const :tag "Ask when there's no context yet" ask-if-none)
-          (const :tag "Pick the first context if none match" pick-first)
-          (const :tag "Don't change the context when none match" nil))
-  :safe 'symbolp
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-crypto-policy
-  '(encrypt-encrypted-replies sign-encrypted-replies)
-  "Policy to control when messages will be signed/encrypted.
-
-The value is a list, whose members determine the behaviour of
-`mu4e~compose-crypto-message'. Specifically, it might contain:
-
-- `sign-all-messages': Always add a signature.
-- `sign-new-messages': Add a signature to new message, ie.
-  messages that aren't responses to another message.
-- `sign-forwarded-messages': Add a signature when forwarding
-  a message
-- `sign-edited-messages': Add a signature to drafts
-- `sign-all-replies': Add a signature when responding to
-  another message.
-- `sign-plain-replies': Add a signature when responding to
-  non-encrypted messages.
-- `sign-encrypted-replies': Add a signature when responding
-  to encrypted messages.
-
-It should be noted that certain symbols have priorities over one
-another. So `sign-all-messages' implies `sign-all-replies', which
-in turn implies `sign-plain-replies'. Adding both to the set, is
-not a contradiction, but a redundant configuration.
-
-All `sign-*' options have a `encrypt-*' analogue."
-  :type '(set :greedy t
-              (const :tag "Sign all messages" sign-all-messages)
-              (const :tag "Encrypt all messages" encrypt-all-messages)
-              (const :tag "Sign new messages" sign-new-messages)
-              (const :tag "Encrypt new messages" encrypt-new-messages)
-              (const :tag "Sign forwarded messages" sign-forwarded-messages)
-              (const :tag "Encrypt forwarded messages" encrypt-forwarded-messages)
-              (const :tag "Sign edited messages" sign-edited-messages)
-              (const :tag "Encrypt edited messages" edited-forwarded-messages)
-              (const :tag "Sign all replies" sign-all-replies)
-              (const :tag "Encrypt all replies" encrypt-all-replies)
-              (const :tag "Sign replies to plain messages" sign-plain-replies)
-              (const :tag "Encrypt replies to plain messages" encrypt-plain-replies)
-              (const :tag "Sign replies to encrypted messages" sign-encrypted-replies)
-              (const :tag "Encrypt replies to encrypted messages" encrypt-encrypted-replies))
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-format-flowed nil
-  "Whether to compose messages to be sent as format=flowed.
-\(Or with long lines if variable `use-hard-newlines' is set to
-nil). The variable `fill-flowed-encode-column' lets you customize
-the width beyond which format=flowed lines are wrapped."
-  :type 'boolean
-  :safe 'booleanp
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-pre-hook nil
-  "Hook run just *before* message composition starts.
-If the compose-type is a symbol, either `reply' or `forward', the
-variable `mu4e-compose-parent-message' points to the message
-replied to / being forwarded / edited, and `mu4e-compose-type'
-contains the type of message to be composed.
-
-Note that there is no draft message yet when this hook runs, it
-is meant for influencing the how mu4e constructs the draft
-message. If you want to do something with the draft messages after
-it has been constructed, `mu4e-compose-mode-hook' would be the
-place to do that."
-  :type 'hook
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-dont-reply-to-self nil
-  "If non-nil, do not include self.
-Selfness is decided by `mu4e-personal-address-p'"
-  :type 'boolean
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-cite-function
-  (or message-cite-function 'message-cite-original-without-signature)
-  "The function for citing message in replies and forwards.
-This is the mu4e-specific version of
-`message-cite-function'."
-  :type 'function
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-signature
-  (or message-signature "Sent with my mu4e")
-  "The message signature.
-\(i.e. the blob at the bottom of messages). This is the
-mu4e-specific version of `message-signature'."
-  :type '(choice string
-                 (const :tag "None" nil)
-                 (const :tag "Contents of signature file" t)
-                 function sexp)
-  :risky t
-  :group 'mu4e-compose)
-
-(defcustom mu4e-compose-signature-auto-include t
-  "Whether to automatically include a message-signature."
-  :type 'boolean
-  :group 'mu4e-compose)
-
-(defvar mu4e-user-agent-string
-  (format "mu4e %s; emacs %s" mu4e-mu-version emacs-version)
-  "The User-Agent string for mu4e, or nil.")
-
-(defvar mu4e-view-date-format)
-
-(defvar mu4e-compose-type nil
-  "The compose-type for this buffer.
-This is a symbol, `new', `forward', `reply' or `edit'.")
-
-
-(defun mu4e~draft-cite-original (msg)
-  "Return a cited version of the original message MSG as a plist.
-This function uses `mu4e-compose-cite-function', and as such all
-its settings apply."
-  (with-temp-buffer
-    (when (fboundp 'mu4e-view-message-text) ;; keep bytecompiler happy
-      (insert (mu4e-view-message-text msg))
-      (message-yank-original)
-      (goto-char (point-min))
-      (push-mark (point-max))
-      ;; set the the signature separator to 'loose', since in the real world,
-      ;; many message don't follow the standard...
-      (let ((message-signature-separator "^-- *$")
-            (message-signature-insert-empty-line t))
-        (funcall mu4e-compose-cite-function))
-      (pop-mark)
-      (goto-char (point-min))
-      (buffer-string))))
-
-(defun mu4e~draft-header (hdr val)
-  "Return a header line of the form \"HDR: VAL\".
-If VAL is a non-empty list, unpack it.
-If VAL is nil, return nil."
-  ;; note: the propertize here is currently useless, since gnus sets its own
-  ;; later.
-  (when-let ((val
-               (if (stringp val)
-                   val
-                 ;; otherwise, convert list into comma sep'd list
-                 ;; of e-mail addresses
-                 (unless (null val)
-                   (mapconcat
-                    (lambda (contact) (mu4e-contact-full contact)) val ", ")))))
-    (format "%s: %s\n"
-            (propertize hdr 'face 'mu4e-header-key-face)
-            (propertize val 'face 'mu4e-header-value-face))))
-
-(defconst mu4e~max-reference-num 21
-  "Specifies the maximum number of References:.
-As suggested by `message-shorten-references'.")
-
-(defun mu4e~shorten-1 (list cut surplus)
-  "Cut SURPLUS elements out of LIST.
-Beginning with CUTth
-one. Code borrowed from `message-shorten-1'."
-  (setcdr (nthcdr (- cut 2) list)
-          (nthcdr (+ (- cut 2) surplus 1) list)))
-
-
-(defun mu4e~fontify-signature ()
-  "Give the message signatures a distinctive color. This is used
-in the view and compose modes and will color each signature in
-digest messages adhering to RFC 1153."
-  (let ((inhibit-read-only t))
-    (save-excursion
-      ;; give the footer a different color...
-      (goto-char (point-min))
-      (while (re-search-forward "^-- *$" nil t)
-        (let ((p (point))
-              (end (or ;; 30 by RFC1153
-                    (re-search-forward "\\(^-\\{30\\}.*$\\)" nil t)
-                    (point-max))))
-          (add-text-properties p end '(face mu4e-footer-face)))))))
-
-(defun mu4e~draft-references-construct (msg)
-  "Construct the value of the References: header based on MSG.
-This assumes a comma-separated string. Normally, this the concatenation of the
-existing References + In-Reply-To (which may be empty, an note
-that :references includes the old in-reply-to as well) and the
-message-id. If the message-id is empty, returns the old
-References. If both are empty, return nil."
-  (let* ( ;; these are the ones from the message being replied to / forwarded
-         (refs (mu4e-message-field msg :references))
-         (msgid (mu4e-message-field msg :message-id))
-         ;; now, append in
-         (refs (if (and msgid (not (string= msgid "")))
-                   (append refs (list msgid)) refs))
-         ;; no doubles
-         (refs (cl-delete-duplicates refs :test #'equal))
-         (refnum (length refs))
-         (cut 2))
-    ;; remove some refs when there are too many
-    (when (> refnum mu4e~max-reference-num)
-      (let ((surplus (- refnum mu4e~max-reference-num)))
-        (mu4e~shorten-1 refs cut surplus)))
-    (mapconcat (lambda (id) (format "<%s>" id)) refs " ")))
-
-
-;;; Determine the recipient fields for new messages
-
-(defun mu4e~draft-address-cell-equal (cell1 cell2)
-  "Return t if CELL1 and CELL2 have the same e-mail address.
-The comparison is done case-insensitively. If the cells done
-match return nil. CELL1 and CELL2 are cons cells of the
-form (NAME . EMAIL)."
-  (string=
-   (downcase (or (mu4e-contact-email cell1) ""))
-   (downcase (or (mu4e-contact-email cell2) ""))))
-
-
-(defun mu4e~draft-create-to-lst (origmsg)
-  "Create a list of address for the To: in a new message.
-This is based on the original message ORIGMSG. If the Reply-To
-address is set, use that, otherwise use the From address. Note,
-whatever was in the To: field before, goes to the Cc:-list (if
-we're doing a reply-to-all). Special case: if we were the sender
-of the original, we simple copy the list form the original."
-  (let* ((reply-to (or (plist-get origmsg :reply-to)
-                       (plist-get origmsg :from)))
-         (reply-to (cl-delete-duplicates reply-to
-                                         :test #'mu4e~draft-address-cell-equal)))
-    (if mu4e-compose-dont-reply-to-self
-        (cl-delete-if
-         (lambda (to-cell)
-           (mu4e-personal-address-p (mu4e-contact-email to-cell)))
-         reply-to)
-      reply-to)))
-
-
-(defun mu4e~strip-ignored-addresses (addrs)
-  "Return all addresses that are not to be ignored.
-I.e. return all the addresses in ADDRS not matching
-`mu4e-compose-reply-ignore-address'."
-  (cond
-   ((null mu4e-compose-reply-ignore-address)
-    addrs)
-   ((functionp mu4e-compose-reply-ignore-address)
-    (cl-remove-if
-     (lambda (elt)
-       (funcall mu4e-compose-reply-ignore-address (mu4e-contact-email elt)))
-     addrs))
-   (t
-    ;; regexp or list of regexps
-    (let* ((regexp mu4e-compose-reply-ignore-address)
-           (regexp (if (listp regexp)
-                       (mapconcat (lambda (elt) (concat "\\(" elt "\\)"))
-                                  regexp "\\|")
-                     regexp)))
-      (cl-remove-if
-       (lambda (elt)
-         (string-match regexp (mu4e-contact-email elt)))
-       addrs)))))
-
-(defun mu4e~draft-create-cc-lst (origmsg &optional reply-all include-from)
-  "Create a list of address for the Cc: in a new message.
-This is based on the original message ORIGMSG, and whether it's a
-REPLY-ALL."
-  (when reply-all
-    (let* ((cc-lst ;; get the cc-field from the original, remove dups
-            (cl-delete-duplicates
-             (append
-              (plist-get origmsg :to)
-              (plist-get origmsg :cc)
-              (when include-from
-                (or (plist-get origmsg :reply-to)
-                    (plist-get origmsg :from)))
-              (plist-get origmsg :list-post))
-             :test #'mu4e~draft-address-cell-equal))
-           ;; now we have the basic list, but we must remove
-           ;; addresses also in the To: list
-           (cc-lst
-            (cl-delete-if
-             (lambda (cc-cell)
-               (cl-find-if
-                (lambda (to-cell)
-                  (mu4e~draft-address-cell-equal cc-cell to-cell))
-                (mu4e~draft-create-to-lst origmsg)))
-             cc-lst))
-           ;; remove ignored addresses
-           (cc-lst (mu4e~strip-ignored-addresses cc-lst))
-           ;; finally, we need to remove ourselves from the cc-list
-           ;; unless mu4e-compose-keep-self-cc is non-nil
-           (cc-lst
-            (if (or mu4e-compose-keep-self-cc (null user-mail-address))
-                cc-lst
-              (cl-delete-if
-               (lambda (cc-cell)
-                 (mu4e-personal-address-p (mu4e-contact-email cc-cell)))
-               cc-lst))))
-      cc-lst)))
-
-(defun mu4e~draft-recipients-construct (field origmsg &optional reply-all include-from)
-  "Create value (a string) for the recipient FIELD.
-\(which is a symbol, :to or :cc), based on the original message ORIGMSG,
-and (optionally) REPLY-ALL which indicates this is a reply-to-all
-message. Return nil if there are no recipients for the particular field."
-  (cl-case field
-    (:to
-     (mu4e~draft-create-to-lst origmsg))
-    (:cc
-     (mu4e~draft-create-cc-lst origmsg reply-all include-from))
-    (otherwise
-     (mu4e-error "Unsupported field"))))
-
-(defun mu4e~draft-from-construct ()
-  "Construct a value for the From:-field of the reply.
-This is based on the variable `user-full-name' and
-`user-mail-address'; if the latter is nil, function returns nil."
-  (when user-mail-address
-    (mu4e-contact-full (mu4e-contact-make
-                        user-full-name
-                        user-mail-address))))
-
-;;; Header separators
-
-(defun mu4e~draft-insert-mail-header-separator ()
-  "Insert `mail-header-separator' in the first empty line of the message.
-`message-mode' needs this line to know where the headers end and
-the body starts. Note, in `mu4e-compose-mode', we use
-`before-save-hook' and `after-save-hook' to ensure that this
-separator is never written to the message file. Also see
-`mu4e-remove-mail-header-separator'."
-    ;; we set this here explicitly, since (as it has happened) a wrong
-    ;; value for this (such as "") breaks address completion and other things
-    (set (make-local-variable 'mail-header-separator) "--text follows this line--")
-    (put 'mail-header-separator 'permanent-local t)
-    (save-excursion
-      ;; make sure there's not one already
-      (mu4e~draft-remove-mail-header-separator)
-      (let ((sepa (propertize mail-header-separator
-                              'intangible t
-                              ;; don't make this read-only, message-mode
-                              ;; seems to require it being writable in some cases
-                              ;;'read-only "Can't touch this"
-                              'rear-nonsticky t
-                              'font-lock-face 'mu4e-compose-separator-face)))
-        (widen)
-        ;; search for the first empty line
-        (goto-char (point-min))
-        (if (search-forward-regexp "^$" nil t)
-            (progn
-              (replace-match sepa)
-              ;; `message-narrow-to-headers` searches for a
-              ;; `mail-header-separator` followed by a new line. Therefore, we
-              ;; must insert a newline if on the last line of the buffer.
-              (when (= (point) (point-max))
-                (insert "\n")))
-          (progn ;; no empty line? then prepend one
-            (goto-char (point-max))
-            (insert "\n" sepa))))))
-
-(defun mu4e~draft-remove-mail-header-separator ()
-  "Remove `mail-header-separator'.
-We do this before saving a
-file (and restore it afterwards), to ensure that the separator
-never hits the disk. Also see
-`mu4e~draft-insert-mail-header-separator."
-  (save-excursion
-    (widen)
-    (goto-char (point-min))
-    ;; remove the --text follows this line-- separator
-    (when (search-forward-regexp (concat "^" mail-header-separator) nil t)
-      (let ((inhibit-read-only t))
-        (replace-match "")))))
-
-(defun mu4e~draft-reply-all-p (origmsg)
-  "Ask user whether she wants to reply to *all* recipients.
-If there is just one recipient of ORIGMSG do nothing."
-  (let* ((recipnum
-          (+ (length (mu4e~draft-create-to-lst origmsg))
-             (length (mu4e~draft-create-cc-lst origmsg t))))
-         (response
-          (if (< recipnum 2)
-              'all ;; with less than 2 recipients, we can reply to 'all'
-            (mu4e-read-option
-             "Reply to "
-             `( (,(format "all %d recipients" recipnum) . all)
-                ("sender only" . sender-only))))))
-    (eq response 'all)))
-
-(defun mu4e~draft-message-filename-construct (&optional flagstr)
-  "Construct a randomized name for a message file with flags FLAGSTR.
-It looks something like
-  <time>-<random>.<hostname>:2,
-You can append flags."
-  (let* ((sysname (if (fboundp 'system-name)
-                      (system-name)
-                    (with-no-warnings system-name)))
-         (sysname (if (string= sysname "") "localhost" sysname))
-         (hostname (downcase
-                    (save-match-data
-                      (substring sysname
-                                 (string-match "^[^.]+" sysname)
-                                 (match-end 0))))))
-    (format "%s.%04x%04x%04x%04x.%s%s2,%s"
-            (format-time-string "%s" (current-time))
-            (random 65535) (random 65535) (random 65535) (random 65535)
-            hostname mu4e-maildir-info-delimiter (or flagstr ""))))
-
-(defun mu4e~draft-common-construct ()
-  "Construct the common headers for each message."
-  (concat
-   (when-let ((organization (message-make-organization)))
-     (mu4e~draft-header "Organization" organization))
-   (when mu4e-user-agent-string
-     (mu4e~draft-header "User-agent" mu4e-user-agent-string))
-   (mu4e~draft-header "Date" (message-make-date))))
-
-(defconst mu4e~draft-reply-prefix "Re: "
-  "String to prefix replies with.")
-
-(defun mu4e~draft-reply-construct-recipients (origmsg)
-  "Determine the to/cc recipients for a reply message."
-  (let* ((return-to (or (plist-get origmsg :reply-to) (plist-get origmsg :from)))
-         (reply-to-self (mu4e-personal-address-p (plist-get (car return-to) :email)))
-         ;; reply-to-self implies reply-all
-         (reply-all (or reply-to-self
-                        (eq mu4e-compose-reply-recipients 'all)
-                        (and (not (eq mu4e-compose-reply-recipients 'sender))
-                             (mu4e~draft-reply-all-p origmsg)))))
-    (concat
-     ;; if there's no-one in To, copy the CC-list
-     (if (zerop (length (mu4e~draft-create-to-lst origmsg)))
-         (mu4e~draft-header "To" (mu4e~draft-recipients-construct
-                                  :cc origmsg reply-all))
-       ;; otherwise...
-       (concat
-        (mu4e~draft-header "To" (mu4e~draft-recipients-construct
-                                 :to origmsg reply-all))
-        (mu4e~draft-header "Cc" (mu4e~draft-recipients-construct
-                                 :cc origmsg reply-all)))))))
-
-(defun mu4e~draft-reply-construct-recipients-list (origmsg)
-  "Determine the to/cc recipients for a reply message to a
-mailing-list."
-  (let* ( ;; reply-to-self implies reply-all
-         (list-post (plist-get origmsg :list-post))
-         (return-to (or (plist-get origmsg :reply-to) (plist-get origmsg :from)))
-         (recipnum
-          (+ (length (mu4e~draft-create-to-lst origmsg))
-             (length (mu4e~draft-create-cc-lst origmsg t t))))
-         (sender (mu4e-contact-full (car return-to)))
-         (reply-type
-          (mu4e-read-option
-           "Reply to mailing-list "
-           `( (,(format "all %d recipient(s)" recipnum)    . all)
-              (,(format "list-only (%s)" (cdar list-post)) . list-only)
-              (,(format "sender-only (%s)" sender)         . sender-only)))))
-    (cl-case reply-type
-      (all
-       (concat
-        (mu4e~draft-header "To" (mu4e~draft-recipients-construct :to origmsg))
-        (mu4e~draft-header "Cc" (mu4e~draft-recipients-construct :cc origmsg t t))))
-      (list-only
-       (mu4e~draft-header "To" list-post))
-      (sender-only
-       (mu4e~draft-header "To" return-to)))))
-
-(defun mu4e~draft-reply-construct (origmsg)
-  "Create a draft message as a reply to ORIGMSG.
-Replying-to-self is special; in that case, the To and Cc fields
-will be the same as in the original."
-  (let* ((old-msgid (plist-get origmsg :message-id))
-         (subject (concat mu4e~draft-reply-prefix
-                          (message-strip-subject-re
-                           (or (plist-get origmsg :subject) ""))))
-         (list-post (plist-get origmsg :list-post)))
-    (concat
-     (mu4e~draft-header "From" (or (mu4e~draft-from-construct) ""))
-     (mu4e~draft-header "Reply-To" mu4e-compose-reply-to-address)
-
-     (if list-post ;; mailing-lists are a bit special.
-         (mu4e~draft-reply-construct-recipients-list origmsg)
-       (mu4e~draft-reply-construct-recipients origmsg))
-
-     (mu4e~draft-header "Subject" subject)
-     (mu4e~draft-header "References"
-                        (mu4e~draft-references-construct origmsg))
-     (mu4e~draft-common-construct)
-     (when old-msgid
-       (mu4e~draft-header "In-reply-to" (format "<%s>" old-msgid)))
-     "\n\n"
-     (mu4e~draft-cite-original origmsg))))
-
-(defconst mu4e~draft-forward-prefix "Fwd: "
-  "String to prefix replies with.")
-
-(defun mu4e~draft-forward-construct (origmsg)
-  "Create a draft forward message for original message ORIGMSG."
-  (let ((subject
-         (or (plist-get origmsg :subject) "")))
-    (concat
-     (mu4e~draft-header "From" (or (mu4e~draft-from-construct) ""))
-     (mu4e~draft-header "Reply-To" mu4e-compose-reply-to-address)
-     (mu4e~draft-header "To" "")
-     (mu4e~draft-common-construct)
-     (mu4e~draft-header "References"
-                        (mu4e~draft-references-construct origmsg))
-     (mu4e~draft-header "Subject"
-                        (concat
-                         ;; if there's no Fwd: yet, prepend it
-                         (if (string-match "^Fwd:" subject)
-                             ""
-                           mu4e~draft-forward-prefix)
-                         subject))
-     (unless mu4e-compose-forward-as-attachment
-       (concat
-        "\n\n"
-        (mu4e~draft-cite-original origmsg))))))
-
-(defun mu4e~draft-newmsg-construct ()
-  "Create a new message."
-  (concat
-   (mu4e~draft-header "From" (or (mu4e~draft-from-construct) ""))
-   (mu4e~draft-header "Reply-To" mu4e-compose-reply-to-address)
-   (mu4e~draft-header "To" "")
-   (mu4e~draft-header "Subject" "")
-   (mu4e~draft-common-construct)))
-
-(defvar mu4e~draft-drafts-folder nil
-  "The drafts-folder for this compose buffer.
-This is based on `mu4e-drafts-folder', which is evaluated once.")
-
-(defun mu4e~draft-open-file (path)
-  "Open the the draft file at PATH."
-  (find-file-noselect path))
-
-
-(defun mu4e~draft-determine-path (draft-dir)
-  "Determines the path for a new draft file in DRAFT-DIR."
-  (format "%s/%s/cur/%s"
-          (mu4e-root-maildir) draft-dir (mu4e~draft-message-filename-construct "DS")))
-
-
-(defun mu4e-draft-open (compose-type &optional msg)
-  "Open a draft file for a message MSG.
-In case of a new message (when COMPOSE-TYPE is `reply', `forward'
- or `new'), open an existing draft (when COMPOSE-TYPE is `edit'),
- or re-send an existing message (when COMPOSE-TYPE is `resend').
-
-The name of the draft folder is constructed from the
-concatenation of `(mu4e-root-maildir)' and `mu4e-drafts-folder' (the
-latter will be evaluated). The message file name is a unique name
-determined by `mu4e-send-draft-file-name'. The initial contents
-will be created from either `mu4e~draft-reply-construct', or
-`mu4e~draft-forward-construct' or `mu4e~draft-newmsg-construct'.
-
-Returns the newly-created draft buffer."
-  (let ((draft-dir nil)
-        (draft-buffer))
-    (cl-case compose-type
-
-      (edit
-       ;; case-1: re-editing a draft messages. in this case, we do know the
-       ;; full path, but we cannot really know 'drafts folder'... we make a
-       ;; guess
-       (setq draft-dir (mu4e--guess-maildir (mu4e-message-field msg :path)))
-       (setq draft-buffer (mu4e~draft-open-file (mu4e-message-field msg :path))))
-
-      (resend
-       ;; case-2: copy some exisisting message to a draft message, then edit
-       ;; that.
-       (setq draft-dir (mu4e--guess-maildir (mu4e-message-field msg :path)))
-       (let ((draft-path (mu4e~draft-determine-path draft-dir)))
-         (copy-file (mu4e-message-field msg :path) draft-path)
-         (setq draft-buffer (mu4e~draft-open-file draft-path))))
-
-      ((reply forward new)
-       ;; case-3: creating a new message; in this case, we can determine
-       ;; mu4e-get-drafts-folder
-       (setq draft-dir (mu4e-get-drafts-folder msg))
-       (let ((draft-path (mu4e~draft-determine-path draft-dir))
-             (initial-contents
-              (cl-case compose-type
-                (reply   (mu4e~draft-reply-construct msg))
-                (forward (mu4e~draft-forward-construct msg))
-                (new     (mu4e~draft-newmsg-construct)))))
-         (setq draft-buffer (mu4e~draft-open-file draft-path))
-         (set-buffer draft-buffer)
-         (insert initial-contents)
-         (newline)
-         ;; include the message signature (if it's set)
-         (if (and mu4e-compose-signature-auto-include mu4e-compose-signature)
-             (let ((message-signature mu4e-compose-signature))
-               (save-excursion
-                 (message-insert-signature)
-                 (mu4e~fontify-signature))))))
-      (t (mu4e-error "Unsupported compose-type %S" compose-type)))
-    ;; if we didn't find a draft folder yet, try some default
-    (unless draft-dir
-      (setq draft-dir (mu4e-get-drafts-folder msg)))
-    ;; evaluate mu4e~drafts-drafts-folder once, here, and use that value
-    ;; throughout.
-    (set (make-local-variable 'mu4e~draft-drafts-folder) draft-dir)
-    (put 'mu4e~draft-drafts-folder 'permanent-local t)
-    (unless mu4e~draft-drafts-folder
-      (mu4e-error "Failed to determine drafts folder"))
-    ;; return the name of the draft buffer
-    draft-buffer))
-
-;;; _
-(provide 'mu4e-draft)
-;;; mu4e-draft.el ends here
diff --git a/mu4e/mu4e-icalendar.el b/mu4e/mu4e-icalendar.el
index 8b4aa757..ad8265ba 100644
--- a/mu4e/mu4e-icalendar.el
+++ b/mu4e/mu4e-icalendar.el
@@ -57,6 +57,7 @@
 (require 'mu4e-contacts)
 (require 'mu4e-headers)
 (require 'mu4e-view)
+(require 'mu4e-obsolete)
 
 
 ;;; Configuration
@@ -133,7 +134,7 @@
           ;; Compose the reply message.
           (save-excursion
             (let ((message-signature nil)
-                  (mu4e-compose-cite-function #'mu4e--icalendar-delete-citation)
+                  (message-cite-function #'mu4e--icalendar-delete-citation)
                   (mu4e-sent-messages-behavior 'delete)
                   (mu4e-compose-reply-recipients 'sender)
                   (ical-msg (cl-copy-list msg)))
@@ -152,7 +153,7 @@
                 (plist-put ical-msg :subject
                            (concat (capitalize (symbol-name status))
                                    ": " (gnus-icalendar-event:summary event))))
-              (mu4e~compose-handler
+              (mu4e--compose-setup
                'reply ical-msg
                `((:buffer-name ,ical-name
                   :mime-type "text/calendar; method=REPLY; charset=utf-8")))
diff --git a/mu4e/mu4e-obsolete.el b/mu4e/mu4e-obsolete.el
index 3bf2a808..6a2fb1f5 100644
--- a/mu4e/mu4e-obsolete.el
+++ b/mu4e/mu4e-obsolete.el
@@ -1,6 +1,6 @@
-;;; mu4e-obsolete-vars.el --- Obsolete things -*- lexical-binding: t -*-
+;;; mu4e-obsolete.el --- Obsolete things -*- lexical-binding: t -*-
 
-;; Copyright (C) 2022 Dirk-Jan C. Binnema
+;; Copyright (C) 2022-2023 Dirk-Jan C. Binnema
 
 ;; Author: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
 ;; Maintainer: Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
@@ -28,7 +28,7 @@
 ;;; Code:
 
 
-;; mu4e-draft
+;; mu4e-draft/compose
 
 (make-obsolete-variable 'mu4e-reply-to-address
                         'mu4e-compose-reply-to-address
@@ -54,6 +54,15 @@
 (make-obsolete-variable 'mu4e-compose-auto-include-date
                         "This is done unconditionally now" "1.3.5")
 
+(make-obsolete-variable 'mu4e-compose-signature-auto-include
+                        "Usage message-signature directly" "1.11.22")
+
+(define-obsolete-variable-alias
+  'mu4e-compose-signature 'message-signature "1.11.22")
+(define-obsolete-variable-alias
+  'mu4e-compose-cite-function 'message-cite-function "1.11.22")
+(define-obsolete-variable-alias
+  'mu4e-compose-in-new-frame 'mu4e-compose-switch "1.11.22")
 
 ;; mu4e-message
 
@@ -111,9 +120,9 @@
 
 
 ;; mu4e-org
-(make-obsolete 'org-mu4e-open 'mu4e-org-open "1.3.6")
-(make-obsolete 'org-mu4e-store-and-capture
-               'mu4e-org-store-and-capture "1.3.6")
+(define-obsolete-function-alias 'org-mu4e-open 'mu4e-org-open "1.3.6")
+(define-obsolete-function-alias 'org-mu4e-store-and-capture
+  'mu4e-org-store-and-capture "1.3.6")
 
 
 ;; mu4e-search
@@ -227,8 +236,32 @@
 ;; mu4e-folder
 (make-obsolete-variable 'mu4e-cache-maildir-list "No longer used" "1.11.15")
 
+;; mu4e-contacts
+
+(define-obsolete-function-alias 'mu4e-user-mail-address-p
+  'mu4e-personal-address-p "1.5.5")
+
+;; don't use the older vars anymore
+(make-obsolete-variable 'mu4e-user-mail-address-regexp
+                        'mu4e-user-mail-address-list "0.9.9.x")
+(make-obsolete-variable 'mu4e-my-email-addresses
+                        'mu4e-user-mail-address-list "0.9.9.x")
+(make-obsolete-variable 'mu4e-user-mail-address-list
+                        "determined by server; see `mu4e-personal-addresses'."
+                        "1.3.8")
+
+(make-obsolete-variable 'mu4e-contact-rewrite-function
+                        "mu4e-contact-process-function (see docstring)"
+                        "mu4e 1.3.2")
+(make-obsolete-variable 'mu4e-compose-complete-ignore-address-regexp
+                        "mu4e-contact-process-function (see docstring)"
+                        "mu4e 1.3.2")
+;; calendar
+(define-obsolete-function-alias 'mu4e-icalendar-setup #'ignore '"1.11.22")
+
 ;; mu4e.
 (make-obsolete 'mu4e-clear-caches "No longer used" "1.11.15")
 
+
 (provide 'mu4e-obsolete)
 ;;; mu4e-obsolete.el ends here
diff --git a/mu4e/mu4e.el b/mu4e/mu4e.el
index a772147d..ed66c97a 100644
--- a/mu4e/mu4e.el
+++ b/mu4e/mu4e.el
@@ -253,7 +253,7 @@ chance."
   (mu4e-setq-if-nil mu4e-erase-func            #'mu4e~headers-clear)
 
   (mu4e-setq-if-nil mu4e-sent-func             #'mu4e--default-handler)
-  (mu4e-setq-if-nil mu4e-compose-func          #'mu4e~compose-handler)
+  (mu4e-setq-if-nil mu4e-compose-func          #'mu4e--compose-setup)
   (mu4e-setq-if-nil mu4e-contacts-func         #'mu4e--update-contacts)
   (mu4e-setq-if-nil mu4e-info-func             #'mu4e--info-handler)
   (mu4e-setq-if-nil mu4e-pong-func             #'mu4e--default-handler)