(define-key map "w" 'notmuch-show-save-attachments)
(define-key map "V" 'notmuch-show-view-raw-message)
(define-key map "v" 'notmuch-show-view-all-mime-parts)
+ (define-key map "b" 'notmuch-show-toggle-current-body)
+ (define-key map "h" 'notmuch-show-toggle-current-header)
(define-key map "-" 'notmuch-show-remove-tag)
(define-key map "+" 'notmuch-show-add-tag)
(define-key map "X" 'notmuch-show-mark-read-then-archive-then-exit)
move past the indentation when testing this pattern, (so that the
pattern can still test against the entire line).")
+(defvar notmuch-show-signature-button-format
+ "[ %d-line signature. Click/Enter to toggle visibility. ]"
+ "String used to construct button text for hidden signatures
+
+Can use up to one integer format parameter, i.e. %d")
+
+(defvar notmuch-show-citation-button-format
+ "[ %d more citation lines. Click/Enter to toggle visibility. ]"
+ "String used to construct button text for hidden citations.
+
+Can use up to one integer format parameter, i.e. %d")
+
(defvar notmuch-show-signature-lines-max 12
"Maximum length of signature that will be hidden by default.")
+(defvar notmuch-show-citation-lines-prefix 4
+ "Always show at least this many lines of a citation.
+
+If there is one more line, show that, otherwise collapse
+remaining lines into a button.")
+
(defvar notmuch-command "notmuch"
"Command to run the notmuch binary.")
(defvar notmuch-show-marker-regexp "\f\\(message\\|header\\|body\\|attachment\\|part\\)[{}].*$")
(defvar notmuch-show-id-regexp "\\(id:[^ ]*\\)")
-(defvar notmuch-show-depth-regexp " depth:\\([0-9]*\\) ")
+(defvar notmuch-show-depth-match-regexp " depth:\\([0-9]*\\).*match:\\([01]\\) ")
(defvar notmuch-show-filename-regexp "filename:\\(.*\\)$")
+(defvar notmuch-show-contentype-regexp "Content-type: \\(.*\\)")
+
(defvar notmuch-show-tags-regexp "(\\([^)]*\\))$")
(defvar notmuch-show-parent-buffer nil)
(with-current-buffer buf
(insert-file-contents filename nil nil nil t)
,@body)
- (kill-buffer buf)))))
+ (kill-buffer buf)))))
(defun notmuch-show-view-all-mime-parts ()
"Use external viewers to view all attachments from the current message."
(interactive)
(with-current-notmuch-show-message
- (mm-display-parts (mm-dissect-buffer))))
+ ; We ovverride the mm-inline-media-tests to indicate which message
+ ; parts are already sufficiently handled by the original
+ ; presentation of the message in notmuch-show mode. These parts
+ ; will be inserted directly into the temporary buffer of
+ ; with-current-notmuch-show-message and silently discarded.
+ ;
+ ; Any MIME part not explicitly mentioned here will be handled by an
+ ; external viewer as configured in the various mailcap files.
+ (let ((mm-inline-media-tests '(
+ ("text/.*" ignore identity)
+ ("application/pgp-signature" ignore identity)
+ ("multipart/alternative" ignore identity)
+ ("multipart/mixed" ignore identity)
+ ("multipart/related" ignore identity)
+ )))
+ (mm-display-parts (mm-dissect-buffer)))))
(defun notmuch-foreach-mime-part (function mm-handle)
(cond ((stringp (car mm-handle))
(lambda (p)
(let ((disposition (mm-handle-disposition p)))
(and (listp disposition)
- (equal (car disposition) "attachment")
+ (or (equal (car disposition) "attachment")
+ (and (equal (car disposition) "inline")
+ (assq 'filename disposition)))
(incf count))))
mm-handle)
count))
(lambda (p)
(let ((disposition (mm-handle-disposition p)))
(and (listp disposition)
- (equal (car disposition) "attachment")
+ (or (equal (car disposition) "attachment")
+ (and (equal (car disposition) "inline")
+ (assq 'filename disposition)))
(or (not queryp)
(y-or-n-p
(concat "Save '" (cdr (assq 'filename disposition)) "' ")))
when a command ends with point on an invisible character).
Emits an error if point is not within a valid message, (that is
-not pattern of `notmuch-show-message-begin-regexp' could be found
+no pattern of `notmuch-show-message-begin-regexp' could be found
by searching backward)."
(beginning-of-line)
(if (not (looking-at notmuch-show-message-begin-regexp))
(not (re-search-forward notmuch-show-message-begin-regexp nil t)))))
(defun notmuch-show-message-unread-p ()
- "Preficate testing whether current message is unread."
+ "Predicate testing whether current message is unread."
(member "unread" (notmuch-show-get-tags)))
+(defun notmuch-show-message-open-p ()
+ "Predicate testing whether current message is open (body is visible)."
+ (let ((btn (previous-button (point) t)))
+ (while (not (button-has-type-p btn 'notmuch-button-body-toggle-type))
+ (setq btn (previous-button (button-start btn))))
+ (not (invisible-p (button-get btn 'invisibility-spec)))))
+
(defun notmuch-show-next-message ()
"Advance to the beginning of the next message in the buffer.
Moves to the last visible character of the current message if
-already on the last message in the buffer."
+already on the last message in the buffer.
+
+Returns nil if already on the last message in the buffer."
(interactive)
(notmuch-show-move-to-current-message-summary-line)
(if (re-search-forward notmuch-show-message-begin-regexp nil t)
- (notmuch-show-move-to-current-message-summary-line)
+ (progn
+ (notmuch-show-move-to-current-message-summary-line)
+ (recenter 0)
+ t)
(goto-char (- (point-max) 1))
(while (point-invisible-p)
- (backward-char)))
- (recenter 0))
+ (backward-char))
+ (recenter 0)
+ nil))
(defun notmuch-show-find-next-message ()
"Returns the position of the next message in the buffer.
(notmuch-show-next-message)))
(defun notmuch-show-next-open-message ()
- "Advance to the next message which is not hidden.
-
-If read messages are currently hidden, advance to the next unread
-message. Otherwise, advance to the next message."
- (if (or (memq 'notmuch-show-body-read buffer-invisibility-spec)
- (assq 'notmuch-show-body-read buffer-invisibility-spec))
- (notmuch-show-next-unread-message)
- (notmuch-show-next-message)))
+ "Advance to the next open message (that is, body is not invisible)."
+ (while (and (notmuch-show-next-message)
+ (not (notmuch-show-message-open-p)))))
(defun notmuch-show-previous-message ()
"Backup to the beginning of the previous message in the buffer.
(defun notmuch-show-next-button ()
"Advance point to the next button in the buffer."
(interactive)
- (goto-char (button-start (next-button (point)))))
+ (forward-button 1))
(defun notmuch-show-previous-button ()
"Move point back to the previous button in the buffer."
(interactive)
- (goto-char (button-start (previous-button (point)))))
+ (backward-button 1))
(defun notmuch-toggle-invisible-action (cite-button)
(let ((invis-spec (button-get cite-button 'invisibility-spec)))
(force-window-update)
(redisplay t))
-(define-button-type 'notmuch-button-invisibility-toggle-type 'action 'notmuch-toggle-invisible-action 'follow-link t)
+(defun notmuch-show-toggle-current-body ()
+ "Toggle the display of the current message body."
+ (interactive)
+ (save-excursion
+ (notmuch-show-move-to-current-message-summary-line)
+ (unless (button-at (point))
+ (notmuch-show-next-button))
+ (push-button))
+ )
+
+(defun notmuch-show-toggle-current-header ()
+ "Toggle the display of the current message header."
+ (interactive)
+ (save-excursion
+ (notmuch-show-move-to-current-message-summary-line)
+ (forward-line)
+ (unless (button-at (point))
+ (notmuch-show-next-button))
+ (push-button))
+ )
+
+(define-button-type 'notmuch-button-invisibility-toggle-type
+ 'action 'notmuch-toggle-invisible-action
+ 'follow-link t
+ 'face 'font-lock-comment-face)
(define-button-type 'notmuch-button-citation-toggle-type 'help-echo "mouse-1, RET: Show citation"
:supertype 'notmuch-button-invisibility-toggle-type)
(define-button-type 'notmuch-button-signature-toggle-type 'help-echo "mouse-1, RET: Show signature"
:supertype 'notmuch-button-invisibility-toggle-type)
(define-button-type 'notmuch-button-headers-toggle-type 'help-echo "mouse-1, RET: Show headers"
:supertype 'notmuch-button-invisibility-toggle-type)
-(define-button-type 'notmuch-button-body-toggle-type 'help-echo "mouse-1, RET: Show message"
+(define-button-type 'notmuch-button-body-toggle-type
+ 'help-echo "mouse-1, RET: Show message"
+ 'face 'notmuch-message-summary-face
:supertype 'notmuch-button-invisibility-toggle-type)
+(defun notmuch-show-citation-regexp (depth)
+ "Build a regexp for matching citations at a given DEPTH (indent)"
+ (let ((line-regexp (format "[[:space:]]\\{%d\\}>.*\n" depth)))
+ (concat "\\(?:^" line-regexp
+ "\\(?:[[:space:]]*\n" line-regexp
+ "\\)?\\)+")))
+
+(defun notmuch-show-region-to-button (beg end type prefix button-text)
+ "Auxilary function to do the actual making of overlays and buttons
+
+BEG and END are buffer locations. TYPE should a string, either
+\"citation\" or \"signature\". PREFIX is some arbitrary text to
+insert before the button, probably for indentation. BUTTON-TEXT
+is what to put on the button."
+
+;; This uses some slightly tricky conversions between strings and
+;; symbols because of the way the button code works. Note that
+;; replacing intern-soft with make-symbol will cause this to fail,
+;; since the newly created symbol has no plist.
+
+ (let ((overlay (make-overlay beg end))
+ (invis-spec (make-symbol (concat "notmuch-" type "-region")))
+ (button-type (intern-soft (concat "notmuch-button-"
+ type "-toggle-type"))))
+ (add-to-invisibility-spec invis-spec)
+ (overlay-put overlay 'invisible invis-spec)
+ (goto-char (1+ end))
+ (save-excursion
+ (goto-char (1- beg))
+ (insert prefix)
+ (insert-button button-text
+ 'invisibility-spec invis-spec
+ :type button-type)
+ )))
+
+
(defun notmuch-show-markup-citations-region (beg end depth)
- (goto-char beg)
- (beginning-of-line)
- (while (< (point) end)
- (let ((beg-sub (point-marker))
- (indent (make-string depth ? ))
- (citation "[[:space:]]*>"))
- (if (looking-at citation)
- (progn
- (while (looking-at citation)
- (forward-line))
- (let ((overlay (make-overlay beg-sub (point)))
- (invis-spec (make-symbol "notmuch-citation-region")))
- (add-to-invisibility-spec invis-spec)
- (overlay-put overlay 'invisible invis-spec)
- (let ((p (point))
- (cite-button-text
- (concat "[" (number-to-string (count-lines beg-sub (point)))
- "-line citation.]")))
- (goto-char (- beg-sub 1))
- (insert (concat "\n" indent))
- (insert-button cite-button-text
- 'invisibility-spec invis-spec
- :type 'notmuch-button-citation-toggle-type)
- (insert "\n")
- (goto-char (+ (length cite-button-text) p))
- ))))
- (move-to-column depth)
- (if (looking-at notmuch-show-signature-regexp)
- (let ((sig-lines (- (count-lines beg-sub end) 1)))
- (if (<= sig-lines notmuch-show-signature-lines-max)
- (progn
- (let ((invis-spec (make-symbol "notmuch-signature-region")))
- (add-to-invisibility-spec invis-spec)
- (overlay-put (make-overlay beg-sub end)
- 'invisible invis-spec)
-
- (goto-char (- beg-sub 1))
- (insert (concat "\n" indent))
- (let ((sig-button-text (concat "[" (number-to-string sig-lines)
- "-line signature.]")))
- (insert-button sig-button-text 'invisibility-spec invis-spec
- :type 'notmuch-button-signature-toggle-type)
- )
- (insert "\n")
- (goto-char end))))))
- (forward-line))))
-
-(defun notmuch-show-markup-part (beg end depth mime-message)
+ "Markup citations, and up to one signature in the given region"
+ ;; it would be nice if the untabify was not required, but
+ ;; that would require notmuch to indent with spaces.
+ (untabify beg end)
+ (let ((citation-regexp (notmuch-show-citation-regexp depth))
+ (signature-regexp (concat (format "^[[:space:]]\\{%d\\}" depth)
+ notmuch-show-signature-regexp))
+ (indent (concat "\n" (make-string depth ? ))))
+ (goto-char beg)
+ (beginning-of-line)
+ (while (and (< (point) end)
+ (re-search-forward citation-regexp end t))
+ (let* ((cite-start (match-beginning 0))
+ (cite-end (match-end 0))
+ (cite-lines (count-lines cite-start cite-end)))
+ (when (> cite-lines (1+ notmuch-show-citation-lines-prefix))
+ (goto-char cite-start)
+ (forward-line notmuch-show-citation-lines-prefix)
+ (notmuch-show-region-to-button
+ (point) cite-end
+ "citation"
+ indent
+ (format notmuch-show-citation-button-format
+ (- cite-lines notmuch-show-citation-lines-prefix))
+ ))))
+ (if (and (< (point) end)
+ (re-search-forward signature-regexp end t))
+ (let* ((sig-start (match-beginning 0))
+ (sig-end (match-end 0))
+ (sig-lines (1- (count-lines sig-start end))))
+ (if (<= sig-lines notmuch-show-signature-lines-max)
+ (notmuch-show-region-to-button
+ sig-start
+ end
+ "signature"
+ indent
+ (format notmuch-show-signature-button-format sig-lines)
+ ))))))
+
+(defun notmuch-show-markup-part (beg end depth)
(if (re-search-forward notmuch-show-part-begin-regexp nil t)
(progn
- (if (eq mime-message nil)
- (let ((filename (notmuch-show-get-filename)))
- (with-temp-buffer
- (insert-file-contents filename nil nil nil t)
- (setq mime-message (mm-dissect-buffer)))))
- (forward-line)
- (let ((part-beg (point-marker)))
- (re-search-forward notmuch-show-part-end-regexp)
-
- (let ((part-end (copy-marker (match-beginning 0))))
- (goto-char part-end)
- (if (not (bolp))
- (insert "\n"))
- (indent-rigidly part-beg part-end depth)
- (save-excursion
- (goto-char part-beg)
- (forward-line -1)
- (beginning-of-line)
- (let ((handle-type (mm-handle-type mime-message))
- mime-type)
- (if (sequencep (car handle-type))
- (setq mime-type (car handle-type))
- (setq mime-type (car (car (cdr handle-type))))
- )
- (if (equal mime-type "text/html")
- (mm-display-part mime-message))))
-
- (notmuch-show-markup-citations-region part-beg part-end depth)
- ; Advance to the next part (if any) (so the outer loop can
- ; determine whether we've left the current message.
- (if (re-search-forward notmuch-show-part-begin-regexp nil t)
- (beginning-of-line)))))
- (goto-char end))
- mime-message)
+ (let (mime-message mime-type)
+ (save-excursion
+ (re-search-forward notmuch-show-contentype-regexp end t)
+ (setq mime-type (car (split-string (buffer-substring
+ (match-beginning 1) (match-end 1))))))
+
+ (if (equal mime-type "text/html")
+ (let ((filename (notmuch-show-get-filename)))
+ (with-temp-buffer
+ (insert-file-contents filename nil nil nil t)
+ (setq mime-message (mm-dissect-buffer)))))
+ (forward-line)
+ (let ((beg (point-marker)))
+ (re-search-forward notmuch-show-part-end-regexp)
+ (let ((end (copy-marker (match-beginning 0))))
+ (goto-char end)
+ (if (not (bolp))
+ (insert "\n"))
+ (indent-rigidly beg end depth)
+ (if (not (eq mime-message nil))
+ (save-excursion
+ (goto-char beg)
+ (forward-line -1)
+ (let ((handle-type (mm-handle-type mime-message))
+ mime-type)
+ (if (sequencep (car handle-type))
+ (setq mime-type (car handle-type))
+ (setq mime-type (car (car (cdr handle-type))))
+ )
+ (if (equal mime-type "text/html")
+ (mm-display-part mime-message))))
+ )
+ (notmuch-show-markup-citations-region beg end depth)
+ ; Advance to the next part (if any) (so the outer loop can
+ ; determine whether we've left the current message.
+ (if (re-search-forward notmuch-show-part-begin-regexp nil t)
+ (beginning-of-line)))))
+ (goto-char end))
+ (goto-char end)))
(defun notmuch-show-markup-parts-region (beg end depth)
(save-excursion
(goto-char beg)
- (let (mime-message)
- (while (< (point) end)
- (setq mime-message
- (notmuch-show-markup-part
- beg end depth mime-message))))))
-
-(defun notmuch-show-markup-body (depth btn)
+ (while (< (point) end)
+ (notmuch-show-markup-part beg end depth))))
+
+(defun notmuch-show-markup-body (depth match btn)
+ "Markup a message body, (indenting, buttonizing citations,
+etc.), and conditionally hiding the body itself if the message
+has been read and does not match the current search.
+
+DEPTH specifies the depth at which this message appears in the
+tree of the current thread, (the top-level messages have depth 0
+and each reply increases depth by 1). MATCH indicates whether
+this message is regarded as matching the current search. BTN is
+the button which is used to toggle the visibility of this
+message.
+
+When this function is called, point must be within the message, but
+before the delimiter marking the beginning of the body."
(re-search-forward notmuch-show-body-begin-regexp)
(forward-line)
(let ((beg (point-marker)))
(overlay-put (make-overlay beg end)
'invisible invis-spec)
(button-put btn 'invisibility-spec invis-spec)
- (if (not (notmuch-show-message-unread-p))
+ (if (not (or (notmuch-show-message-unread-p) match))
(add-to-invisibility-spec invis-spec)))
(set-marker beg nil)
(set-marker end nil)
)))
+
(defun notmuch-fontify-headers ()
- (progn
- (if (looking-at "[Tt]o:")
- (progn
- (overlay-put (make-overlay (point) (re-search-forward ":"))
- 'face 'message-header-name)
- (overlay-put (make-overlay (point) (re-search-forward ".*$"))
- 'face 'message-header-to))
+ (while (looking-at "[[:space:]]")
+ (forward-char))
+ (if (looking-at "[Tt]o:")
+ (progn
+ (overlay-put (make-overlay (point) (re-search-forward ":"))
+ 'face 'message-header-name)
+ (overlay-put (make-overlay (point) (re-search-forward ".*$"))
+ 'face 'message-header-to))
(if (looking-at "[B]?[Cc][Cc]:")
(progn
(overlay-put (make-overlay (point) (re-search-forward ":"))
- 'face 'message-header-name)
- (overlay-put (make-overlay (point) (re-search-forward ".*$"))
- 'face 'message-header-cc))
- (if (looking-at "[Ss]ubject:")
- (progn
- (overlay-put (make-overlay (point) (re-search-forward ":"))
- 'face 'message-header-name)
- (overlay-put (make-overlay (point) (re-search-forward ".*$"))
- 'face 'message-header-subject))
- (if (looking-at "[Ff]rom:")
- (progn
- (overlay-put (make-overlay (point) (re-search-forward ":"))
- 'face 'message-header-name)
- (overlay-put (make-overlay (point) (re-search-forward ".*$"))
- 'face 'message-header-other))))))))
-
-(defun notmuch-show-markup-header (depth)
+ 'face 'message-header-name)
+ (overlay-put (make-overlay (point) (re-search-forward ".*$"))
+ 'face 'message-header-cc))
+ (if (looking-at "[Ss]ubject:")
+ (progn
+ (overlay-put (make-overlay (point) (re-search-forward ":"))
+ 'face 'message-header-name)
+ (overlay-put (make-overlay (point) (re-search-forward ".*$"))
+ 'face 'message-header-subject))
+ (if (looking-at "[Ff]rom:")
+ (progn
+ (overlay-put (make-overlay (point) (re-search-forward ":"))
+ 'face 'message-header-name)
+ (overlay-put (make-overlay (point) (re-search-forward ".*$"))
+ 'face 'message-header-other)))))))
+
+(defun notmuch-show-markup-header (message-begin depth)
+ "Buttonize and decorate faces in a message header.
+
+MESSAGE-BEGIN is the position of the absolute first character in
+the message (including all delimiters that will end up being
+invisible etc.). This is to allow a button to reliably extend to
+the beginning of the message even if point is positioned at an
+invisible character (such as the beginning of the buffer).
+
+DEPTH specifies the depth at which this message appears in the
+tree of the current thread, (the top-level messages have depth 0
+and each reply increases depth by 1)."
(re-search-forward notmuch-show-header-begin-regexp)
(forward-line)
(let ((beg (point-marker))
+ (summary-end (copy-marker (line-beginning-position 2)))
+ (subject-end (copy-marker (line-end-position 2)))
+ (invis-spec (make-symbol "notmuch-show-header"))
(btn nil))
- (end-of-line)
- ; Inverse video for subject
- (overlay-put (make-overlay beg (point)) 'face '(:inverse-video t))
- (setq btn (make-button beg (point) :type 'notmuch-button-body-toggle-type))
- (forward-line 1)
- (end-of-line)
- (let ((beg-hidden (point-marker)))
- (re-search-forward notmuch-show-header-end-regexp)
- (beginning-of-line)
- (let ((end (point-marker)))
- (goto-char beg)
- (forward-line)
- (while (looking-at "[A-Za-z][-A-Za-z0-9]*:")
- (beginning-of-line)
- (notmuch-fontify-headers)
- (forward-line)
- )
- (indent-rigidly beg end depth)
- (let ((invis-spec (make-symbol "notmuch-show-header")))
- (add-to-invisibility-spec (cons invis-spec t))
- (overlay-put (make-overlay beg-hidden end)
- 'invisible invis-spec)
- (goto-char beg)
- (forward-line)
- (make-button (line-beginning-position) (line-end-position)
- 'invisibility-spec (cons invis-spec t)
- :type 'notmuch-button-headers-toggle-type))
- (goto-char end)
- (insert "\n")
- (set-marker beg nil)
- (set-marker beg-hidden nil)
- (set-marker end nil)
- ))
- btn))
+ (re-search-forward notmuch-show-header-end-regexp)
+ (beginning-of-line)
+ (let ((end (point-marker)))
+ (indent-rigidly beg end depth)
+ (goto-char beg)
+ (setq btn (make-button message-begin summary-end :type 'notmuch-button-body-toggle-type))
+ (forward-line)
+ (add-to-invisibility-spec invis-spec)
+ (overlay-put (make-overlay subject-end end)
+ 'invisible invis-spec)
+ (make-button (line-beginning-position) subject-end
+ 'invisibility-spec invis-spec
+ :type 'notmuch-button-headers-toggle-type)
+ (while (looking-at "[[:space:]]*[A-Za-z][-A-Za-z0-9]*:")
+ (beginning-of-line)
+ (notmuch-fontify-headers)
+ (forward-line)
+ )
+ (goto-char end)
+ (insert "\n")
+ (set-marker beg nil)
+ (set-marker summary-end nil)
+ (set-marker subject-end nil)
+ (set-marker end nil)
+ )
+ btn))
(defun notmuch-show-markup-message ()
(if (re-search-forward notmuch-show-message-begin-regexp nil t)
- (progn
- (re-search-forward notmuch-show-depth-regexp)
+ (let ((message-begin (match-beginning 0)))
+ (re-search-forward notmuch-show-depth-match-regexp)
(let ((depth (string-to-number (buffer-substring (match-beginning 1) (match-end 1))))
+ (match (string= "1" (buffer-substring (match-beginning 2) (match-end 2))))
(btn nil))
- (setq btn (notmuch-show-markup-header depth))
- (notmuch-show-markup-body depth btn)))
+ (setq btn (notmuch-show-markup-header message-begin depth))
+ (notmuch-show-markup-body depth match btn)))
(goto-char (point-max))))
(defun notmuch-show-hide-markers ()
(lambda()
(hl-line-mode 1) ))
-(defun notmuch-show (thread-id &optional parent-buffer)
+(defun notmuch-show (thread-id &optional parent-buffer query-context)
"Run \"notmuch show\" with the given thread ID and display results.
The optional PARENT-BUFFER is the notmuch-search buffer from
which this notmuch-show command was executed, (so that the next
-thread from that buffer can be show when done with this one)."
+thread from that buffer can be show when done with this one).
+
+The optional QUERY-CONTEXT is a notmuch search term. Only messages from the thread
+matching this search term are shown if non-nil. "
(interactive "sNotmuch show: ")
(let ((buffer (get-buffer-create (concat "*notmuch-show-" thread-id "*"))))
(switch-to-buffer buffer)
(erase-buffer)
(goto-char (point-min))
(save-excursion
- (call-process notmuch-command nil t nil "show" thread-id)
+ (let* ((basic-args (list notmuch-command nil t nil "show" "--entire-thread" thread-id))
+ (args (if query-context (append basic-args (list "and (" query-context ")")) basic-args)))
+ (apply 'call-process args)
+ (when (and (eq (buffer-size) 0) query-context)
+ (apply 'call-process basic-args)))
(notmuch-show-markup-messages)
)
(run-hooks 'notmuch-show-hook)
- ; Move straight to the first unread message
- (if (not (notmuch-show-message-unread-p))
- (progn
- (notmuch-show-next-unread-message)
- ; But if there are no unread messages, go back to the
- ; beginning of the buffer, and open up the bodies of all
- ; read message.
- (if (not (notmuch-show-message-unread-p))
- (progn
- (goto-char (point-min))
- (let ((btn (forward-button 1)))
- (while btn
- (if (button-has-type-p btn 'notmuch-button-body-toggle-type)
- (push-button))
- (condition-case err
- (setq btn (forward-button 1))
- (error (setq btn nil)))
- ))
- (goto-char (point-min))
- ))))
+ ; Move straight to the first open message
+ (if (not (notmuch-show-message-open-p))
+ (notmuch-show-next-open-message))
)))
(defvar notmuch-search-authors-width 40
(defvar notmuch-search-oldest-first t
"Show the oldest mail first in the search-mode")
+(defvar notmuch-search-disjunctive-regexp "\\<[oO][rR]\\>")
+
(defun notmuch-search-scroll-up ()
"Move forward through search results by one window's worth."
(interactive)
(interactive)
(goto-char (point-min)))
+(defface notmuch-message-summary-face
+ '((((class color) (background light)) (:background "#f0f0f0"))
+ (((class color) (background dark)) (:background "#303030")))
+ "Face for the single-line message summary in notmuch-show-mode."
+ :group 'notmuch)
+
(defface notmuch-tag-face
'((((class color)
(background dark))
"Return the thread for the current thread"
(get-text-property (point) 'notmuch-search-thread-id))
+(defun notmuch-search-find-authors ()
+ "Return the authors for the current thread"
+ (get-text-property (point) 'notmuch-search-authors))
+
+(defun notmuch-search-find-subject ()
+ "Return the subject for the current thread"
+ (get-text-property (point) 'notmuch-search-subject))
+
(defun notmuch-search-show-thread ()
"Display the currently selected thread."
(interactive)
(let ((thread-id (notmuch-search-find-thread-id)))
(if (> (length thread-id) 0)
- (notmuch-show thread-id (current-buffer))
+ (notmuch-show thread-id (current-buffer) notmuch-search-query-string)
(error "End of search results"))))
(defun notmuch-search-reply-to-thread ()
which match the current search terms."
(interactive
(list (notmuch-select-tag-with-completion "Tag to add: ")))
- (notmuch-call-notmuch-process "tag" (concat "+" tag) (notmuch-search-find-thread-id) " and " notmuch-search-query-string)
+ (notmuch-call-notmuch-process "tag" (concat "+" tag) (notmuch-search-find-thread-id))
(notmuch-search-set-tags (delete-dups (sort (cons tag (notmuch-search-get-tags)) 'string<))))
(defun notmuch-search-remove-tag (tag)
which match the current search terms."
(interactive
(list (notmuch-select-tag-with-completion "Tag to remove: " (notmuch-search-find-thread-id))))
- (notmuch-call-notmuch-process "tag" (concat "-" tag) (notmuch-search-find-thread-id) " and " notmuch-search-query-string)
+ (notmuch-call-notmuch-process "tag" (concat "-" tag) (notmuch-search-find-thread-id))
(notmuch-search-set-tags (delete tag (notmuch-search-get-tags))))
(defun notmuch-search-archive-thread ()
(goto-char (point-max))
(let ((beg (point-marker)))
(insert (format "%s %-7s %-40s %s (%s)\n" date count authors subject tags))
- (put-text-property beg (point-marker) 'notmuch-search-thread-id thread-id))
+ (put-text-property beg (point-marker) 'notmuch-search-thread-id thread-id)
+ (put-text-property beg (point-marker) 'notmuch-search-authors authors)
+ (put-text-property beg (point-marker) 'notmuch-search-subject subject))
(set 'line (match-end 0)))
(set 'more nil))))))
(delete-process proc))))
Runs a new search matching only messages that match both the
current search results AND the additional query string provided."
(interactive "sFilter search: ")
- (notmuch-search (concat notmuch-search-query-string " and " query) notmuch-search-oldest-first))
+ (let ((grouped-query (if (string-match-p notmuch-search-disjunctive-regexp query) (concat "( " query " )") query)))
+ (notmuch-search (concat notmuch-search-query-string " and " grouped-query) notmuch-search-oldest-first)))
(defun notmuch-search-filter-by-tag (tag)
"Filter the current search results based on a single tag.
(define-key map "?" 'notmuch-help)
(define-key map "x" 'kill-this-buffer)
(define-key map "q" 'kill-this-buffer)
+ (define-key map "m" 'message-mail)
+ (define-key map "e" 'notmuch-folder-show-empty-toggle)
(define-key map ">" 'notmuch-folder-last)
(define-key map "<" 'notmuch-folder-first)
(define-key map "=" 'notmuch-folder)
(define-key map "s" 'notmuch-search)
(define-key map [mouse-1] 'notmuch-folder-show-search)
(define-key map (kbd "RET") 'notmuch-folder-show-search)
+ (define-key map " " 'notmuch-folder-show-search)
(define-key map "p" 'notmuch-folder-previous)
(define-key map "n" 'notmuch-folder-next)
map)
(goto-char (point-max))
(forward-line -1))
+(defun notmuch-folder-count (search)
+ (car (process-lines notmuch-command "count" search)))
+
+(setq notmuch-folder-show-empty t)
+
+(defun notmuch-folder-show-empty-toggle ()
+ "Toggle the listing of empty folders"
+ (interactive)
+ (setq notmuch-folder-show-empty (not notmuch-folder-show-empty))
+ (notmuch-folder))
+
(defun notmuch-folder-add (folders)
(if folders
- (let ((name (car (car folders)))
+ (let* ((name (car (car folders)))
(inhibit-read-only t)
- (search (cdr (car folders))))
- (insert name)
- (indent-to 16 1)
- (call-process notmuch-command nil t nil "count" search)
+ (search (cdr (car folders)))
+ (count (notmuch-folder-count search)))
+ (if (or notmuch-folder-show-empty
+ (not (equal count "0")))
+ (progn
+ (insert name)
+ (indent-to 16 1)
+ (insert count)
+ (insert "\n")
+ )
+ )
(notmuch-folder-add (cdr folders)))))
(defun notmuch-folder-find-name ()
(save-excursion
(beginning-of-line)
(let ((beg (point)))
- (forward-word)
- (filter-buffer-substring beg (point)))))
+ (re-search-forward "\\([ \t]*[^ \t]+\\)")
+ (filter-buffer-substring (match-beginning 1) (match-end 1)))))
(defun notmuch-folder-show-search (&optional folder)
"Show a search window for the search related to the specified folder."
projects / notmuch / blobdiff