X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=emacs%2Fnotmuch.el;h=4a9223e4dfa8f1f0e95c76e10219a8f1a1863581;hp=e20718018a05cd0040f048e4c01ba3cc9f874571;hb=7171e77d4d1e83fdf9c7a56987b98bce3f181598;hpb=975307c945575bc660b451d13291956271e92e93 diff --git a/emacs/notmuch.el b/emacs/notmuch.el index e2071801..4a9223e4 100644 --- a/emacs/notmuch.el +++ b/emacs/notmuch.el @@ -47,7 +47,7 @@ ; kudos: Notmuch list (subscription is not ; required, but is available from http://notmuchmail.org). -(require 'cl) +(eval-when-compile (require 'cl)) (require 'mm-view) (require 'message) @@ -55,6 +55,8 @@ (require 'notmuch-show) (require 'notmuch-mua) (require 'notmuch-hello) +(require 'notmuch-maildir-fcc) +(require 'notmuch-message) (defcustom notmuch-search-result-format `(("date" . "%s ") @@ -230,7 +232,7 @@ For a mouse binding, return nil." "Exit the search buffer, calling any defined continuation function." (interactive) (let ((continuation notmuch-search-continuation)) - (kill-this-buffer) + (notmuch-kill-this-buffer) (when continuation (funcall continuation)))) @@ -283,6 +285,38 @@ For a mouse binding, return nil." "Face for the single-line message summary in notmuch-show-mode." :group 'notmuch) +(defface notmuch-search-date + '((t :inherit default)) + "Face used in search mode for dates." + :group 'notmuch) + +(defface notmuch-search-count + '((t :inherit default)) + "Face used in search mode for the count matching the query." + :group 'notmuch) + +(defface notmuch-search-subject + '((t :inherit default)) + "Face used in search mode for subjects." + :group 'notmuch) + +(defface notmuch-search-matching-authors + '((t :inherit default)) + "Face used in search mode for authors matching the query." + :group 'notmuch) + +(defface notmuch-search-non-matching-authors + '((((class color) + (background dark)) + (:foreground "grey30")) + (((class color) + (background light)) + (:foreground "grey60")) + (t + (:italic t))) + "Face used in search mode for authors not matching the query." + :group 'notmuch) + (defface notmuch-tag-face '((((class color) (background dark)) @@ -292,10 +326,9 @@ For a mouse binding, return nil." (:foreground "navy blue" :bold t)) (t (:bold t))) - "Notmuch search mode face used to highligh tags." + "Face used in search mode face for tags." :group 'notmuch) -;;;###autoload (defun notmuch-search-mode () "Major mode displaying results of a notmuch search. @@ -425,7 +458,7 @@ and will also appear in a buffer named \"*Notmuch errors*\"." (let ((end (point))) (delete-region beg end) (insert (propertize (mapconcat 'identity tags " ") - 'font-lock-face 'notmuch-tag-face)))))) + 'face 'notmuch-tag-face)))))) (defun notmuch-search-get-tags () (save-excursion @@ -541,55 +574,107 @@ This function advances the next thread when finished." (if (and atbob (not (string= notmuch-search-target-thread "found"))) (set 'never-found-target-thread t)))))) - (if (and never-found-target-thread + (when (and never-found-target-thread notmuch-search-target-line) - (goto-line notmuch-search-target-line))))))) + (goto-char (point-min)) + (forward-line (1- notmuch-search-target-line)))))))) (defcustom notmuch-search-line-faces nil "Tag/face mapping for line highlighting in notmuch-search. Here is an example of how to color search results based on tags. -(the following text would be placed in your ~/.emacs file): + (the following text would be placed in your ~/.emacs file): -(setq notmuch-search-line-faces '((\"delete\" . '(:foreground \"red\")) - (\"unread\" . '(:foreground \"green\")))) + (setq notmuch-search-line-faces '((\"delete\" . '(:foreground \"red\" + :background \"blue\")) + (\"unread\" . '(:foreground \"green\")))) -Order matters: for lines with multiple tags, the the first -matching will be applied." +The attributes defined for matching tags are merged, with later +attributes overriding earlier. A message having both \"delete\" +and \"unread\" tags with the above settings would have a green +foreground and blue background." :type '(alist :key-type (string) :value-type (list)) :group 'notmuch) (defun notmuch-search-color-line (start end line-tag-list) - "Colorize lines in notmuch-show based on tags" - (if notmuch-search-line-faces - (let ((overlay (make-overlay start end)) - (tags-faces (copy-alist notmuch-search-line-faces))) - (while tags-faces - (let* ((tag-face (car tags-faces)) - (tag (car tag-face)) - (face (cdr tag-face))) - (cond ((member tag line-tag-list) - (overlay-put overlay 'face face) - (setq tags-faces nil)) - (t - (setq tags-faces (cdr tags-faces))))))))) + "Colorize lines in `notmuch-show' based on tags." + ;; Create the overlay only if the message has tags which match one + ;; of those specified in `notmuch-search-line-faces'. + (let (overlay) + (mapc '(lambda (elem) + (let ((tag (car elem)) + (attributes (cdr elem))) + (when (member tag line-tag-list) + (when (not overlay) + (setq overlay (make-overlay start end))) + ;; Merge the specified properties with any already + ;; applied from an earlier match. + (overlay-put overlay 'face + (append (overlay-get overlay 'face) attributes))))) + notmuch-search-line-faces))) + +(defun notmuch-search-isearch-authors-show (overlay) + (remove-from-invisibility-spec (cons (overlay-get overlay 'invisible) t))) + +(defun notmuch-search-insert-authors (format-string authors) + (let* ((propertized-authors + ;; Need to save the match data to avoid interfering with + ;; `notmuch-search-process-filter'. + (save-match-data + ;; Authors that don't match the search query are shown in a + ;; different font. + (if (string-match "\\(.*\\)|\\(..*\\)" authors) + (concat (propertize (concat (match-string 1 authors) ",") + 'face 'notmuch-search-matching-authors) + (propertize (match-string 2 authors) + 'face 'notmuch-search-non-matching-authors)) + (propertize authors 'face 'notmuch-search-matching-authors)))) + + (formatted-sample (format format-string "")) + (formatted-authors (format format-string propertized-authors)) + visible-string invisible-string) + + ;; Determine the part of the authors that will be visible by + ;; default. + (if (> (length formatted-authors) + (length formatted-sample)) + ;; 4 is `(length "... ")'. + (let ((visible-length (- (length formatted-sample) 4))) + (setq visible-string (substring propertized-authors 0 visible-length) + invisible-string (substring propertized-authors visible-length))) + (setq visible-string formatted-authors + invisible-string nil)) + + ;; Insert both the visible and invisible author strings. + (insert visible-string) + (when invisible-string + (let ((start (point)) + (invis-spec (make-symbol "notmuch-search-authors")) + overlay) + (insert invisible-string) + ;; Using a cons-cell here causes an ellipsis to be inserted + ;; instead of the invisible text. + (add-to-invisibility-spec (cons invis-spec t)) + (setq overlay (make-overlay start (point))) + (overlay-put overlay 'invisible invis-spec) + (overlay-put overlay 'isearch-open-invisible #'notmuch-search-isearch-authors-show) + (insert " "))))) (defun notmuch-search-insert-field (field date count authors subject tags) (cond ((string-equal field "date") - (insert (format (cdr (assoc field notmuch-search-result-format)) date))) + (insert (propertize (format (cdr (assoc field notmuch-search-result-format)) date) + 'face 'notmuch-search-date))) ((string-equal field "count") - (insert (format (cdr (assoc field notmuch-search-result-format)) count))) - ((string-equal field "authors") - (insert (let* ((format-string (cdr (assoc field notmuch-search-result-format))) - (formatted-sample (format format-string "")) - (formatted-authors (format format-string authors))) - (if (> (length formatted-authors) - (length formatted-sample)) - (concat (substring authors 0 (- (length formatted-sample) 4)) "... ") - formatted-authors)))) + (insert (propertize (format (cdr (assoc field notmuch-search-result-format)) count) + 'face 'notmuch-search-count))) ((string-equal field "subject") - (insert (format (cdr (assoc field notmuch-search-result-format)) subject))) + (insert (propertize (format (cdr (assoc field notmuch-search-result-format)) subject) + 'face 'notmuch-search-subject))) + + ((string-equal field "authors") + (notmuch-search-insert-authors (cdr (assoc field notmuch-search-result-format)) authors)) + ((string-equal field "tags") (insert (concat "(" (propertize tags 'font-lock-face 'notmuch-tag-face) ")"))))) @@ -611,7 +696,7 @@ matching will be applied." (more t) (inhibit-read-only t)) (while more - (if (string-match "^\\(thread:[0-9A-Fa-f]*\\) \\(.*\\) \\(\\[[0-9/]*\\]\\) \\([^;]*\\); \\(.*\\) (\\([^()]*\\))$" string line) + (if (string-match "^\\(thread:[0-9A-Fa-f]*\\) \\([^][]*\\) \\(\\[[0-9/]*\\]\\) \\([^;]*\\); \\(.*\\) (\\([^()]*\\))$" string line) (let* ((thread-id (match-string 1 string)) (date (match-string 2 string)) (count (match-string 3 string)) @@ -661,19 +746,25 @@ characters as well as `_.+-'. (defun notmuch-search-buffer-title (query) "Returns the title for a buffer with notmuch search results." - (let* ((folder (rassoc-if (lambda (key) - (string-match (concat "^" (regexp-quote key)) - query)) - notmuch-folders)) - (folder-name (car folder)) - (folder-query (cdr folder))) - (cond ((and folder (equal folder-query query)) - ;; Query is the same as folder search (ignoring case) - (concat "*notmuch-folder-" folder-name "*")) - (folder + (let* ((saved-search + (let (longest + (longest-length 0)) + (loop for tuple in notmuch-saved-searches + if (let ((quoted-query (regexp-quote (cdr tuple)))) + (and (string-match (concat "^" quoted-query) query) + (> (length (match-string 0 query)) + longest-length))) + do (setq longest tuple)) + longest)) + (saved-search-name (car saved-search)) + (saved-search-query (cdr saved-search))) + (cond ((and saved-search (equal saved-search-query query)) + ;; Query is the same as saved search (ignoring case) + (concat "*notmuch-saved-search-" saved-search-name "*")) + (saved-search (concat "*notmuch-search-" - (replace-regexp-in-string (concat "^" (regexp-quote folder-query)) - (concat "[ " folder-name " ]") + (replace-regexp-in-string (concat "^" (regexp-quote saved-search-query)) + (concat "[ " saved-search-name " ]") query) "*")) (t @@ -708,10 +799,13 @@ The optional parameters are used as follows: (erase-buffer) (goto-char (point-min)) (save-excursion - (let ((proc (start-process-shell-command - "notmuch-search" buffer notmuch-command "search" - (if oldest-first "--sort=oldest-first" "--sort=newest-first") - (shell-quote-argument query)))) + (let ((proc (start-process + "notmuch-search" buffer + notmuch-command "search" + (if oldest-first + "--sort=oldest-first" + "--sort=newest-first") + query))) (set-process-sentinel proc 'notmuch-search-process-sentinel) (set-process-filter proc 'notmuch-search-process-filter)))) (run-hooks 'notmuch-search-hook))) @@ -730,7 +824,7 @@ same relative position within the new buffer." (target-thread (notmuch-search-find-thread-id)) (query notmuch-search-query-string) (continuation notmuch-search-continuation)) - (kill-this-buffer) + (notmuch-kill-this-buffer) (notmuch-search query oldest-first target-thread target-line continuation) (goto-char (point-min)))) @@ -739,9 +833,9 @@ same relative position within the new buffer." If this variable is non empty, then it should name a script to be invoked by `notmuch-search-poll-and-refresh-view' and -`notmuch-folder-poll-and-refresh-view' (each have a default -keybinding of 'G'). The script could do any of the following -depending on the user's needs: +`notmuch-hello-poll-and-update' (each have a default keybinding +of 'G'). The script could do any of the following depending on +the user's needs: 1. Invoke a program to transfer mail to the local mail store 2. Invoke \"notmuch new\" to incorporate the new mail @@ -811,148 +905,4 @@ current search results AND that are tagged with the given tag." (setq mail-user-agent 'notmuch-user-agent) -(defvar notmuch-folder-mode-map - (let ((map (make-sparse-keymap))) - (define-key map "?" 'notmuch-help) - (define-key map "x" 'kill-this-buffer) - (define-key map "q" 'kill-this-buffer) - (define-key map "m" 'notmuch-mua-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 "G" 'notmuch-folder-poll-and-refresh-view) - (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) - "Keymap for \"notmuch folder\" buffers.") - -(fset 'notmuch-folder-mode-map notmuch-folder-mode-map) - -(defun notmuch-folder-mode () - "Major mode for showing notmuch 'folders'. - -This buffer contains a list of message counts returned by a -customizable set of searches of your email archives. Each line in -the buffer shows the name of a saved search and the resulting -message count. - -Pressing RET on any line opens a search window containing the -results for the saved search on that line. - -Here is an example of how the search list could be -customized, (the following text would be placed in your ~/.emacs -file): - -(setq notmuch-folders '((\"inbox\" . \"tag:inbox\") - (\"unread\" . \"tag:inbox AND tag:unread\") - (\"notmuch\" . \"tag:inbox AND to:notmuchmail.org\"))) - -Of course, you can have any number of folders, each configured -with any supported search terms (see \"notmuch help search-terms\"). - -Currently available key bindings: - -\\{notmuch-folder-mode-map}" - (interactive) - (kill-all-local-variables) - (use-local-map 'notmuch-folder-mode-map) - (setq truncate-lines t) - (hl-line-mode 1) - (setq major-mode 'notmuch-folder-mode - mode-name "notmuch-folder") - (setq buffer-read-only t)) - -(defun notmuch-folder-next () - "Select the next folder in the list." - (interactive) - (forward-line 1) - (if (eobp) - (forward-line -1))) - -(defun notmuch-folder-previous () - "Select the previous folder in the list." - (interactive) - (forward-line -1)) - -(defun notmuch-folder-first () - "Select the first folder in the list." - (interactive) - (goto-char (point-min))) - -(defun notmuch-folder-last () - "Select the last folder in the list." - (interactive) - (goto-char (point-max)) - (forward-line -1)) - -(defun notmuch-folder-count (search) - (car (process-lines notmuch-command "count" search))) - -(defvar notmuch-folder-show-empty t - "Whether `notmuch-folder-mode' should display empty folders.") - -(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))) - (inhibit-read-only t) - (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))) - (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." - (interactive) - (if (null folder) - (setq folder (notmuch-folder-find-name))) - (let ((search (assoc folder notmuch-folders))) - (if search - (notmuch-search (cdr search) notmuch-search-oldest-first)))) - -(defun notmuch-folder-poll-and-refresh-view () - "Invoke `notmuch-poll' to import mail, then refresh the folder view." - (interactive) - (notmuch-poll) - (notmuch-folder)) - -;;;###autoload -(defun notmuch-folder () - "Show the notmuch folder view and update the displayed counts." - (interactive) - (let ((buffer (get-buffer-create "*notmuch-folders*"))) - (switch-to-buffer buffer) - (let ((inhibit-read-only t) - (n (line-number-at-pos))) - (erase-buffer) - (notmuch-folder-mode) - (notmuch-folder-add notmuch-folders) - (goto-char (point-min)) - (goto-line n)))) - (provide 'notmuch)