rmailsum.el 68.9 KB
Newer Older
1
;;; rmailsum.el --- make summary buffers for the mail reader  -*- lexical-binding:t -*-
2

Paul Eggert's avatar
Paul Eggert committed
3
;; Copyright (C) 1985, 1993-1996, 2000-2021 Free Software Foundation,
Paul Eggert's avatar
Paul Eggert committed
4
;; Inc.
5

6
;; Maintainer: emacs-devel@gnu.org
7
;; Keywords: mail
8
;; Package: rmail
9 10 11 12 13 14 15 16 17 18 19 20 21 22

;; This file is 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
23
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
24 25 26 27 28 29 30 31 32

;;; Commentary:

;; Extended by Bob Weiner of Motorola
;;   Provided all commands from rmail-mode in rmail-summary-mode and made key
;;   bindings in both modes wholly compatible.

;;; Code:

Glenn Morris's avatar
Glenn Morris committed
33
;; For rmail-select-summary.
34
(require 'rmail)
Kenichi Handa's avatar
Kenichi Handa committed
35
(require 'rfc2047)
36 37

(defcustom rmail-summary-scroll-between-messages t
38 39 40 41
  "Non-nil means Rmail summary scroll commands move between messages.
That is, after `rmail-summary-scroll-msg-up' reaches the end of a
message, it moves to the next message; and similarly for
`rmail-summary-scroll-msg-down'."
42 43 44
  :type 'boolean
  :group 'rmail-summary)

45 46
;; FIXME could do with a :set function that regenerates the summary
;; and updates rmail-summary-vector.
47
(defcustom rmail-summary-line-count-flag t
48 49
  "Non-nil means Rmail summary should show the number of lines in each message.
Setting this option to nil might speed up the generation of summaries."
50 51 52 53
  :type 'boolean
  :group 'rmail-summary)

(defvar rmail-summary-font-lock-keywords
54 55
  '(("^ *[0-9]+D.*" . font-lock-string-face)			; Deleted.
    ("^ *[0-9]+-.*" . font-lock-type-face)			; Unread.
56
    ;; Neither of the below will be highlighted if either of the above are:
57
    ("^ *[0-9]+[^D-] \\(......\\)" 1 font-lock-keyword-face)	; Date.
58 59 60
    ("{ \\([^\n}]+\\) }" 1 font-lock-comment-face))		; Labels.
  "Additional expressions to highlight in Rmail Summary mode.")

Glenn Morris's avatar
Glenn Morris committed
61
(defvar rmail-summary-redo nil
62 63
  "(FUNCTION . ARGS) to regenerate this Rmail summary buffer.")

Glenn Morris's avatar
Glenn Morris committed
64 65
(defvar rmail-summary-overlay nil
  "Overlay used to highlight the current message in the Rmail summary.")
66 67
(put 'rmail-summary-overlay 'permanent-local t)

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
(defvar rmail-summary-mode-map
  (let ((map (make-keymap)))
    (suppress-keymap map)
    (define-key map [mouse-2] 'rmail-summary-mouse-goto-message)
    (define-key map "a"      'rmail-summary-add-label)
    (define-key map "b"      'rmail-summary-bury)
    (define-key map "c"      'rmail-summary-continue)
    (define-key map "d"      'rmail-summary-delete-forward)
    (define-key map "\C-d"   'rmail-summary-delete-backward)
    (define-key map "e"      'rmail-summary-edit-current-message)
    (define-key map "f"      'rmail-summary-forward)
    (define-key map "g"      'rmail-summary-get-new-mail)
    (define-key map "h"      'rmail-summary)
    (define-key map "i"      'rmail-summary-input)
    (define-key map "j"      'rmail-summary-goto-msg)
    (define-key map "\C-m"   'rmail-summary-goto-msg)
    (define-key map "k"      'rmail-summary-kill-label)
    (define-key map "l"      'rmail-summary-by-labels)
    (define-key map "\e\C-h" 'rmail-summary)
    (define-key map "\e\C-l" 'rmail-summary-by-labels)
    (define-key map "\e\C-r" 'rmail-summary-by-recipients)
    (define-key map "\e\C-s" 'rmail-summary-by-regexp)
    ;; `f' for "from".
    (define-key map "\e\C-f" 'rmail-summary-by-senders)
    (define-key map "\e\C-t" 'rmail-summary-by-topic)
    (define-key map "m"      'rmail-summary-mail)
    (define-key map "\M-m"   'rmail-summary-retry-failure)
    (define-key map "n"      'rmail-summary-next-msg)
    (define-key map "\en"    'rmail-summary-next-all)
    (define-key map "\e\C-n" 'rmail-summary-next-labeled-message)
    (define-key map "o"      'rmail-summary-output)
    (define-key map "\C-o"   'rmail-summary-output-as-seen)
    (define-key map "p"      'rmail-summary-previous-msg)
    (define-key map "\ep"    'rmail-summary-previous-all)
    (define-key map "\e\C-p" 'rmail-summary-previous-labeled-message)
    (define-key map "q"      'rmail-summary-quit)
    (define-key map "Q"      'rmail-summary-wipe)
    (define-key map "r"      'rmail-summary-reply)
    (define-key map "s"      'rmail-summary-expunge-and-save)
    ;; See rms's comment in rmail.el
    ;; (define-key map "\er"    'rmail-summary-search-backward)
    (define-key map "\es"    'rmail-summary-search)
    (define-key map "t"      'rmail-summary-toggle-header)
    (define-key map "u"      'rmail-summary-undelete)
    (define-key map "\M-u"   'rmail-summary-undelete-many)
    (define-key map "x"      'rmail-summary-expunge)
    (define-key map "w"      'rmail-summary-output-body)
    (define-key map "v"      'rmail-mime)
    (define-key map "."      'rmail-summary-beginning-of-message)
    (define-key map "/"      'rmail-summary-end-of-message)
    (define-key map "<"      'rmail-summary-first-message)
    (define-key map ">"      'rmail-summary-last-message)
    (define-key map " "      'rmail-summary-scroll-msg-up)
121
    (define-key map [?\S-\ ] 'rmail-summary-scroll-msg-down)
122 123
    (define-key map "\177"   'rmail-summary-scroll-msg-down)
    (define-key map "?"      'describe-mode)
124
    (define-key map "\C-c\C-d"      'rmail-summary-epa-decrypt)
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
    (define-key map "\C-c\C-n" 'rmail-summary-next-same-subject)
    (define-key map "\C-c\C-p" 'rmail-summary-previous-same-subject)
    (define-key map "\C-c\C-s\C-d" 'rmail-summary-sort-by-date)
    (define-key map "\C-c\C-s\C-s" 'rmail-summary-sort-by-subject)
    (define-key map "\C-c\C-s\C-a" 'rmail-summary-sort-by-author)
    (define-key map "\C-c\C-s\C-r" 'rmail-summary-sort-by-recipient)
    (define-key map "\C-c\C-s\C-c" 'rmail-summary-sort-by-correspondent)
    (define-key map "\C-c\C-s\C-l" 'rmail-summary-sort-by-lines)
    (define-key map "\C-c\C-s\C-k" 'rmail-summary-sort-by-labels)
    (define-key map "\C-x\C-s" 'rmail-summary-save-buffer)

    ;; Menu bar bindings.

    (define-key map [menu-bar] (make-sparse-keymap))

    (define-key map [menu-bar classify]
      (cons "Classify" (make-sparse-keymap "Classify")))

    (define-key map [menu-bar classify output-menu]
      '("Output (Rmail Menu)..." . rmail-summary-output-menu))

    (define-key map [menu-bar classify input-menu]
      '("Input Rmail File (menu)..." . rmail-input-menu))

    (define-key map [menu-bar classify input-menu]
      '(nil))

    (define-key map [menu-bar classify output-menu]
      '(nil))

    (define-key map [menu-bar classify output-body]
      '("Output body..." . rmail-summary-output-body))

    (define-key map [menu-bar classify output-inbox]
      '("Output..." . rmail-summary-output))

    (define-key map [menu-bar classify output]
      '("Output as seen..." . rmail-summary-output-as-seen))

    (define-key map [menu-bar classify kill-label]
      '("Kill Label..." . rmail-summary-kill-label))

    (define-key map [menu-bar classify add-label]
      '("Add Label..." . rmail-summary-add-label))

    (define-key map [menu-bar summary]
      (cons "Summary" (make-sparse-keymap "Summary")))

    (define-key map [menu-bar summary senders]
      '("By Senders..." . rmail-summary-by-senders))

    (define-key map [menu-bar summary labels]
      '("By Labels..." . rmail-summary-by-labels))

    (define-key map [menu-bar summary recipients]
      '("By Recipients..." . rmail-summary-by-recipients))

    (define-key map [menu-bar summary topic]
      '("By Topic..." . rmail-summary-by-topic))

    (define-key map [menu-bar summary regexp]
      '("By Regexp..." . rmail-summary-by-regexp))

    (define-key map [menu-bar summary all]
      '("All" . rmail-summary))

    (define-key map [menu-bar mail]
      (cons "Mail" (make-sparse-keymap "Mail")))

    (define-key map [menu-bar mail rmail-summary-get-new-mail]
      '("Get New Mail" . rmail-summary-get-new-mail))

    (define-key map [menu-bar mail lambda]
      '("----"))

    (define-key map [menu-bar mail continue]
      '("Continue" . rmail-summary-continue))

    (define-key map [menu-bar mail resend]
      '("Re-send..." . rmail-summary-resend))

    (define-key map [menu-bar mail forward]
      '("Forward" . rmail-summary-forward))

    (define-key map [menu-bar mail retry]
      '("Retry" . rmail-summary-retry-failure))

    (define-key map [menu-bar mail reply]
      '("Reply" . rmail-summary-reply))

    (define-key map [menu-bar mail mail]
      '("Mail" . rmail-summary-mail))

    (define-key map [menu-bar delete]
      (cons "Delete" (make-sparse-keymap "Delete")))

    (define-key map [menu-bar delete expunge/save]
      '("Expunge/Save" . rmail-summary-expunge-and-save))

    (define-key map [menu-bar delete expunge]
      '("Expunge" . rmail-summary-expunge))

    (define-key map [menu-bar delete undelete]
      '("Undelete" . rmail-summary-undelete))

    (define-key map [menu-bar delete delete]
      '("Delete" . rmail-summary-delete-forward))

    (define-key map [menu-bar move]
      (cons "Move" (make-sparse-keymap "Move")))

    (define-key map [menu-bar move search-back]
      '("Search Back..." . rmail-summary-search-backward))

    (define-key map [menu-bar move search]
      '("Search..." . rmail-summary-search))

    (define-key map [menu-bar move previous]
      '("Previous Nondeleted" . rmail-summary-previous-msg))

    (define-key map [menu-bar move next]
      '("Next Nondeleted" . rmail-summary-next-msg))

    (define-key map [menu-bar move last]
      '("Last" . rmail-summary-last-message))

    (define-key map [menu-bar move first]
      '("First" . rmail-summary-first-message))

    (define-key map [menu-bar move previous]
      '("Previous" . rmail-summary-previous-all))

    (define-key map [menu-bar move next]
      '("Next" . rmail-summary-next-all))
    map)
Glenn Morris's avatar
Glenn Morris committed
260
  "Keymap used in Rmail summary mode.")
261 262 263 264 265 266

;; Entry points for making a summary buffer.

;; Regenerate the contents of the summary
;; using the same selection criterion as last time.
;; M-x revert-buffer in a summary buffer calls this function.
267
(defun rmail-update-summary (&rest _)
268 269 270 271 272 273
  (apply (car rmail-summary-redo) (cdr rmail-summary-redo)))

;;;###autoload
(defun rmail-summary ()
  "Display a summary of all messages, one line per message."
  (interactive)
Glenn Morris's avatar
Glenn Morris committed
274
  (rmail-new-summary "All" '(rmail-summary) nil))
275 276 277 278 279 280 281 282 283 284 285 286 287

;;;###autoload
(defun rmail-summary-by-labels (labels)
  "Display a summary of all messages with one or more LABELS.
LABELS should be a string containing the desired labels, separated by commas."
  (interactive "sLabels to summarize by: ")
  (if (string= labels "")
      (setq labels (or rmail-last-multi-labels
		       (error "No label specified"))))
  (setq rmail-last-multi-labels labels)
  (rmail-new-summary (concat "labels " labels)
		     (list 'rmail-summary-by-labels labels)
		     'rmail-message-labels-p
288 289 290
		     (concat " \\("
			     (mail-comma-list-regexp labels)
			     "\\)\\(,\\|\\'\\)")))
291 292 293 294 295 296 297

;;;###autoload
(defun rmail-summary-by-recipients (recipients &optional primary-only)
  "Display a summary of all messages with the given RECIPIENTS.
Normally checks the To, From and Cc fields of headers;
but if PRIMARY-ONLY is non-nil (prefix arg given),
 only look in the To and From fields.
298
RECIPIENTS is a regular expression."
299 300 301 302
  (interactive "sRecipients to summarize by: \nP")
  (rmail-new-summary
   (concat "recipients " recipients)
   (list 'rmail-summary-by-recipients recipients primary-only)
303
   'rmail-message-recipients-p recipients primary-only))
304 305 306 307 308 309

(defun rmail-message-recipients-p (msg recipients &optional primary-only)
  (rmail-apply-in-message msg 'rmail-message-recipients-p-1
			  recipients primary-only))

(defun rmail-message-recipients-p-1 (recipients &optional primary-only)
310 311
  ;; mail-fetch-field does not care where it starts from.
  (narrow-to-region (point) (progn (search-forward "\n\n") (point)))
312 313 314 315 316
  (or (string-match recipients (or (mail-fetch-field "To") ""))
      (string-match recipients (or (mail-fetch-field "From") ""))
      (if (not primary-only)
	  (string-match recipients (or (mail-fetch-field "Cc") "")))))

317 318 319
;; FIXME I find this a non-obvious name for what this function does.
;; Also, the optional WHOLE-MESSAGE argument of r-s-by-topic would
;; seem more natural here.
320 321 322 323 324
;;;###autoload
(defun rmail-summary-by-regexp (regexp)
  "Display a summary of all messages according to regexp REGEXP.
If the regular expression is found in the header of the message
\(including in the date and other lines, as well as the subject line),
325
Emacs will list the message in the summary."
326 327 328 329 330 331 332 333 334 335 336 337 338 339
  (interactive "sRegexp to summarize by: ")
  (if (string= regexp "")
      (setq regexp (or rmail-last-regexp
			 (error "No regexp specified"))))
  (setq rmail-last-regexp regexp)
  (rmail-new-summary (concat "regexp " regexp)
		     (list 'rmail-summary-by-regexp regexp)
		     'rmail-message-regexp-p
                     regexp))

(defun rmail-message-regexp-p (msg regexp)
  "Return t, if for message number MSG, regexp REGEXP matches in the header."
  (rmail-apply-in-message msg 'rmail-message-regexp-p-1 msg regexp))

340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
(defun rmail--decode-and-apply (function &rest args)
  "Make an RFC2047-decoded copy of current buffer, apply FUNCTION with ARGS."
  (let ((buff (current-buffer)))
    (with-temp-buffer
      (insert-buffer-substring buff)
      (goto-char (point-min))
      ;; FIXME?  In rmail-show-message-1, decoding depends on
      ;; rmail-enable-mime being non-nil (?).
      (rfc2047-decode-region (point-min)
			     (save-excursion
			       (progn
				 (search-forward "\n\n" nil 'move)
				 (point))))
      (apply function args))))

355
(defun rmail-message-regexp-p-1 (msg regexp)
356
  ;; Search functions can expect to start from the beginning.
357
  (narrow-to-region (point) (save-excursion (search-forward "\n\n") (point)))
Glenn Morris's avatar
Glenn Morris committed
358 359 360
  (if (and rmail-enable-mime
	   rmail-search-mime-header-function)
      (funcall rmail-search-mime-header-function msg regexp (point))
361 362 363
    ;; We need to search the full headers, but probably want to decode
    ;; them so they match the ones people see displayed.  (Bug#19088)
    (rmail--decode-and-apply 're-search-forward regexp nil t)))
364 365 366 367

;;;###autoload
(defun rmail-summary-by-topic (subject &optional whole-message)
  "Display a summary of all messages with the given SUBJECT.
368 369
Normally checks just the Subject field of headers; but with prefix
argument WHOLE-MESSAGE is non-nil, looks in the whole message.
370
SUBJECT is a regular expression."
371
  (interactive
372 373 374
   ;; We quote the default subject, because if it contains regexp
   ;; special characters (eg "?"), it can fail to match itself.  (Bug#2333)
   (let* ((subject (regexp-quote (rmail-simplified-subject)))
375 376 377 378 379 380 381
	  (prompt (concat "Topics to summarize by (regexp"
			  (if subject ", default current subject" "")
			  "): ")))
     (list (read-string prompt nil nil subject) current-prefix-arg)))
  (rmail-new-summary
   (concat "about " subject)
   (list 'rmail-summary-by-topic subject whole-message)
382
   'rmail-message-subject-p subject whole-message))
383 384 385

(defun rmail-message-subject-p (msg subject &optional whole-message)
  (if whole-message
386 387 388
      ;; SUBJECT and rmail-simplified-subject are 2047 decoded.
      (rmail-apply-in-message msg 'rmail--decode-and-apply
			      're-search-forward subject nil t)
389 390 391 392
    (string-match subject (rmail-simplified-subject msg))))

;;;###autoload
(defun rmail-summary-by-senders (senders)
393
  "Display a summary of all messages whose \"From\" field matches SENDERS.
394
SENDERS is a regular expression.  The default for SENDERS matches the
Paul Eggert's avatar
Paul Eggert committed
395
sender of the current message."
396 397 398 399 400 401 402 403 404
  (interactive
   (let* ((def (rmail-get-header "From"))
          ;; We quote the default argument, because if it contains regexp
          ;; special characters (eg "?"), it can fail to match itself.
          (sender (regexp-quote def))
	  (prompt (concat "Senders to summarize by (regexp"
			  (if sender ", default this message's sender" "")
			  "): ")))
     (list (read-string prompt nil nil sender))))
405 406
  (rmail-new-summary
   (concat "senders " senders)
407
   (list 'rmail-summary-by-senders senders) 'rmail-message-senders-p senders))
408 409 410 411 412 413 414 415 416 417

(defun rmail-message-senders-p (msg senders)
  (string-match senders (or (rmail-get-header "From" msg) "")))

;; General making of a summary buffer.

(defvar rmail-summary-symbol-number 0)

(defvar rmail-new-summary-line-count)

418
(defun rmail-new-summary (desc redo function &rest args)
419
  "Create a summary of selected messages.
420 421 422 423 424 425 426 427
DESC makes part of the mode line of the summary buffer.
REDO is what to put in `rmail-summary-redo'; usually
its car is the function that called `rmail-new-summary'
and its cdr is the arguments passed to that function.

For each message, applies FUNCTION to the message number and ARGS...,
and if the result is non-nil, it includes that message in the summary.
If FUNCTION is nil, includes all messages."
428 429 430
  (message "Computing summary lines...")
  (unless rmail-buffer
    (error "No RMAIL buffer found"))
431
  (let (mesg was-in-summary sumbuf)
432
    (if (derived-mode-p 'rmail-summary-mode)
433 434
	(setq was-in-summary t))
    (with-current-buffer rmail-buffer
435
      (setq rmail-summary-buffer (rmail-new-summary-1 desc redo function args)
436
	    ;; r-s-b is buffer-local.
437 438
	    sumbuf rmail-summary-buffer
	    mesg rmail-current-message))
439 440 441 442 443 444 445 446 447
    ;; Now display the summary buffer and go to the right place in it.
    (unless was-in-summary
      (if (and (one-window-p)
	       pop-up-windows
	       (not pop-up-frames))
	  ;; If there is just one window, put the summary on the top.
	  (progn
	    (split-window (selected-window) rmail-summary-window-size)
	    (select-window (next-window (frame-first-window)))
448
	    (rmail-pop-to-buffer sumbuf)
449 450
	    ;; If pop-to-buffer did not use that window, delete that
	    ;; window.  (This can happen if it uses another frame.)
451
	    (if (not (eq sumbuf (window-buffer (frame-first-window))))
452
		(delete-other-windows)))
453
	(rmail-pop-to-buffer sumbuf))
454 455 456 457
      (set-buffer rmail-buffer)
      ;; This is how rmail makes the summary buffer reappear.
      ;; We do this here to make the window the proper size.
      (rmail-select-summary nil)
458
      (set-buffer sumbuf))
459 460 461 462
    (rmail-summary-goto-msg mesg t t)
    (rmail-summary-construct-io-menu)
    (message "Computing summary lines...done")))

463
(defun rmail-new-summary-1 (description redo function args)
464 465 466 467
  "Filter messages to obtain summary lines.
DESCRIPTION is added to the mode line.

Return the summary buffer by invoking FUNCTION on each message
468
passing the message number and ARGS.
469

470
REDO is what to put in `rmail-summary-redo'.
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496

The current buffer must be a Rmail buffer either containing a
collection of mbox formatted messages or displaying a single
message."
  (let ((summary-msgs ())
	(rmail-new-summary-line-count 0)
	(sumbuf (rmail-get-create-summary-buffer)))
    ;; Scan the messages, getting their summary strings
    ;; and putting the list of them in SUMMARY-MSGS.
    (let ((msgnum 1)
	  (main-buffer (current-buffer))
	  (total rmail-total-messages)
	  (inhibit-read-only t))
      (save-excursion
	;; Go where the mbox text is.
	(if (rmail-buffers-swapped-p)
	    (set-buffer rmail-view-buffer))
	(let ((old-min (point-min-marker))
	      (old-max (point-max-marker)))
	  (unwind-protect
	      ;; Can't use save-restriction here; that doesn't work if we
	      ;; plan to modify text outside the original restriction.
	      (save-excursion
		(widen)
		(goto-char (point-min))
		(while (>= total msgnum)
Eli Zaretskii's avatar
Eli Zaretskii committed
497 498
		  ;; Go back to the Rmail buffer so FUNCTION and
		  ;; rmail-get-summary can see its local vars.
499 500 501 502 503 504 505 506 507
		  (with-current-buffer main-buffer
		    ;; First test whether to include this message.
		    (if (or (null function)
			    (apply function msgnum args))
			(setq summary-msgs
			      (cons (cons msgnum (rmail-get-summary msgnum))
				    summary-msgs))))
		  (setq msgnum (1+ msgnum))
		  ;; Provide a periodic User progress message.
508 509
		  (if (and (not (zerop rmail-new-summary-line-count))
			   (zerop (% rmail-new-summary-line-count 10)))
510 511 512 513 514 515
		      (message "Computing summary lines...%d"
			       rmail-new-summary-line-count)))
		(setq summary-msgs (nreverse summary-msgs)))
	    (narrow-to-region old-min old-max)))))
    ;; Temporarily, while summary buffer is unfinished,
    ;; we "don't have" a summary.
516
    (setq rmail-summary-buffer nil)
517
    ;; I have not a clue what this clause is doing.  If you read this
518
    ;; chunk of code and have a clue, then please  write it here.
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
    (if rmail-enable-mime
	(with-current-buffer rmail-buffer
	  (setq rmail-summary-buffer nil)))
    (save-excursion
      (let ((rbuf (current-buffer))
	    (total rmail-total-messages))
	(set-buffer sumbuf)
	;; Set up the summary buffer's contents.
	(let ((buffer-read-only nil))
	  (erase-buffer)
	  (while summary-msgs
	    (princ (cdr (car summary-msgs)) sumbuf)
	    (setq summary-msgs (cdr summary-msgs)))
	  (goto-char (point-min)))
	;; Set up the rest of its state and local variables.
	(setq buffer-read-only t)
	(rmail-summary-mode)
Stefan Kangas's avatar
Stefan Kangas committed
536
        (setq-local minor-mode-alist (list (list t (concat ": " description))))
537
	(setq rmail-buffer rbuf
538
	      rmail-summary-redo redo
539 540 541 542
	      rmail-total-messages total)))
    sumbuf))

(defun rmail-get-create-summary-buffer ()
543 544
  "Return the Rmail summary buffer.
If necessary, it is created and undo is disabled."
545 546
  (if (and rmail-summary-buffer (buffer-name rmail-summary-buffer))
      rmail-summary-buffer
547 548 549 550
    (let ((buff (generate-new-buffer (concat (buffer-name) "-summary"))))
      (with-current-buffer buff
	(setq buffer-undo-list t))
      buff)))
551

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574

;; Low levels of generating a summary.

(defun rmail-get-summary (msgnum)
  "Return the summary line for message MSGNUM.
The mbox buffer must be current when you call this function
even if its text is swapped.

If the message has a summary line already, it will be stored in
the message as a header and simply returned, otherwise the
summary line is created, saved in the message header, cached and
returned.

The current buffer contains the unrestricted message collection."
  (let ((line (aref rmail-summary-vector (1- msgnum))))
    (unless line
      ;; Register a summary line for MSGNUM.
      (setq rmail-new-summary-line-count (1+ rmail-new-summary-line-count)
	    line (rmail-create-summary-line msgnum))
      ;; Cache the summary line for use during this Rmail session.
      (aset rmail-summary-vector (1- msgnum) line))
    line))

Kenichi Handa's avatar
Kenichi Handa committed
575
(defcustom rmail-summary-line-decoder (function rfc2047-decode-string)
576
  "Function to decode a Rmail summary line.
577 578 579
It receives the summary line for one message as a string
and should return the decoded string.

Kenichi Handa's avatar
Kenichi Handa committed
580 581
By default, it is `rfc2047-decode-string', which decodes MIME-encoded
subject."
582
  :type 'function
Kenichi Handa's avatar
Kenichi Handa committed
583
  :version "23.3"
584 585 586 587 588 589 590 591 592 593 594 595
  :group 'rmail-summary)

(defun rmail-create-summary-line (msgnum)
  "Return the summary line for message MSGNUM.
Obtain the message summary from the header if it is available
otherwise create it and store it in the message header.

The mbox buffer must be current when you call this function
even if its text is swapped."
  (let ((beg (rmail-msgbeg msgnum))
	(end (rmail-msgend msgnum))
	(deleted (rmail-message-deleted-p msgnum))
596 597 598
	;; Does not work (swapped?)
;;;	(unseen (rmail-message-unseen-p msgnum))
	unseen lines)
599 600 601 602 603 604 605 606 607
    (save-excursion
      ;; Switch to the buffer that has the whole mbox text.
      (if (rmail-buffers-swapped-p)
	  (set-buffer rmail-view-buffer))
      ;; Now we can compute the line count.
      (if rmail-summary-line-count-flag
	  (setq lines (count-lines beg end)))
      ;; Narrow to the message header.
      (save-excursion
608 609 610 611 612 613 614 615 616 617 618 619 620 621
	(save-restriction
	  (widen)
	  (goto-char beg)
	  (if (search-forward "\n\n" end t)
	      (progn
		(narrow-to-region beg (point))
		;; Replace rmail-message-unseen-p from above.
		(goto-char beg)
		(setq unseen (and (search-forward
				   (concat rmail-attribute-header ": ") nil t)
				  (looking-at "......U")))
		;; Generate a status line from the message.
		(rmail-create-summary msgnum deleted unseen lines))
	    (rmail-error-bad-format msgnum)))))))
622

623 624 625 626 627 628 629 630 631
;; FIXME this is now unused.
;; The intention was to display in the summary something like {E}
;; for an edited messaged, similarly for answered, etc.
;; But that conflicts with the previous rmail usage, where
;; any user-defined { labels } occupied this space.
;; So whilst it would be nice to have this information in the summary,
;; it would need to go somewhere else.
(defun rmail-get-summary-status ()
  "Return a coded string wrapped in curly braces denoting the status.
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652

The current buffer must already be narrowed to the message headers for
the message being processed."
  (let ((status (mail-fetch-field rmail-attribute-header))
	(index 0)
	(result "")
	char)
    ;; Strip off the read/unread and the deleted attribute which are
    ;; handled separately.
    (setq status
	  (if status
	      (concat (substring status 0 1) (substring status 2 6))
	    ""))
    (while (< index (length status))
      (unless (string= "-" (setq char (substring status index (1+ index))))
	(setq result (concat result char)))
      (setq index (1+ index)))
    (when (> (length result) 0)
      (setq result (concat "{" result "}")))
    result))

653 654
(autoload 'rmail-make-label "rmailkwd")

655 656 657 658 659 660
(defun rmail-get-summary-labels ()
  "Return a string wrapped in curly braces with the current message labels.
Returns nil if there are no labels.  The current buffer must
already be narrowed to the message headers for the message being
processed."
  (let ((labels (mail-fetch-field rmail-keyword-header)))
661 662
    (and labels
	 (not (string-equal labels ""))
663 664 665 666
	 (progn
	   ;; Intern so that rmail-read-label can offer completion.
	   (mapc 'rmail-make-label (split-string labels ", "))
	   (format "{ %s } " labels)))))
667

668 669 670 671 672 673 674 675 676 677 678
(defun rmail-create-summary (msgnum deleted unseen lines)
  "Return the summary line for message MSGNUM.
The current buffer should already be narrowed to the header for that message.
It could be either buffer, so don't access Rmail local variables.
DELETED is t if this message is marked deleted.
UNSEEN is t if it is marked unseen.
LINES is the number of lines in the message (if we should display that)
 or else nil."
  (goto-char (point-min))
  (let ((line (rmail-header-summary))
	(labels (rmail-get-summary-labels))
679
        status prefix basic-start basic-end linecount-string)
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694

    (setq linecount-string
	  (cond
	   ((not lines)       " ")
	   ((<= lines      9) (format "   [%d]" lines))
	   ((<= lines     99) (format "  [%d]" lines))
	   ((<= lines    999) (format " [%d]" lines))
	   ((<= lines   9999) (format "  [%dk]" (/ lines 1000)))
	   ((<= lines  99999) (format " [%dk]" (/ lines 1000)))
	   (t                 (format "[%dk]" (/ lines 1000)))))

    (setq status (cond
		  (deleted ?D)
		  (unseen ?-)
		  (t ? ))
695
	  prefix (format "%5d%c " msgnum status)
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
	  basic-start (car line)
	  basic-end (cadr line))
    (funcall rmail-summary-line-decoder
	     (concat prefix basic-start linecount-string " "
		     labels basic-end))))

(defun rmail-header-summary ()
  "Return a message summary based on the message headers.
The value is a list of two strings, the first and second parts of the summary.

The current buffer must already be narrowed to the message headers for
the message being processed."
  (goto-char (point-min))
  (list
   (concat (save-excursion
	     (if (not (re-search-forward "^Date:" nil t))
		 "      "
713 714 715 716
	       ;; Match month names case-insensitively
	       (cond ((let ((case-fold-search t))
			(re-search-forward "\\([^0-9:]\\)\\([0-3]?[0-9]\\)\\([- \t_]+\\)\\([adfjmnos][aceopu][bcglnprtvy]\\)"
					   (line-end-position) t))
717 718 719 720 721 722
		      (format "%2d-%3s"
			      (string-to-number (buffer-substring
						 (match-beginning 2)
						 (match-end 2)))
			      (buffer-substring
			       (match-beginning 4) (match-end 4))))
723 724 725
		     ((let ((case-fold-search t))
			(re-search-forward "\\([^a-z]\\)\\([adfjmnos][acepou][bcglnprtvy]\\)\\([-a-z \t_]*\\)\\([0-9][0-9]?\\)"
					   (line-end-position) t))
726 727 728 729 730 731 732
		      (format "%2d-%3s"
			      (string-to-number (buffer-substring
						 (match-beginning 4)
						 (match-end 4)))
			      (buffer-substring
			       (match-beginning 2) (match-end 2))))
		     ((re-search-forward "\\(19\\|20\\)\\([0-9][0-9]\\)-\\([01][0-9]\\)-\\([0-3][0-9]\\)"
733
		       (line-end-position) t)
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
		      (format "%2s%2s%2s"
			      (buffer-substring
			       (match-beginning 2) (match-end 2))
			      (buffer-substring
			       (match-beginning 3) (match-end 3))
			      (buffer-substring
			       (match-beginning 4) (match-end 4))))
		     (t "??????"))))
	   "  "
	   (save-excursion
	     (let* ((from (and (re-search-forward "^From:[ \t]*" nil t)
			       (mail-strip-quoted-names
				(buffer-substring
				 (1- (point))
				 ;; Get all the lines of the From field
				 ;; so that we get a whole comment if there is one,
				 ;; so that mail-strip-quoted-names can discard it.
751
				 (progn
752 753 754 755 756 757
				   (while (progn (forward-line 1)
						 (looking-at "[ \t]")))
				   ;; Back up over newline, then trailing spaces or tabs
				   (forward-char -1)
				   (skip-chars-backward " \t")
				   (point))))))
Richard Stallman's avatar
Richard Stallman committed
758 759 760
		    len mch lo newline)
               ;; If there are multiple lines in FROM,
               ;; discard up to the last newline in it.
761 762
               (while (and (stringp from)
                           (setq newline (string-match "\n" from)))
Richard Stallman's avatar
Richard Stallman committed
763
                 (setq from (substring from (1+ newline))))
764 765 766 767 768 769
	       (if (or (null from)
		       (string-match
			(or rmail-user-mail-address-regexp
			    (concat "^\\("
				    (regexp-quote (user-login-name))
				    "\\($\\|@\\)\\|"
770
				    (regexp-quote user-mail-address)
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
				    "\\>\\)"))
			from))
		   ;; No From field, or it's this user.
		   (save-excursion
		     (goto-char (point-min))
		     (if (not (re-search-forward "^To:[ \t]*" nil t))
			 nil
		       (setq from
			     (concat "to: "
				     (mail-strip-quoted-names
				      (buffer-substring
				       (point)
				       (progn (end-of-line)
					      (skip-chars-backward " \t")
					      (point)))))))))
	       (if (null from)
		   "                         "
788 789 790 791 792 793
		 ;; We are going to return only 25 characters of the
		 ;; address, so make sure it is RFC2047 decoded before
		 ;; taking its substring.  This is important when the address is not on the same line as the name, e.g.:
		 ;; To: =?UTF-8?Q?=C5=A0t=C4=9Bp=C3=A1n_?= =?UTF-8?Q?N=C4=9Bmec?=
		 ;; <stepnem@gmail.com>
		 (setq from (rfc2047-decode-string from))
794 795 796 797 798
                 ;; We cannot tolerate any leftover newlines in From,
                 ;; as that disrupts the rmail-summary display.
                 ;; Newlines can be left in From if it was malformed,
                 ;; e.g. had unbalanced quotes.
                 (setq from (replace-regexp-in-string "\n+" " " from))
799 800 801 802 803 804 805 806 807 808 809 810
		 (setq len (length from))
		 (setq mch (string-match "[@%]" from))
		 (format "%25s"
			 (if (or (not mch) (<= len 25))
			     (substring from (max 0 (- len 25)))
			   (substring from
				      (setq lo (cond ((< (- mch 14) 0) 0)
						     ((< len (+ mch 11))
						      (- len 25))
						     (t (- mch 14))))
				      (min len (+ lo 25)))))))))
   (concat (if (re-search-forward "^Subject:" nil t)
Kenichi Handa's avatar
Kenichi Handa committed
811 812 813 814 815
	       (let (pos str)
		 (skip-chars-forward " \t")
		 (setq pos (point))
		 (forward-line 1)
		 (setq str (buffer-substring pos (1- (point))))
816
		 (while (looking-at "[ \t]")
817
		   (setq str (concat str " "
Kenichi Handa's avatar
Kenichi Handa committed
818 819 820 821
				     (buffer-substring (match-end 0)
						       (line-end-position))))
		   (forward-line 1))
		 str)
822 823 824 825 826 827 828 829
	     (re-search-forward "[\n][\n]+" nil t)
	     (buffer-substring (point) (progn (end-of-line) (point))))
	   "\n")))

;; Simple motion in a summary buffer.

(defun rmail-summary-next-all (&optional number)
  (interactive "p")
830 831
  (or number (setq number 1))
  (forward-line number)
832 833 834 835 836 837 838
  ;; It doesn't look nice to move forward past the last message line.
  (and (eobp) (> number 0)
       (forward-line -1))
  (display-buffer rmail-buffer))

(defun rmail-summary-previous-all (&optional number)
  (interactive "p")
Glenn Morris's avatar
Glenn Morris committed
839
  (rmail-summary-next-all (- (or number 1))))
840 841 842 843 844 845

(defun rmail-summary-next-msg (&optional number)
  "Display next non-deleted msg from rmail file.
With optional prefix argument NUMBER, moves forward this number of non-deleted
messages, or backward if NUMBER is negative."
  (interactive "p")
846
  (or number (setq number 1))
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
  (forward-line 0)
  (and (> number 0) (end-of-line))
  (let ((count (if (< number 0) (- number) number))
	(search (if (> number 0) 're-search-forward 're-search-backward))
	(non-del-msg-found nil))
    (while (and (> count 0) (setq non-del-msg-found
				  (or (funcall search "^.....[^D]" nil t)
				      non-del-msg-found)))
      (setq count (1- count))))
  (beginning-of-line)
  (display-buffer rmail-buffer))

(defun rmail-summary-previous-msg (&optional number)
  "Display previous non-deleted msg from rmail file.
With optional prefix argument NUMBER, moves backward this number of
non-deleted messages."
  (interactive "p")
Glenn Morris's avatar
Glenn Morris committed
864
  (rmail-summary-next-msg (- (or number 1))))
865 866 867 868 869 870

(defun rmail-summary-next-labeled-message (n labels)
  "Show next message with LABELS.  Defaults to last labels used.
With prefix argument N moves forward N messages with these labels."
  (interactive "p\nsMove to next msg with labels: ")
  (let (msg)
871
    (with-current-buffer rmail-buffer
872 873 874 875 876 877 878 879 880
      (rmail-next-labeled-message n labels)
      (setq msg rmail-current-message))
    (rmail-summary-goto-msg msg)))

(defun rmail-summary-previous-labeled-message (n labels)
  "Show previous message with LABELS.  Defaults to last labels used.
With prefix argument N moves backward N messages with these labels."
  (interactive "p\nsMove to previous msg with labels: ")
  (let (msg)
881
    (with-current-buffer rmail-buffer
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
      (rmail-previous-labeled-message n labels)
      (setq msg rmail-current-message))
    (rmail-summary-goto-msg msg)))

(defun rmail-summary-next-same-subject (n)
  "Go to the next message in the summary having the same subject.
With prefix argument N, do this N times.
If N is negative, go backwards."
  (interactive "p")
  (let ((forward (> n 0))
	subject i found)
    (with-current-buffer rmail-buffer
      (setq subject (rmail-simplified-subject)
	    i rmail-current-message))
    (save-excursion
      (while (and (/= n 0)
		  (if forward
		      (not (eobp))
		    (not (bobp))))
	(let (done)
	  (while (and (not done)
		      (if forward
			  (not (eobp))
			(not (bobp))))
	    ;; Advance thru summary.
	    (forward-line (if forward 1 -1))
	    ;; Get msg number of this line.
	    (setq i (string-to-number
		     (buffer-substring (point)
				       (min (point-max) (+ 6 (point))))))
	    (setq done (string-equal subject (rmail-simplified-subject i))))
	  (if done (setq found i)))
	(setq n (if forward (1- n) (1+ n)))))
    (if found
	(rmail-summary-goto-msg found)
      (error "No %s message with same subject"
	     (if forward "following" "previous")))))

(defun rmail-summary-previous-same-subject (n)
  "Go to the previous message in the summary having the same subject.
With prefix argument N, do this N times.
If N is negative, go forwards instead."
  (interactive "p")
  (rmail-summary-next-same-subject (- n)))

;; Delete and undelete summary commands.

(defun rmail-summary-delete-forward (&optional count)
  "Delete this message and move to next nondeleted one.
Deleted messages stay in the file until the \\[rmail-expunge] command is given.
A prefix argument serves as a repeat count;
a negative argument means to delete and move backward."
  (interactive "p")
  (unless (numberp count) (setq count 1))
936 937
  (let (del-msg
        (backward (< count 0)))
938 939 940 941 942
    (while (/= count 0)
      ;; Don't waste time counting down without doing anything if we
      ;; are at the beginning and trying to go backward.
      (if (and backward (bobp))
          (setq count -1))
943 944
      (rmail-summary-goto-msg)
      (with-current-buffer rmail-buffer
945 946
	(setq del-msg rmail-current-message)
	(rmail-delete-message))
947 948 949 950 951
      (rmail-summary-mark-deleted del-msg)
      (while (and (not (if backward (bobp) (eobp)))
		  (save-excursion (beginning-of-line)
				  (looking-at " *[0-9]+D")))
	(forward-line (if backward -1 1)))
952 953
      (setq count
	    (if (> count 0) (1- count) (1+ count)))
954
      ;; It looks ugly to move to the empty line at end of buffer.
955
      ;; And don't waste time after hitting the end.
956
      (and (eobp) (not backward)
957 958
	   (progn (setq count 0)
		  (forward-line -1))))))
959 960 961 962 963 964 965 966 967 968

(defun rmail-summary-delete-backward (&optional count)
  "Delete this message and move to previous nondeleted one.
Deleted messages stay in the file until the \\[rmail-expunge] command is given.
A prefix argument serves as a repeat count;
a negative argument means to delete and move forward."
  (interactive "p")
  (rmail-summary-delete-forward (- count)))

(defun rmail-summary-mark-deleted (&optional n undel)
969 970 971
  (and n (not (eq n (rmail-summary-msg-number)))
       ;; Since third arg is t, this only alters summary, not the Rmail buf.
       (rmail-summary-goto-msg n t t))
972 973 974 975
  (or (eobp)
      (not (overlay-get rmail-summary-overlay 'face))
      (let ((buffer-read-only nil))
	(skip-chars-forward " ")
Glenn Morris's avatar
Glenn Morris committed
976
	(skip-chars-forward "0-9")
977 978 979 980
	(if undel
	    (if (looking-at "D")
		(progn (delete-char 1) (insert " ")))
	  (delete-char 1)
981
	  (insert "D"))
982
	;; Discard cached new summary line.
983 984 985
        (when n
	  (with-current-buffer rmail-buffer
	    (aset rmail-summary-vector (1- n) nil)))))
986 987
  (beginning-of-line))

988 989 990 991 992 993 994 995 996 997 998
(defun rmail-summary-update-line (n)
  "Update the summary line for message N."
  (when (rmail-summary-goto-msg n t t)
    (let* ((buffer-read-only nil)
	   (start (line-beginning-position))
	   (end (line-beginning-position 2))
	   (overlays (overlays-in start end))
	   high ov)
      (while (and (setq ov (car overlays))
		  (not (setq high (overlay-get ov 'rmail-summary))))
	(setq overlays (cdr overlays)))
999
      (delete-region start end)
1000 1001 1002 1003 1004 1005 1006 1007
      (princ
       (with-current-buffer rmail-buffer
	 (aset rmail-summary-vector (1- n) (rmail-create-summary-line n)))
       (current-buffer))
      (when high
	(forward-line -1)
	(rmail-summary-update-highlight nil)))))

1008 1009 1010 1011 1012 1013 1014
(defun rmail-summary-mark-undeleted (n)
  (rmail-summary-mark-deleted n t))

(defun rmail-summary-deleted-p (&optional n)
  (save-excursion
    (and n (rmail-summary-goto-msg n nil t))
    (skip-chars-forward " ")
Glenn Morris's avatar
Glenn Morris committed
1015
    (skip-chars-forward "0-9")
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
    (looking-at "D")))

(defun rmail-summary-undelete (&optional arg)
  "Undelete current message.
Optional prefix ARG means undelete ARG previous messages."
  (interactive "p")
  (if (/= arg 1)
      (rmail-summary-undelete-many arg)
    (let ((buffer-read-only nil)
	  (opoint (point)))
      (end-of-line)
      (cond ((re-search-backward "\\(^ *[0-9]*\\)\\(D\\)" nil t)
	     (replace-match "\\1 ")
	     (rmail-summary-goto-msg)
	     (if rmail-enable-mime
		 (set-buffer rmail-buffer)
1032
	       (rmail-pop-to-buffer rmail-buffer))
1033
	     (and (rmail-message-deleted-p rmail-current-message)
1034
		  (rmail-undelete-previous-message 1))
1035
	     (if rmail-enable-mime
1036 1037
		 (rmail-pop-to-buffer rmail-buffer))
	     (rmail-pop-to-buffer rmail-summary-buffer))
1038 1039 1040 1041 1042
	    (t (goto-char opoint))))))

(defun rmail-summary-undelete-many (&optional n)
  "Undelete all deleted msgs, optional prefix arg N means undelete N prev msgs."
  (interactive "P")
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
  (if n
      (while (and (> n 0) (not (eobp)))
	(rmail-summary-goto-msg)
	(let (del-msg)
	  (when (rmail-summary-deleted-p)
	    (with-current-buffer rmail-buffer
	      (rmail-undelete-previous-message 1)
	      (setq del-msg rmail-current-message))
	    (rmail-summary-mark-undeleted del-msg)))
	(while (and (not (eobp))
		    (save-excursion (beginning-of-line)
				    (looking-at " *[0-9]+ ")))
	  (forward-line 1))
	(setq n (1- n)))
    (rmail-summary-goto-msg 1)
1058
    (dotimes (_ rmail-total-messages)
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
      (rmail-summary-goto-msg)
      (let (del-msg)
	(when (rmail-summary-deleted-p)
	  (with-current-buffer rmail-buffer
	    (rmail-undelete-previous-message 1)
	    (setq del-msg rmail-current-message))
	  (rmail-summary-mark-undeleted del-msg)))
      (if (not (eobp))
	  (forward-line 1))))

  ;; It looks ugly to move to the empty line at end of buffer.
  (and (eobp)
       (forward-line -1)))
1072 1073 1074 1075

;; Rmail Summary mode is suitable only for specially formatted data.
(put 'rmail-summary-mode 'mode-class 'special)

1076
(define-derived-mode rmail-summary-mode special-mode "RMAIL Summary"
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
  "Rmail Summary Mode is invoked from Rmail Mode by using \\<rmail-mode-map>\\[rmail-summary].
As commands are issued in the summary buffer, they are applied to the
corresponding mail messages in the rmail buffer.

All normal editing commands are turned off.
Instead, nearly all the Rmail mode commands are available,
though many of them move only among the messages in the summary.

These additional commands exist:

\\[rmail-summary-undelete-many]	Undelete all or prefix arg deleted messages.
\\[rmail-summary-wipe] Delete the summary and go to the Rmail buffer.

Commands for sorting the summary:

\\[rmail-summary-sort-by-date] Sort by date.
\\[rmail-summary-sort-by-subject] Sort by subject.
\\[rmail-summary-sort-by-author] Sort by author.
\\[rmail-summary-sort-by-recipient] Sort by recipient.
\\[rmail-summary-sort-by-correspondent] Sort by correspondent.
\\[rmail-summary-sort-by-lines] Sort by lines.
\\[rmail-summary-sort-by-labels] Sort by labels."
  (setq truncate-lines t)
  (setq buffer-read-only t)
  (set-syntax-table text-mode-syntax-table)
  (make-local-variable 'rmail-buffer)
  (make-local-variable 'rmail-total-messages)
Stefan Kangas's avatar
Stefan Kangas committed
1104 1105
  (setq-local rmail-current-message nil)
  (setq-local rmail-summary-redo nil)
1106
  (make-local-variable 'revert-buffer-function)
Stefan Kangas's avatar
Stefan Kangas committed
1107
  (setq-local font-lock-defaults '(rmail-summary-font-lock-keywords t))
1108
  (rmail-summary-enable))
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120

;; Summary features need to be disabled during edit mode.
(defun rmail-summary-disable ()
  (use-local-map text-mode-map)
  (remove-hook 'post-command-hook 'rmail-summary-rmail-update t)
  (setq revert-buffer-function nil))

(defun rmail-summary-enable ()
  (use-local-map rmail-summary-mode-map)
  (add-hook 'post-command-hook 'rmail-summary-rmail-update nil t)
  (setq revert-buffer-function 'rmail-update-summary))

1121
(defun rmail-summary-mark-seen (n &optional nomove unseen)
Glenn Morris's avatar
Glenn Morris committed
1122 1123
  "Remove the unseen mark from the current message, update the summary vector.
N is the number of the current message.  Optional argument NOMOVE
1124 1125
non-nil means we are already at the right column.  Optional argument
UNSEEN non-nil means mark the message as unseen."
Glenn Morris's avatar
Glenn Morris committed
1126 1127 1128 1129 1130
  (save-excursion
    (unless nomove
      (beginning-of-line)
      (skip-chars-forward " ")
      (skip-chars-forward "0-9"))
1131
    (when (char-equal (following-char) (if unseen ?\s ?-))
Glenn Morris's avatar
Glenn Morris committed
1132 1133
      (let ((buffer-read-only nil))
	(delete-char 1)
1134
	(insert (if unseen "-" " ")))
Glenn Morris's avatar
Glenn Morris committed
1135 1136 1137 1138 1139
      (let ((line (buffer-substring-no-properties (line-beginning-position)
						  (line-beginning-position 2))))
      (with-current-buffer rmail-buffer
	(aset rmail-summary-vector (1- n) line))))))

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
(defvar rmail-summary-put-back-unseen nil
  "Used for communicating between calls to `rmail-summary-rmail-update'.
If it moves to a message within an Incremental Search, and removes
the `unseen' attribute from that message, it sets this flag
so that if the next motion between messages is in the same Incremental
Search, the `unseen' attribute is restored.")

;; Show in Rmail the message described by the summary line that point is on,
;; but only if the Rmail buffer is already visible.
;; This is a post-command-hook in summary buffers.
(defun rmail-summary-rmail-update ()
  (let (buffer-read-only)
    (save-excursion
      ;; If at end of buffer, pretend we are on the last text line.
      (if (eobp)
	  (forward-line -1))
      (beginning-of-line)
      (skip-chars-forward " ")
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
      ;; If the summary is empty, don't do anything.
      (unless (eobp)
	(let ((msg-num (string-to-number (buffer-substring
					  (point)
					  (progn (skip-chars-forward "0-9")
						 (point))))))
	  ;; Always leave `unseen' removed
	  ;; if we get out of isearch mode.
	  ;; Don't let a subsequent isearch restore that `unseen'.
	  (if (not isearch-mode)
	      (setq rmail-summary-put-back-unseen nil))

	  (or (eq rmail-current-message msg-num)
	      (let ((window (get-buffer-window rmail-buffer t))
		    (owin (selected-window)))
		(if isearch-mode
		    (progn
		      ;; If we first saw the previous message in this search,
		      ;; and we have gone to a different message while searching,
		      ;; put back `unseen' on the former one.
		      (when rmail-summary-put-back-unseen
			(rmail-set-attribute rmail-unseen-attr-index t
					     rmail-current-message)
			(save-excursion
			  (goto-char rmail-summary-put-back-unseen)
			  (rmail-summary-mark-seen rmail-current-message t t)))
		      ;; Arrange to do that later, for the new current message,
		      ;; if it still has `unseen'.
		      (setq rmail-summary-put-back-unseen
			    (if (rmail-message-unseen-p msg-num)
				(point))))
		  (setq rmail-summary-put-back-unseen nil))
		;; Go to the desired message.
		(setq rmail-current-message msg-num)
		;; Update the summary to show the message has been seen.
		(rmail-summary-mark-seen msg-num t)
		(if window
		    ;; Using save-window-excursion would cause the new value
		    ;; of point to get lost.
		    (unwind-protect
			(progn
			  (select-window window)
			  (rmail-show-message msg-num t))
		      (select-window owin))
		  (if (buffer-name rmail-buffer)
		      (with-current-buffer rmail-buffer
			(rmail-show-message msg-num t))))
		;; In linum mode, the message buffer must be specially
		;; updated (Bug#4878).
		(and (fboundp 'linum-update)
		     (buffer-name rmail-buffer)
		     (linum-update rmail-buffer))))
	  (rmail-summary-update-highlight nil))))))
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225

(defun rmail-summary-save-buffer ()
  "Save the buffer associated with this RMAIL summary."
  (interactive)
  (save-window-excursion
    (save-excursion
      (switch-to-buffer rmail-buffer)
      (save-buffer))))

(defun rmail-summary-mouse-goto-message (event)
  "Select the message whose summary line you click on."
  (interactive "@e")
  (goto-char (posn-point (event-end event)))
  (rmail-summary-goto-msg))

1226 1227 1228 1229 1230 1231 1232
(defun rmail-summary-msg-number ()
  (save-excursion
    (beginning-of-line)
    (string-to-number
     (buffer-substring (point)
		       (min (point-max) (+ 6 (point)))))))

1233 1234 1235 1236 1237 1238
(defun rmail-summary-goto-msg (&optional n nowarn skip-rmail)
  "Go to message N in the summary buffer and the Rmail buffer.
If N is nil, use the message corresponding to point in the summary
and move to that message in the Rmail buffer.

If NOWARN, don't say anything if N is out of range.
1239 1240
If SKIP-RMAIL, don't do anything to the Rmail buffer.
Returns non-nil if message N was found."
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
  (interactive "P")
  (if (consp n) (setq n (prefix-numeric-value n)))
  (if (eobp) (forward-line -1))
  (beginning-of-line)
  (let* ((obuf (current-buffer))
	 (buf rmail-buffer)
	 (cur (point))
	 message-not-found
	 (curmsg (string-to-number
		  (buffer-substring (point)
				    (min (point-max) (+ 6 (point))))))
1252
	 (total (with-current-buffer buf rmail-total-messages)))
1253 1254 1255 1256
    ;; CURMSG should be nil when there's no current summary message
    ;; (for instance, if the summary is empty).
    (if (= curmsg 0)
	(setq curmsg nil))
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
    ;; If message number N was specified, find that message's line
    ;; or set message-not-found.
    ;; If N wasn't specified or that message can't be found.
    ;; set N by default.
    (if (not n)
	(setq n curmsg)
      (if (< n 1)
	  (progn (message "No preceding message")
		 (setq n 1)))
      (if (and (> n total)
	       (> total 0))
	  (progn (message "No following message")
		 (goto-char (point-max))
		 (rmail-summary-goto-msg nil nowarn skip-rmail)))
      (goto-char (point-min))
      (if (not (re-search-forward (format "^%5d[^0-9]" n) nil t))
	  (progn (or nowarn (message "Message %d not found" n))
		 (setq n curmsg)
		 (setq message-not-found t)
		 (goto-char cur))))
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
    ;; N can be nil now, along with CURMSG,
    ;; if the summary is empty.
    (when n
      (rmail-summary-mark-seen n)
      (rmail-summary-update-highlight message-not-found)
      (beginning-of-line)
      (unless skip-rmail
	(let ((selwin (selected-window)))
	  (unwind-protect
	      (progn (rmail-pop-to-buffer buf)
		     (rmail-show-message n))
	    (select-window selwin)
	    ;; The actions above can alter the current buffer.  Preserve it.
	    (set-buffer obuf)))))
1291
    (not message-not-found)))
1292 1293 1294 1295 1296 1297 1298 1299

;; Update the highlighted line in an rmail summary buffer.
;; That should be current.  We highlight the line point is on.
;; If NOT-FOUND is non-nil, we turn off highlighting.
(defun rmail-summary-update-highlight (not-found)
  ;; Make sure we have an overlay to use.
  (or rmail-summary-overlay
      (progn
Stefan Kangas's avatar
Stefan Kangas committed
1300
        (setq-local rmail-summary-overlay (make-overlay (point) (point)))
1301
	(overlay-put rmail-summary-overlay 'rmail-summary t)))
1302 1303 1304 1305 1306 1307 1308 1309
  ;; If this message is in the summary, use the overlay to highlight it.
  ;; Otherwise, don't highlight anything.
  (if not-found
      (overlay-put rmail-summary-overlay 'face nil)
    (move-overlay rmail-summary-overlay
		  (save-excursion (beginning-of-line)
				  (skip-chars-forward " ")
				  (point))
1310
		  (line-end-position))
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
    (overlay-put rmail-summary-overlay 'face 'highlight)))

(defun rmail-summary-scroll-msg-up (&optional dist)
  "Scroll the Rmail window forward.
If the Rmail window is displaying the end of a message,
advance to the next message."
  (interactive "P")
  (if (eq dist '-)
      (rmail-summary-scroll-msg-down nil)
    (let ((rmail-buffer-window (get-buffer-window rmail-buffer)))
      (if rmail-buffer-window
	  (if (let ((rmail-summary-window (selected-window)))
		(select-window rmail-buffer-window)
		(prog1
		    ;; Is EOB visible in the buffer?
1326
                    (pos-visible-in-window-p (point-max))
1327 1328