|
0
|
1 ;;; Summary gathering and formatting routines for VM
|
|
20
|
2 ;;; Copyright (C) 1989-1995 Kyle E. Jones
|
|
0
|
3 ;;;
|
|
|
4 ;;; This program is free software; you can redistribute it and/or modify
|
|
|
5 ;;; it under the terms of the GNU General Public License as published by
|
|
|
6 ;;; the Free Software Foundation; either version 1, or (at your option)
|
|
|
7 ;;; any later version.
|
|
|
8 ;;;
|
|
|
9 ;;; This program is distributed in the hope that it will be useful,
|
|
|
10 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
11 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
12 ;;; GNU General Public License for more details.
|
|
|
13 ;;;
|
|
|
14 ;;; You should have received a copy of the GNU General Public License
|
|
|
15 ;;; along with this program; if not, write to the Free Software
|
|
|
16 ;;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
17
|
|
|
18 (provide 'vm-summary)
|
|
|
19
|
|
|
20 (defun vm-summary-mode-internal ()
|
|
|
21 (setq mode-name "VM Summary"
|
|
|
22 major-mode 'vm-summary-mode
|
|
|
23 mode-line-format vm-mode-line-format
|
|
|
24 ;; must come after the setting of major-mode
|
|
20
|
25 mode-popup-menu (and vm-use-menus vm-popup-menu-on-mouse-3
|
|
0
|
26 (vm-menu-support-possible-p)
|
|
|
27 (vm-menu-mode-menu))
|
|
|
28 buffer-read-only t
|
|
|
29 vm-summary-pointer nil
|
|
|
30 vm-summary-=> (if (stringp vm-summary-arrow) vm-summary-arrow "")
|
|
|
31 vm-summary-no-=> (make-string (length vm-summary-=>) ? )
|
|
|
32 truncate-lines t)
|
|
|
33 ;; horizontal scrollbar off by default
|
|
|
34 ;; user can turn it on in summary hook if desired.
|
|
|
35 (and (fboundp 'set-specifier)
|
|
|
36 scrollbar-height
|
|
|
37 (set-specifier scrollbar-height (cons (current-buffer) 0)))
|
|
|
38 (use-local-map vm-summary-mode-map)
|
|
|
39 (and (vm-menu-support-possible-p)
|
|
|
40 (vm-menu-install-menus))
|
|
20
|
41 (and vm-mouse-track-summary
|
|
|
42 (vm-mouse-support-possible-p)
|
|
0
|
43 (vm-mouse-xemacs-mouse-p)
|
|
|
44 (add-hook 'mode-motion-hook 'mode-motion-highlight-line))
|
|
|
45 (if (or vm-frame-per-folder vm-frame-per-summary)
|
|
|
46 (vm-set-hooks-for-frame-deletion))
|
|
|
47 (run-hooks 'vm-summary-mode-hook)
|
|
|
48 ;; Lucid Emacs apparently used this name
|
|
|
49 (run-hooks 'vm-summary-mode-hooks))
|
|
|
50
|
|
|
51 (fset 'vm-summary-mode 'vm-mode)
|
|
|
52 (put 'vm-summary-mode 'mode-class 'special)
|
|
|
53
|
|
20
|
54 (defun vm-summarize (&optional display raise)
|
|
0
|
55 "Summarize the contents of the folder in a summary buffer.
|
|
|
56 The format is as described by the variable vm-summary-format. Generally
|
|
|
57 one line per message is most pleasing to the eye but this is not
|
|
|
58 mandatory."
|
|
20
|
59 (interactive "p\np")
|
|
0
|
60 (vm-select-folder-buffer)
|
|
|
61 (vm-check-for-killed-summary)
|
|
|
62 (if (null vm-summary-buffer)
|
|
|
63 (let ((b (current-buffer))
|
|
|
64 (read-only vm-folder-read-only))
|
|
|
65 (setq vm-summary-buffer
|
|
|
66 (get-buffer-create (format "%s Summary" (buffer-name))))
|
|
|
67 (save-excursion
|
|
|
68 (set-buffer vm-summary-buffer)
|
|
|
69 (abbrev-mode 0)
|
|
|
70 (auto-fill-mode 0)
|
|
|
71 (if (fboundp 'buffer-disable-undo)
|
|
|
72 (buffer-disable-undo (current-buffer))
|
|
|
73 ;; obfuscation to make the v19 compiler not whine
|
|
|
74 ;; about obsolete functions.
|
|
|
75 (let ((x 'buffer-flush-undo))
|
|
|
76 (funcall x (current-buffer))))
|
|
|
77 (setq vm-mail-buffer b
|
|
|
78 vm-folder-read-only read-only)
|
|
|
79 (vm-summary-mode-internal))
|
|
|
80 (vm-set-summary-redo-start-point t)))
|
|
|
81 (if display
|
|
|
82 (save-excursion
|
|
20
|
83 (vm-goto-new-summary-frame-maybe)
|
|
0
|
84 (vm-display vm-summary-buffer t
|
|
|
85 '(vm-summarize
|
|
|
86 vm-summarize-other-frame)
|
|
20
|
87 (list this-command) (not raise))
|
|
0
|
88 ;; need to do this after any frame creation because the
|
|
|
89 ;; toolbar sets frame-specific height and width specifiers.
|
|
|
90 (set-buffer vm-summary-buffer)
|
|
|
91 (and (vm-toolbar-support-possible-p) vm-use-toolbar
|
|
|
92 (vm-toolbar-install-toolbar)))
|
|
|
93 (vm-display nil nil '(vm-summarize vm-summarize-other-frame)
|
|
|
94 (list this-command)))
|
|
|
95 (vm-update-summary-and-mode-line))
|
|
|
96
|
|
|
97 (defun vm-summarize-other-frame (&optional display)
|
|
|
98 "Like vm-summarize, but run in a newly created frame."
|
|
|
99 (interactive "p")
|
|
|
100 (if (vm-multiple-frames-possible-p)
|
|
|
101 (vm-goto-new-frame 'summary))
|
|
|
102 (vm-summarize display)
|
|
|
103 (if (vm-multiple-frames-possible-p)
|
|
|
104 (vm-set-hooks-for-frame-deletion)))
|
|
|
105
|
|
|
106 (defun vm-do-summary (&optional start-point)
|
|
|
107 (let ((m-list (or start-point vm-message-list))
|
|
|
108 mp
|
|
|
109 (n 0)
|
|
|
110 ;; Just for laughs, make the update interval vary.
|
|
|
111 (modulus (+ (% (vm-abs (random)) 11) 10))
|
|
|
112 (mouse-track-func
|
|
20
|
113 (and vm-mouse-track-summary
|
|
|
114 (vm-mouse-support-possible-p)
|
|
0
|
115 (vm-mouse-fsfemacs-mouse-p)
|
|
|
116 (function vm-mouse-set-mouse-track-highlight)))
|
|
|
117 summary)
|
|
|
118 (setq mp m-list)
|
|
|
119 (save-excursion
|
|
|
120 (set-buffer vm-summary-buffer)
|
|
|
121 (let ((buffer-read-only nil)
|
|
|
122 (modified (buffer-modified-p)))
|
|
|
123 (unwind-protect
|
|
|
124 (progn
|
|
|
125 (if start-point
|
|
|
126 (if (vm-su-start-of (car mp))
|
|
|
127 (progn
|
|
|
128 (goto-char (vm-su-start-of (car mp)))
|
|
|
129 (delete-region (point) (point-max)))
|
|
|
130 (goto-char (point-max)))
|
|
|
131 (erase-buffer)
|
|
|
132 (setq vm-summary-pointer nil))
|
|
|
133 ;; avoid doing long runs down the marker chain while
|
|
|
134 ;; building the summary. use integers to store positions
|
|
|
135 ;; and then convert them to markers after all the
|
|
|
136 ;; insertions are done.
|
|
|
137 (while mp
|
|
|
138 (setq summary (vm-su-summary (car mp)))
|
|
|
139 (vm-set-su-start-of (car mp) (point))
|
|
|
140 (insert vm-summary-no-=>)
|
|
|
141 (vm-tokenized-summary-insert (car mp) (vm-su-summary (car mp)))
|
|
|
142 (vm-set-su-end-of (car mp) (point))
|
|
|
143 (setq mp (cdr mp) n (1+ n))
|
|
|
144 (if (zerop (% n modulus))
|
|
|
145 (vm-unsaved-message "Generating summary... %d" n)))
|
|
|
146 ;; now convert the ints to markers.
|
|
|
147 (if (>= n modulus)
|
|
|
148 (vm-unsaved-message "Generating summary markers... "))
|
|
|
149 (setq mp m-list)
|
|
|
150 (while mp
|
|
|
151 (and mouse-track-func (funcall mouse-track-func
|
|
|
152 (vm-su-start-of (car mp))
|
|
|
153 (vm-su-end-of (car mp))))
|
|
|
154 (vm-set-su-start-of (car mp) (vm-marker (vm-su-start-of (car mp))))
|
|
|
155 (vm-set-su-end-of (car mp) (vm-marker (vm-su-end-of (car mp))))
|
|
|
156 (setq mp (cdr mp))))
|
|
|
157 (set-buffer-modified-p modified))
|
|
|
158 (run-hooks 'vm-summary-redo-hook)))
|
|
|
159 (if (>= n modulus)
|
|
|
160 (vm-unsaved-message "Generating summary... done"))))
|
|
|
161
|
|
|
162 (defun vm-do-needed-summary-rebuild ()
|
|
|
163 (if (and vm-summary-redo-start-point vm-summary-buffer)
|
|
|
164 (progn
|
|
|
165 (vm-copy-local-variables vm-summary-buffer 'vm-summary-show-threads)
|
|
|
166 (vm-do-summary (and (consp vm-summary-redo-start-point)
|
|
|
167 vm-summary-redo-start-point))
|
|
|
168 (setq vm-summary-redo-start-point nil)
|
|
|
169 (and vm-message-pointer
|
|
|
170 (vm-set-summary-pointer (car vm-message-pointer)))
|
|
|
171 (setq vm-need-summary-pointer-update nil))
|
|
|
172 (and vm-need-summary-pointer-update
|
|
|
173 vm-summary-buffer
|
|
|
174 vm-message-pointer
|
|
|
175 (progn
|
|
|
176 (vm-set-summary-pointer (car vm-message-pointer))
|
|
|
177 (setq vm-need-summary-pointer-update nil)))))
|
|
|
178
|
|
|
179 (defun vm-update-message-summary (m)
|
|
|
180 (if (and (vm-su-start-of m)
|
|
|
181 (marker-buffer (vm-su-start-of m)))
|
|
|
182 (let ((modified (buffer-modified-p))
|
|
|
183 (mouse-track-func
|
|
20
|
184 (and vm-mouse-track-summary
|
|
|
185 (vm-mouse-support-possible-p)
|
|
0
|
186 (vm-mouse-fsfemacs-mouse-p)
|
|
|
187 (function vm-mouse-set-mouse-track-highlight)))
|
|
|
188 summary)
|
|
|
189 (save-excursion
|
|
|
190 (setq summary (vm-su-summary m))
|
|
|
191 (set-buffer (marker-buffer (vm-su-start-of m)))
|
|
|
192 (let ((buffer-read-only nil)
|
|
|
193 (selected nil)
|
|
|
194 (modified (buffer-modified-p)))
|
|
|
195 (unwind-protect
|
|
|
196 (save-excursion
|
|
|
197 (goto-char (vm-su-start-of m))
|
|
|
198 (setq selected (not (looking-at vm-summary-no-=>)))
|
|
|
199 ;; We do a little dance to update the text in
|
|
20
|
200 ;; order to make the markers in the text do
|
|
0
|
201 ;; what we want.
|
|
|
202 ;;
|
|
|
203 ;; 1. We need to avoid having the su-start-of
|
|
|
204 ;; and su-end-of market clumping together at
|
|
|
205 ;; the start position.
|
|
|
206 ;;
|
|
|
207 ;; 2. We want the window point market (w->pointm
|
|
|
208 ;; in the Emacs display code) to move to the
|
|
|
209 ;; start of the summary entry if it is
|
|
|
210 ;; anywhere within the su-start-of to
|
|
|
211 ;; su-end-of region.
|
|
|
212 ;;
|
|
|
213 ;; We achieve (2) by deleting before inserting.
|
|
|
214 ;; Reversing the order of insertion/deletion
|
|
|
215 ;; pushes the point marker into the next
|
|
|
216 ;; summary entry. We achieve (1) by inserting a
|
|
|
217 ;; placeholder character at the end of the
|
|
|
218 ;; summary entry before deleting the region.
|
|
|
219 (goto-char (vm-su-end-of m))
|
|
|
220 (insert-before-markers "z")
|
|
|
221 (goto-char (vm-su-start-of m))
|
|
|
222 (delete-region (point) (1- (vm-su-end-of m)))
|
|
|
223 (if (not selected)
|
|
|
224 (insert vm-summary-no-=>)
|
|
|
225 (insert vm-summary-=>))
|
|
|
226 (vm-tokenized-summary-insert m (vm-su-summary m))
|
|
|
227 (delete-char 1)
|
|
|
228 (run-hooks 'vm-summary-update-hook)
|
|
|
229 (and mouse-track-func (funcall mouse-track-func
|
|
|
230 (vm-su-start-of m)
|
|
|
231 (vm-su-end-of m)))
|
|
|
232 (if (and selected vm-summary-highlight-face)
|
|
|
233 (vm-summary-highlight-region (vm-su-start-of m) (point)
|
|
|
234 vm-summary-highlight-face)))
|
|
|
235 (set-buffer-modified-p modified)))))))
|
|
|
236
|
|
|
237 (defun vm-set-summary-pointer (m)
|
|
|
238 (if vm-summary-buffer
|
|
|
239 (let ((w (vm-get-visible-buffer-window vm-summary-buffer))
|
|
|
240 (mouse-track-func
|
|
20
|
241 (and vm-mouse-track-summary
|
|
|
242 (vm-mouse-support-possible-p)
|
|
0
|
243 (vm-mouse-fsfemacs-mouse-p)
|
|
|
244 (function vm-mouse-set-mouse-track-highlight)))
|
|
|
245 (old-window nil))
|
|
|
246 (vm-save-buffer-excursion
|
|
|
247 (unwind-protect
|
|
|
248 (progn
|
|
|
249 (set-buffer vm-summary-buffer)
|
|
|
250 (if w
|
|
|
251 (progn
|
|
|
252 (setq old-window (selected-window))
|
|
|
253 (select-window w)))
|
|
|
254 (let ((buffer-read-only nil))
|
|
|
255 (if (and vm-summary-pointer
|
|
|
256 (vm-su-start-of vm-summary-pointer))
|
|
|
257 (progn
|
|
|
258 (goto-char (vm-su-start-of vm-summary-pointer))
|
|
|
259 (insert vm-summary-no-=>)
|
|
|
260 (delete-char (length vm-summary-=>))
|
|
|
261 (and mouse-track-func
|
|
|
262 (funcall mouse-track-func
|
|
|
263 (- (point) (length vm-summary-=>))
|
|
|
264 (point)))))
|
|
|
265 (setq vm-summary-pointer m)
|
|
|
266 (goto-char (vm-su-start-of m))
|
|
|
267 (let ((modified (buffer-modified-p)))
|
|
|
268 (unwind-protect
|
|
|
269 (progn
|
|
|
270 (insert vm-summary-=>)
|
|
|
271 (delete-char (length vm-summary-=>))
|
|
|
272 (and mouse-track-func
|
|
|
273 (funcall mouse-track-func
|
|
|
274 (- (point) (length vm-summary-=>))
|
|
|
275 (point))))
|
|
|
276 (set-buffer-modified-p modified)))
|
|
|
277 (forward-char (- (length vm-summary-=>)))
|
|
|
278 (if vm-summary-highlight-face
|
|
|
279 (vm-summary-highlight-region
|
|
|
280 (vm-su-start-of m) (vm-su-end-of m)
|
|
|
281 vm-summary-highlight-face))
|
|
|
282 (and w vm-auto-center-summary (vm-auto-center-summary))
|
|
|
283 (run-hooks 'vm-summary-pointer-update-hook)))
|
|
|
284 (and old-window (select-window old-window)))))))
|
|
|
285
|
|
|
286 (defun vm-summary-highlight-region (start end face)
|
|
|
287 (cond ((fboundp 'make-overlay)
|
|
|
288 (if (and vm-summary-overlay (overlay-buffer vm-summary-overlay))
|
|
|
289 (move-overlay vm-summary-overlay start end)
|
|
|
290 (setq vm-summary-overlay (make-overlay start end))
|
|
|
291 (overlay-put vm-summary-overlay 'evaporate nil)
|
|
|
292 (overlay-put vm-summary-overlay 'face face)))
|
|
|
293 ((fboundp 'make-extent)
|
|
|
294 (if (and vm-summary-overlay (extent-end-position vm-summary-overlay))
|
|
|
295 (set-extent-endpoints vm-summary-overlay start end)
|
|
|
296 (setq vm-summary-overlay (make-extent start end))
|
|
20
|
297 ;; the reason this isn't needed under FSF Emacs is
|
|
24
|
298 ;; that insert-before-markers also inserts before
|
|
20
|
299 ;; overlays! so a summary update of an entry just
|
|
|
300 ;; before this overlay in the summary buffer won't
|
|
|
301 ;; leak into the overlay, but it _will_ leak into an
|
|
|
302 ;; XEmacs extent.
|
|
|
303 (set-extent-property vm-summary-overlay 'start-open t)
|
|
0
|
304 (set-extent-property vm-summary-overlay 'detachable nil)
|
|
|
305 (set-extent-property vm-summary-overlay 'face face)))))
|
|
|
306
|
|
|
307 (defun vm-auto-center-summary ()
|
|
|
308 (if vm-auto-center-summary
|
|
|
309 (if (or (eq vm-auto-center-summary t) (not (one-window-p t)))
|
|
|
310 (recenter '(4)))))
|
|
|
311
|
|
|
312 (defun vm-sprintf (format-variable message &optional tokenize)
|
|
|
313 ;; compile the format into an eval'able s-expression
|
|
|
314 ;; if it hasn't been compiled already.
|
|
|
315 (if (not (eq (get format-variable 'vm-compiled-format)
|
|
|
316 (symbol-value format-variable)))
|
|
|
317 (vm-compile-format format-variable tokenize))
|
|
|
318 ;; The local variable name `vm-su-message' is mandatory here for
|
|
|
319 ;; the format s-expression to work.
|
|
|
320 (let ((vm-su-message message))
|
|
|
321 (eval (get format-variable 'vm-format-sexp))))
|
|
|
322
|
|
|
323 (defun vm-tokenized-summary-insert (message tokens)
|
|
|
324 (if (stringp tokens)
|
|
|
325 (insert tokens)
|
|
|
326 (let (token)
|
|
|
327 (while tokens
|
|
|
328 (setq token (car tokens))
|
|
|
329 (cond ((stringp token)
|
|
24
|
330 (if vm-display-using-mime
|
|
|
331 (insert (vm-decode-mime-encoded-words-in-string token))
|
|
|
332 (insert token)))
|
|
0
|
333 ((eq token 'number)
|
|
|
334 (insert (vm-padded-number-of message)))
|
|
|
335 ((eq token 'mark)
|
|
|
336 (insert (vm-su-mark message)))
|
|
|
337 ((eq token 'thread-indent)
|
|
|
338 (if (and vm-summary-show-threads
|
|
|
339 (natnump vm-summary-thread-indent-level))
|
|
|
340 (insert-char ?\ (* vm-summary-thread-indent-level
|
|
|
341 (vm-th-thread-indentation message))))))
|
|
|
342 (setq tokens (cdr tokens))))))
|
|
|
343
|
|
|
344 (defun vm-compile-format (format-variable &optional tokenize)
|
|
|
345 (let ((format (symbol-value format-variable))
|
|
|
346 (case-fold-search nil)
|
|
|
347 (done nil)
|
|
|
348 (list nil)
|
|
|
349 (sexp nil)
|
|
|
350 (sexp-fmt nil)
|
|
|
351 (last-match-end 0)
|
|
|
352 token conv-spec)
|
|
|
353 (store-match-data nil)
|
|
|
354 (while (not done)
|
|
|
355 (setq token nil)
|
|
|
356 (while
|
|
|
357 (and (not token)
|
|
|
358 (string-match
|
|
|
359 "%\\(-\\)?\\([0-9]+\\)?\\(\\.\\(-?[0-9]+\\)\\)?\\([aAcdfFhHiIlLmMnstTwyz*%]\\|U[A-Za-z]\\)"
|
|
|
360 format (match-end 0)))
|
|
|
361 (setq conv-spec (aref format (match-beginning 5)))
|
|
|
362 (if (memq conv-spec '(?a ?A ?c ?d ?f ?F ?h ?H ?i ?L ?I ?l ?M
|
|
|
363 ?m ?n ?s ?t ?T ?U ?w ?y ?z ?* ))
|
|
|
364 (progn
|
|
|
365 (cond ((= conv-spec ?a)
|
|
|
366 (setq sexp (cons (list 'vm-su-attribute-indicators
|
|
|
367 'vm-su-message) sexp)))
|
|
|
368 ((= conv-spec ?A)
|
|
|
369 (setq sexp (cons (list 'vm-su-attribute-indicators-long
|
|
|
370 'vm-su-message) sexp)))
|
|
|
371 ((= conv-spec ?c)
|
|
|
372 (setq sexp (cons (list 'vm-su-byte-count
|
|
|
373 'vm-su-message) sexp)))
|
|
|
374 ((= conv-spec ?d)
|
|
|
375 (setq sexp (cons (list 'vm-su-monthday
|
|
|
376 'vm-su-message) sexp)))
|
|
|
377 ((= conv-spec ?f)
|
|
|
378 (setq sexp (cons (list 'vm-su-interesting-from
|
|
|
379 'vm-su-message) sexp)))
|
|
|
380 ((= conv-spec ?F)
|
|
|
381 (setq sexp (cons (list 'vm-su-interesting-full-name
|
|
|
382 'vm-su-message) sexp)))
|
|
|
383 ((= conv-spec ?h)
|
|
|
384 (setq sexp (cons (list 'vm-su-hour
|
|
|
385 'vm-su-message) sexp)))
|
|
|
386 ((= conv-spec ?H)
|
|
|
387 (setq sexp (cons (list 'vm-su-hour-short
|
|
|
388 'vm-su-message) sexp)))
|
|
|
389 ((= conv-spec ?i)
|
|
|
390 (setq sexp (cons (list 'vm-su-message-id
|
|
|
391 'vm-su-message) sexp)))
|
|
|
392 ((= conv-spec ?I)
|
|
|
393 (if tokenize
|
|
|
394 (setq token ''thread-indent)
|
|
|
395 (setq sexp (cons (list 'vm-su-thread-indent
|
|
|
396 'vm-su-message) sexp))))
|
|
|
397 ((= conv-spec ?l)
|
|
|
398 (setq sexp (cons (list 'vm-su-line-count
|
|
|
399 'vm-su-message) sexp)))
|
|
|
400 ((= conv-spec ?L)
|
|
|
401 (setq sexp (cons (list 'vm-su-labels
|
|
|
402 'vm-su-message) sexp)))
|
|
|
403 ((= conv-spec ?m)
|
|
|
404 (setq sexp (cons (list 'vm-su-month
|
|
|
405 'vm-su-message) sexp)))
|
|
|
406 ((= conv-spec ?M)
|
|
|
407 (setq sexp (cons (list 'vm-su-month-number
|
|
|
408 'vm-su-message) sexp)))
|
|
|
409 ((= conv-spec ?n)
|
|
|
410 (if tokenize
|
|
|
411 (setq token ''number)
|
|
|
412 (setq sexp (cons (list 'vm-padded-number-of
|
|
|
413 'vm-su-message) sexp))))
|
|
|
414 ((= conv-spec ?s)
|
|
|
415 (setq sexp (cons (list 'vm-su-subject
|
|
|
416 'vm-su-message) sexp)))
|
|
|
417 ((= conv-spec ?T)
|
|
|
418 (setq sexp (cons (list 'vm-su-to-names
|
|
|
419 'vm-su-message) sexp)))
|
|
|
420 ((= conv-spec ?t)
|
|
|
421 (setq sexp (cons (list 'vm-su-to
|
|
|
422 'vm-su-message) sexp)))
|
|
|
423 ((= conv-spec ?U)
|
|
|
424 (setq sexp
|
|
|
425 (cons (list 'vm-run-user-summary-function
|
|
|
426 (list 'quote
|
|
|
427 (intern
|
|
|
428 (concat
|
|
|
429 "vm-summary-function-"
|
|
|
430 (substring
|
|
|
431 format
|
|
|
432 (1+ (match-beginning 5))
|
|
|
433 (+ 2 (match-beginning 5))))))
|
|
|
434 'vm-su-message) sexp)))
|
|
|
435 ((= conv-spec ?w)
|
|
|
436 (setq sexp (cons (list 'vm-su-weekday
|
|
|
437 'vm-su-message) sexp)))
|
|
|
438 ((= conv-spec ?y)
|
|
|
439 (setq sexp (cons (list 'vm-su-year
|
|
|
440 'vm-su-message) sexp)))
|
|
|
441 ((= conv-spec ?z)
|
|
|
442 (setq sexp (cons (list 'vm-su-zone
|
|
|
443 'vm-su-message) sexp)))
|
|
|
444 ((= conv-spec ?*)
|
|
|
445 (if tokenize
|
|
|
446 (setq token ''mark)
|
|
|
447 (setq sexp (cons (list 'vm-su-mark
|
|
|
448 'vm-su-message) sexp)))))
|
|
24
|
449 (cond ((and (not token) vm-display-using-mime)
|
|
|
450 (setcar sexp
|
|
|
451 (list 'vm-decode-mime-encoded-words-in-string
|
|
|
452 (car sexp)))))
|
|
0
|
453 (cond ((and (not token) (match-beginning 1))
|
|
|
454 (setcar sexp
|
|
|
455 (list 'vm-left-justify-string (car sexp)
|
|
|
456 (string-to-int
|
|
|
457 (substring format
|
|
|
458 (match-beginning 2)
|
|
|
459 (match-end 2))))))
|
|
|
460 ((and (not token) (match-beginning 2))
|
|
|
461 (setcar sexp
|
|
|
462 (list 'vm-right-justify-string (car sexp)
|
|
|
463 (string-to-int
|
|
|
464 (substring format
|
|
|
465 (match-beginning 2)
|
|
|
466 (match-end 2)))))))
|
|
|
467 (cond ((and (not token) (match-beginning 3))
|
|
|
468 (setcar sexp
|
|
|
469 (list 'vm-truncate-string (car sexp)
|
|
|
470 (string-to-int
|
|
|
471 (substring format
|
|
|
472 (match-beginning 4)
|
|
|
473 (match-end 4)))))))
|
|
24
|
474 (cond ((and (not token) vm-display-using-mime)
|
|
|
475 (setcar sexp
|
|
|
476 (list 'vm-reencode-mime-encoded-words-in-string
|
|
|
477 (car sexp)))))
|
|
0
|
478 (setq sexp-fmt
|
|
|
479 (cons (if token "" "%s")
|
|
|
480 (cons (substring format
|
|
|
481 last-match-end
|
|
|
482 (match-beginning 0))
|
|
|
483 sexp-fmt))))
|
|
|
484 (setq sexp-fmt
|
|
|
485 (cons "%%"
|
|
|
486 (cons (substring format
|
|
|
487 (or last-match-end 0)
|
|
|
488 (match-beginning 0))
|
|
|
489 sexp-fmt))))
|
|
|
490 (setq last-match-end (match-end 0)))
|
|
|
491 (if (not token)
|
|
|
492 (setq sexp-fmt
|
|
|
493 (cons (substring format last-match-end (length format))
|
|
|
494 sexp-fmt)
|
|
|
495 done t))
|
|
|
496 (setq sexp-fmt (apply 'concat (nreverse sexp-fmt)))
|
|
|
497 (if sexp
|
|
|
498 (setq sexp (cons 'format (cons sexp-fmt (nreverse sexp))))
|
|
|
499 (setq sexp sexp-fmt))
|
|
|
500 (if tokenize
|
|
|
501 (setq list (nconc list (if (equal sexp "") nil (list sexp))
|
|
|
502 (and token (list token)))
|
|
|
503 sexp nil
|
|
|
504 sexp-fmt nil)))
|
|
|
505 (put format-variable 'vm-compiled-format format)
|
|
|
506 (put format-variable 'vm-format-sexp (if list (cons 'list list) sexp))))
|
|
|
507
|
|
20
|
508 (defun vm-get-header-contents (message header-name-regexp &optional clump-sep)
|
|
0
|
509 (let ((contents nil)
|
|
|
510 regexp)
|
|
|
511 (setq regexp (concat "^\\(" header-name-regexp "\\)")
|
|
|
512 message (vm-real-message-of message))
|
|
|
513 (save-excursion
|
|
|
514 (set-buffer (vm-buffer-of (vm-real-message-of message)))
|
|
|
515 (save-restriction
|
|
|
516 (widen)
|
|
|
517 (goto-char (vm-headers-of message))
|
|
|
518 (let ((case-fold-search t))
|
|
20
|
519 (while (and (or (null contents) clump-sep)
|
|
|
520 (re-search-forward regexp (vm-text-of message) t)
|
|
0
|
521 (save-excursion (goto-char (match-beginning 0))
|
|
|
522 (vm-match-header)))
|
|
|
523 (if contents
|
|
|
524 (setq contents
|
|
20
|
525 (concat contents clump-sep (vm-matched-header-contents)))
|
|
0
|
526 (setq contents (vm-matched-header-contents))))))
|
|
|
527 contents )))
|
|
|
528
|
|
|
529 (defun vm-left-justify-string (string width)
|
|
|
530 (if (>= (length string) width)
|
|
|
531 string
|
|
|
532 (concat string (make-string (- width (length string)) ?\ ))))
|
|
|
533
|
|
|
534 (defun vm-right-justify-string (string width)
|
|
|
535 (if (>= (length string) width)
|
|
|
536 string
|
|
|
537 (concat (make-string (- width (length string)) ?\ ) string)))
|
|
|
538
|
|
|
539 (defun vm-truncate-string (string width)
|
|
24
|
540 (cond
|
|
|
541 ;; doesn't work because the width of wide chars such as the Kanji
|
|
|
542 ;; glyphs as not even multiples of the default face's font width.
|
|
|
543 ;; ((fboundp 'char-width)
|
|
|
544 ;; (let ((i 0)
|
|
|
545 ;; (lim (length string))
|
|
|
546 ;; (total 0))
|
|
|
547 ;; (while (and (< i lim) (<= total width))
|
|
|
548 ;; (setq total (+ total (char-width (aref string i)))
|
|
|
549 ;; i (1+ i)))
|
|
|
550 ;; (if (<= total width)
|
|
|
551 ;; string
|
|
|
552 ;; (substring string 0 (1- i)))))
|
|
|
553 ((<= (length string) width)
|
|
0
|
554 string)
|
|
|
555 ((< width 0)
|
|
|
556 (substring string width))
|
|
|
557 (t
|
|
|
558 (substring string 0 width))))
|
|
|
559
|
|
|
560 (defun vm-su-attribute-indicators (m)
|
|
|
561 (concat
|
|
|
562 (cond ((vm-deleted-flag m) "D")
|
|
|
563 ((vm-new-flag m) "N")
|
|
|
564 ((vm-unread-flag m) "U")
|
|
|
565 (t " "))
|
|
|
566 (cond ((vm-filed-flag m) "F")
|
|
|
567 ((vm-written-flag m) "W")
|
|
|
568 (t " "))
|
|
|
569 (cond ((vm-replied-flag m) "R")
|
|
|
570 ((vm-forwarded-flag m) "Z")
|
|
|
571 ((vm-redistributed-flag m) "B")
|
|
|
572 (t " "))
|
|
|
573 (cond ((vm-edited-flag m) "E")
|
|
|
574 (t " "))))
|
|
|
575
|
|
|
576 (defun vm-su-attribute-indicators-long (m)
|
|
|
577 (concat
|
|
|
578 (cond ((vm-deleted-flag m) "D")
|
|
|
579 ((vm-new-flag m) "N")
|
|
|
580 ((vm-unread-flag m) "U")
|
|
|
581 (t " "))
|
|
|
582 (if (vm-replied-flag m) "r" " ")
|
|
|
583 (if (vm-forwarded-flag m) "z" " ")
|
|
|
584 (if (vm-redistributed-flag m) "b" " ")
|
|
|
585 (if (vm-filed-flag m) "f" " ")
|
|
|
586 (if (vm-written-flag m) "w" " ")
|
|
|
587 (if (vm-edited-flag m) "e" " ")))
|
|
|
588
|
|
|
589 (defun vm-su-byte-count (m)
|
|
|
590 (or (vm-byte-count-of m)
|
|
|
591 (vm-set-byte-count-of
|
|
|
592 m
|
|
|
593 (int-to-string
|
|
|
594 (- (vm-text-end-of (vm-real-message-of m))
|
|
|
595 (vm-text-of (vm-real-message-of m)))))))
|
|
|
596
|
|
|
597 (defun vm-su-weekday (m)
|
|
|
598 (or (vm-weekday-of m)
|
|
|
599 (progn (vm-su-do-date m) (vm-weekday-of m))))
|
|
|
600
|
|
|
601 (defun vm-su-monthday (m)
|
|
|
602 (or (vm-monthday-of m)
|
|
|
603 (progn (vm-su-do-date m) (vm-monthday-of m))))
|
|
|
604
|
|
|
605 (defun vm-su-month (m)
|
|
|
606 (or (vm-month-of m)
|
|
|
607 (progn (vm-su-do-date m) (vm-month-of m))))
|
|
|
608
|
|
|
609 (defun vm-su-month-number (m)
|
|
|
610 (or (vm-month-number-of m)
|
|
|
611 (progn (vm-su-do-date m) (vm-month-number-of m))))
|
|
|
612
|
|
|
613 (defun vm-su-year (m)
|
|
|
614 (or (vm-year-of m)
|
|
|
615 (progn (vm-su-do-date m) (vm-year-of m))))
|
|
|
616
|
|
|
617 (defun vm-su-hour-short (m)
|
|
|
618 (let ((string (vm-su-hour m)))
|
|
|
619 (if (> (length string) 5)
|
|
|
620 (substring string 0 5)
|
|
|
621 string)))
|
|
|
622
|
|
|
623 (defun vm-su-hour (m)
|
|
|
624 (or (vm-hour-of m)
|
|
|
625 (progn (vm-su-do-date m) (vm-hour-of m))))
|
|
|
626
|
|
|
627 (defun vm-su-zone (m)
|
|
|
628 (or (vm-zone-of m)
|
|
|
629 (progn (vm-su-do-date m) (vm-zone-of m))))
|
|
|
630
|
|
|
631 (defun vm-su-mark (m) (if (vm-mark-of m) "*" " "))
|
|
|
632
|
|
|
633 ;; Some yogurt-headed delivery agents don't provide a Date: header.
|
|
|
634 (defun vm-grok-From_-date (message)
|
|
|
635 ;; This works only on the From_ types, obviously
|
|
|
636 (if (not (memq (vm-message-type-of message)
|
|
|
637 '(From_ From_-with-Content-Length)))
|
|
|
638 nil
|
|
|
639 (save-excursion
|
|
|
640 (set-buffer (vm-buffer-of (vm-real-message-of message)))
|
|
20
|
641 (save-excursion
|
|
|
642 (save-restriction
|
|
|
643 (widen)
|
|
|
644 (goto-char (vm-start-of message))
|
|
|
645 (let ((case-fold-search nil))
|
|
|
646 (if (or (looking-at
|
|
|
647 ;; special case this so that the "remote from blah"
|
|
|
648 ;; isn't included.
|
|
|
649 "From [^ \t\n]*[ \t]+\\([^ \t\n].*\\) remote from .*")
|
|
|
650 (looking-at "From [^ \t\n]*[ \t]+\\([^ \t\n].*\\)"))
|
|
|
651 (vm-buffer-substring-no-properties
|
|
|
652 (match-beginning 1)
|
|
|
653 (match-end 1)))))))))
|
|
0
|
654
|
|
|
655 (defun vm-parse-date (date)
|
|
|
656 (let ((weekday "")
|
|
|
657 (monthday "")
|
|
|
658 (month "")
|
|
|
659 (year "")
|
|
|
660 (hour "")
|
|
|
661 (timezone "")
|
|
|
662 (start nil)
|
|
|
663 string
|
|
|
664 (case-fold-search t))
|
|
|
665 (if (string-match "sun\\|mon\\|tue\\|wed\\|thu\\|fri\\|sat" date)
|
|
|
666 (setq weekday (substring date (match-beginning 0) (match-end 0))))
|
|
|
667 (if (string-match "jan\\|feb\\|mar\\|apr\\|may\\|jun\\|jul\\|aug\\|sep\\|oct\\|nov\\|dec" date)
|
|
|
668 (setq month (substring date (match-beginning 0) (match-end 0))))
|
|
|
669 (if (string-match "[0-9]?[0-9]:[0-9][0-9]\\(:[0-9][0-9]\\)?" date)
|
|
|
670 (setq hour (substring date (match-beginning 0) (match-end 0))))
|
|
|
671 (if (or (string-match "[^a-z][+---][0-9][0-9][0-9][0-9]" date)
|
|
|
672 (string-match "e[ds]t\\|c[ds]t\\|p[ds]t\\|m[ds]t" date)
|
|
|
673 (string-match "ast\\|nst\\|met\\|eet\\|jst\\|bst\\|ut" date)
|
|
|
674 (string-match "gmt\\([+---][0-9]+\\)?" date))
|
|
|
675 (setq timezone (substring date (match-beginning 0) (match-end 0))))
|
|
|
676 (while (string-match "\\(\\`\\|[^:+---0-9]\\|[a-z]-\\)[0-9]+\\(\\'\\|[^:]\\)"
|
|
|
677 date start)
|
|
|
678 (setq string (substring date (match-end 1) (match-beginning 2))
|
|
|
679 start (match-end 0))
|
|
|
680 (cond ((string-match "\\`[4-9]." string)
|
|
|
681 ;; Assume that any two digits less than 40 are a date and not
|
|
|
682 ;; a year. The world will surely end soon.
|
|
|
683 (setq year (concat "19" string)))
|
|
|
684 ((< (length string) 3)
|
|
|
685 (setq monthday string))
|
|
|
686 (t (setq year string))))
|
|
|
687
|
|
|
688 (aset vm-parse-date-workspace 0 weekday)
|
|
|
689 (aset vm-parse-date-workspace 1 monthday)
|
|
|
690 (aset vm-parse-date-workspace 2 month)
|
|
|
691 (aset vm-parse-date-workspace 3 year)
|
|
|
692 (aset vm-parse-date-workspace 4 hour)
|
|
|
693 (aset vm-parse-date-workspace 5 timezone)
|
|
|
694 vm-parse-date-workspace))
|
|
|
695
|
|
|
696 (defun vm-su-do-date (m)
|
|
|
697 (let ((case-fold-search t)
|
|
|
698 vector date)
|
|
|
699 (setq date (or (vm-get-header-contents m "Date:") (vm-grok-From_-date m)))
|
|
|
700 (cond
|
|
|
701 ((null date)
|
|
|
702 (vm-set-weekday-of m "")
|
|
|
703 (vm-set-monthday-of m "")
|
|
|
704 (vm-set-month-of m "")
|
|
|
705 (vm-set-month-number-of m "")
|
|
|
706 (vm-set-year-of m "")
|
|
|
707 (vm-set-hour-of m "")
|
|
|
708 (vm-set-zone-of m ""))
|
|
|
709 ((string-match
|
|
|
710 ;; The date format recognized here is the one specified in RFC 822.
|
|
|
711 ;; Some slop is allowed e.g. dashes between the monthday, month and year
|
|
|
712 ;; because such malformed headers have been observed.
|
|
|
713 "\\(\\([a-z][a-z][a-z]\\),\\)?[ \t\n]*\\([0-9][0-9]?\\)[ \t\n---]*\\([a-z][a-z][a-z]\\)[ \t\n---]*\\([0-9]*[0-9][0-9]\\)[ \t\n]*\\([0-9:]+\\)[ \t\n]*\\([a-z][a-z]?[a-z]?\\|[---+][0-9][0-9][0-9][0-9]\\)"
|
|
|
714 date)
|
|
|
715 (if (match-beginning 2)
|
|
|
716 (vm-set-weekday-of m (substring date (match-beginning 2)
|
|
|
717 (match-end 2)))
|
|
|
718 (vm-set-weekday-of m ""))
|
|
|
719 (vm-set-monthday-of m (substring date (match-beginning 3) (match-end 3)))
|
|
|
720 (vm-su-do-month m (substring date (match-beginning 4) (match-end 4)))
|
|
|
721 (vm-set-year-of m (substring date (match-beginning 5) (match-end 5)))
|
|
|
722 (if (= 2 (length (vm-year-of m)))
|
|
|
723 (vm-set-year-of m (concat "19" (vm-year-of m))))
|
|
|
724 (vm-set-hour-of m (substring date (match-beginning 6) (match-end 6)))
|
|
|
725 (vm-set-zone-of m (substring date (match-beginning 7) (match-end 7))))
|
|
|
726 ((string-match
|
|
|
727 ;; UNIX ctime(3) format, with slop allowed in the whitespace, and we allow for
|
|
|
728 ;; the possibility of a timezone at the end.
|
|
|
729 "\\([a-z][a-z][a-z]\\)[ \t\n]*\\([a-z][a-z][a-z]\\)[ \t\n]*\\([0-9][0-9]?\\)[ \t\n]*\\([0-9:]+\\)[ \t\n]*\\([0-9][0-9][0-9][0-9]\\)[ \t\n]*\\([a-z][a-z]?[a-z]?\\|[---+][0-9][0-9][0-9][0-9]\\)?"
|
|
|
730 date)
|
|
|
731 (vm-set-weekday-of m (substring date (match-beginning 1) (match-end 1)))
|
|
|
732 (vm-su-do-month m (substring date (match-beginning 2) (match-end 2)))
|
|
|
733 (vm-set-monthday-of m (substring date (match-beginning 3) (match-end 3)))
|
|
|
734 (vm-set-hour-of m (substring date (match-beginning 4) (match-end 4)))
|
|
|
735 (vm-set-year-of m (substring date (match-beginning 5) (match-end 5)))
|
|
|
736 (if (match-beginning 6)
|
|
|
737 (vm-set-zone-of m (substring date (match-beginning 6)
|
|
|
738 (match-end 6)))))
|
|
|
739 (t
|
|
|
740 (setq vector (vm-parse-date date))
|
|
|
741 (vm-set-weekday-of m (elt vector 0))
|
|
|
742 (vm-set-monthday-of m (elt vector 1))
|
|
|
743 (vm-su-do-month m (elt vector 2))
|
|
|
744 (vm-set-year-of m (elt vector 3))
|
|
|
745 (vm-set-hour-of m (elt vector 4))
|
|
|
746 (vm-set-zone-of m (elt vector 5)))))
|
|
|
747
|
|
|
748 ;; Normalize all hour and date specifications to avoid jagged margins.
|
|
|
749 ;; If the hour is " 3:..." or "3:...", turn it into "03:...".
|
|
|
750 ;; If the date is "03", turn it into " 3".
|
|
|
751 (cond ((null (vm-hour-of m)) nil)
|
|
|
752 ((string-match "\\`[0-9]:" (vm-hour-of m))
|
|
|
753 (vm-set-hour-of m (concat "0" (vm-hour-of m)))))
|
|
|
754 (cond ((null (vm-monthday-of m)) nil)
|
|
|
755 ((string-match "\\`0[0-9]\\'" (vm-monthday-of m))
|
|
|
756 (vm-set-monthday-of m (substring (vm-monthday-of m) 1 2))))
|
|
|
757 )
|
|
|
758
|
|
|
759 (defun vm-su-do-month (m month-abbrev)
|
|
|
760 (let ((val (assoc (downcase month-abbrev) vm-month-alist)))
|
|
|
761 (if val
|
|
|
762 (progn (vm-set-month-of m (nth 1 val))
|
|
|
763 (vm-set-month-number-of m (nth 2 val)))
|
|
|
764 (vm-set-month-of m "")
|
|
|
765 (vm-set-month-number-of m ""))))
|
|
|
766
|
|
|
767 (defun vm-run-user-summary-function (function message)
|
|
|
768 (let ((message (vm-real-message-of message)))
|
|
|
769 (save-excursion
|
|
|
770 (set-buffer (vm-buffer-of message))
|
|
|
771 (save-restriction
|
|
|
772 (widen)
|
|
|
773 (save-excursion
|
|
|
774 (narrow-to-region (vm-headers-of message) (vm-text-end-of message))
|
|
|
775 (funcall function message))))))
|
|
|
776
|
|
|
777 (defun vm-su-full-name (m)
|
|
|
778 (or (vm-full-name-of m)
|
|
|
779 (progn (vm-su-do-author m) (vm-full-name-of m))))
|
|
|
780
|
|
|
781 (defun vm-su-interesting-full-name (m)
|
|
|
782 (if vm-summary-uninteresting-senders
|
|
|
783 (let ((case-fold-search nil))
|
|
|
784 (if (string-match vm-summary-uninteresting-senders (vm-su-from m))
|
|
|
785 (concat vm-summary-uninteresting-senders-arrow (vm-su-to-names m))
|
|
|
786 (vm-su-full-name m)))
|
|
|
787 (vm-su-full-name m)))
|
|
|
788
|
|
|
789 (defun vm-su-from (m)
|
|
|
790 (or (vm-from-of m)
|
|
|
791 (progn (vm-su-do-author m) (vm-from-of m))))
|
|
|
792
|
|
|
793 (defun vm-su-interesting-from (m)
|
|
|
794 (if vm-summary-uninteresting-senders
|
|
|
795 (let ((case-fold-search nil))
|
|
|
796 (if (string-match vm-summary-uninteresting-senders (vm-su-from m))
|
|
|
797 (concat vm-summary-uninteresting-senders-arrow (vm-su-to m))
|
|
|
798 (vm-su-from m)))
|
|
|
799 (vm-su-from m)))
|
|
|
800
|
|
|
801 ;; Some yogurt-headed delivery agents don't even provide a From: header.
|
|
|
802 (defun vm-grok-From_-author (message)
|
|
|
803 ;; This works only on the From_ types, obviously
|
|
|
804 (if (not (memq (vm-message-type-of message)
|
|
|
805 '(From_ From_-with-Content-Length)))
|
|
|
806 nil
|
|
|
807 (save-excursion
|
|
|
808 (set-buffer (vm-buffer-of message))
|
|
20
|
809 (save-excursion
|
|
|
810 (save-restriction
|
|
|
811 (widen)
|
|
|
812 (goto-char (vm-start-of message))
|
|
|
813 (let ((case-fold-search nil))
|
|
|
814 (if (looking-at "From \\([^ \t\n]+\\)")
|
|
|
815 (vm-buffer-substring-no-properties
|
|
|
816 (match-beginning 1)
|
|
|
817 (match-end 1)))))))))
|
|
0
|
818
|
|
|
819 (defun vm-su-do-author (m)
|
|
|
820 (let ((full-name (vm-get-header-contents m "Full-Name:"))
|
|
20
|
821 (from (or (vm-get-header-contents m "From:" ", ")
|
|
0
|
822 (vm-grok-From_-author m)))
|
|
20
|
823 pair i)
|
|
0
|
824 (if (and full-name (string-match "^[ \t]*$" full-name))
|
|
|
825 (setq full-name nil))
|
|
|
826 (if (null from)
|
|
|
827 (progn
|
|
|
828 (setq from "???")
|
|
|
829 (if (null full-name)
|
|
|
830 (setq full-name "???")))
|
|
|
831 (setq pair (funcall vm-chop-full-name-function from)
|
|
|
832 from (or (nth 1 pair) from)
|
|
|
833 full-name (or full-name (nth 0 pair) from)))
|
|
|
834 (if (string-match "\\`\"\\([^\"]+\\)\"\\'" full-name)
|
|
|
835 (setq full-name
|
|
|
836 (substring full-name (match-beginning 1) (match-end 1))))
|
|
20
|
837 (while (setq i (string-match "\n" full-name i))
|
|
|
838 (aset full-name i ?\ ))
|
|
0
|
839 (vm-set-full-name-of m full-name)
|
|
|
840 (vm-set-from-of m from)))
|
|
|
841
|
|
|
842 (defun vm-default-chop-full-name (address)
|
|
|
843 (let ((from address)
|
|
|
844 (full-name nil))
|
|
|
845 (cond ((string-match
|
|
|
846 "\\`[ \t\n]*\\([^< \t\n]+\\([ \t\n]+[^< \t\n]+\\)*\\)?[ \t\n]*<\\([^>]+\\)>[ \t\n]*\\'"
|
|
|
847 address)
|
|
|
848 (if (match-beginning 1)
|
|
|
849 (setq full-name
|
|
|
850 (substring address (match-beginning 1) (match-end 1))))
|
|
|
851 (setq from
|
|
|
852 (substring address (match-beginning 3) (match-end 3))))
|
|
|
853 ((string-match
|
|
|
854 "\\`[ \t\n]*\\(\\(\"[^\"]+\"\\|[^\"( \t\n]\\)+\\)[ \t\n]*(\\([^ \t\n]+\\([ \t\n]+[^ \t\n]+\\)*\\)?)[ \t\n]*\\'"
|
|
|
855 address)
|
|
|
856 (if (match-beginning 3)
|
|
|
857 (setq full-name
|
|
|
858 (substring address (match-beginning 3) (match-end 3))))
|
|
|
859 (setq from
|
|
|
860 (substring address (match-beginning 1) (match-end 1)))))
|
|
|
861 (list full-name from)))
|
|
|
862
|
|
|
863 ;; test for existence and functionality of mail-extract-address-components
|
|
|
864 ;; there are versions out there that don't work right, so we run
|
|
|
865 ;; some test data through it to see if we can trust it.
|
|
|
866 (defun vm-choose-chop-full-name-function (address)
|
|
|
867 (let ((test-data '(("kyle@uunet.uu.net" .
|
|
|
868 (nil "kyle@uunet.uu.net"))
|
|
|
869 ("c++std=lib@inet.research.att.com" .
|
|
|
870 (nil "c++std=lib@inet.research.att.com"))
|
|
|
871 ("\"Piet.Rypens\" <rypens@reks.uia.ac.be>" .
|
|
|
872 ("Piet Rypens" "rypens@reks.uia.ac.be"))
|
|
|
873 ("makke@wins.uia.ac.be (Marc.Gemis)" .
|
|
|
874 ("Marc Gemis" "makke@wins.uia.ac.be"))
|
|
|
875 ("" . (nil nil))))
|
|
|
876 (failed nil)
|
|
|
877 result)
|
|
|
878 (while test-data
|
|
|
879 (setq result (condition-case nil
|
|
|
880 (mail-extract-address-components (car (car test-data)))
|
|
|
881 (error nil)))
|
|
|
882 (if (not (equal result (cdr (car test-data))))
|
|
|
883 ;; failed test, use default
|
|
|
884 (setq failed t
|
|
|
885 test-data nil)
|
|
|
886 (setq test-data (cdr test-data))))
|
|
|
887 (if failed
|
|
|
888 ;; it failed, use default
|
|
|
889 (setq vm-chop-full-name-function 'vm-default-chop-full-name)
|
|
|
890 ;; it passed the tests
|
|
|
891 (setq vm-chop-full-name-function 'mail-extract-address-components))
|
|
|
892 (funcall vm-chop-full-name-function address)))
|
|
|
893
|
|
|
894 (defun vm-su-do-recipients (m)
|
|
20
|
895 (let ((mail-use-rfc822 t) i names addresses to cc all list full-name)
|
|
|
896 (setq to (or (vm-get-header-contents m "To:" ", ")
|
|
|
897 (vm-get-header-contents m "Apparently-To:" ", ")
|
|
0
|
898 ;; desperation....
|
|
|
899 (user-login-name))
|
|
20
|
900 cc (vm-get-header-contents m "Cc:" ", ")
|
|
0
|
901 all to
|
|
|
902 all (if all (concat all ", " cc) cc)
|
|
|
903 addresses (rfc822-addresses all))
|
|
|
904 (setq list (vm-parse-addresses all))
|
|
|
905 (while list
|
|
20
|
906 ;; Just like vm-su-do-author:
|
|
|
907 (setq full-name (or (nth 0 (funcall vm-chop-full-name-function
|
|
|
908 (car list)))
|
|
|
909 (car list)))
|
|
|
910 ;; If double quoted are around the full name, fish the name out.
|
|
|
911 (if (string-match "\\`\"\\([^\"]+\\)\"\\'" full-name)
|
|
|
912 (setq full-name
|
|
|
913 (substring full-name (match-beginning 1) (match-end 1))))
|
|
|
914 (while (setq i (string-match "\n" full-name i))
|
|
|
915 (aset full-name i ?\ ))
|
|
|
916 (setq names (cons full-name names))
|
|
0
|
917 (setq list (cdr list)))
|
|
|
918 (setq names (nreverse names)) ; added by jwz for fixed vm-parse-addresses
|
|
|
919 (vm-set-to-of m (mapconcat 'identity addresses ", "))
|
|
|
920 (vm-set-to-names-of m (mapconcat 'identity names ", "))))
|
|
|
921
|
|
|
922 (defun vm-su-to (m)
|
|
|
923 (or (vm-to-of m) (progn (vm-su-do-recipients m) (vm-to-of m))))
|
|
|
924
|
|
|
925 (defun vm-su-to-names (m)
|
|
|
926 (or (vm-to-names-of m) (progn (vm-su-do-recipients m) (vm-to-names-of m))))
|
|
|
927
|
|
|
928 (defun vm-su-message-id (m)
|
|
|
929 (or (vm-message-id-of m)
|
|
|
930 (vm-set-message-id-of
|
|
|
931 m
|
|
|
932 (or (vm-get-header-contents m "Message-Id:")
|
|
|
933 ;; try running md5 on the message body to produce an ID
|
|
|
934 ;; better than nothing.
|
|
|
935 (save-excursion
|
|
|
936 (set-buffer (vm-buffer-of (vm-real-message-of m)))
|
|
|
937 (save-restriction
|
|
|
938 (widen)
|
|
|
939 (condition-case nil
|
|
|
940 (concat "<fake-VM-id."
|
|
|
941 (vm-pop-md5-string
|
|
|
942 (buffer-substring
|
|
|
943 (vm-text-of (vm-real-message-of m))
|
|
|
944 (vm-text-end-of (vm-real-message-of m))))
|
|
|
945 "@talos.iv>")
|
|
|
946 (error nil))))
|
|
|
947 (concat "<" (int-to-string (vm-abs (random))) "@toto.iv>")))))
|
|
|
948
|
|
|
949 (defun vm-su-line-count (m)
|
|
|
950 (or (vm-line-count-of m)
|
|
|
951 (vm-set-line-count-of
|
|
|
952 m
|
|
|
953 (save-excursion
|
|
|
954 (set-buffer (vm-buffer-of (vm-real-message-of m)))
|
|
|
955 (save-restriction
|
|
|
956 (widen)
|
|
|
957 (int-to-string
|
|
|
958 (count-lines (vm-text-of (vm-real-message-of m))
|
|
|
959 (vm-text-end-of (vm-real-message-of m)))))))))
|
|
|
960
|
|
|
961 (defun vm-su-subject (m)
|
|
|
962 (or (vm-subject-of m)
|
|
|
963 (vm-set-subject-of
|
|
|
964 m
|
|
20
|
965 (let ((subject (or (vm-get-header-contents m "Subject:" " ") ""))
|
|
0
|
966 (i nil))
|
|
20
|
967 (while (setq i (string-match "\n" subject i))
|
|
|
968 (aset subject i ?\ ))
|
|
0
|
969 subject ))))
|
|
|
970
|
|
|
971 (defun vm-su-summary (m)
|
|
|
972 (if (and (vm-virtual-message-p m) (not (vm-virtual-messages-of m)))
|
|
|
973 (or (vm-virtual-summary-of m)
|
|
|
974 (save-excursion
|
|
|
975 (vm-select-folder-buffer)
|
|
|
976 (vm-set-virtual-summary-of m (vm-sprintf 'vm-summary-format m t))
|
|
|
977 (vm-virtual-summary-of m)))
|
|
|
978 (or (vm-summary-of m)
|
|
|
979 (save-excursion
|
|
|
980 (vm-select-folder-buffer)
|
|
|
981 (vm-set-summary-of m (vm-sprintf 'vm-summary-format m t))
|
|
|
982 (vm-summary-of m)))))
|
|
|
983
|
|
|
984 (defun vm-fix-my-summary!!! ()
|
|
|
985 (interactive)
|
|
|
986 (vm-select-folder-buffer)
|
|
|
987 (vm-check-for-killed-summary)
|
|
|
988 (vm-error-if-folder-empty)
|
|
|
989 (vm-unsaved-message "Fixing your summary...")
|
|
|
990 (let ((mp vm-message-list))
|
|
|
991 (while mp
|
|
|
992 (vm-set-summary-of (car mp) nil)
|
|
|
993 (vm-mark-for-summary-update (car mp))
|
|
|
994 (setq mp (cdr mp)))
|
|
20
|
995 (vm-stuff-folder-attributes nil)
|
|
0
|
996 (set-buffer-modified-p t)
|
|
|
997 (vm-update-summary-and-mode-line))
|
|
|
998 (vm-unsaved-message "Fixing your summary... done"))
|
|
|
999
|
|
|
1000 (defun vm-su-thread-indent (m)
|
|
|
1001 (if (natnump vm-summary-thread-indent-level)
|
|
|
1002 (make-string (* (vm-th-thread-indentation m)
|
|
|
1003 vm-summary-thread-indent-level)
|
|
|
1004 ?\ )
|
|
|
1005 "" ))
|
|
|
1006
|
|
|
1007 (defun vm-su-labels (m)
|
|
|
1008 (or (vm-label-string-of m)
|
|
|
1009 (vm-set-label-string-of
|
|
|
1010 m
|
|
|
1011 (mapconcat 'identity (vm-labels-of m) ","))
|
|
|
1012 (vm-label-string-of m)))
|
