path: root/_spacemacs.d/local/mu4e/mu4e-view.el

;;; mu4e-view.el -- part of mu4e, the mu mail user agent
;;
;; Copyright (C) 2011-2016 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.
;;
;; GNU Emacs 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.

;; GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; In this file we define mu4e-view-mode (+ helper functions), which is used for
;; viewing e-mail messages

;;; Code:
(require 'mu4e-utils) ;; utility functions
(require 'mu4e-vars)
(require 'mu4e-mark)
(require 'mu4e-proc)
(require 'mu4e-compose)
(require 'mu4e-actions)
(require 'mu4e-message)

(require 'comint)
(require 'browse-url)
(require 'button)
(require 'epa)
(require 'epg)
(require 'thingatpt)
(require 'calendar)

(eval-when-compile (byte-compile-disable-warning 'cl-functions))
(require 'cl)


;; the message view
(defgroup mu4e-view nil
  "Settings for the message view."
  :group 'mu4e)

(defcustom mu4e-view-fields
  '(:from :to  :cc :subject :flags :date :maildir :mailing-list :tags
          :attachments :signature :decryption)
  "Header fields to display in the message view buffer.
For the complete list of available headers, see `mu4e-header-info'."
  :type (list 'symbol)
  :group 'mu4e-view)


(defcustom mu4e-view-show-addresses nil
  "Whether to initially show full e-mail addresses for contacts in
address fields, rather than only their names."
  :type 'boolean
  :group 'mu4e-view)

(make-obsolete-variable 'mu4e-view-wrap-lines nil "0.9.9-dev7")
(make-obsolete-variable 'mu4e-view-hide-cited nil "0.9.9-dev7")

(defcustom mu4e-view-date-format "%c"
  "Date format to use in the message view.
In the format of `format-time-string'."
  :type 'string
  :group 'mu4e-view)

(defcustom mu4e-view-image-max-width 800
  "The maximum width for images to display.
This is only effective if you're using an emacs with Imagemagick
support, and `mu4e-view-show-images' is non-nil."
  :group 'mu4e-view)

(defcustom mu4e-view-image-max-height 600
  "The maximum height for images to display.
This is only effective if you're using an emacs with Imagemagick
support, and `mu4e-view-show-images' is non-nil."
  :group 'mu4e-view)

(defcustom mu4e-view-scroll-to-next t
  "If non-nil, move to the next message when calling
`mu4e-view-scroll-up-or-next' (typically bound to SPC) when at the
end of a message. Otherwise, don't move to the next message.")

(defcustom mu4e-save-multiple-attachments-without-asking nil
  "If non-nil, saving multiple attachments asks once for a
directory and saves all attachments in the chosen directory."
  :type 'boolean
  :group 'mu4e-view)

(defvar mu4e-view-actions
  '( ("capture message"  . mu4e-action-capture-message)
     ("view as pdf"      . mu4e-action-view-as-pdf)
     ("show this thread" . mu4e-action-show-thread))
  "List of actions to perform on messages in view mode.
The actions are of the form:
  (NAME FUNC)
where:
* NAME is the name of the action (e.g. \"Count lines\")
* FUNC is a function which receives a message plist as an argument.

The first letter of NAME is used as a shortcut character.")

(defvar mu4e-view-attachment-actions
  '( ("wopen-with" . mu4e-view-open-attachment-with)
     ("ein-emacs"  . mu4e-view-open-attachment-emacs)
     ("dimport-in-diary"  . mu4e-view-import-attachment-diary)
     ("|pipe"      . mu4e-view-pipe-attachment))
  "List of actions to perform on message attachments.
The actions are cons-cells of the form:
 (NAME . FUNC)
where:
* NAME is the name of the action (e.g. \"Count lines\")
* FUNC is a function which receives two arguments: the message
  plist and the attachment number.
The first letter of NAME is used as a shortcut character.")

(defvar mu4e-view-fill-headers t
  "If non-nil, automatically fill the headers when viewing them.")

(defvar mu4e-view-contacts-header-keymap
  (let ((map (make-sparse-keymap)))
    (define-key map [mouse-2] 'mu4e~view-compose-contact)
    (define-key map "C"  'mu4e~view-compose-contact)
    (define-key map "c"  'mu4e~view-copy-contact)
    map)
  "Keymap used for the contacts in the header fields.")

(defvar mu4e-view-clickable-urls-keymap
  (let ((map (make-sparse-keymap)))
    (define-key map [mouse-1] 'mu4e~view-browse-url-from-binding)
    (define-key map [?\M-\r] 'mu4e~view-browse-url-from-binding)
    map)
  "Keymap used for the urls inside the body.")

(defvar mu4e-view-attachments-header-keymap
  (let ((map (make-sparse-keymap)))
    (define-key map [mouse-1] 'mu4e~view-open-attach-from-binding)
    (define-key map  [?\M-\r] 'mu4e~view-open-attach-from-binding)
    (define-key map [mouse-2] 'mu4e~view-save-attach-from-binding)
    (define-key map (kbd "<S-return>") 'mu4e~view-save-attach-from-binding)
    map)
  "Keymap used in the \"Attachements\" header field.")

(defcustom mu4e-view-auto-mark-as-read t
  "Automatically mark messages are 'read' when you read
them. This is typically the expected behavior, but can be turned
off, for example when using a read-only file-system."
  :type 'boolean
  :group 'mu4e-view)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(defvar mu4e~view-cited-hidden nil "Whether cited lines are hidden.")
(defvar mu4e~view-link-map nil
  "A map of some number->url so we can jump to url by number.")

(defvar mu4e~path-parent-docid-map (make-hash-table :test 'equal)
  "A map of msg paths --> parent-docids.
This is to determine what is the parent docid for embedded
message extracted at some path.")

(defvar mu4e~view-attach-map nil
  "A mapping of user-visible attachment number to the actual part index.")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun mu4e-view-message-with-message-id (msgid)
  "View message with message-id MSGID. This (re)creates a
headers-buffer with a search for MSGID, then open a view for that
message."
  (mu4e-headers-search (concat "msgid:" msgid) nil nil t msgid t))

(define-obsolete-function-alias 'mu4e-view-message-with-msgid
  'mu4e-view-message-with-message-id "0.9.17")

(defun mu4e~view-custom-field (msg field)
  "Show some custom header field, or raise an error if it is not
found."
  (let* ((item (or (assoc field mu4e-header-info-custom)
		 (mu4e-error "field %S not found" field)))
	  (func (or (plist-get (cdr-safe item) :function)
		  (mu4e-error "no :function defined for field %S %S"
		    field (cdr item)))))
    (funcall func msg)))


(defun mu4e-view-message-text (msg)
  "Return the message to display (as a string), based on the MSG plist."
  (concat
    (mapconcat
      (lambda (field)
	(let ((fieldval (mu4e-message-field msg field)))
	  (case field
	    (:subject  (mu4e~view-construct-header field fieldval))
	    (:path     (mu4e~view-construct-header field fieldval))
	    (:maildir  (mu4e~view-construct-header field fieldval))
	    ((:flags :tags) (mu4e~view-construct-flags-tags-header
			      field fieldval))

	    ;; contact fields
	    (:to       (mu4e~view-construct-contacts-header msg field))
	    (:from     (mu4e~view-construct-contacts-header msg field))
	    (:cc       (mu4e~view-construct-contacts-header msg field))
	    (:bcc      (mu4e~view-construct-contacts-header msg field))

	    ;; if we (`user-mail-address' are the From, show To, otherwise,
	    ;; show From
	    (:from-or-to
	      (let* ((from (mu4e-message-field msg :from))
		      (from (and from (cdar from))))
		(if (mu4e-user-mail-address-p from)
		  (mu4e~view-construct-contacts-header msg :to)
		  (mu4e~view-construct-contacts-header msg :from))))
	    ;; date
	    (:date
	      (let ((datestr
		      (when fieldval (format-time-string mu4e-view-date-format
				       fieldval))))
		(if datestr (mu4e~view-construct-header field datestr) "")))
	    ;; size
	    (:size
	      (mu4e~view-construct-header field (mu4e-display-size fieldval)))
	    (:mailing-list
	      (mu4e~view-construct-header field fieldval))
	    (:message-id
	      (mu4e~view-construct-header field fieldval))
	    ;; attachments
	    (:attachments (mu4e~view-construct-attachments-header msg))
	    ;; pgp-signatures
	    (:signature   (mu4e~view-construct-signature-header msg))
	    ;; pgp-decryption
	    (:decryption  (mu4e~view-construct-decryption-header msg))
	    (t (mu4e~view-construct-header field
		 (mu4e~view-custom-field msg field))))))
      mu4e-view-fields "")
    "\n"
    (let ((body (mu4e-message-body-text msg)))
      (when (fboundp 'add-face-text-property)
        (add-face-text-property 0 (length body) 'mu4e-view-body-face t body))
      body)))

(defun mu4e~view-embedded-winbuf ()
  "Get a buffer (shown in a window) for the embedded message."
  (let* ((buf (get-buffer-create mu4e~view-embedded-buffer-name))
	  (win (or (get-buffer-window buf) (split-window-vertically))))
    (select-window win)
    (switch-to-buffer buf)))

(defun mu4e~delete-all-overlays ()
  "`delete-all-overlays' with compatibility fallback."
  (if (functionp 'delete-all-overlays)
    (delete-all-overlays)
    (remove-overlays)))


(defun mu4e-view (msg headersbuf)
  "Display the message MSG in a new buffer, and keep in sync with HDRSBUF.
'In sync' here means that moving to the next/previous message in
the the message view affects HDRSBUF, as does marking etc.

As a side-effect, a message that is being viewed loses its 'unread'
marking if it still had that."
  (let* ((embedded ;; is it as an embedded msg (ie. message/rfc822 att)?
	   (when (gethash (mu4e-message-field msg :path)
		   mu4e~path-parent-docid-map) t))
	  (buf
	    (if embedded
	      (mu4e~view-embedded-winbuf)
	      (get-buffer-create mu4e~view-buffer-name))))
    ;; note: mu4e~view-mark-as-read-maybe will pseudo-recursively call mu4e-view
    ;; again by triggering mu4e~view again as it marks the message as read
    (with-current-buffer buf
      (switch-to-buffer buf)
      (setq mu4e~view-msg msg)
      (when (or embedded (not (mu4e~view-mark-as-read-maybe msg)))
	(let ((inhibit-read-only t))
	  (erase-buffer)
	  (mu4e~delete-all-overlays)
	  (insert (mu4e-view-message-text msg))
	  (goto-char (point-min))
	  (mu4e~fontify-cited)
	  (mu4e~fontify-signature)
	  (mu4e~view-make-urls-clickable)
	  (mu4e~view-show-images-maybe msg)
	  (setq
	    mu4e~view-buffer buf
	    mu4e~view-headers-buffer headersbuf)
	  (when embedded (local-set-key "q" 'kill-buffer-and-window))
	  (mu4e-view-mode))))))

(defun mu4e~view-get-property-from-event (prop)
  "Get the property PROP at point, or the location of the mouse.
The action is chosen based on the `last-command-event'.
Meant to be evoked from interactive commands."
  (if (and (eventp last-command-event)
	   (mouse-event-p last-command-event))
      (let ((posn (event-end last-command-event)))
        (when (numberp (posn-point posn))
          (get-text-property
           (posn-point posn)
           prop
           (window-buffer (posn-window posn)))
          ))
    (get-text-property (point) prop)))

(defun mu4e~view-construct-header (field val &optional dont-propertize-val)
  "Return header field FIELD (as in `mu4e-header-info') with value
VAL if VAL is non-nil. If DONT-PROPERTIZE-VAL is non-nil, do not
add text-properties to VAL."
  (let* ((info (cdr (assoc field
		      (append mu4e-header-info mu4e-header-info-custom))))
	  (key (plist-get info :name))
	  (help (plist-get info :help)))
    (if (and val (> (length val) 0))
    (with-temp-buffer
      (insert (propertize (concat key ":")
		'face 'mu4e-header-key-face
		'help-echo help) " "
	(if dont-propertize-val
	  val
	  (propertize val 'face 'mu4e-header-value-face)) "\n")
      (when mu4e-view-fill-headers
	;; temporarily set the fill column <margin> positions to the right, so
	;; we can indent the following lines correctly
	(let* ((margin 1)
		(fill-column (max (- fill-column margin) 0)))
	  (fill-region (point-min) (point-max))
	  (goto-char (point-min))
	  (while (and (zerop (forward-line 1)) (not (looking-at "^$")))
	    (indent-to-column margin))))
      (buffer-string))
    "")))

(defun mu4e~view-compose-contact (&optional point)
  "Compose a message for the address at point."
  (interactive)
  (unless (get-text-property (or point (point)) 'email)
    (mu4e-error "No address at point"))
  (mu4e~compose-mail (get-text-property (or point (point)) 'long)))

(defun mu4e~view-copy-contact (&optional full)
  "Compose a message for the address at (point)."
  (interactive "P")
  (let ((email (get-text-property (point) 'email))
	 (long (get-text-property (point) 'long)))
    (unless email (mu4e-error "No address at point"))
    (kill-new (if full long email))
    (mu4e-message "Address copied.")))

(defun mu4e~view-construct-contacts-header (msg field)
  "Add a header for a contact field (ie., :to, :from, :cc, :bcc)."
  (mu4e~view-construct-header field
    (mapconcat
      (lambda(c)
	(let* ((name (when (car c)
		       (replace-regexp-in-string "[[:cntrl:]]" "" (car c))))
		(email (when (cdr c)
			 (replace-regexp-in-string "[[:cntrl:]]" "" (cdr c))))
		(short (or name email)) ;; name may be nil
		(long (if name (format "%s <%s>" name email) email)))
	  (propertize
	    (if mu4e-view-show-addresses long short)
	    'long long
	    'short short
	    'email email
	    'keymap mu4e-view-contacts-header-keymap
	    'face 'mu4e-contact-face
	    'mouse-face 'highlight
	    'help-echo (format "<%s>\n%s" email
			 "[mouse-2] or C to compose a mail for this recipient"))))
	  (mu4e-message-field msg field) ", ") t))


(defun mu4e~view-construct-flags-tags-header (field val)
  "Construct a Flags: header."
  (mu4e~view-construct-header
    field
    (mapconcat
      (lambda (flag)
	(propertize
	  (if (symbolp flag)
	    (symbol-name flag)
	    flag)
	  'face 'mu4e-special-header-value-face))
      val
      (propertize ", " 'face 'mu4e-header-value-face)) t))

(defun mu4e~view-construct-signature-header (msg)
  "Construct a Signature: header, if there are any signed parts."
  (let* ((parts (mu4e-message-field msg :parts))
	  (verdicts
	    (remove-if 'null
	      (mapcar (lambda (part) (mu4e-message-part-field part :signature))
		parts)))
	  (val (when verdicts
		 (mapconcat
		   (lambda (v)
		     (propertize (symbol-name v)
		       'face (if (eq v 'verified)
			       'mu4e-ok-face 'mu4e-warning-face)))
		   verdicts ", ")))
	  (btn (when val
		 (with-temp-buffer
		   (insert-text-button "Details"
		     'action (lambda (b)
			       (mu4e-view-verify-msg-popup
				 (button-get b 'msg))))
		   (buffer-string))))
	  (val (when val (concat val " (" btn ")"))))
    (mu4e~view-construct-header :signature val t)))

(defun mu4e~view-construct-decryption-header (msg)
  "Construct a Decryption: header, if there are any encrypted parts."
  (let* ((parts (mu4e-message-field msg :parts))
	 (verdicts
	  (remove-if 'null
	    (mapcar (lambda (part)
		      (mu4e-message-part-field part :decryption))
	      parts)))
	 (succeeded (remove-if (lambda (v) (eq v 'failed)) verdicts))
	 (failed (remove-if (lambda (v) (eq v 'succeeded)) verdicts))
	 (succ (when succeeded
		 (propertize
		  (concat (number-to-string (length succeeded))
			  " part(s) decrypted")
		  'face 'mu4e-ok-face)))
	 (fail (when failed
		 (propertize
		  (concat (number-to-string (length failed))
			  " part(s) failed")
		  'face 'mu4e-warning-face)))
	 (val (concat succ fail)))
    (mu4e~view-construct-header :decryption val t)))

(defun mu4e~view-open-attach-from-binding ()
  "Open the attachement at point, or click location."
  (interactive)
  (let* (( msg (mu4e~view-get-property-from-event 'mu4e-msg))
         ( attnum (mu4e~view-get-property-from-event 'mu4e-attnum)))
    (when (and msg attnum)
      (mu4e-view-open-attachment msg attnum))))

(defun mu4e~view-save-attach-from-binding ()
  "Save the attachement at point, or click location."
  (interactive)
  (let* (( msg (mu4e~view-get-property-from-event 'mu4e-msg))
         ( attnum (mu4e~view-get-property-from-event 'mu4e-attnum)))
    (when (and msg attnum)
      (mu4e-view-save-attachment-single msg attnum))))

(defun mu4e~view-construct-attachments-header (msg)
  "Display attachment information; the field looks like something like:
   	:parts ((:index 1 :name \"1.part\" :mime-type \"text/plain\"
                 :type (leaf) :attachment nil :size 228)
                (:index 2 :name \"analysis.doc\"
                 :mime-type \"application/msword\"
                 :type (leaf attachment) :attachment nil :size 605196))"
  (setq mu4e~view-attach-map ;; buffer local
    (make-hash-table :size 64 :weakness nil))
  (let* ((id 0)
	  (attachments
	    ;; we only list parts that look like attachments, ie. that have a
	    ;; non-nil :attachment property; we record a mapping between
	    ;; user-visible numbers and the part indices
	    (remove-if-not
	      (lambda (part)
		(let* ((mtype (or (mu4e-message-part-field part :mime-type)
				"application/octet-stream"))
			(attachtype (mu4e-message-part-field part :type))
			(isattach
			  (or ;; we consider parts marked either
			    ;; "attachment" or "inline" as attachment.
			    (member 'attachment attachtype)
			    ;; list inline parts as attachment (so they can be
			    ;; saved), unless they are text/plain, which are
			    ;; usually just message footers in mailing lists
			    (and (member 'inline attachtype)
			      (not (string-match "^text/plain" mtype))))))
		  (or ;; remove if it's not an attach *or* if it's an
		    ;; image/audio/application type (but not a signature)
		    isattach
		    (string-match "^\\(image\\|audio\\)" mtype)
		    (string= "message/rfc822" mtype)
		    (string= "text/calendar" mtype)
		    (and (string-match "^application" mtype)
		      (not (string-match "signature" mtype))))))
	      (mu4e-message-field msg :parts)))
	  (attstr
	    (mapconcat
	      (lambda (part)
		(let ((index (mu4e-message-part-field part :index))
		       (name (mu4e-message-part-field part :name))
		       (size (mu4e-message-part-field part :size)))
		  (incf id)
		  (puthash id index mu4e~view-attach-map)

		  (concat
		    (propertize (format "[%d]" id)
		      'face 'mu4e-attach-number-face)
		    (propertize name 'face 'mu4e-link-face
		      'keymap mu4e-view-attachments-header-keymap
		      'mouse-face 'highlight
		      'help-echo (concat
				  "[mouse-1] or [M-RET] opens the attachment\n"
				  "[mouse-2] or [S-RET] offers to save it")
		      'mu4e-msg msg
		      'mu4e-attnum id
		      )
		    (when (and size (> size 0))
		      (propertize (format "(%s)" (mu4e-display-size size))
                                  'face 'mu4e-header-key-face)))))
	      attachments ", ")))
    (when attachments
      (mu4e~view-construct-header :attachments attstr t))))

(defun mu4e-view-for-each-part (msg func)
  "Apply FUNC to each part in MSG.
FUNC should be a function taking two arguments:
 1. the message MSG, and
 2. a plist describing the attachment. The plist looks like:
    	 (:index 1 :name \"test123.doc\"
          :mime-type \"application/msword\" :attachment t :size 1234)."
  (dolist (part (mu4e-msg-field msg :parts))
    (funcall func msg part)))

(defvar mu4e-view-mode-map nil
  "Keymap for \"*mu4e-view*\" buffers.")
(unless mu4e-view-mode-map
  (setq mu4e-view-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 "q" 'mu4e~view-quit-buffer)

      ;; note, 'z' is by-default bound to 'bury-buffer'
      ;; but that's not very useful in this case
      (define-key map "z" 'ignore)

      (define-key map "s" 'mu4e-headers-search)
      (define-key map "S" 'mu4e-view-search-edit)
      (define-key map "/" 'mu4e-view-search-narrow)

      (define-key map (kbd "<M-left>")  'mu4e-headers-query-prev)
      (define-key map (kbd "<M-right>") 'mu4e-headers-query-next)

      (define-key map "b" 'mu4e-headers-search-bookmark)
      (define-key map "B" 'mu4e-headers-search-bookmark-edit)

      (define-key map "%" 'mu4e-view-mark-pattern)
      (define-key map "t" 'mu4e-view-mark-subthread)
      (define-key map "T" 'mu4e-view-mark-thread)

      (define-key map "v" 'mu4e-view-verify-msg-popup)

      (define-key map "j" 'mu4e~headers-jump-to-maildir)

      (define-key map "g" 'mu4e-view-go-to-url)
      (define-key map "k" 'mu4e-view-save-url)
      (define-key map "f" 'mu4e-view-fetch-url)

      (define-key map "F" 'mu4e-compose-forward)
      (define-key map "R" 'mu4e-compose-reply)
      (define-key map "C" 'mu4e-compose-new)
      (define-key map "E" 'mu4e-compose-edit)

      (define-key map "." 'mu4e-view-raw-message)
      (define-key map "|" 'mu4e-view-pipe)
      (define-key map "a" 'mu4e-view-action)

      (define-key map ";" 'mu4e-context-switch)
      
      ;; toggle header settings
      (define-key map "O" 'mu4e-headers-change-sorting)
      (define-key map "P" 'mu4e-headers-toggle-threading)
      (define-key map "Q" 'mu4e-headers-toggle-full-search)
      (define-key map "W" 'mu4e-headers-toggle-include-related)

      ;; change the number of headers
      (define-key map (kbd "C-+") 'mu4e-headers-split-view-grow)
      (define-key map (kbd "C--") 'mu4e-headers-split-view-shrink)
      (define-key map (kbd "<C-kp-add>") 'mu4e-headers-split-view-grow)
      (define-key map (kbd "<C-kp-subtract>") 'mu4e-headers-split-view-shrink)

      ;; intra-message navigation
      (define-key map (kbd "SPC") 'mu4e-view-scroll-up-or-next)
      (define-key map (kbd "<home>") 'beginning-of-buffer)
      (define-key map (kbd "<end>") 'end-of-buffer)
      (define-key map (kbd "RET") 'mu4e-scroll-up)
      (define-key map (kbd "<backspace>") 'mu4e-scroll-down)

      ;; navigation between messages
      (define-key map "p" 'mu4e-view-headers-prev)
      (define-key map "n" 'mu4e-view-headers-next)
      ;; the same
      (define-key map (kbd "<M-down>") 'mu4e-view-headers-next)
      (define-key map (kbd "<M-up>") 'mu4e-view-headers-prev)

      (define-key map (kbd "[") 'mu4e-view-headers-prev-unread)
      (define-key map (kbd "]") 'mu4e-view-headers-next-unread)
      
      ;; switching to view mode (if it's visible)
      (define-key map "y" 'mu4e-select-other-view)

      ;; attachments
      (define-key map "e" 'mu4e-view-save-attachment)
      (define-key map "o" 'mu4e-view-open-attachment)
      (define-key map "A" 'mu4e-view-attachment-action)

      ;; marking/unmarking
      (define-key map "d" 'mu4e-view-mark-for-trash)
      (define-key map (kbd "<delete>") 'mu4e-view-mark-for-delete)
      (define-key map (kbd "<deletechar>") 'mu4e-view-mark-for-delete)
      (define-key map (kbd "D") 'mu4e-view-mark-for-delete)
      (define-key map (kbd "m") 'mu4e-view-mark-for-move)
      (define-key map (kbd "r") 'mu4e-view-mark-for-refile)

      (define-key map (kbd "?") 'mu4e-view-mark-for-unread)
      (define-key map (kbd "!") 'mu4e-view-mark-for-read)

      (define-key map (kbd "+") 'mu4e-view-mark-for-flag)
      (define-key map (kbd "-") 'mu4e-view-mark-for-unflag)
      (define-key map (kbd "=") 'mu4e-view-mark-for-untrash)
      (define-key map (kbd "&") 'mu4e-view-mark-custom)
      
      (define-key map (kbd "*")             'mu4e-view-mark-for-something)
      (define-key map (kbd "<kp-multiply>") 'mu4e-view-mark-for-something)
      (define-key map (kbd "<insert>")     'mu4e-view-mark-for-something)
      (define-key map (kbd "<insertchar>") 'mu4e-view-mark-for-something)

      (define-key map (kbd "#") 'mu4e-mark-resolve-deferred-marks)

      ;; misc
      (define-key map "w" 'visual-line-mode)
      (define-key map "#" 'mu4e-view-toggle-hide-cited)
      (define-key map "h" 'mu4e-view-toggle-html)
      (define-key map (kbd "M-q") 'mu4e-view-fill-long-lines)

      ;; next 3 only warn user when attempt in the message view
      (define-key map "u" 'mu4e-view-unmark)
      (define-key map "U" 'mu4e-view-unmark-all)
      (define-key map "x" 'mu4e-view-marked-execute)

      (define-key map "$" 'mu4e-show-log)
      (define-key map "H" 'mu4e-display-manual)

      ;; menu
      (define-key map [menu-bar] (make-sparse-keymap))
      (let ((menumap (make-sparse-keymap "View")))
	(define-key map [menu-bar headers] (cons "View" menumap))

	(define-key menumap [quit-buffer]
	  '("Quit view" . mu4e~view-quit-buffer))
	(define-key menumap [display-help] '("Help" . mu4e-display-manual))

	(define-key menumap [sepa0] '("--"))
	(define-key menumap [wrap-lines]
	  '("Toggle wrap lines" . visual-line-mode))
	(define-key menumap [toggle-html]
	  '("Toggle view-html" . mu4e-view-toggle-html))
	(define-key menumap [hide-cited]
	  '("Toggle hide cited" . mu4e-view-toggle-hide-cited))
	(define-key menumap [raw-view]
	  '("View raw message" . mu4e-view-raw-message))
	(define-key menumap [pipe]
	  '("Pipe through shell" . mu4e-view-pipe))
	;; (define-key menumap [inspect]
	;;   '("Inspect with guile" . mu4e-inspect-message))

	(define-key menumap [sepa8] '("--"))
	(define-key menumap [open-att]
	  '("Open attachment" . mu4e-view-open-attachment))
	(define-key menumap [extract-att]
	  '("Extract attachment" . mu4e-view-save-attachment))

	(define-key menumap [save-url]
	  '("Save URL to kill-ring" . mu4e-view-save-url))
	(define-key menumap [fetch-url]
	  '("Fetch URL" . mu4e-view-fetch-url))
	(define-key menumap [goto-url]
	  '("Visit URL" . mu4e-view-go-to-url))

	(define-key menumap [sepa1] '("--"))
	(define-key menumap [mark-delete]
	  '("Mark for deletion" . mu4e-view-mark-for-delete))
	(define-key menumap [mark-trash]
	  '("Mark for trash" .  mu4e-view-mark-for-trash))
	(define-key menumap [mark-move]
	  '("Mark for move" . mu4e-view-mark-for-move))

	(define-key menumap [sepa2] '("--"))
	(define-key menumap [resend]  '("Resend" . mu4e-compose-resend))
	(define-key menumap [forward]  '("Forward" . mu4e-compose-forward))
	(define-key menumap [reply]  '("Reply" . mu4e-compose-reply))
	(define-key menumap [compose-new]  '("Compose new" . mu4e-compose-new))
	(define-key menumap [sepa3] '("--"))

	(define-key menumap [query-next]
	  '("Next query" . mu4e-headers-query-next))
	(define-key menumap [query-prev]
	  '("Previous query" . mu4e-headers-query-prev))
	(define-key menumap [narrow-search]
	  '("Narrow search" . mu4e-headers-search-narrow))
	(define-key menumap [bookmark]
	  '("Search bookmark" . mu4e-headers-search-bookmark))
	(define-key menumap [jump]
	  '("Jump to maildir" . mu4e~headers-jump-to-maildir))
	(define-key menumap [search]
	  '("Search" . mu4e-headers-search))

	(define-key menumap [sepa4] '("--"))
	(define-key menumap [next]  '("Next" . mu4e-view-headers-next))
	(define-key menumap [previous]  '("Previous" . mu4e-view-headers-prev)))
      map)))

(fset 'mu4e-view-mode-map mu4e-view-mode-map)

(defcustom mu4e-view-mode-hook nil
  "Hook run when entering Mu4e-View mode."
  :options '(turn-on-visual-line-mode)
  :type 'hook
  :group 'mu4e-view)

(defvar mu4e-view-mode-abbrev-table nil)
(define-derived-mode mu4e-view-mode special-mode "mu4e:view"
  "Major mode for viewing an e-mail message in mu4e.
\\{mu4e-view-mode-map}."
  (use-local-map mu4e-view-mode-map)

  (make-local-variable 'mu4e~view-headers-buffer)
  (make-local-variable 'mu4e~view-msg)
  (make-local-variable 'mu4e~view-link-map)
  (make-local-variable 'mu4e~view-attach-map)
  (make-local-variable 'mu4e~view-cited-hidden)

  ;; show context in mode-string
  (set (make-local-variable 'global-mode-string) '(:eval (mu4e-context-label))) 
 
  (setq buffer-undo-list t);; don't record undo info
     
  ;; autopair mode gives error when pressing RET
  ;; turn it off
  (when (boundp 'autopair-dont-activate)
    (setq autopair-dont-activate t)))

(defun mu4e~view-mark-as-read-maybe (msg)
  "Clear the message MSG New/Unread status and set it to Seen.
If the message is not New/Unread, do nothing. Evaluates to t if it
triggers any changes, nil otherwise. If this function does any
changes, it triggers a refresh."
  (when (and mu4e-view-auto-mark-as-read msg)
    (let ((flags (mu4e-message-field msg :flags))
	   (msgid (mu4e-message-field msg :message-id))
	   (docid (mu4e-message-field msg :docid)))
      ;; attached (embedded) messages don't have docids; leave them alone if it is a new message
      (when (and docid (or (member 'unread flags) (member 'new flags)))
	;; mark /all/ messages with this message-id as read, so all copies of
	;; this message will be marked as read.
	(mu4e~proc-move msgid nil "+S-u-N")
	t))))

(defun mu4e~view-browse-url-func (url)
  "Return a function that executes `browse-url' with URL.
What browser is called is depending on
`browse-url-browser-function' and `browse-url-mailto-function'."
  (save-match-data
    (if (string-match "^mailto:" url)
      (lexical-let ((url url))
	(lambda ()
	  (interactive)
	  (mu4e~compose-browse-url-mail url)))
      (lexical-let ((url url))
	(lambda ()
	  (interactive)
	  (browse-url url))))))

(defun mu4e~view-browse-url-from-binding (&optional url)
  "View in browser the url at point, or click location.
If the optional argument URL is provided, browse that instead.
If the url is mailto link, start writing an email to that address."
  (interactive)
  (let* (( url (or url (mu4e~view-get-property-from-event 'mu4e-url))))
    (when url
      (if (string-match-p "^mailto:" url)
	  (mu4e~compose-browse-url-mail url)
	(browse-url url)))))

(defun mu4e~view-show-images-maybe (msg)
  "Show attached images, if `mu4e-show-images' is non-nil."
  (when (and (display-images-p) mu4e-view-show-images)
    (mu4e-view-for-each-part msg
      (lambda (msg part)
	(when (string-match "^image/"
		(or (mu4e-message-part-field part :mime-type)
		  "application/object-stream"))
	  (let ((imgfile (mu4e-message-part-field part :temp)))
	    (when (and imgfile (file-exists-p imgfile))
 	      (save-excursion
		(goto-char (point-max))
		(mu4e-display-image imgfile
		  mu4e-view-image-max-width
		  mu4e-view-image-max-height)))))))))


(defvar mu4e~view-beginning-of-url-regexp
  "https?\\://\\|mailto:"
  "Regexp that matches the beginning of http:/https:/mailto:
URLs; match-string 1 will contain the matched URL, if any.")

;; this is fairly simplistic...
(defun mu4e~view-make-urls-clickable ()
  "Turn things that look like URLs into clickable things.
Also number them so they can be opened using `mu4e-view-go-to-url'."
  (let ((num 0))
    (save-excursion
      (setq mu4e~view-link-map ;; buffer local
	(make-hash-table :size 32 :weakness nil))
      (goto-char (point-min))
      (while (re-search-forward mu4e~view-beginning-of-url-regexp nil t)
	(let ((bounds (thing-at-point-bounds-of-url-at-point)))
	  (when bounds
	    (let* ((url (thing-at-point-url-at-point))
		    (ov (make-overlay (car bounds) (cdr bounds))))
	      (puthash (incf num) url mu4e~view-link-map)
	      (add-text-properties
		(car bounds)
		(cdr bounds)
		`(face mu4e-link-face
		   mouse-face highlight
		   mu4e-url ,url
		   keymap ,mu4e-view-clickable-urls-keymap
		   help-echo
		   "[mouse-1] or [M-RET] to open the link"))
	      (overlay-put ov 'after-string
		(propertize (format "[%d]" num)
		  'face 'mu4e-url-number-face)))))))))


(defun mu4e~view-hide-cited ()
  "Toggle hiding of cited lines in the message body."
  (save-excursion
    (let ((inhibit-read-only t))
      (goto-char (point-min))
      (flush-lines mu4e-cited-regexp)
      (setq mu4e~view-cited-hidden t))))

(defmacro mu4e~view-in-headers-context (&rest body)
  "Evaluate BODY in the context of the headers buffer connected to
this view."
  `(progn
     (unless (buffer-live-p mu4e~view-headers-buffer)
       (mu4e-error "no headers-buffer connected"))
     (let* ((msg (mu4e-message-at-point))
	     (docid (mu4e-message-field msg :docid))
	     (curwin (selected-window)))
       (unless docid
	 (mu4e-error "message without docid: action is not possible."))
       (with-current-buffer mu4e~view-headers-buffer
	 (when (get-buffer-window)
	   (select-window (get-buffer-window)))
	 (if (mu4e~headers-goto-docid docid)
	   ,@body
	   (mu4e-error "cannot find message in headers buffer."))))))

(defun mu4e-view-headers-next (&optional n)
  "Move point to the next message header in the headers buffer
connected with this message view. If this succeeds, return the new
docid. Otherwise, return nil. Optionally, takes an integer
N (prefix argument), to the Nth next header."
  (interactive "P")
  (mu4e~view-in-headers-context
    (mu4e~headers-move (or n 1))))

(defun mu4e-view-headers-prev (&optional n)
  "Move point to the previous message header in the headers buffer
connected with this message view. If this succeeds, return the new
docid. Otherwise, return nil. Optionally, takes an integer
N (prefix argument), to the Nth previous header."
  (interactive "P")
  (mu4e~view-in-headers-context
    (mu4e~headers-move (- (or n 1)))))

(defun mu4e~view-prev-or-next-unread (backwards)
  "Move point to the next or previous (when BACKWARDS is non-`nil')
unread message header in the headers buffer connected with this
message view. If this succeeds, return the new docid. Otherwise,
return nil."
  (mu4e~view-in-headers-context 
    (mu4e~headers-prev-or-next-unread backwards))
  (mu4e-select-other-view)
  (mu4e-headers-view-message))

(defun mu4e-view-headers-prev-unread ()
"Move point to the previous unread message header in the headers
buffer connected with this message view. If this succeeds, return
the new docid. Otherwise, return nil."
  (interactive)
  (mu4e~view-prev-or-next-unread t))

(defun mu4e-view-headers-next-unread ()
  "Move point to the next unread message header in the headers
buffer connected with this message view. If this succeeds, return
the new docid. Otherwise, return nil."
  (interactive)
  (mu4e~view-prev-or-next-unread nil))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Interactive functions

(defun mu4e-view-toggle-hide-cited ()
  "Toggle hiding of cited lines in the message body."
  (interactive)
  (if mu4e~view-cited-hidden
    (mu4e-view-refresh)
    (mu4e~view-hide-cited)))

(defun mu4e-view-toggle-html ()
  "Toggle html-display of the message body (if any)."
  (interactive)
  (setq mu4e-view-prefer-html (not mu4e-view-prefer-html)) 
  (mu4e-view-refresh)) 

(defun mu4e-view-refresh ()
  "Redisplay the current message."
  (interactive)
  (mu4e-view mu4e~view-msg mu4e~view-headers-buffer)
  (setq mu4e~view-cited-hidden nil))

(defun mu4e-view-action (&optional msg)
  "Ask user for some action to apply on MSG, then do it.
If MSG is nil apply action to message returned
bymessage-at-point.  The actions are specified in
`mu4e-view-actions'."
  (interactive)
  (let* ((msg (or msg (mu4e-message-at-point)))
	  (actionfunc (mu4e-read-option "Action: " mu4e-view-actions)))
    (funcall actionfunc msg)))

(defun mu4e-view-mark-pattern ()
    "Ask user for a kind of mark (move, delete etc.), a field to
match and a regular expression to match with. Then, mark all
matching messages with that mark."
  (interactive)
  (mu4e~view-in-headers-context (mu4e-headers-mark-pattern)))

(defun mu4e-view-mark-thread (&optional markpair)
  "Ask user for a kind of mark (move, delete etc.), and apply it
to all messages in the thread at point in the headers view. The
optional MARKPAIR can also be used to provide the mark
selection."
  (interactive)
  (mu4e~view-in-headers-context
   (if markpair (mu4e-headers-mark-thread nil markpair)
       (call-interactively 'mu4e-headers-mark-thread))))

(defun mu4e-view-mark-subthread (&optional markpair)
  "Ask user for a kind of mark (move, delete etc.), and apply it
to all messages in the subthread at point in the headers view.
The optional MARKPAIR can also be used to provide the mark
selection."
  (interactive)
  (mu4e~view-in-headers-context
   (if markpair (mu4e-headers-mark-subthread markpair)
     (mu4e-headers-mark-subthread))))

(defun mu4e-view-search-narrow ()
  "Run `mu4e-headers-search-narrow' in the headers buffer."
  (interactive)
  (mu4e~view-in-headers-context
    (call-interactively 'mu4e-headers-search-narrow)))

(defun mu4e-view-search-edit ()
  "Run `mu4e-headers-search-edit' in the headers buffer."
  (interactive)
  (mu4e~view-in-headers-context (mu4e-headers-search-edit)))

(defun mu4e-mark-region-code ()
  "Highlight region marked with `message-mark-inserted-region'.
Add this function to `mu4e-view-mode-hook' to enable this feature."
  (require 'message)
  (let (beg end ov-beg ov-end ov-inv)
    (save-excursion
      (goto-char (point-min))
      (while (re-search-forward
              (concat "^" message-mark-insert-begin) nil t)
        (setq ov-beg (match-beginning 0)
              ov-end (match-end 0)
              ov-inv (make-overlay ov-beg ov-end)
              beg    ov-end)
        (overlay-put ov-inv 'invisible t)
        (when (re-search-forward
               (concat "^" message-mark-insert-end) nil t)
          (setq ov-beg (match-beginning 0)
                ov-end (match-end 0)
                ov-inv (make-overlay ov-beg ov-end)
                end    ov-beg)
          (overlay-put ov-inv 'invisible t))
        (when (and beg end)
          (let ((ov (make-overlay beg end)))
            (overlay-put ov 'face 'mu4e-region-code))
          (setq beg nil end nil))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Wash functions
(defun mu4e-view-fill-long-lines ()
  "Fill lines that are wider than the window width or `fill-column'."
  (interactive)
  (with-current-buffer mu4e~view-buffer
    (save-excursion
      (let ((inhibit-read-only t)
            (width (window-width (get-buffer-window (current-buffer)))))
        (save-restriction
          (message-goto-body)
          (while (not (eobp))
            (end-of-line)
            (when (>= (current-column) (min fill-column width))
              (narrow-to-region (min (1+ (point)) (point-max))
                                (point-at-bol))
              (let ((goback (point-marker)))
                (fill-paragraph nil)
                (goto-char (marker-position goback)))
              (widen))
            (forward-line 1)))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; attachment handling
(defun mu4e~view-get-attach-num (prompt msg &optional multi)
  "Ask the user with PROMPT for an attachment number for MSG, and
ensure it is valid. The number is [1..n] for attachments
\[0..(n-1)] in the message. If MULTI is nil, return the number for
the attachment; otherwise (MULTI is non-nil), accept ranges of
attachment numbers, as per `mu4e-split-ranges-to-numbers', and
return the corresponding string."
  (let* ((count (hash-table-count mu4e~view-attach-map)) (def))
    (when (zerop count) (mu4e-error "No attachments for this message"))
    (if (not multi)
      (if (= count 1)
	(read-number (mu4e-format "%s: " prompt) 1)
	(read-number (mu4e-format "%s (1-%d): " prompt count)))
      (progn
	(setq def (if (= count 1) "1" (format "1-%d" count)))
	(read-string (mu4e-format "%s (default %s): " prompt def)
	  nil nil def)))))

(defun mu4e~view-get-attach (msg attnum)
  "Return the attachment plist in MSG corresponding to attachment
number ATTNUM."
  (let* ((partid (gethash attnum mu4e~view-attach-map))
	 (attach
	   (find-if
	     (lambda (part)
	       (eq (mu4e-message-part-field part :index) partid))
	     (mu4e-message-field msg :parts))))
    (or attach (mu4e-error "Not a valid attachment"))))


(defun mu4e~view-request-attachment-path (fname path)
  "Ask the user where to save FNAME (default is PATH/FNAME)."
  (let ((fpath (expand-file-name
                (read-file-name
                 (mu4e-format "Save as ")
                 path nil nil fname) path)))
    (if (file-directory-p fpath)
      (expand-file-name fname fpath)
      fpath)))

(defun mu4e~view-request-attachments-dir (path)
  "Ask the user where to save multiple attachments (default is PATH)."
  (let ((fpath (expand-file-name
                (read-directory-name
                 (mu4e-format "Save in directory ")
                 path nil nil nil) path)))
    (if (file-directory-p fpath)
        fpath)))

(defun mu4e-view-save-attachment-single (&optional msg attnum)
  "Save attachment number ATTNUM from MSG.
If MSG is nil use the message returned by `message-at-point'.
If ATTNUM is nil ask for the attachment number."
  (interactive)
  (let* ((msg (or msg (mu4e-message-at-point)))
	  (attnum (or attnum
		    (mu4e~view-get-attach-num "Attachment to save" msg)))
	  (att (mu4e~view-get-attach msg attnum))
	  (fname  (plist-get att :name))
	  (mtype  (plist-get att :mime-type))
	  (path (concat
		  (mu4e~get-attachment-dir fname mtype) "/"))
	  (index (plist-get att :index))
	  (retry t) (fpath))
    (while retry
      (setq fpath (mu4e~view-request-attachment-path fname path))
      (setq retry
	(and (file-exists-p fpath)
	  (not (y-or-n-p (mu4e-format "Overwrite '%s'?" fpath))))))
    (mu4e~proc-extract
      'save (mu4e-message-field msg :docid)
      index mu4e-decryption-policy fpath)))


(defun mu4e-view-save-attachment-multi (&optional msg)
  "Offer to save multiple email attachments from the current message.
Default is to save all messages, [1..n], where n is the number of
attachments.  You can type multiple values separated by space, e.g.
  1 3-6 8
will save attachments 1,3,4,5,6 and 8.

Furthermore, there is a shortcut \"a\" which so means all
attachments, but as this is the default, you may not need it."
  (interactive)
  (let* ((msg (or msg (mu4e-message-at-point)))
         (attachstr (mu4e~view-get-attach-num
                     "Attachment number range (or 'a' for 'all')" msg t))
         (count (hash-table-count mu4e~view-attach-map))
         (attachnums (mu4e-split-ranges-to-numbers attachstr count)))
    (if mu4e-save-multiple-attachments-without-asking
        (let* ((path (concat (mu4e~get-attachment-dir) "/"))
               (attachdir (mu4e~view-request-attachments-dir path)))
          (dolist (num attachnums)
            (let* ((att (mu4e~view-get-attach msg num))
                   (fname  (plist-get att :name))
                   (index (plist-get att :index))
                   (retry t)
		   fpath)
              (while retry
                (setq fpath (expand-file-name (concat attachdir fname) path))
                (setq retry
                      (and (file-exists-p fpath)
			(not (y-or-n-p
			       (mu4e-format "Overwrite '%s'?" fpath))))))
              (mu4e~proc-extract
		'save (mu4e-message-field msg :docid)
		index mu4e-decryption-policy fpath))))
      (dolist (num attachnums)
        (mu4e-view-save-attachment-single msg num)))))

(defun mu4e-view-save-attachment (&optional multi)
  "Offer to save attachment(s).
If MULTI (prefix-argument) is nil, save a single one, otherwise,
offer to save a range of attachments."
  (interactive "P")
  (if multi
    (mu4e-view-save-attachment-multi)
    (mu4e-view-save-attachment-single)))

(defun mu4e-view-open-attachment (&optional msg attnum)
  "Open attachment number ATTNUM from MSG.
If MSG is nil use the message returned by `message-at-point'.
If ATTNUM is nil ask for the attachment number."
  (interactive)
  (let* ((msg (or msg (mu4e-message-at-point)))
	  (attnum (or attnum
		    (mu4e~view-get-attach-num "Attachment to open" msg)))
	  (att (or (mu4e~view-get-attach msg attnum)))
	  (index (plist-get att :index))
	  (docid (mu4e-message-field msg :docid))
	  (mimetype (plist-get att :mime-type)))
    (if (and mimetype (string= mimetype "message/rfc822"))
      ;; special handling for message-attachments; we open them in mu4e. we also
      ;; send the docid as parameter (4th arg); we'll get this back from the
      ;; server, and use it to determine the parent message (ie., the current
      ;; message) when showing the embedded message/rfc822, and return to the
      ;; current message when quitting that one.
      (mu4e~view-temp-action docid index "mu4e" docid)
      ;; otherwise, open with the default program (handled in mu-server
      (mu4e~proc-extract 'open docid index mu4e-decryption-policy))))


(defun mu4e~view-temp-action (docid index what &optional param)
  "Open attachment INDEX for message with DOCID, and invoke ACTION."
  (interactive)
  (mu4e~proc-extract 'temp docid index mu4e-decryption-policy nil what param ))

(defvar mu4e~view-open-with-hist nil "History list for the open-with argument.")

(defun mu4e-view-open-attachment-with (msg attachnum &optional cmd)
  "Open MSG's attachment ATTACHNUM with CMD.
If CMD is nil, ask user for it."
  (interactive)
  (let* ((att (mu4e~view-get-attach msg attachnum))
	  (cmd (or cmd
		 (read-string
		   (mu4e-format "Shell command to open it with: ")
		   nil 'mu4e~view-open-with-hist)))
	  (index (plist-get att :index)))
    (mu4e~view-temp-action
      (mu4e-message-field msg :docid) index "open-with" cmd)))

(defvar mu4e~view-pipe-hist nil
  "History list for the pipe argument.")

(defun mu4e-view-pipe-attachment (msg attachnum &optional pipecmd)
  "Feed MSG's attachment ATTACHNUM through pipe PIPECMD.
If PIPECMD is nil, ask user for it."
  (interactive)
  (let* ((att (mu4e~view-get-attach msg attachnum))
	  (pipecmd (or pipecmd
		     (read-string
		       (mu4e-format "Pipe: ")
		       nil
		       'mu4e~view-pipe-hist)))
	  (index (plist-get att :index)))
    (mu4e~view-temp-action
      (mu4e-message-field msg :docid) index "pipe" pipecmd)))


(defun mu4e-view-open-attachment-emacs (msg attachnum)
  "Open MSG's attachment ATTACHNUM in the current emacs instance."
  (interactive)
  (let* ((att (mu4e~view-get-attach msg attachnum))
	  (index (plist-get att :index)))
    (mu4e~view-temp-action (mu4e-message-field msg :docid) index "emacs")))

(defun mu4e-view-import-attachment-diary (msg attachnum)
  "Open MSG's attachment ATTACHNUM in the current emacs instance."
  (interactive)
  (let* ((att (mu4e~view-get-attach msg attachnum))
	  (index (plist-get att :index)))
    (mu4e~view-temp-action (mu4e-message-field msg :docid) index "diary")))

(defun mu4e-view-attachment-action (&optional msg)
  "Ask user what to do with attachments in MSG
If MSG is nil use the message returned by `message-at-point'.
The actions are specified in `mu4e-view-attachment-actions'."
  (interactive)
  (let* ((msg (or msg (mu4e-message-at-point)))
	  (actionfunc (mu4e-read-option
			"Action on attachment: "
			mu4e-view-attachment-actions))
	  (attnum (mu4e~view-get-attach-num "Which attachment" msg)))
    (when (and actionfunc attnum)
      (funcall actionfunc msg attnum))))

;; handler-function to handle the response we get from the server when we
;; want to do something with one of the attachments.
(defun mu4e~view-temp-handler (path what docid param)
  "Handler function for doing things with temp files (ie.,
attachments) in response to a (mu4e~proc-extract 'temp ... )."
  (cond
    ((string= what "open-with")
      ;; 'param' will be the program to open-with
      (start-process "*mu4e-open-with-proc*" "*mu4e-open-with*" param path))
    ((string= what "pipe")
      ;; 'param' will be the pipe command, path the infile for this
      (mu4e-process-file-through-pipe path param))
    ;; if it's mu4e, it's some embedded message; 'param' may contain the docid
    ;; of the parent message.
    ((string= what "mu4e")
      ;; remember the mapping path->docid, which maps the path of the embedded
      ;; message to the docid of its parent
      (puthash path docid mu4e~path-parent-docid-map)
      (mu4e~proc-view-path path mu4e-view-show-images mu4e-decryption-policy))
    ((string= what "emacs")
      (find-file path)
      ;; make the buffer read-only since it usually does not make
      ;; sense to edit the temp buffer; use C-x C-q if you insist...
      (setq buffer-read-only t))
    ((string= what "diary")
     (icalendar-import-file path diary-file))
    (t (mu4e-error "Unsupported action %S" what))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun mu4e-view-mark-custom ()
  "Run some custom mark function."
  (mu4e~view-in-headers-context
    (mu4e-headers-mark-custom)))

(defun mu4e~view-split-view-p ()
  "Return t if we're in split-view, nil otherwise."
  (member mu4e-split-view '(horizontal vertical)))

(defun mu4e-view-scroll-up-or-next ()
  "Scroll-up the current message.
If `mu4e-view-scroll-to-next' is non-nil, and we can't scroll-up
anymore, go the next message."
  (interactive)
  (condition-case nil
    (scroll-up)
    (error
      (when mu4e-view-scroll-to-next
	(mu4e-view-headers-next)))))

(defun mu4e-scroll-up ()
  "Scroll text of selected window up one line."
  (interactive)
  (scroll-up 1))

(defun mu4e-scroll-down ()
  "Scroll text of selected window down one line."
  (interactive)
  (scroll-down 1))

(defun mu4e-view-unmark-all ()
  "If we're in split-view, unmark all messages.
Otherwise, warn user that unmarking only works in the header
list."
  (interactive)
  (if (mu4e~view-split-view-p)
    (mu4e~view-in-headers-context (mu4e-mark-unmark-all))
    (mu4e-message "Unmarking needs to be done in the header list view")))

(defun mu4e-view-unmark ()
  "If we're in split-view, unmark message at point.
Otherwise, warn user that unmarking only works in the header
list."
  (interactive)
  (if (mu4e~view-split-view-p)
    (mu4e-view-mark-for-unmark)
    (mu4e-message "Unmarking needs to be done in the header list view")))


(defmacro mu4e~view-defun-mark-for (mark)
  "Define a function mu4e-view-mark-for-MARK."
  (let ((funcname (intern (format "mu4e-view-mark-for-%s" mark)))
	(docstring (format "Mark the current message for %s." mark)))
    `(progn
       (defun ,funcname () ,docstring
	 (interactive)
	 (mu4e~view-in-headers-context
	  (mu4e-headers-mark-and-next ',mark)))
       (put ',funcname 'definition-name ',mark))))

(mu4e~view-defun-mark-for move)
(mu4e~view-defun-mark-for trash)
(mu4e~view-defun-mark-for refile)
(mu4e~view-defun-mark-for delete)
(mu4e~view-defun-mark-for flag)
(mu4e~view-defun-mark-for unflag)
(mu4e~view-defun-mark-for unmark)
(mu4e~view-defun-mark-for something)
(mu4e~view-defun-mark-for read)
(mu4e~view-defun-mark-for unread)

(defun mu4e-view-marked-execute ()
  "Execute the marks."
  (interactive)
  (mu4e~view-in-headers-context
    (mu4e-mark-execute-all)))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; URL handling
(defun mu4e~view-get-urls-num (prompt &optional multi)
  "Ask the user with PROMPT for an URL number for MSG, and ensure
it is valid. The number is [1..n] for URLs \[0..(n-1)] in the
message. If MULTI is nil, return the number for the URL;
otherwise (MULTI is non-nil), accept ranges of URL numbers, as
per `mu4e-split-ranges-to-numbers', and return the corresponding
string."
  (let* ((count (hash-table-count mu4e~view-link-map)) (def))
    (when (zerop count) (mu4e-error "No links for this message"))
    (if (not multi)
      (if (= count 1)
	(read-number (mu4e-format "%s: " prompt) 1)
	(read-number (mu4e-format "%s (1-%d): " prompt count)))
      (progn
	(setq def (if (= count 1) "1" (format "1-%d" count)))
	(read-string (mu4e-format "%s (default %s): " prompt def)
	  nil nil def)))))

(defun mu4e-view-go-to-url (&optional multi)
  "Offer to go to url(s). If MULTI (prefix-argument) is nil, go to
a single one, otherwise, offer to go to a range of urls."
  (interactive "P")
  (mu4e~view-handle-urls "URL to visit"
    multi (lambda (url) (mu4e~view-browse-url-from-binding url))))

(defun mu4e-view-save-url (&optional multi)
  "Offer to save urls(s) to the kill-ring. If
MULTI (prefix-argument) is nil, save a single one, otherwise, offer
to save a range of URLs."
  (interactive "P")
  (mu4e~view-handle-urls "URL to save" multi
    (lambda (url)
      (kill-new url)
      (mu4e-message "Saved %s to the kill-ring" url))))

(defun mu4e-view-fetch-url (&optional multi)
  "Offer to fetch (download) urls(s). If MULTI (prefix-argument) is nil,
download a single one, otherwise, offer to fetch a range of
URLs. The urls are fetched to `mu4e-attachment-dir'."
  (interactive "P")
  (mu4e~view-handle-urls "URL to fetch" multi
    (lambda (url)
      (let ((target (concat (mu4e~get-attachment-dir url) "/"
		      (file-name-nondirectory url))))
	(url-copy-file url target)
      (mu4e-message "Fetched %s -> %s" url target)))))

(defun mu4e~view-handle-urls (prompt multi urlfunc)
  "If MULTI is nil, apply URLFUNC to a single uri, otherwise, apply
it to a range of uris. PROMPT is the query to present to the user."
  (interactive "P")
  (if multi
    (mu4e~view-handle-multi-urls prompt urlfunc)
    (mu4e~view-handle-single-url prompt urlfunc)))

(defun mu4e~view-handle-single-url (prompt urlfunc &optional num)
  "Apply URLFUNC to url NUM in the current message, prompting the
user with PROMPT."
  (interactive)
  (let* ((num (or num (mu4e~view-get-urls-num prompt)))
         (url (gethash num mu4e~view-link-map)))
    (unless url (mu4e-warn "Invalid number for URL"))
    (funcall urlfunc url)))

(defun mu4e~view-handle-multi-urls (prompt urlfunc)
  "Apply URLFUNC to a a range of urls in the current message,
prompting the user with PROMPT.

Default is to aplly it to all URLs, [1..n], where n is the number
of urls. You can type multiple values separated by space, e.g.  1
3-6 8 will visit urls 1,3,4,5,6 and 8.

Furthermore, there is a shortcut \"a\" which means all urls, but as
this is the default, you may not need it."
  (interactive)
  (let* ((linkstr (mu4e~view-get-urls-num
		      "URL number range (or 'a' for 'all')" t))
	  (count (hash-table-count mu4e~view-link-map))
	  (linknums (mu4e-split-ranges-to-numbers linkstr count)))
    (dolist (num linknums)
      (mu4e~view-handle-single-url prompt urlfunc num))))

(defun mu4e-view-for-each-uri (func)
  "Execute FUNC (which receives a uri) for each uri in the current
  message."
  (maphash (lambda (num uri) (funcall func uri)) mu4e~view-link-map))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defconst mu4e~view-raw-buffer-name " *mu4e-raw-view*"
  "*internal* Name for the raw message view buffer")

(defun mu4e-view-raw-message ()
  "Display the raw contents of message at point in a new buffer."
  (interactive)
  (let ((path (mu4e-message-field-at-point :path))
	 (buf (get-buffer-create mu4e~view-raw-buffer-name)))
    (unless (and path (file-readable-p path))
      (mu4e-error "Not a readable file: %S" path))
    (with-current-buffer buf
      (let ((inhibit-read-only t))
	(erase-buffer)
	(insert-file-contents path)
	(view-mode)
	(goto-char (point-min))))
    (switch-to-buffer buf)))

(defun mu4e-view-pipe (cmd)
  "Pipe the message at point through shell command CMD, and display
the results."
  (interactive "sShell command: ")
  (let ((path (mu4e-message-field (mu4e-message-at-point) :path)))
    (mu4e-process-file-through-pipe path cmd)))

(defconst mu4e~verify-buffer-name " *mu4e-verify*")

(defun mu4e-view-verify-msg-popup (&optional msg)
  "Pop-up a little signature verification window for (optional) MSG
or message-at-point."
  (interactive)
  (let* ((msg (or msg (mu4e-message-at-point)))
	  (path (mu4e-message-field msg :path))
	  (cmd (format "%s verify --verbose %s %s"
		 mu4e-mu-binary
		 (shell-quote-argument path)
		 (if mu4e-decryption-policy
		     "--decrypt --use-agent"
		     "")))
	  (output (shell-command-to-string cmd))
	    ;; create a new one
	  (buf (get-buffer-create mu4e~verify-buffer-name))
	  (win (or (get-buffer-window buf)
		 (split-window-vertically (- (window-height) 6)))))
    (with-selected-window win
      (let ((inhibit-read-only t))
	;; (set-window-dedicated-p win t)
	(switch-to-buffer buf)
	(erase-buffer)
	(insert output)
	(goto-char (point-min))
	(local-set-key "q" 'kill-buffer-and-window))
      (setq buffer-read-only t))
    (select-window win)))


(defun mu4e~view-quit-buffer ()
  "Quit the mu4e-view buffer.
This is a rather complex function, to ensure we don't disturb
other windows."
  (interactive)
  (unless (eq major-mode 'mu4e-view-mode)
    (mu4e-error "Must be in mu4e-view-mode (%S)" major-mode))
  (let ((curbuf (current-buffer)) (curwin (selected-window))
	 (headers-win))
    (walk-windows
      (lambda (win)
	;; check whether the headers buffer window is visible
	(when (eq mu4e~view-headers-buffer (window-buffer win))
	  (setq headers-win win))
	;; and kill any _other_ (non-selected) window that shows the current
	;; buffer
	(when
	  (and
	    (eq curbuf (window-buffer win)) ;; does win show curbuf?
	    (not (eq curwin win))	    ;; but it's not the curwin?
	    (not (one-window-p))) ;; and not the last one on the frame?
	  (delete-window win))))  ;; delete it!
    ;; now, all *other* windows should be gone.
    ;; if the headers view is also visible, kill ourselves + window; otherwise
    ;; switch to the headers view
    (if (window-live-p headers-win)
      ;; headers are visible
      (progn
	(kill-buffer-and-window) ;; kill the view win
        (setq mu4e~headers-view-win nil)
	(select-window headers-win)) ;; and switch to the headers win...
      ;; headers are not visible...
      (progn
	(kill-buffer)
        (setq mu4e~headers-view-win nil)
	(when (buffer-live-p mu4e~view-headers-buffer)
	  (switch-to-buffer mu4e~view-headers-buffer))))))

(provide 'mu4e-view)
;; end of mu4e-view