"A buffer local copy of argument open-target to the function notmuch-pick")
(make-variable-buffer-local 'notmuch-pick-open-target)
-(defvar notmuch-pick-buffer-name nil
- "A buffer local copy of argument buffer-name to the function notmuch-pick")
-(make-variable-buffer-local 'notmuch-pick-buffer-name)
-
(defvar notmuch-pick-message-window nil
"The window of the message pane.
(defvar notmuch-pick-mode-map
(let ((map (make-sparse-keymap)))
+ (set-keymap-parent map notmuch-common-keymap)
+ ;; The following override the global keymap.
+ ;; Override because we want to close message pane first.
+ (define-key map "?" (notmuch-pick-close-message-pane-and #'notmuch-help))
+ ;; Override because we first close message pane and then close pick buffer.
+ (define-key map "q" 'notmuch-pick-quit)
+ ;; Override because we close message pane after the search query is entered.
+ (define-key map "s" 'notmuch-pick-to-search)
+ ;; Override because we want to close message pane first.
+ (define-key map "m" (notmuch-pick-close-message-pane-and #'notmuch-mua-new-mail))
+
(define-key map [mouse-1] 'notmuch-pick-show-message)
;; these use notmuch-show functions directly
(define-key map "|" 'notmuch-show-pipe-message)
(define-key map "e" (notmuch-pick-to-message-pane #'notmuch-pick-button-activate))
;; bindings from show (or elsewhere) but we close the message pane first.
- (define-key map "m" (notmuch-pick-close-message-pane-and #'notmuch-mua-new-mail))
(define-key map "f" (notmuch-pick-close-message-pane-and #'notmuch-show-forward-message))
(define-key map "r" (notmuch-pick-close-message-pane-and #'notmuch-show-reply-sender))
(define-key map "R" (notmuch-pick-close-message-pane-and #'notmuch-show-reply))
(define-key map "V" (notmuch-pick-close-message-pane-and #'notmuch-show-view-raw-message))
- (define-key map "?" (notmuch-pick-close-message-pane-and #'notmuch-help))
;; The main pick bindings
- (define-key map "q" 'notmuch-pick-quit)
(define-key map "x" 'notmuch-pick-quit)
+ (define-key map "A" 'notmuch-pick-archive-thread)
(define-key map "a" 'notmuch-pick-archive-message-then-next)
(define-key map "=" 'notmuch-pick-refresh-view)
- (define-key map "s" 'notmuch-pick-to-search)
(define-key map "z" 'notmuch-pick-to-pick)
(define-key map "n" 'notmuch-pick-next-matching-message)
(define-key map "p" 'notmuch-pick-prev-matching-message)
(define-key map "N" 'notmuch-pick-next-message)
(define-key map "P" 'notmuch-pick-prev-message)
+ (define-key map (kbd "M-p") 'notmuch-pick-prev-thread)
+ (define-key map (kbd "M-n") 'notmuch-pick-next-thread)
(define-key map "-" 'notmuch-pick-remove-tag)
(define-key map "+" 'notmuch-pick-add-tag)
+ (define-key map "*" 'notmuch-pick-tag-thread)
(define-key map " " 'notmuch-pick-scroll-or-next)
(define-key map "b" 'notmuch-pick-scroll-message-window-back)
map))
(let ((inhibit-read-only t)
(basic-query notmuch-pick-basic-query)
(query-context notmuch-pick-query-context)
- (target (notmuch-pick-get-message-id))
- (buffer-name notmuch-pick-buffer-name))
+ (target (notmuch-pick-get-message-id)))
(erase-buffer)
(notmuch-pick-worker basic-query
query-context
- target
- (get-buffer buffer-name))))
+ target)))
(defun notmuch-pick-thread-top ()
(when (notmuch-pick-get-message-properties)
(while (not (or (notmuch-pick-get-prop :first) (eobp)))
(forward-line -1))))
+(defun notmuch-pick-prev-thread ()
+ (interactive)
+ (forward-line -1)
+ (notmuch-pick-thread-top))
+
+(defun notmuch-pick-next-thread ()
+ (interactive)
+ (forward-line 1)
+ (while (not (or (notmuch-pick-get-prop :first) (eobp)))
+ (forward-line 1)))
+
(defun notmuch-pick-thread-mapcar (function)
"Iterate through all messages in the current thread
and call FUNCTION for side effects."
(notmuch-pick-thread-mapcar 'notmuch-pick-get-message-id)
" or "))
+(defun notmuch-pick-tag-thread (&optional tag-changes)
+ "Tag all messages in the current thread"
+ (interactive)
+ (when (notmuch-pick-get-message-properties)
+ (let ((tag-changes (notmuch-tag (notmuch-pick-get-messages-ids-thread-search) tag-changes)))
+ (notmuch-pick-thread-mapcar
+ (lambda () (notmuch-pick-tag-update-display tag-changes))))))
+
+(defun notmuch-pick-archive-thread (&optional unarchive)
+ "Archive each message in thread.
+
+Archive each message currently shown by applying the tag changes
+in `notmuch-archive-tags' to each. If a prefix argument is given,
+the messages will be \"unarchived\", i.e. the tag changes in
+`notmuch-archive-tags' will be reversed.
+
+Note: This command is safe from any race condition of new messages
+being delivered to the same thread. It does not archive the
+entire thread, but only the messages shown in the current
+buffer."
+ (interactive "P")
+ (when notmuch-archive-tags
+ (notmuch-pick-tag-thread
+ (notmuch-tag-change-list notmuch-archive-tags unarchive))))
+
;; Functions below here display the pick buffer itself.
(defun notmuch-pick-clean-address (address)
;; If we have a name return that otherwise return the address.
(or p-name p-address)))
-(defun notmuch-pick-insert-field (field format-string msg)
+(defun notmuch-pick-format-field (field format-string msg)
+ "Format a FIELD of MSG according to FORMAT-STRING and return string"
(let* ((headers (plist-get msg :headers))
- (match (plist-get msg :match)))
+ (match (plist-get msg :match))
+ formatted-field)
(cond
+ ((listp field)
+ (setq formatted-field
+ (format format-string (notmuch-pick-format-field-list field msg))))
+
((string-equal field "date")
(let ((face (if match
'notmuch-pick-match-date-face
'notmuch-pick-no-match-date-face)))
- (insert (propertize (format format-string (plist-get msg :date_relative))
- 'face face))))
+ (setq formatted-field
+ (propertize (format format-string (plist-get msg :date_relative))
+ 'face face))))
((string-equal field "subject")
(let ((tree-status (plist-get msg :tree-status))
(face (if match
'notmuch-pick-match-subject-face
'notmuch-pick-no-match-subject-face)))
- (insert (propertize (format format-string
- (concat
- (mapconcat #'identity (reverse tree-status) "")
- (if (string= notmuch-pick-previous-subject bare-subject)
- " ..."
- bare-subject)))
- 'face face))
+ (setq formatted-field
+ (propertize (format format-string
+ (concat
+ (mapconcat #'identity (reverse tree-status) "")
+ (if (string= notmuch-pick-previous-subject bare-subject)
+ " ..."
+ bare-subject)))
+ 'face face))
(setq notmuch-pick-previous-subject bare-subject)))
((string-equal field "authors")
'notmuch-pick-no-match-author-face)))
(when (> (length author) len)
(setq author (substring author 0 len)))
- (insert (propertize (format format-string author)
- 'face face))))
+ (setq formatted-field
+ (propertize (format format-string author)
+ 'face face))))
((string-equal field "tags")
(let ((tags (plist-get msg :tags))
(face (if match
'notmuch-pick-match-tag-face
'notmuch-pick-no-match-tag-face)))
- (when tags
- (insert (propertize (format format-string
- (mapconcat #'identity tags ", "))
- 'face face))))))))
+ (setq formatted-field
+ (propertize (format format-string
+ (mapconcat #'identity tags ", "))
+ 'face face)))))
+ formatted-field))
+
+(defun notmuch-pick-format-field-list (field-list msg)
+ "Format fields of MSG according to FIELD-LIST and return string"
+ (let (result-string)
+ (dolist (spec field-list result-string)
+ (let ((field-string (notmuch-pick-format-field (car spec) (cdr spec) msg)))
+ (setq result-string (concat result-string field-string))))))
(defun notmuch-pick-insert-msg (msg)
"Insert the message MSG according to notmuch-pick-result-format"
;; We need to save the previous subject as it will get overwritten
;; by the insert-field calls.
(let ((previous-subject notmuch-pick-previous-subject))
- (dolist (spec notmuch-pick-result-format)
- (notmuch-pick-insert-field (car spec) (cdr spec) msg))
+ (insert (notmuch-pick-format-field-list notmuch-pick-result-format msg))
(notmuch-pick-set-message-properties msg)
(notmuch-pick-set-prop :previous-subject previous-subject)
(insert "\n")))
(interactive)
(kill-all-local-variables)
+ (setq notmuch-buffer-refresh-function #'notmuch-pick-refresh-view)
(use-local-map notmuch-pick-mode-map)
(setq major-mode 'notmuch-pick-mode
mode-name "notmuch-pick")
(notmuch-sexp-parse-partial-list 'notmuch-pick-insert-forest-thread
results-buf)))))
-(defun notmuch-pick-worker (basic-query &optional query-context target buffer open-target)
+(defun notmuch-pick-worker (basic-query &optional query-context target open-target)
+ "Insert the actual pick search in the current buffer.
+
+This is is a helper function for notmuch-pick. The arguments are
+the same as for the function notmuch-pick."
(interactive)
(notmuch-pick-mode)
(setq notmuch-pick-basic-query basic-query)
(setq notmuch-pick-query-context query-context)
- (setq notmuch-pick-buffer-name (buffer-name buffer))
(setq notmuch-pick-target-msg target)
(setq notmuch-pick-open-target open-target)
(if (equal (car (process-lines notmuch-command "count" search-args)) "0")
(setq search-args basic-query))
(let ((proc (notmuch-start-notmuch
- "notmuch-pick" buffer #'notmuch-pick-process-sentinel
+ "notmuch-pick" (current-buffer) #'notmuch-pick-process-sentinel
"show" "--body=false" "--format=sexp"
message-arg search-args))
;; Use a scratch buffer to accumulate partial output.
BUFFER-NAME: the name of the buffer to show the pick tree. If
it is nil \"*notmuch-pick\" followed by QUERY is used.
OPEN-TARGET: If TRUE open the target message in the message pane."
- (interactive "sNotmuch pick: ")
+ (interactive)
(if (null query)
(setq query (notmuch-read-query "Notmuch pick: ")))
(let ((buffer (get-buffer-create (generate-new-buffer-name
(concat "*notmuch-pick-" query "*")))))
(inhibit-read-only t))
- (switch-to-buffer buffer)
- ;; Don't track undo information for this buffer
- (set 'buffer-undo-list t)
+ (switch-to-buffer buffer))
+ ;; Don't track undo information for this buffer
+ (set 'buffer-undo-list t)
- (notmuch-pick-worker query query-context target buffer open-target)
+ (notmuch-pick-worker query query-context target open-target)
- (setq truncate-lines t)))
+ (setq truncate-lines t))
;; Set up key bindings from the rest of notmuch.